bool TangibleObjectImplementation::isAttackableBy(CreatureObject* object) {
if (isImperial() && !(object->isRebel())) {
return false;
} else if (isRebel() && !(object->isImperial())) {
return false;
} else if (object->isPlayerCreature() && object->getPlayerObject()) {
if (isImperial() && (object->getPlayerObject())->getFactionStatus() == 0) {
return false;
}
if (isRebel() && (object->getPlayerObject())->getFactionStatus() == 0) {
return false;
}
} else if (object->isAiAgent()) {
AiAgent* ai = object->asAiAgent();
if (ai->getHomeObject().get() == asTangibleObject()) {
return false;
}
if (ai->isPet()) {
ManagedReference<PetControlDevice*> pcd = ai->getControlDevice().get().castTo<PetControlDevice*>();
if (pcd != NULL && pcd->getPetType() == PetManager::FACTIONPET && isNeutral()) {
return false;
}
}
}
return pvpStatusBitmask & CreatureFlag::ATTACKABLE;
}
CreatureObject* CreatureManagerImplementation::spawnCreatureAsEventMob(uint32 templateCRC, float x, float z, float y, uint64 parentID) {
CreatureTemplate* creoTempl = creatureTemplateManager->getTemplate(templateCRC);
if (creoTempl == NULL)
return NULL;
CreatureObject* creo = NULL;
String templateToSpawn = getTemplateToSpawn(templateCRC);
uint32 objectCRC = templateToSpawn.hashCode();
creo = createCreature(objectCRC, false, templateCRC);
if (creo != NULL && creo->isAiAgent()) {
AiAgent* creature = cast<AiAgent*>(creo);
creature->loadTemplateData(creoTempl);
UnicodeString eventName;
eventName = creature->getDisplayedName() + " (event)";
creature->setCustomObjectName(eventName, false);
} else if (creo == NULL) {
error("could not spawn template " + templateToSpawn);
}
placeCreature(creo, x, z, y, parentID);
if (creo != NULL && creo->isAiAgent())
cast<AiAgent*>(creo)->activateLoad("");
return creo;
}
void CreatureManagerImplementation::placeCreature(CreatureObject* creature, float x, float z, float y, uint64 parentID) {
if (creature == NULL)
return;
Reference<SceneObject*> cellParent = NULL;
if (parentID != 0) {
cellParent = zoneServer->getObject(parentID);
if (cellParent != NULL && !cellParent->isCellObject()) {
error("trying to set a parent that is not a cell to creature");
cellParent = NULL;
}
}
//addCreatureToMap(creature);
Locker _locker(creature);
if (creature->isAiAgent()) {
AiAgent* aio = cast<AiAgent*>(creature);
aio->setHomeLocation(x, z, y, cellParent);
}
creature->initializePosition(x, z, y);
//creature->insertToZone(zone);
if (cellParent != NULL) {
cellParent->transferObject(creature, -1);
} else
zone->transferObject(creature, -1, true);
}
CreatureObject* CreatureManagerImplementation::spawnCreature(uint32 templateCRC, uint32 objectCRC, float x, float z, float y, uint64 parentID, bool persistent) {
CreatureTemplate* creoTempl = creatureTemplateManager->getTemplate(templateCRC);
if (creoTempl == NULL)
return spawnCreature(objectCRC, x, z, y, parentID);
CreatureObject* creature = NULL;
String templateToSpawn;
if (objectCRC == 0) {
templateToSpawn = getTemplateToSpawn(templateCRC);
objectCRC = templateToSpawn.hashCode();
}
creature = createCreature(objectCRC, persistent, templateCRC);
if (creature != NULL && creature->isAiAgent()) {
AiAgent* npc = cast<AiAgent*>(creature);
npc->loadTemplateData(creoTempl);
} else if (creature == NULL) {
error("could not spawn template " + templateToSpawn);
}
placeCreature(creature, x, z, y, parentID);
return creature;
}
void PetControlDeviceImplementation::setTrainingCommand( unsigned int commandID ){
ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get();
if (controlledObject == NULL || !controlledObject->isAiAgent())
return;
AiAgent* pet = cast<AiAgent*>(controlledObject.get());
if( pet == NULL )
return;
// Check power on droids
if( petType == PetManager::DROIDPET) {
ManagedReference<DroidObject*> droid = this->controlledObject.get().castTo<DroidObject*>();
if (droid == NULL)
return;
if( !droid->hasPower() ){
droid->showFlyText("npc_reaction/flytext","low_power", 204, 0, 0); // "*Low Power*"
return;
}
}
trainingCommand = commandID;
pet->showFlyText("npc_reaction/flytext","alert", 204, 0, 0); // "?"
}
int LairObserverImplementation::notifyObserverEvent(unsigned int eventType, Observable* observable, ManagedObject* arg1, int64 arg2) {
int ret = 1;
int i = 0;
Reference<LairAggroTask*> task = NULL;
SceneObject* sourceObject = cast<SceneObject*>(arg1);
AiAgent* agent = NULL;
ManagedReference<LairObserver*> lairObserver = _this.get();
ManagedReference<TangibleObject*> lair = cast<TangibleObject*>(observable);
ManagedReference<TangibleObject*> attacker = cast<TangibleObject*>(arg1);
switch (eventType) {
case ObserverEventType::OBJECTREMOVEDFROMZONE:
despawnSpawns();
return 1;
break;
case ObserverEventType::OBJECTDESTRUCTION:
notifyDestruction(lair, attacker, (int)arg2);
return 1;
break;
case ObserverEventType::DAMAGERECEIVED:
// if there are living creatures, make them aggro
if(getLivingCreatureCount() > 0 ){
task = new LairAggroTask(lair, attacker.get(), _this.get(), false);
task->execute();
}
EXECUTE_TASK_3(lairObserver, lair, attacker, {
Locker locker(lair_p);
lairObserver_p->checkForNewSpawns(lair_p, attacker_p);
});
checkForHeal(lair, attacker);
break;
case ObserverEventType::AIMESSAGE:
if (sourceObject == NULL) {
Logger::console.error("LairObserverImplemenation::notifyObserverEvent does not have a source object");
return 1;
}
for (i = 0; i < spawnedCreatures.size(); i++) {
agent = cast<AiAgent*>(spawnedCreatures.get(i).get());
if (agent == NULL)
continue;
agent->activateInterrupt(sourceObject, arg2);
}
break;
}
void SpawnObserverImplementation::despawnSpawns() {
for (int i = 0; i < spawnedCreatures.size(); ++i) {
CreatureObject* obj = spawnedCreatures.get(i);
if (obj->isAiAgent()) {
AiAgent* aiObj = cast<AiAgent*>(obj);
Locker locker(aiObj);
aiObj->setDespawnOnNoPlayerInRange(true);
}
}
spawnedCreatures.removeAll();
}
int LuaAiAgent::assist(lua_State* L) {
SceneObject* obj = (SceneObject*) lua_touserdata(L, -1);
if (obj == NULL || !obj->isAiAgent())
return 0;
AiAgent* agent = cast<AiAgent*>(obj);
if (agent == NULL)
return 0;
SceneObject* target = agent->getFollowObject();
Locker locker(realObject);
realObject->setDefender(target);
return 0;
}
int LairObserverImplementation::notifyObserverEvent(unsigned int eventType, Observable* observable, ManagedObject* arg1, int64 arg2) {
int ret = 1;
int i = 0;
Reference<LairAggroTask*> task = NULL;
SceneObject* sourceObject = cast<SceneObject*>(arg1);
AiAgent* agent = NULL;
switch (eventType) {
case ObserverEventType::OBJECTDESTRUCTION:
notifyDestruction(cast<TangibleObject*>(observable), cast<TangibleObject*>(arg1), (int)arg2);
return 1;
break;
case ObserverEventType::DAMAGERECEIVED:
// if there are living creatures, make them aggro
if(getLivingCreatureCount() > 0 ){
task = new LairAggroTask(cast<TangibleObject*>(observable), cast<TangibleObject*>(arg1), _this.get(), false);
task->execute();
}
// if new creatures have spawned or there are live creatures near the lair
if( checkForNewSpawns(cast<TangibleObject*>(observable), cast<TangibleObject*>(arg1)) || getLivingCreatureCount() > 0 )
checkForHeal(cast<TangibleObject*>(observable), cast<TangibleObject*>(arg1));
break;
case ObserverEventType::AIMESSAGE:
if (sourceObject == NULL) {
Logger::console.error("LairObserverImplemenation::notifyObserverEvent does not have a source object");
return 1;
}
for (i = 0; i < spawnedCreatures.size(); i++) {
agent = cast<AiAgent*>(spawnedCreatures.get(i).get());
if (agent == NULL)
continue;
agent->activateInterrupt(sourceObject, arg2);
}
break;
}
return 0;
}
void PetControlDeviceImplementation::trainAsMount(CreatureObject* player) {
if (isTrainedAsMount())
return;
PetManager* petManager = player->getZoneServer()->getPetManager();
if (petManager == NULL)
return;
if (petManager->checkMountEligibility(_this.get()) != PetManager::CANBEMOUNTTRAINED)
return;
ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get();
if (controlledObject == NULL || !controlledObject->isAiAgent())
return;
AiAgent* pet = cast<AiAgent*>(controlledObject.get());
if( pet == NULL )
return;
trainedAsMount = true;
pet->setOptionsBitmask(0x1080);
}
int HuntingMissionObjectiveImplementation::notifyObserverEvent(MissionObserver* observer, uint32 eventType, Observable* observable, ManagedObject* arg1, int64 arg2) {
ManagedReference<MissionObject* > mission = this->mission.get();
if (eventType == ObserverEventType::KILLEDCREATURE) {
if (cast<CreatureObject*>(observable) != getPlayerOwner().get())
return 0;
CreatureObject* creature = cast<CreatureObject*>(arg1);
AiAgent* agent = cast<AiAgent*>(creature);
if (agent == NULL)
return 0;
CreatureTemplate* creatureTemplate = agent->getCreatureTemplate();
if (creatureTemplate == NULL)
return 0;
String temp1 = mission->getTemplateString1();
String temp2 = mission->getTemplateString2();
if (creatureTemplate->getTemplateName() == temp1 || creatureTemplate->getTemplateName() == temp2) {
targetsKilled--;
if (targetsKilled <= 0) {
complete();
return 1;
}
StringIdChatParameter message("mission/mission_generic", "hunting_kills_remaining");
message.setDI(targetsKilled);
message.setTO(mission->getTargetName());
getPlayerOwner().get()->sendSystemMessage(message);
}
}
return 0;
}
bool PetControlDeviceImplementation::isValidPet() {
ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get();
if (controlledObject == NULL || !controlledObject->isAiAgent())
return true;
AiAgent* pet = cast<AiAgent*>(controlledObject.get());
if (pet == NULL)
return true;
PetDeed* deed = pet->getPetDeed();
if (deed != NULL) {
// time to calculate!
int calculatedLevel = deed->calculatePetLevel();
if (pet->getTemplateLevel() == 0)
return true;
if (pet->getTemplateLevel() >= (calculatedLevel * 0.85)) {
return true;
} else {
return false;
}
}
return true;
}
int FactionRecruiterContainerComponent::canAddObject(SceneObject* sceneObject, SceneObject* object, int containmentType, String& errorDescription) {
if (sceneObject == object) {
return TransferErrorCode::CANTADDTOITSELF;
}
if (!sceneObject->isAiAgent()) {
return TransferErrorCode::INVALIDTYPE;
}
AiAgent* recruiter = cast<AiAgent*>(sceneObject);
String recruiterFaction = recruiter->getFactionString().toLowerCase();
if (recruiterFaction != "imperial" && recruiterFaction != "rebel") {
return TransferErrorCode::INVALIDTYPE;
}
CreatureObject* player = object->getParentRecursively(SceneObjectType::PLAYERCREATURE).get().castTo<CreatureObject*>();
if (player == NULL) {
return TransferErrorCode::MUSTBEINPLAYERINVENTORY;
}
if (object->getObjectTemplate()->getFullTemplateString() == "object/tangible/encoded_disk/message_assembled_base.iff") {
CoaMessageDataComponent* data = object->getDataObjectComponent()->castTo<CoaMessageDataComponent*>();
if (data != NULL) {
String faction = data->getFaction().toLowerCase();
if (faction == "imperial" || faction == "rebel") {
return TransferErrorCode::SUCCESS;
}
}
}
return TransferErrorCode::INVALIDTYPE;
}
bool TangibleObjectImplementation::isAttackableBy(CreatureObject* object) {
if (isImperial() && !(object->isRebel())) {
return false;
} else if (isRebel() && !(object->isImperial())) {
return false;
} else if (object->isPlayerCreature() && object->getPlayerObject()) {
if (isImperial() && (object->getPlayerObject())->getFactionStatus() == 0) {
return false;
}
if (isRebel() && (object->getPlayerObject())->getFactionStatus() == 0) {
return false;
}
} else if (object->isAiAgent()) {
AiAgent* ai = cast<AiAgent*>(object);
if (ai->getHomeObject() == _this.get()) {
return false;
}
}
return pvpStatusBitmask & CreatureFlag::ATTACKABLE;
}
void PetControlDeviceImplementation::trainAsMount(CreatureObject* player) {
if (isTrainedAsMount() || !player->hasSkill("outdoors_creaturehandler_support_04"))
return;
PetManager* petManager = player->getZoneServer()->getPetManager();
if (petManager == NULL)
return;
if (petManager->checkMountEligibility(_this.getReferenceUnsafeStaticCast()) != PetManager::CANBEMOUNTTRAINED)
return;
ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get();
if (controlledObject == NULL || !controlledObject->isAiAgent())
return;
AiAgent* pet = cast<AiAgent*>(controlledObject.get());
if( pet == NULL )
return;
assert(pet->isLockedByCurrentThread());
trainedAsMount = true;
pet->setOptionBit(0x1000);
}
void CreatureManagerImplementation::placeCreature(CreatureObject* creature, float x, float z, float y, uint64 parentID) {
if (creature == NULL)
return;
Reference<CellObject*> cellParent = NULL;
if (parentID != 0) {
cellParent = zoneServer->getObject(parentID).castTo<CellObject*>();
}
Locker _locker(creature);
if (creature->isAiAgent()) {
AiAgent* aio = cast<AiAgent*>(creature);
aio->setHomeLocation(x, z, y, cellParent);
}
creature->initializePosition(x, z, y);
if (cellParent != NULL) {
cellParent->transferObject(creature, -1);
} else
zone->transferObject(creature, -1, true);
}
void PetControlDeviceImplementation::setTrainingCommand( unsigned int commandID ){
// we set to 0 to flag completion so skip all this then.
if (commandID == 0) {
trainingCommand = 0;
return;
}
ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get();
if (controlledObject == NULL || !controlledObject->isAiAgent())
return;
AiAgent* pet = cast<AiAgent*>(controlledObject.get());
if( pet == NULL )
return;
ManagedReference<CreatureObject*> owner = pet->getLinkedCreature().get();
if (owner == NULL || !owner->isPlayerCreature())
return;
if( petType == PetManager::DROIDPET) {
ManagedReference<DroidObject*> droid = this->controlledObject.get().castTo<DroidObject*>();
if (droid == NULL)
return;
// Check power on droids
if( !droid->hasPower() ){
droid->showFlyText("npc_reaction/flytext","low_power", 204, 0, 0); // "*Low Power*"
return;
}
if(((commandID == PetManager::ATTACK || commandID == PetManager::GUARD) && !droid->isCombatDroid()) ||
(commandID == PetManager::RANGED_ATTACK && (!droid->isCombatDroid() || !droid->hasRangedWeapon())) ||
(commandID == PetManager::RECHARGEOTHER && !droid->isPowerDroid()) ||
(commandID == PetManager::TRANSFER) ||
(commandID == PetManager::SPECIAL_ATTACK1) ||
(commandID == PetManager::SPECIAL_ATTACK2) ||
(commandID == PetManager::TRICK1) ||
(commandID == PetManager::TRICK2)){
return;
}
}
else if(petType == PetManager::CREATUREPET){
if(((commandID == PetManager::ATTACK || commandID == PetManager::FOLLOW || commandID == PetManager::STORE) && !owner->hasSkill("outdoors_creaturehandler_novice") ) ||
(commandID == PetManager::STAY && !owner->hasSkill("outdoors_creaturehandler_training_01")) ||
(commandID == PetManager::GUARD && !owner->hasSkill("outdoors_creaturehandler_training_02")) ||
(commandID == PetManager::FRIEND && !owner->hasSkill("outdoors_creaturehandler_support_03")) ||
((commandID == PetManager::PATROL || commandID == PetManager::GETPATROLPOINT || commandID == PetManager::CLEARPATROLPOINTS) && !owner->hasSkill("outdoors_creaturehandler_training_03")) ||
((commandID == PetManager::FORMATION1 || commandID == PetManager::FORMATION2) && !owner->hasSkill("outdoors_creaturehandler_training_04")) ||
(commandID == PetManager::TRANSFER && !owner->hasSkill("outdoors_creaturehandler_master")) ||
(commandID == PetManager::TRICK1 && !owner->hasSkill("outdoors_creaturehandler_healing_01")) ||
(commandID == PetManager::TRICK2 && !owner->hasSkill("outdoors_creaturehandler_healing_03")) ||
(commandID == PetManager::GROUP && !owner->hasSkill("outdoors_creaturehandler_support_01")) ||
(commandID == PetManager::SPECIAL_ATTACK1 && (!owner->hasSkill("outdoors_creaturehandler_taming_03") || !pet->hasSpecialAttack(1))) ||
(commandID == PetManager::SPECIAL_ATTACK2 && (!owner->hasSkill("outdoors_creaturehandler_taming_04") || !pet->hasSpecialAttack(2))) ||
(commandID == PetManager::RANGED_ATTACK && (!owner->hasSkill("outdoors_creaturehandler_master") || !pet->hasRangedWeapon())) ||
(commandID == PetManager::FOLLOWOTHER && !owner->hasSkill("outdoors_creaturehandler_support_02")) ||
(commandID == PetManager::RECHARGEOTHER))
return;
}
else if(petType == PetManager::FACTIONPET){
if(commandID == PetManager::RECHARGEOTHER ||
(commandID == PetManager::TRANSFER) ||
(commandID == PetManager::SPECIAL_ATTACK1) ||
(commandID == PetManager::SPECIAL_ATTACK2) ||
(commandID == PetManager::TRICK1) ||
(commandID == PetManager::TRICK2))
return;
}
/** Check for converse and if so, get its personalityStf**/
if (pet->getOptionsBitmask() & OptionBitmask::CONVERSE) {
String stf = pet->getPersonalityStf();
StringBuffer message;
message << stf << ":start_convo_4";
StringIdChatParameter chat;
chat.setStringId(message.toString());
pet->getZoneServer()->getChatManager()->broadcastChatMessage(pet,chat,0,0,0);
} else {
pet->showFlyText("npc_reaction/flytext","alert", 204, 0, 0); // "?"
}
trainingCommand = commandID;
}
void PetControlDeviceImplementation::spawnObject(CreatureObject* player) {
ZoneServer* zoneServer = getZoneServer();
ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get();
if (controlledObject == NULL)
return;
if (!isASubChildOf(player))
return;
ManagedReference<TradeSession*> tradeContainer = player->getActiveSession(SessionFacadeType::TRADE).castTo<TradeSession*>();
if (tradeContainer != NULL) {
server->getZoneServer()->getPlayerManager()->handleAbortTradeMessage(player);
}
controlledObject->initializePosition(player->getPositionX(), player->getPositionZ(), player->getPositionY());
ManagedReference<CreatureObject*> creature = NULL;
if (controlledObject->isCreatureObject()) {
creature = cast<CreatureObject*>(controlledObject.get());
creature->setCreatureLink(player);
creature->setControlDevice(_this.get());
creature->setFaction(player->getFaction());
creature->setObjectMenuComponent("PetMenuComponent");
if (player->getPvpStatusBitmask() & CreatureFlag::PLAYER)
creature->setPvpStatusBitmask(player->getPvpStatusBitmask() - CreatureFlag::PLAYER, true);
else
creature->setPvpStatusBitmask(player->getPvpStatusBitmask(), true);
}
Zone* zone = player->getZone();
if (zone == NULL)
return;
ManagedReference<SceneObject*> parent = player->getParent();
if (parent != NULL && parent->isCellObject())
parent->transferObject(controlledObject, -1, true);
else
zone->transferObject(controlledObject, -1, true);
updateStatus(1);
if (petControlObserver != NULL)
player->dropObserver(ObserverEventType::STARTCOMBAT, petControlObserver);
AiAgent* pet = cast<AiAgent*>(creature.get());
if (pet == NULL)
return;
ManagedReference<PlayerObject*> ghost = player->getPlayerObject();
ghost->addToActivePets(pet);
if (pet->isDroidObject()) {
DroidObject* droid = cast<DroidObject*>(pet);
if( droid == NULL )
return;
// Sanity check that there isn't another power task outstanding
droid->removePendingTask( "droid_power" );
// Submit new power task
Reference<Task*> droidPowerTask = new DroidPowerTask( droid );
droid->addPendingTask("droid_power", droidPowerTask, 120000); // 2 min
if( droid->hasPower() ){
// TODO Temporarily set to autofollow player
droid->setFollowObject(player);
}
else{
droid->handleLowPower();
}
} else {
pet->setFollowObject(player);
}
// Not training any commands
trainingCommand = 0;
}
int PetMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) {
if (!sceneObject->isPet())
return 0;
AiAgent* pet = cast<AiAgent*>(sceneObject);
if (!player->getPlayerObject()->isPrivileged() && pet->getLinkedCreature() != player)
return 0;
if (pet->getLinkedCreature() != player) {
player = pet->getLinkedCreature().get();
}
ManagedReference<PetControlDevice*> petControlDevice = pet->getControlDevice().get().castTo<PetControlDevice*>();
if (petControlDevice == NULL || player == NULL)
return 0;
PetManager* petManager = pet->getZoneServer()->getPetManager();
if (petManager == NULL)
return 0;
// Store
if (selectedID == 59) {
petControlDevice->storeObject(player);
return 0;
}
// Recharge
if (selectedID == 234 && petControlDevice->getPetType() == PetManager::DROIDPET ){
petManager->enqueueOwnerOnlyPetCommand(player, pet, String("petRecharge").toLowerCase().hashCode(), "");
}
// Feed
if (selectedID == 234 && petControlDevice->getPetType() == PetManager::CREATUREPET ){
petManager->enqueueOwnerOnlyPetCommand(player, pet, String("petFeed").toLowerCase().hashCode(), "");
}
// Trained Command: Recharge Other
if (selectedID == 235 ){
petControlDevice->setTrainingCommand( PetManager::RECHARGEOTHER );
}
// Train Command: Follow
if (selectedID == 142 ){ // PET_FOLLOW
petControlDevice->setTrainingCommand( PetManager::FOLLOW );
}
// Train Command: Stay
if (selectedID == 143 ){ // PET_STAY
petControlDevice->setTrainingCommand( PetManager::STAY );
}
// Train Command: Guard
if (selectedID == 144 ){ // PET_GUARD
petControlDevice->setTrainingCommand( PetManager::GUARD );
}
// Train Command: Friend
if (selectedID == 145 ){ // PET_FRIEND
petControlDevice->setTrainingCommand( PetManager::FRIEND );
}
// Train Command: Attack
if (selectedID == 146 ){ // PET_ATTACK
petControlDevice->setTrainingCommand( PetManager::ATTACK );
}
// Train Command: Patrol
if (selectedID == 147 ){ // PET_PATROL
petControlDevice->setTrainingCommand( PetManager::PATROL );
}
// Get Patrol Point
if (selectedID == 148 ){ // PET_GET_PATROL_POINT
// TODO Handle setting patrol point
player->sendSystemMessage("PET_GET_PATROL_POINT pet command is not yet implemented.");
}
// Clear Patrol Points
if (selectedID == 149 ){ // PET_CLEAR_PATROL_POINTS
// TODO Handle clearing patrol points
player->sendSystemMessage("PET_CLEAR_PATROL_POINTS pet command is not yet implemented.");
}
// Train Command: Wedge Formation
if (selectedID == 150 ){ // PET_ASSUME_FORMATION_1
petControlDevice->setTrainingCommand( PetManager::FORMATION1 );
}
// Train Command: Column Formation
if (selectedID == 151 ){ // PET_ASSUME_FORMATION_2
petControlDevice->setTrainingCommand( PetManager::FORMATION2 );
}
// Train Command: Transfer
if (selectedID == 152 ){ // PET_TRANSFER
petControlDevice->setTrainingCommand( PetManager::TRANSFER );
}
// Train Command: Trick 1
if (selectedID == 154 ){ // PET_TRICK_1
petControlDevice->setTrainingCommand( PetManager::TRICK1 );
}
// Train Command: Trick 2
if (selectedID == 155 ){ // PET_TRICK_2
petControlDevice->setTrainingCommand( PetManager::TRICK2 );
}
// Train Command: Group
if (selectedID == 158 ){ // PET_GROUP
petControlDevice->setTrainingCommand( PetManager::GROUP );
}
// Train Command: Special Attack 1
if (selectedID == 161 ){ // PET_SPECIAL_ATTACK_ONE
petControlDevice->setTrainingCommand( PetManager::SPECIAL_ATTACK1 );
}
// Train Command: Special Attack 2
if (selectedID == 162 ){ // PET_SPECIAL_ATTACK_TWO
petControlDevice->setTrainingCommand( PetManager::SPECIAL_ATTACK2 );
}
// Train Command: Ranged Attack
if (selectedID == 163 ){
petControlDevice->setTrainingCommand( PetManager::RANGED_ATTACK );
}
// Train Command: Store
if (selectedID == 164 ){
petControlDevice->setTrainingCommand( PetManager::STORE );
}
// Train Command: Follow Other
if (selectedID == 165 ){
petControlDevice->setTrainingCommand( PetManager::FOLLOWOTHER );
}
if (selectedID == 166 ){
petManager->enqueueOwnerOnlyPetCommand(player, pet, String("petRecover").toLowerCase().hashCode(), "");
}
// Train Pet As A Mount
if (selectedID == 207 ){
petControlDevice->trainAsMount(player);
}
return TangibleObjectMenuComponent::handleObjectMenuSelect(sceneObject, player, selectedID);
}
void CreatureManagerImplementation::tame(Creature* creature, CreatureObject* player, bool force) {
Zone* zone = creature->getZone();
if (zone == NULL || !creature->isCreature())
return;
if(player->getPendingTask("tame_pet") != NULL) {
player->sendSystemMessage("You are already taming a pet");
return;
}
if(player->getPendingTask("call_pet") != NULL) {
player->sendSystemMessage("You cannot tame a pet while another is being called");
return;
}
if (!creature->canTameMe(player) || !creature->isAttackableBy(player)) {
player->sendSystemMessage("@pet/pet_menu:sys_cant_tame"); // You can't tame that
return;
}
CreatureTemplate* creatureTemplate = creature->getCreatureTemplate();
if (creatureTemplate == NULL)
return;
int templateLevel = creatureTemplate->getLevel();
int maxLevelofPets = player->getSkillMod("tame_level");
if (!player->hasSkill("outdoors_creaturehandler_novice") || (templateLevel > maxLevelofPets)) {
player->sendSystemMessage("@pet/pet_menu:sys_lack_skill"); // You lack the skill to be able to tame that creature.
return;
}
if ((creature->isVicious() && player->getSkillMod("tame_aggro") < 1) || creature->getChanceToTame(player) <= 0) {
player->sendSystemMessage("@pet/pet_menu:sys_lack_skill"); // You lack the skill to be able to tame that creature.
return;
}
ManagedReference<SceneObject*> datapad = player->getSlottedObject("datapad");
if (datapad == NULL)
return;
if (datapad->getContainerObjectsSize() >= datapad->getContainerVolumeLimit()) {
player->sendSystemMessage("@faction_recruiter:datapad_full"); // Your datapad is full. You must first free some space.
return;
}
ManagedReference<PlayerManager*> playerManager = zoneServer->getPlayerManager();
int numberStored = 0;
int maxStoredPets = playerManager->getBaseStoredCreaturePets() + player->getSkillMod("stored_pets");
for (int i = 0; i < datapad->getContainerObjectsSize(); ++i) {
ManagedReference<SceneObject*> object = datapad->getContainerObject(i);
if (object != NULL && object->isPetControlDevice()) {
PetControlDevice* device = cast<PetControlDevice*>( object.get());
if (device->getPetType() == PetManager::CREATUREPET) {
if (++numberStored >= maxStoredPets) {
player->sendSystemMessage("@pet/pet_menu:sys_too_many_stored"); // There are too many pets stored in this container. Release some of them to make room for more.
return;
}
}
}
}
ManagedReference<PlayerObject*> ghost = player->getPlayerObject();
int currentlySpawned = 0;
int spawnedLevel = 0;
int level = creature->getLevel();
int maxPets = player->getSkillMod("keep_creature");
for (int i = 0; i < ghost->getActivePetsSize(); ++i) {
ManagedReference<AiAgent*> object = ghost->getActivePet(i);
if (object != NULL) {
ManagedReference<PetControlDevice*> pcd = object->getControlDevice().get().castTo<PetControlDevice*>();
if (pcd == NULL || pcd->getPetType() != PetManager::CREATUREPET) {
continue;
}
if (++currentlySpawned >= maxPets) {
player->sendSystemMessage("@pet/pet_menu:too_many"); // You can't control any more pets. Store one first
return;
}
spawnedLevel += object->getLevel();
if ((spawnedLevel + level) >= maxLevelofPets) {
player->sendSystemMessage("Taming this pet would exceed your control level ability.");
return;
}
}
}
if (force && !ghost->isPrivileged())
force = false;
ChatManager* chatManager = player->getZoneServer()->getChatManager();
chatManager->broadcastMessage(player, "@hireling/hireling:taming_1"); // Easy.
Locker clocker(creature);
int mask = creature->getPvpStatusBitmask();
creature->setPvpStatusBitmask(0, true);
if (creature->isAiAgent()) {
AiAgent* agent = cast<AiAgent*>(creature);
agent->activateLoad("wait");
}
ManagedReference<TameCreatureTask*> task = new TameCreatureTask(creature, player, mask, force);
player->addPendingTask("tame_pet", task, 8000);
}
bool LairObserverImplementation::checkForNewSpawns(TangibleObject* lair, TangibleObject* attacker, bool forceSpawn) {
if (lair->getZone() == NULL)
return false;
if (spawnedCreatures.size() >= lairTemplate->getSpawnLimit() && !lairTemplate->hasBossMobs())
return false;
if (forceSpawn) {
spawnNumber++;
} else if (getMobType() == LairTemplate::NPC) {
return false;
} else {
int conditionDamage = lair->getConditionDamage();
int maxCondition = lair->getMaxCondition();
switch (spawnNumber) {
case 0:
spawnNumber++;
break;
case 1:
if (conditionDamage > (maxCondition / 10)) {
spawnNumber++;
} else {
return false;
}
break;
case 2:
if (conditionDamage > (maxCondition / 2)) {
spawnNumber++;
} else {
return false;
}
break;
case 3:
if (lairTemplate->hasBossMobs() && conditionDamage > ((maxCondition * 9) / 10)) {
spawnNumber++;
} else {
return false;
}
break;
default:
return false;
break;
}
}
VectorMap<String, int> objectsToSpawn; // String mobileTemplate, int number to spawn
if (spawnNumber == 4) {
if (System::random(100) > 9)
return false;
VectorMap<String, int>* mobs = lairTemplate->getBossMobiles();
for (int i = 0; i < mobs->size(); i++) {
objectsToSpawn.put(mobs->elementAt(i).getKey(), mobs->elementAt(i).getValue());
}
} else {
Vector<String>* mobiles = lairTemplate->getWeightedMobiles();
int amountToSpawn = 0;
if (getMobType() == LairTemplate::CREATURE) {
amountToSpawn = System::random(3) + ((lairTemplate->getSpawnLimit() / 3) - 2);
} else {
amountToSpawn = System::random(lairTemplate->getSpawnLimit() / 2) + (lairTemplate->getSpawnLimit() / 2);
}
if (amountToSpawn < 1)
amountToSpawn = 1;
for (int i = 0; i < amountToSpawn; i++) {
int num = System::random(mobiles->size() - 1);
String mob = mobiles->get(num);
if (objectsToSpawn.contains(mob)) {
int value = objectsToSpawn.get(mob);
objectsToSpawn.drop(mob);
objectsToSpawn.put(mob, value + 1);
} else {
objectsToSpawn.put(mob, 1);
}
}
}
for(int i = 0; i < objectsToSpawn.size(); ++i) {
if (spawnNumber != 4 && spawnedCreatures.size() >= lairTemplate->getSpawnLimit())
return true;
String templateToSpawn = objectsToSpawn.elementAt(i).getKey();
int numberToSpawn = objectsToSpawn.get(templateToSpawn);
CreatureTemplate* creatureTemplate = CreatureTemplateManager::instance()->getTemplate(templateToSpawn);
if (creatureTemplate == NULL)
continue;
float tamingChance = creatureTemplate->getTame();
CreatureManager* creatureManager = lair->getZone()->getCreatureManager();
for (int j = 0; j < numberToSpawn; j++) {
float x = lair->getPositionX() + (size - System::random(size * 20) / 10.0f);
float y = lair->getPositionY() + (size - System::random(size * 20) / 10.0f);
float z = lair->getZone()->getHeight(x, y);
ManagedReference<CreatureObject*> creo = NULL;
if (creatureManager->checkSpawnAsBaby(tamingChance, babiesSpawned, 500)) {
creo = creatureManager->spawnCreatureAsBaby(templateToSpawn.hashCode(), x, z, y);
babiesSpawned++;
}
if (creo == NULL)
creo = creatureManager->spawnCreatureWithAi(templateToSpawn.hashCode(), x, z, y);
if (creo == NULL)
continue;
if (!creo->isAiAgent()) {
error("spawned non player creature with template " + templateToSpawn);
} else {
AiAgent* ai = cast<AiAgent*>( creo.get());
//Locker clocker(npc, lair);
ai->setDespawnOnNoPlayerInRange(false);
ai->setHomeLocation(x, z, y);
ai->setRespawnTimer(0);
ai->setHomeObject(lair);
spawnedCreatures.add(creo);
}
}
}
if (spawnNumber == 4) {
Reference<LairAggroTask*> task = new LairAggroTask(lair, attacker, _this.get(), true);
task->schedule(1000);
}
return objectsToSpawn.size() > 0;
}
void SpawnAreaMap::loadStaticSpawns() {
String planetName = zone->getZoneName();
LuaObject obj = lua->getGlobalObject(planetName + "_static_spawns");
if (!obj.isValidTable()) {
obj.pop();
return;
}
int count = 0;
int max = obj.getTableSize();
for (int i = 1; i <= obj.getTableSize(); ++i) {
lua_rawgeti(obj.getLuaState(), -1, i);
LuaObject spawn(obj.getLuaState());
if (spawn.isValidTable()) {
CreatureManager* creatureManager = zone->getCreatureManager();
String name = obj.getStringAt(1);
uint32 respawn = obj.getIntAt(2);
float x = obj.getFloatAt(3);
float z = obj.getFloatAt(4);
float y = obj.getFloatAt(5);
float heading = obj.getFloatAt(6);
uint64 parentID = obj.getLongAt(7);
String moodString;
UnicodeString customName;
int junkDealerBuyingType =0;
int junkDealerConversationType =0;
if (obj.getTableSize() > 7)
moodString = obj.getStringAt(8);
if (obj.getTableSize() > 8)
customName = obj.getStringAt(9);
if (obj.getTableSize() > 9)
junkDealerBuyingType = obj.getIntAt(10);
if (obj.getTableSize() > 10)
junkDealerConversationType = obj.getIntAt(11);
if (parentID == 0)
z = zone->getHeight(x, y);
ManagedReference<CreatureObject*> creatureObject = creatureManager->spawnCreature(name.hashCode(), 0, x, z, y, parentID);
if (creatureObject != NULL) {
creatureObject->setDirection(Math::deg2rad(heading));
if (creatureObject->isJunkDealer()){
cast<JunkdealerCreature*>(creatureObject.get())->setJunkDealerConversationType(junkDealerConversationType);
cast<JunkdealerCreature*>(creatureObject.get())->setJunkDealerBuyerType(junkDealerBuyingType);
}
if (!moodString.isEmpty()) {
creatureObject->setMoodString(moodString);
//TODO: remove after fixing commoners
if (moodString == "conversation" || moodString == "calm") {
creatureObject->setPvpStatusBitmask(0);
creatureObject->setCloseObjects(NULL);
}
}
if (!customName.isEmpty())
creatureObject->setCustomObjectName(customName, true);
if (creatureObject->isAiAgent()) {
AiAgent* ai = cast<AiAgent*>( creatureObject.get());
ai->setRespawnTimer(respawn);
}
if (name.contains("trainer_")) {
Vector3 coords(creatureObject.get()->getWorldPositionX(), creatureObject.get()->getWorldPositionY(), 0);
trainerObjects.add(coords);
}
} else {
StringBuffer msg;
msg << "could not spawn mobile: " + name;
error(msg.toString());
}
}
spawn.pop();
if (ConfigManager::instance()->isProgressMonitorActivated())
printf("\r\tLoading static spawns: [%d] / [%d]\t", ++count, max);
}
obj.pop();
//--{"mobile", x, z, y, degrees heading, parentID}
//spawnCreature(uint32 templateCRC, uint32 objectCRC, float x, float z, float y, uint64 parentID)
}
bool FactionRecruiterContainerComponent::transferObject(SceneObject* sceneObject, SceneObject* object, int containmentType, bool notifyClient, bool allowOverflow) {
CoaMessageDataComponent* data = object->getDataObjectComponent()->castTo<CoaMessageDataComponent*>();
if (data == NULL) {
return false;
}
CreatureObject* player = object->getParentRecursively(SceneObjectType::PLAYERCREATURE).get().castTo<CreatureObject*>();
if (player == NULL) {
return false;
}
ZoneServer* zoneServer = player->getZoneServer();
PlayerObject* ghost = player->getPlayerObject();
if (zoneServer == NULL || ghost == NULL) {
return false;
}
if (!sceneObject->isAiAgent()) {
return false;
}
AiAgent* recruiter = cast<AiAgent*>(sceneObject);
String recruiterFaction = recruiter->getFactionString().toLowerCase();
bool hasBadge = ghost->hasBadge(Badge::EVENT_PROJECT_DEAD_EYE_1);
String faction = data->getFaction().toLowerCase();
StringBuffer response;
response << "@encoded_disk/message_fragment:response_event";
if (faction == "rebel") {
response << "reb1_";
} else if (faction == "imperial") {
response << "imp1_";
}
response << recruiterFaction;
ChatManager* chatManager = zoneServer->getChatManager();
if (chatManager == NULL) {
return false;
}
Locker locker(recruiter);
chatManager->broadcastMessage(recruiter,response.toString(), 0, 0, 0);
object->destroyObjectFromWorld(true);
object->destroyObjectFromDatabase();
int credits = System::random(500) + 500;
player->sendSystemMessage("You receive " + String::valueOf(credits) + " credits.");
player->addCashCredits(credits, true);
if (!hasBadge) {
ghost->awardBadge(Badge::EVENT_PROJECT_DEAD_EYE_1);
ghost->increaseFactionStanding(recruiterFaction, 500);
}
return true;
}
int ContainerImplementation::canAddObject(SceneObject* object, int containmentType, String& errorDescription) {
// if (locked)
// return TransferErrorCode::CONTAINERLOCKED;
if ((object->isIntangibleObject() && getContainerType() != 3)
|| (getContainerType() == 3 && !object->isIntangibleObject())) {
errorDescription = "@container_error_message:container07"; // You cannot put that kind of item in that kind of container.
return TransferErrorCode::INVALIDTYPE;
}
if (containmentType == -1) {
if ((gameObjectType == SceneObjectType::WEARABLECONTAINER && object->getGameObjectType() == SceneObjectType::WEARABLECONTAINER)) {
errorDescription = "@container_error_message:container12"; // This item is too bulky to fit inside this container.
return TransferErrorCode::CANTNESTOBJECT;
}
if (object->isContainerObject() && getArrangementDescriptorSize() == 0) {
errorDescription = "@container_error_message:container12"; // This item is too bulky to fit inside this container.
return TransferErrorCode::CANTNESTOBJECT;
}
// Find out how much room we need
int objectSize;
if (object->isContainerObject())
objectSize = object->getContainerObjectsSize() + 1;
else
objectSize = 1;
// Return if there's not enough room in the container
if (getContainerVolumeLimit() < getCountableObjectsRecursive() + objectSize) {
errorDescription = "@container_error_message:container03"; // This container is full.
return TransferErrorCode::CONTAINERFULL;
}
ManagedReference<SceneObject*> wearableParent = getParentRecursively(SceneObjectType::WEARABLECONTAINER);
ManagedReference<SceneObject*> playerParent = getParentRecursively(SceneObjectType::PLAYERCREATURE);
// If there's a wearable container parent, return if it doesn't have enough room
if (wearableParent != NULL) {
if (wearableParent->getContainerVolumeLimit() < wearableParent->getCountableObjectsRecursive() + objectSize) {
errorDescription = "@container_error_message:container03"; // This container is full.
return TransferErrorCode::CONTAINERFULL;
}
// It has room. Check if it's not equipped and on a player.
ManagedReference<WearableContainerObject*> wearable = cast<WearableContainerObject*>(wearableParent.get());
if (!wearable->isEquipped() && playerParent != NULL) {
SceneObject* inventory = playerParent->getSlottedObject("inventory");
SceneObject* bank = playerParent->getSlottedObject("bank");
SceneObject* parentOfWearableParent = wearable->getParent().get();
// Return if it's in a player inventory which doesn't have room
if (parentOfWearableParent == inventory) {
if (inventory->getContainerVolumeLimit() < inventory->getCountableObjectsRecursive() + objectSize) {
errorDescription = "@error_message:inv_full"; // Your inventory is full.
return TransferErrorCode::CONTAINERFULL;
}
// Return if it's in a player bank that doesn't have room
} else if (parentOfWearableParent == bank) {
if (bank->getContainerVolumeLimit() < bank->getCountableObjectsRecursive() + objectSize) {
errorDescription = "@container_error_message:container03"; // This container is full.
return TransferErrorCode::CONTAINERFULL;
}
}
}
} else {
// There's no parent that's a wearable container. Check if this is
if (gameObjectType == SceneObjectType::WEARABLECONTAINER) {
WearableContainerObject* pack = cast<WearableContainerObject*>(_this.getReferenceUnsafeStaticCast());
if (pack != NULL && !pack->isEquipped()) {
// This is a wearable container, and it's not equipped.
if (playerParent != NULL ) {
SceneObject* inventory = playerParent->getSlottedObject("inventory");
SceneObject* bank = playerParent->getSlottedObject("bank");
SceneObject* thisParent = getParent().get();
// Return if the container is in a player inventory without room
if (thisParent == inventory) {
if (inventory->getContainerVolumeLimit() < inventory->getCountableObjectsRecursive() + objectSize) {
errorDescription = "@error_message:inv_full"; // Your inventory is full.
return TransferErrorCode::CONTAINERFULL;
}
// Return if it's in a player bank that doesn't have room
} else if (thisParent == bank) {
if (bank->getContainerVolumeLimit() < bank->getCountableObjectsRecursive() + objectSize) {
errorDescription = "@container_error_message:container03"; // This container is full.
return TransferErrorCode::CONTAINERFULL;
}
}
}
}
} else {
// This is a non-wearable container.
if (playerParent != NULL ) {
SceneObject* inventory = playerParent->getSlottedObject("inventory");
SceneObject* bank = playerParent->getSlottedObject("bank");
SceneObject* thisParent = getParent().get();
// Return if the container is in a player inventory without room
if (thisParent == inventory) {
if (inventory->getContainerVolumeLimit() < inventory->getCountableObjectsRecursive() + objectSize) {
errorDescription = "@error_message:inv_full"; // Your inventory is full.
return TransferErrorCode::CONTAINERFULL;
}
// Return if it's in a player bank that doesn't have room
} else if (thisParent == bank) {
if (bank->getContainerVolumeLimit() < bank->getCountableObjectsRecursive() + objectSize) {
errorDescription = "@container_error_message:container03"; // This container is full.
return TransferErrorCode::CONTAINERFULL;
}
}
}
}
}
// Check if the container is in a building or factory ingredient hopper
if (playerParent == NULL) {
ManagedReference<SceneObject*> rootParent = getRootParent();
if (rootParent != NULL) {
if (rootParent->isBuildingObject()) {
BuildingObject* building = rootParent.castTo<BuildingObject*>();
if (!building->isStaticBuilding() && (building->getCurrentNumberOfPlayerItems() + objectSize > building->getMaximumNumberOfPlayerItems())) {
errorDescription = "@container_error_message:container13"; // This house has too many items in it
return TransferErrorCode::TOOMANYITEMSINHOUSE;
}
} else if (rootParent->isFactory()) {
FactoryObject* factory = rootParent.castTo<FactoryObject*>();
SceneObject* hopper = factory->getSlottedObject("ingredient_hopper");
if (hopper->getContainerVolumeLimit() < hopper->getCountableObjectsRecursive() + objectSize) {
errorDescription = "@container_error_message:container03"; // This container is full.
return TransferErrorCode::CONTAINERFULL;
}
}
}
}
ManagedReference<SceneObject*> myParent = getParent();
ManagedReference<SceneObject*> otherParent = object->getParent();
if (myParent != NULL && otherParent != NULL) {
if (otherParent->isCreatureObject()) {
AiAgent* ai = dynamic_cast<AiAgent*>(otherParent.get());
if (ai != NULL) {
SceneObject* creatureInventory = ai->getSlottedObject("inventory");
if (creatureInventory != NULL) {
uint64 lootOwnerID = creatureInventory->getContainerPermissions()->getOwnerID();
if (lootOwnerID != myParent->getObjectID()) {
errorDescription = "@group:no_loot_permission";
return TransferErrorCode::NOLOOTPERMISSION;
}
}
}
}
}
}
return TangibleObjectImplementation::canAddObject(object, containmentType, errorDescription);
}
int PetMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) {
if (!sceneObject->isPet() || player == NULL)
return 0;
AiAgent* pet = cast<AiAgent*>(sceneObject);
if (!player->getPlayerObject()->isPrivileged() && pet->getLinkedCreature().get() != player)
return 0;
Locker crossLocker(pet, player);
ManagedReference<PetControlDevice*> petControlDevice = pet->getControlDevice().get().castTo<PetControlDevice*>();
if (petControlDevice == NULL)
return 0;
PetManager* petManager = pet->getZoneServer()->getPetManager();
if (petManager == NULL)
return 0;
Locker locker(petControlDevice);
// Store
if (selectedID == 59) {
if (pet->getLinkedCreature() != player) {
ManagedReference<CreatureObject*> owner = pet->getLinkedCreature().get();
if (owner != NULL) {
Reference<PetControlDeviceStoreObjectTask*> task = new PetControlDeviceStoreObjectTask(petControlDevice, owner, true);
task->execute();
}
} else {
petControlDevice->storeObject(player);
}
return 0;
}
if (pet->getLinkedCreature().get() != player)
return 0;
switch(selectedID) {
case 142: // Train Command: Follow
petControlDevice->setTrainingCommand( PetManager::FOLLOW );
break;
case 143: // Train Command: Stay
petControlDevice->setTrainingCommand( PetManager::STAY );
break;
case 144: // Train Command: Guard
petControlDevice->setTrainingCommand( PetManager::GUARD );
break;
case 145: // Train Command: Friend
petControlDevice->setTrainingCommand( PetManager::FRIEND );
break;
case 146: // Train Command: Attack
petControlDevice->setTrainingCommand( PetManager::ATTACK );
break;
case 147: // Train Command: Patrol
petControlDevice->setTrainingCommand( PetManager::PATROL );
break;
case 148: // Train Command: Get Patrol Point
petControlDevice->setTrainingCommand( PetManager::GETPATROLPOINT );
break;
case 149: // Train Command: Clear Patrol Points
petControlDevice->setTrainingCommand( PetManager::CLEARPATROLPOINTS );
break;
case 150: // Train Command: Wedge Formation
petControlDevice->setTrainingCommand( PetManager::FORMATION1 );
break;
case 151: // Train Command: Column Formation
petControlDevice->setTrainingCommand( PetManager::FORMATION2 );
break;
case 152: // Train Command: Transfer
petControlDevice->setTrainingCommand( PetManager::TRANSFER );
break;
case 154: // Train Command: Trick 1
petControlDevice->setTrainingCommand( PetManager::TRICK1 );
break;
case 155: // Train Command: Trick 2
petControlDevice->setTrainingCommand( PetManager::TRICK2 );
break;
case 158: // Train Command: Group
petControlDevice->setTrainingCommand( PetManager::GROUP );
break;
case 161: // Train Command: Special Attack 1
petControlDevice->setTrainingCommand( PetManager::SPECIAL_ATTACK1 );
break;
case 162: // Train Command: Special Attack 2
petControlDevice->setTrainingCommand( PetManager::SPECIAL_ATTACK2 );
break;
case 163: // Train Command: Ranged Attack
petControlDevice->setTrainingCommand( PetManager::RANGED_ATTACK );
break;
case 164: // Train Command: Store
petControlDevice->setTrainingCommand( PetManager::STORE );
break;
case 165: // Train Command: Follow Other
petControlDevice->setTrainingCommand( PetManager::FOLLOWOTHER );
break;
case 166: // Incapacitation Recovery
petManager->enqueueOwnerOnlyPetCommand(player, pet, String("petRecover").toLowerCase().hashCode(), "");
break;
case 207: // Train Pet As A Mount
if (petControlDevice->getPetType() != PetManager::CREATUREPET) {
return 0;
}
petControlDevice->trainAsMount(player);
break;
case 234: // Recharge/Feed
if (petControlDevice->getPetType() == PetManager::DROIDPET) {
petManager->enqueueOwnerOnlyPetCommand(player, pet, String("petRecharge").toLowerCase().hashCode(), "");
} else if (petControlDevice->getPetType() == PetManager::CREATUREPET) {
petManager->enqueueOwnerOnlyPetCommand(player, pet, String("petFeed").toLowerCase().hashCode(), "");
}
break;
case 235: // Train Command: Recharge Other
petControlDevice->setTrainingCommand( PetManager::RECHARGEOTHER );
break;
default:
break;
}
return 0;
}
void PetMenuComponent::fillObjectMenuResponse(SceneObject* sceneObject, ObjectMenuResponse* menuResponse, CreatureObject* player) {
if (!sceneObject->isPet())
return;
AiAgent* pet = cast<AiAgent*>(sceneObject);
if (pet->getGroup() != NULL) {
ManagedReference<GroupObject*> group = player->getGroup();
if (group == pet->getGroup()) {
if (group->getLeader() == player) {
menuResponse->addRadialMenuItem(40, 3, "@ui_radial:group_kick"); // Kick from Group
menuResponse->addRadialMenuItemToRadialID(40, 41, 3, "@ui_radial:group_disband" ); // Disband Group
} else {
menuResponse->addRadialMenuItem(39, 3, "@ui_radial:group_leave"); // Leave Group
}
}
}
if (pet->isIncapacitated() && pet->isAttackableBy(player))
menuResponse->addRadialMenuItem(6, 3, "@ui_radial:combat_death_blow"); // Death Blow
if (!player->getPlayerObject()->isPrivileged() && pet->getLinkedCreature() != player) {
return;
}
menuResponse->addRadialMenuItem(59, 3, "@pet/pet_menu:menu_store"); // Store
if (pet->getLinkedCreature().get() != player)
return;
ManagedReference<PetControlDevice*> controlDevice = pet->getControlDevice().get().castTo<PetControlDevice*>();
if( controlDevice == NULL )
return;
PetManager* petManager = pet->getZoneServer()->getPetManager();
if (petManager == NULL)
return;
// DROIDS
if( controlDevice->getPetType() == PetManager::DROIDPET ){
ManagedReference<DroidObject*> droidObject = dynamic_cast<DroidObject*>(controlDevice->getControlledObject());
bool conversingDroid = (pet->getOptionsBitmask() & OptionBitmask::CONVERSE);
if(conversingDroid) {
menuResponse->addRadialMenuItem(132, 3, "@pet/pet_menu:droid_options"); // SERVER_ITEM_OPTIONS
menuResponse->addRadialMenuItemToRadialID(132, 234, 3, "@pet/pet_menu:menu_recharge" ); // PET_FEED
// convsering droids have less re-programmable commands
} else {
menuResponse->addRadialMenuItem(132, 3, "@pet/pet_menu:droid_options"); // SERVER_ITEM_OPTIONS
menuResponse->addRadialMenuItemToRadialID(132, 234, 3, "@pet/pet_menu:menu_recharge" ); // PET_FEED
menuResponse->addRadialMenuItem(141, 3, "@pet/pet_menu:menu_command_droid"); // PET_COMMAND
menuResponse->addRadialMenuItemToRadialID(141, 142, 3, "@pet/pet_menu:menu_follow" ); // PET_FOLLOW
menuResponse->addRadialMenuItemToRadialID(141, 143, 3, "@pet/pet_menu:menu_stay" ); // PET_STAY
if (droidObject != NULL && droidObject->isCombatDroid())
menuResponse->addRadialMenuItemToRadialID(141, 144, 3, "@pet/pet_menu:menu_guard" ); // PET_GUARD
menuResponse->addRadialMenuItemToRadialID(141, 145, 3, "@pet/pet_menu:menu_friend" ); // PET_FRIEND
if (droidObject != NULL && droidObject->isCombatDroid())
menuResponse->addRadialMenuItemToRadialID(141, 146, 3, "@pet/pet_menu:menu_attack" ); // PET_ATTACK
menuResponse->addRadialMenuItemToRadialID(141, 147, 3, "@pet/pet_menu:menu_patrol" ); // PET_PATROL
menuResponse->addRadialMenuItemToRadialID(141, 148, 3, "@pet/pet_menu:menu_get_patrol_point" ); // PET_GET_PATROL_POINT
menuResponse->addRadialMenuItemToRadialID(141, 149, 3, "@pet/pet_menu:menu_clear_patrol_points" ); // PET_CLEAR_PATROL_POINTS
menuResponse->addRadialMenuItemToRadialID(141, 150, 3, "@pet/pet_menu:menu_assume_formation_1" ); // PET_ASSUME_FORMATION_1
menuResponse->addRadialMenuItemToRadialID(141, 151, 3, "@pet/pet_menu:menu_assume_formation_2" ); // PET_ASSUME_FORMATION_2
menuResponse->addRadialMenuItemToRadialID(141, 158, 3, "@pet/pet_menu:menu_group" ); // PET_GROUP
if (droidObject != NULL && droidObject->isCombatDroid() && droidObject->hasRangedWeapon())
menuResponse->addRadialMenuItemToRadialID(141, 163, 3, "@pet/pet_menu:menu_ranged_attack" );
menuResponse->addRadialMenuItemToRadialID(141, 164, 3, "@pet/pet_menu:menu_store" );
menuResponse->addRadialMenuItemToRadialID(141, 165, 3, "@pet/pet_menu:menu_follow_other" );
if( droidObject != NULL && droidObject->isPowerDroid() ){
menuResponse->addRadialMenuItemToRadialID(141, 235, 3, "@pet/pet_menu:menu_recharge_other" );
}
}
if( pet->isIncapacitated() ){
menuResponse->addRadialMenuItem(166, 3, "@pet/pet_menu:awaken" );
}
}
// FACTION
else if( controlDevice->getPetType() == PetManager::FACTIONPET ){
// future, if conversion do as droid objects above and not add this menu at all.
//bool conversingPet = (pet->getOptionsBitmask() & OptionBitmask::CONVERSE);
menuResponse->addRadialMenuItem(141, 3, "@pet/pet_menu:menu_command"); // PET_COMMAND
menuResponse->addRadialMenuItemToRadialID(141, 142, 3, "@pet/pet_menu:menu_follow" ); // PET_FOLLOW
menuResponse->addRadialMenuItemToRadialID(141, 143, 3, "@pet/pet_menu:menu_stay" ); // PET_STAY
menuResponse->addRadialMenuItemToRadialID(141, 144, 3, "@pet/pet_menu:menu_guard" ); // PET_GUARD
menuResponse->addRadialMenuItemToRadialID(141, 145, 3, "@pet/pet_menu:menu_friend" ); // PET_FRIEND
menuResponse->addRadialMenuItemToRadialID(141, 146, 3, "@pet/pet_menu:menu_attack" ); // PET_ATTACK
menuResponse->addRadialMenuItemToRadialID(141, 147, 3, "@pet/pet_menu:menu_patrol" ); // PET_PATROL
menuResponse->addRadialMenuItemToRadialID(141, 148, 3, "@pet/pet_menu:menu_get_patrol_point" ); // PET_GET_PATROL_POINT
menuResponse->addRadialMenuItemToRadialID(141, 149, 3, "@pet/pet_menu:menu_clear_patrol_points" ); // PET_CLEAR_PATROL_POINTS
menuResponse->addRadialMenuItemToRadialID(141, 150, 3, "@pet/pet_menu:menu_assume_formation_1" ); // PET_ASSUME_FORMATION_1
menuResponse->addRadialMenuItemToRadialID(141, 151, 3, "@pet/pet_menu:menu_assume_formation_2" ); // PET_ASSUME_FORMATION_2
menuResponse->addRadialMenuItemToRadialID(141, 158, 3, "@pet/pet_menu:menu_group" ); // PET_GROUP
menuResponse->addRadialMenuItemToRadialID(141, 163, 3, "@pet/pet_menu:menu_ranged_attack" );
menuResponse->addRadialMenuItemToRadialID(141, 164, 3, "@pet/pet_menu:menu_store" );
menuResponse->addRadialMenuItemToRadialID(141, 165, 3, "@pet/pet_menu:menu_follow_other" );
if( pet->isIncapacitated() ){
menuResponse->addRadialMenuItem(166, 3, "@pet/pet_menu:awaken" );
}
}
// CREATURES
else if( controlDevice->getPetType() == PetManager::CREATUREPET ){
menuResponse->addRadialMenuItem(234, 3, "@pet/pet_menu:menu_feed" ); // PET_FEED
menuResponse->addRadialMenuItem(141, 3, "@pet/pet_menu:menu_command"); // PET_COMMAND
if( player->hasSkill( "outdoors_creaturehandler_novice" ) ){
menuResponse->addRadialMenuItemToRadialID(141, 142, 3, "@pet/pet_menu:menu_follow" ); // PET_FOLLOW
menuResponse->addRadialMenuItemToRadialID(141, 146, 3, "@pet/pet_menu:menu_attack" ); // PET_ATTACK
menuResponse->addRadialMenuItemToRadialID(141, 164, 3, "@pet/pet_menu:menu_store" );
}
if( player->hasSkill( "outdoors_creaturehandler_training_01" ) ){
menuResponse->addRadialMenuItemToRadialID(141, 143, 3, "@pet/pet_menu:menu_stay" ); // PET_STAY
}
if( player->hasSkill( "outdoors_creaturehandler_training_02" ) ){
menuResponse->addRadialMenuItemToRadialID(141, 144, 3, "@pet/pet_menu:menu_guard" ); // PET_GUARD
}
if( player->hasSkill( "outdoors_creaturehandler_training_03" ) ){
menuResponse->addRadialMenuItemToRadialID(141, 147, 3, "@pet/pet_menu:menu_patrol" ); // PET_PATROL
menuResponse->addRadialMenuItemToRadialID(141, 148, 3, "@pet/pet_menu:menu_get_patrol_point" ); // PET_GET_PATROL_POINT
menuResponse->addRadialMenuItemToRadialID(141, 149, 3, "@pet/pet_menu:menu_clear_patrol_points" ); // PET_CLEAR_PATROL_POINTS
}
if( player->hasSkill( "outdoors_creaturehandler_training_04" ) ){
menuResponse->addRadialMenuItemToRadialID(141, 150, 3, "@pet/pet_menu:menu_assume_formation_1" ); // PET_ASSUME_FORMATION_1
menuResponse->addRadialMenuItemToRadialID(141, 151, 3, "@pet/pet_menu:menu_assume_formation_2" ); // PET_ASSUME_FORMATION_2
}
if( player->hasSkill( "outdoors_creaturehandler_healing_01" ) ){
menuResponse->addRadialMenuItemToRadialID(141, 154, 3, "@pet/pet_menu:menu_trick_1" ); // PET_TRICK_1
}
if( player->hasSkill( "outdoors_creaturehandler_healing_03" ) ){
menuResponse->addRadialMenuItemToRadialID(141, 155, 3, "@pet/pet_menu:menu_trick_2" ); // PET_TRICK_2
}
if( player->hasSkill( "outdoors_creaturehandler_support_01" ) ){
menuResponse->addRadialMenuItemToRadialID(141, 158, 3, "@pet/pet_menu:menu_group" ); // PET_GROUP
}
if( player->hasSkill( "outdoors_creaturehandler_support_02" ) ){
menuResponse->addRadialMenuItemToRadialID(141, 165, 3, "@pet/pet_menu:menu_follow_other" );
}
if( player->hasSkill( "outdoors_creaturehandler_support_03" ) ){
menuResponse->addRadialMenuItemToRadialID(141, 145, 3, "@pet/pet_menu:menu_friend" ); // PET_FRIEND
}
if( player->hasSkill( "outdoors_creaturehandler_taming_03" ) && pet->hasSpecialAttack(1) ){
menuResponse->addRadialMenuItemToRadialID(141, 161, 3, "@pet/pet_menu:menu_specialattack_one" ); // PET_SPECIAL_ATTACK_ONE
}
if( player->hasSkill( "outdoors_creaturehandler_taming_04" ) && pet->hasSpecialAttack(2) ){
menuResponse->addRadialMenuItemToRadialID(141, 162, 3, "@pet/pet_menu:menu_specialattack_two" ); // PET_SPECIAL_ATTACK_TWO
}
if( player->hasSkill( "outdoors_creaturehandler_master" ) ){
if (pet->hasRangedWeapon()) {
menuResponse->addRadialMenuItemToRadialID(141, 163, 3, "@pet/pet_menu:menu_ranged_attack" );
}
menuResponse->addRadialMenuItemToRadialID(141, 152, 3, "@pet/pet_menu:menu_transfer" ); // PET_TRANSFER
}
if( player->hasSkill( "outdoors_creaturehandler_support_04") && !controlDevice->isTrainedAsMount() && petManager->checkMountEligibility(controlDevice) == PetManager::CANBEMOUNTTRAINED){
menuResponse->addRadialMenuItemToRadialID(141, 207, 3, "@pet/pet_menu:menu_train_mount" ); // Train Pet As A Mount
}
if( pet->isIncapacitated() ){
menuResponse->addRadialMenuItem(166, 3, "@pet/pet_menu:awaken" );
}
if (controlDevice->isTrainedAsMount() && !pet->isDead() && !pet->isIncapacitated()) {
Reference<SceneObject*> rider = pet->getSlottedObject("rider");
if (rider == NULL) {
menuResponse->addRadialMenuItem(205, 3, "@pet/pet_menu:menu_mount"); // Climb Aboard Pet
} else {
menuResponse->addRadialMenuItem(206, 3, "@pet/pet_menu:menu_dismount"); // Climb Off Of Pet
}
}
}
}
void ChatManagerImplementation::broadcastMessage(CreatureObject* player, const UnicodeString& message, uint64 target, uint32 moodid, uint32 mood2) {
Zone* zone = player->getZone();
PlayerObject* myGhost = NULL;
bool godMode = false;
if (zone == NULL)
return;
int language = 0;
String firstName;
if (player->isPlayerCreature() /*|| !((Player *)player)->isChatMuted() */) {
CreatureObject* playerCreature = cast<CreatureObject*>(player);
if (playerCreature)
{
firstName = playerCreature->getFirstName().toLowerCase();
myGhost = playerCreature->getPlayerObject();
}
if (myGhost)
language = myGhost->getLanguageID();
}
if (myGhost)
{
if (myGhost->hasGodMode())
godMode = true;
}
StringIdChatParameter* param = NULL;
if (message[0] == '@' && message.indexOf(":") != -1) {
param = new StringIdChatParameter(message.toString());
}
CloseObjectsVector* closeObjects = (CloseObjectsVector*) player->getCloseObjects();
SortedVector<QuadTreeEntry*> closeEntryObjects(200, 50);
if (closeObjects != NULL) {
closeObjects->safeCopyTo(closeEntryObjects);
} else {
player->info("Null closeobjects vector in ChatManager::broadcastMessage", true);
zone->getInRangeObjects(player->getWorldPositionX(), player->getWorldPositionY(), 128, &closeEntryObjects, true);
}
float range = defaultSpatialChatDistance;
float specialRange = spatialChatDistances.get(mood2);
if (specialRange != -1) {
range = specialRange;
}
try {
for (int i = 0; i < closeEntryObjects.size(); ++i) {
SceneObject* object = cast<SceneObject*>(closeEntryObjects.get(i));
if (player->isInRange(object, range)) {
//Notify observers that are expecting spatial chat.
if (object->getObserverCount(ObserverEventType::SPATIALCHATRECEIVED)) {
ManagedReference<ChatMessage*> chatMessage = new ChatMessage();
chatMessage->setString(message.toString());
EXECUTE_TASK_3(object, chatMessage, player, {
if (player_p == NULL || object_p == NULL)
return;
Locker locker(object_p);
SortedVector<ManagedReference<Observer*> > observers = object_p->getObservers(ObserverEventType::SPATIALCHATRECEIVED);
for (int oc = 0; oc < observers.size(); oc++) {
Observer* observer = observers.get(oc);
Locker clocker(observer, object_p);
if (observer->notifyObserverEvent(ObserverEventType::SPATIALCHATRECEIVED, object_p, chatMessage_p, player_p->getObjectID()) == 1)
object_p->dropObserver(ObserverEventType::SPATIALCHATRECEIVED, observer);
}
});
}
if (object->isPlayerCreature()) {
CreatureObject* creature = cast<CreatureObject*>(object);
PlayerObject* ghost = creature->getPlayerObject();
if (ghost == NULL)
continue;
if (!ghost->isIgnoring(firstName) || godMode) {
SpatialChat* cmsg = NULL;
if (param == NULL) {
cmsg = new SpatialChat(player->getObjectID(), creature->getObjectID(), message, target, moodid, mood2, language);
} else {
cmsg = new SpatialChat(player->getObjectID(), creature->getObjectID(), *param, target, moodid, mood2);
}
creature->sendMessage(cmsg);
}
}
else if( object->isPet() ){
AiAgent* pet = cast<AiAgent*>(object);
if (pet == NULL )
continue;
if( pet->isDead() || pet->isIncapacitated() )
continue;
PetManager* petManager = server->getPetManager();
Locker clocker(pet, player);
petManager->handleChat( player, pet, message.toString() );
}
}
}
void PetControlDeviceImplementation::spawnObject(CreatureObject* player) {
ZoneServer* zoneServer = getZoneServer();
ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get();
if (controlledObject == NULL)
return;
assert(controlledObject->isLockedByCurrentThread());
if (!isASubChildOf(player))
return;
ManagedReference<TradeSession*> tradeContainer = player->getActiveSession(SessionFacadeType::TRADE).castTo<TradeSession*>();
if (tradeContainer != NULL) {
server->getZoneServer()->getPlayerManager()->handleAbortTradeMessage(player);
}
controlledObject->initializePosition(player->getPositionX(), player->getPositionZ(), player->getPositionY());
ManagedReference<CreatureObject*> creature = NULL;
if (controlledObject->isCreatureObject()) {
creature = cast<CreatureObject*>(controlledObject.get());
creature->setCreatureLink(player);
creature->setControlDevice(_this.getReferenceUnsafeStaticCast());
creature->setFaction(player->getFaction());
creature->setObjectMenuComponent("PetMenuComponent");
if (player->getPvpStatusBitmask() & CreatureFlag::PLAYER)
creature->setPvpStatusBitmask(player->getPvpStatusBitmask() - CreatureFlag::PLAYER, true);
else
creature->setPvpStatusBitmask(player->getPvpStatusBitmask(), true);
if (trainedAsMount && (creature->getOptionsBitmask() ^ 0x1000)) {
creature->setOptionBit(0x1000);
}
}
Zone* zone = player->getZone();
if (zone == NULL)
return;
ManagedReference<CellObject*> parent = player->getParent().get().castTo<CellObject*>();
if (parent != NULL)
parent->transferObject(controlledObject, -1, true);
else
zone->transferObject(controlledObject, -1, true);
updateStatus(1);
if (petControlObserver != NULL)
player->dropObserver(ObserverEventType::STARTCOMBAT, petControlObserver);
AiAgent* pet = cast<AiAgent*>(creature.get());
if (pet == NULL)
return;
ManagedReference<PlayerObject*> ghost = player->getPlayerObject();
ghost->addToActivePets(pet);
bool isDroid = false;
if (pet->isDroidObject()) {
DroidObject* droid = cast<DroidObject*>(pet);
isDroid = true;
if( droid == NULL )
return;
// Sanity check that there aren't outstanding power/skill mod tasks
droid->removePendingTask( "droid_power" );
droid->removePendingTask( "droid_skill_mod" );
droid->initDroidModules();
droid->onCall();
droid->loadSkillMods(player);
// Submit new power task
Reference<Task*> droidPowerTask = new DroidPowerTask( droid );
droid->addPendingTask("droid_power", droidPowerTask, 120000); // 2 min
// Submit new skill mod task
Reference<Task*> droidSkillModTask = new DroidSkillModTask( droid, player );
droid->addPendingTask("droid_skill_mod", droidSkillModTask, 3000); // 3 sec
}
pet->setHomeLocation(player->getPositionX(), player->getPositionZ(), player->getPositionY(), parent);
pet->setNextStepPosition(player->getPositionX(), player->getPositionZ(), player->getPositionY(), parent);
pet->clearPatrolPoints();
if (petType == PetManager::CREATUREPET) {
pet->setCreatureBitmask(CreatureFlag::PET);
}
if (petType == PetManager::DROIDPET) {
pet->setCreatureBitmask(CreatureFlag::DROID_PET);
}
if (petType == PetManager::FACTIONPET) {
pet->setCreatureBitmask(CreatureFlag::FACTION_PET);
/** dont know if npc faction pets trained via converse instead of radial
if (pet->isNonPlayerCreatureObject() && pet->getDiet() != CreatureFlag::NONE) // show converse to npcs that eat food i.e. not atst
pet->setOptionBit(OptionBitmask::CONVERSE,true);
**/
}
pet->activateLoad("");
pet->activateRecovery();
// Not training any commands
trainingCommand = 0;
clearPatrolPoints();
}