TEST_F(LuaMobileTest, LuaMobileTemplatesTest) {
CreatureTemplateManager::DEBUG_MODE = 1;
// Verify that all mobiles load
ASSERT_EQ(CreatureTemplateManager::instance()->loadTemplates(), 0);
// Verify loot group map loaded
ASSERT_EQ(LootGroupMap::ERROR_CODE, 0);
// Verify factions load
FactionManager::instance()->loadData();
ASSERT_FALSE(FactionManager::instance()->getFactionMap()->isEmpty());
// Load Templates
ASSERT_TRUE( TemplateManager::instance() != NULL );
if( TemplateManager::instance()->loadedTemplatesCount == 0 ){
TemplateManager::instance()->loadLuaTemplates();
ASSERT_EQ(TemplateManager::ERROR_CODE, 0);
}
// verify DNA manager loads
DnaManager::instance()->loadSampleData();
ASSERT_TRUE( DnaManager::instance() != NULL);
// Test Creature Templates
HashTableIterator<uint32, Reference<CreatureTemplate*> > creatureIterator = CreatureTemplateManager::instance()->iterator();
while (creatureIterator.hasNext()) {
CreatureTemplate* creature = creatureIterator.next();
std::string templateName( creature->getTemplateName().toCharArray() );
//Verify non-empty objectName is a valid string
String objName = creature->getObjectName();
if (!objName.isEmpty()) {
std::string name = objName.toCharArray();
EXPECT_TRUE( mobNames.contains(objName) ) << "Mobile " << templateName << " has invalid objectName: " << name;
}
// Check configured templates
Vector<String> objTemps = creature->getTemplates();
EXPECT_FALSE( objTemps.isEmpty() ) << "Mobile " << templateName << " does not have any templates configured";
int objectType = 0;
for( int j=0; j< objTemps.size(); j++ ){
SharedObjectTemplate* templateData = templateManager->getTemplate(objTemps.get(j).hashCode());
std::string objName = objTemps.get(j).toCharArray();
EXPECT_TRUE( templateData != NULL ) << "Mobile " << templateName << " has invalid template configured: " << objName;
// Check Template Genetics math to find invalid mobs
if (templateData != NULL) {
SharedCreatureObjectTemplate* creoData = dynamic_cast<SharedCreatureObjectTemplate*> (templateData);
if (creoData != NULL) {
}
}
if (objectType == 0) {
objectType = templateData->getGameObjectType();
}
}
// Verify that control device template is valid
String controlDeviceTemplate = creature->getControlDeviceTemplate();
if (!controlDeviceTemplate.isEmpty()) {
SharedObjectTemplate* controlDeviceTemplateData = templateManager->getTemplate(controlDeviceTemplate.hashCode());
EXPECT_TRUE( controlDeviceTemplateData != NULL ) << "Control device template " << controlDeviceTemplate.toCharArray() << " from " << templateName << " does not exist.";
EXPECT_TRUE( controlDeviceTemplate.beginsWith("object/intangible/pet/") ) << "Control device template " << controlDeviceTemplate.toCharArray() << " from " << templateName << " is not a pet/droid control device template.";
}
// Verify that faction is valid
String faction = creature->getFaction();
if (!faction.isEmpty()) {
EXPECT_TRUE( FactionManager::instance()->isFaction(faction) ) << "Faction, " << faction.toCharArray() << ", from mobile template " << templateName << " does not exist.";
}
// Verify level
int level = creature->getLevel();
EXPECT_TRUE( level > 0 ) << "Level is not a positive value on mobile: " << templateName;
// Verify hit chance
float hitChance = creature->getChanceHit();
EXPECT_TRUE( hitChance > 0 ) << "ChanceHit is not a positive value on mobile: " << templateName;
// Verify xp
int xp = creature->getBaseXp();
EXPECT_TRUE( xp >= 0 ) << "Xp has a negative value on mobile: " << templateName;
// Verify damage
int minDamage = creature->getDamageMin();
int maxDamage = creature->getDamageMax();
EXPECT_TRUE( minDamage > 0 ) << "Min damage is not a positive value on mobile: " << templateName;
EXPECT_TRUE( maxDamage >= minDamage ) << "Max damage is lower than min damage on mobile: " << templateName;
// Verify HAM
int minHam = creature->getBaseHAM();
int maxHam = creature->getBaseHAMmax();
EXPECT_TRUE( minHam > 0 ) << "Base ham is not a positive value on mobile: " << templateName;
EXPECT_TRUE( maxHam >= minHam ) << "Base ham max is lower than base ham on mobile: " << templateName;
// Verify armor
int armor = creature->getArmor();
EXPECT_TRUE( armor >= 0 && armor <= 3 ) << "Armor is not a valid value on mobile: " << templateName;
// Verify resists
float kinetic = creature->getKinetic();
EXPECT_TRUE( kinetic >= -1 && kinetic <= 200 ) << "Kinetic resist is not a valid value on mobile: " << templateName;
float energy = creature->getEnergy();
EXPECT_TRUE( energy >= -1 && energy <= 200 ) << "Energy resist is not a valid value on mobile: " << templateName;
float electricity = creature->getElectricity();
EXPECT_TRUE( electricity >= -1 && electricity <= 200 ) << "Electricity resist is not a valid value on mobile: " << templateName;
float stun = creature->getStun();
EXPECT_TRUE( stun >= -1 && stun <= 200 ) << "Stun resist is not a valid value on mobile: " << templateName;
float blast = creature->getBlast();
EXPECT_TRUE( blast >= -1 && blast <= 200 ) << "Blast resist is not a valid value on mobile: " << templateName;
float heat = creature->getHeat();
EXPECT_TRUE( heat >= -1 && heat <= 200 ) << "Heat resist is not a valid value on mobile: " << templateName;
float cold = creature->getCold();
EXPECT_TRUE( cold >= -1 && cold <= 200 ) << "Cold resist is not a valid value on mobile: " << templateName;
float acid = creature->getAcid();
EXPECT_TRUE( acid >= -1 && acid <= 200 ) << "Acid resist is not a valid value on mobile: " << templateName;
float lightSaber = creature->getLightSaber();
EXPECT_TRUE( lightSaber >= -1 && lightSaber <= 200 ) << "LightSaber resist is not a valid value on mobile: " << templateName;
// Verify creature resources
String meat = creature->getMeatType();
float meatMax = creature->getMeatMax();
if (!meat.isEmpty()) {
String meatResources = "meat_domesticated,meat_wild,meat_herbivore,meat_carnivore,meat_reptilian,meat_avian,meat_insect";
StringTokenizer tokenizer(meatResources);
tokenizer.setDelimeter(",");
bool match = false;
String token;
while (tokenizer.hasMoreTokens()) {
tokenizer.getStringToken(token);
if (meat == token)
match = true;
}
EXPECT_TRUE( match ) << "Meat type on mobile " << templateName << " is not a valid meat resource";
EXPECT_TRUE( meatMax > 0 ) << "Meat amount on mobile " << templateName << " is zero.";
} else {
EXPECT_TRUE( meatMax == 0 ) << "MeatAmount is not zero yet has no type defined on mobile " << templateName;
}
String hide = creature->getHideType();
float hideMax = creature->getHideMax();
if (!hide.isEmpty()) {
String hideResources = "hide_bristley,hide_leathery,hide_scaley,hide_wooly";
StringTokenizer tokenizer(hideResources);
tokenizer.setDelimeter(",");
bool match = false;
String token;
while (tokenizer.hasMoreTokens()) {
tokenizer.getStringToken(token);
if (hide == token)
match = true;
}
EXPECT_TRUE( match ) << "Hide type on mobile " << templateName << " is not a valid hide resource";
EXPECT_TRUE( hideMax > 0 ) << "Hide amount on mobile " << templateName << " is zero.";
} else {
EXPECT_TRUE( hideMax == 0 ) << "HideAmount is not zero yet has no type defined on mobile " << templateName;
}
String bone = creature->getBoneType();
float boneMax = creature->getBoneMax();
if (!bone.isEmpty()) {
String boneResources = "bone_avian,bone_mammal";
StringTokenizer tokenizer(boneResources);
tokenizer.setDelimeter(",");
bool match = false;
String token;
while (tokenizer.hasMoreTokens()) {
tokenizer.getStringToken(token);
if (bone == token)
match = true;
}
EXPECT_TRUE( match ) << "Bone type on mobile " << templateName << " is not a valid bone resource";
EXPECT_TRUE( boneMax > 0 ) << "Bone amount on mobile " << templateName << " is zero.";
} else {
EXPECT_TRUE( boneMax == 0 ) << "BoneAmount is not zero yet has no type defined on mobile " << templateName;
}
String milk = creature->getMilkType();
float milkMax = creature->getMilk();
if (!milk.isEmpty()) {
String milkResources = "milk_domesticated,milk_wild";
StringTokenizer tokenizer(milkResources);
tokenizer.setDelimeter(",");
bool match = false;
String token;
while (tokenizer.hasMoreTokens()) {
tokenizer.getStringToken(token);
if (milk == token)
match = true;
}
EXPECT_TRUE( match ) << "Milk type on mobile " << templateName << " is not a valid milk resource";
EXPECT_TRUE( milkMax > 0 ) << "Milk amount on mobile " << templateName << " is zero.";
} else {
EXPECT_TRUE( milkMax == 0 ) << "Milk is not zero yet has no type defined on mobile " << templateName;
}
// Verify taming chance
float tamingChance = creature->getTame();
EXPECT_TRUE( tamingChance >= 0 && tamingChance <= 1 ) << "Taming chance is not a valid value on mobile: " << templateName;
// Verify scale
float scale = creature->getScale();
EXPECT_TRUE( scale > 0 ) << "Scale is not a positive value on mobile: " << templateName;
// Verify loot group percentages
LootGroupCollection* groupCollection = creature->getLootGroups();
if( groupCollection->count() > 0 ){
for( int i = 0; i < groupCollection->count(); i++ ){
LootGroupCollectionEntry* collectionEntry = groupCollection->get(i);
LootGroups* groups = collectionEntry->getLootGroups();
if( groups->count() > 0){
int totalChance = 0;
for( int j = 0; j < groups->count(); j++ ){
LootGroupEntry* lootGroup = groups->get(j);
totalChance += lootGroup->getLootChance();
// Verify loot group is configured correctly
LootGroupTemplate* foundGroup = lootGroupMap->getLootGroupTemplate( lootGroup->getLootGroupName() );
std::string groupName( lootGroup->getLootGroupName().toCharArray() );
EXPECT_TRUE( foundGroup != NULL ) << "Loot group " << groupName << " from " << templateName << " was not found in LootGroupMap";
}
EXPECT_EQ( 10000000, totalChance ) << "Loot groups total chance is incorrect " << templateName;
}
}
}
// Verify weapon groups exist
Vector<String> weapons = creature->getWeapons();
for (int i = 0; i < weapons.size(); i++) {
String weaponGroup = weapons.get(i);
std::string groupName( weaponGroup.toCharArray() );
Vector<String> group = CreatureTemplateManager::instance()->getWeapons(weaponGroup);
EXPECT_TRUE( group.size() > 0 ) << "Weapon group " << groupName << " from " << templateName << " was not found in weaponMap";
}
// Verify conversation template exist, and the mob has converse option bit
uint32 convoTemplate = creature->getConversationTemplate();
uint32 optionsBitmask = creature->getOptionsBitmask();
if (convoTemplate != 0) {
ConversationTemplate* convoTemp = CreatureTemplateManager::instance()->getConversationTemplate(convoTemplate);
EXPECT_TRUE( convoTemp != NULL ) << "Conversation template from " << templateName << " was not found.";
EXPECT_TRUE( optionsBitmask & OptionBitmask::CONVERSE ) << templateName << " has a convo template but not the CONVERSE options bit.";
}
// Verify that mobs with converse option bit have a convo template
if (optionsBitmask & OptionBitmask::CONVERSE) {
EXPECT_TRUE( convoTemplate != 0 ) << templateName << " has the CONVERSE options bit but not a convo template.";
}
// Verify that outfits exist
String outfit = creature->getOutfit();
if (!outfit.isEmpty()) {
MobileOutfitGroup* outfitGroup = CreatureTemplateManager::instance()->getMobileOutfitGroup(outfit);
EXPECT_TRUE( outfitGroup != NULL ) << "Outfit group " << outfit.toCharArray() << " from " << templateName << " was not found.";
}
// Verify attacks are valid commands
CreatureAttackMap* cam = creature->getAttacks();
for (int i = 0; i < cam->size(); i++) {
String commandName = cam->getCommand(i);
EXPECT_TRUE( commandName.isEmpty() || commandConfigManager->contains(commandName) ) << "Attack: " << commandName.toCharArray() << " is not a valid command in mobile template: " << templateName;
}
// Very attackable npcs
uint32 pvpBitmask = creature->getPvpBitmask();
if ((pvpBitmask & CreatureFlag::ATTACKABLE) && objectType == 1025) {
// Verify attackable npcs have attacks
EXPECT_TRUE( cam->size() > 0 ) << "Attackable npc " << templateName << " does not have attacks.";
}
}
// Test Lair Templates
HashTableIterator<uint32, Reference<LairTemplate*> > lairIterator = CreatureTemplateManager::instance()->lairTemplateIterator();
while (lairIterator.hasNext()) {
LairTemplate* lair = lairIterator.next();
std::string templateName( lair->getName().toCharArray() );
// Verify that mobiles exist and that their weighting is positive
VectorMap<String, int>* mobiles = lair->getMobiles();
for (int i = 0; i < mobiles->size(); i++) {
int weighting = mobiles->elementAt(i).getValue();
String mobile = mobiles->elementAt(i).getKey();
std::string mobName = mobile.toCharArray();
EXPECT_TRUE( CreatureTemplateManager::instance()->getTemplate(mobile) != NULL ) << "Mobile " << mobName << " in lair template " << templateName << " does not exist";
EXPECT_TRUE( weighting > 0 ) << "Mobile " << mobName << " in lair template " << templateName << " has a non positive weighting";
}
// Verify that boss mobiles exist and that their count is positive
VectorMap<String, int>* bossMobiles = lair->getBossMobiles();
for (int i = 0; i < bossMobiles->size(); i++) {
int count = bossMobiles->elementAt(i).getValue();
String bossMob = bossMobiles->elementAt(i).getKey();
std::string bossName = bossMob.toCharArray();
EXPECT_TRUE( CreatureTemplateManager::instance()->getTemplate(bossMob) != NULL ) << "Boss mobile " << bossName << " in lair template " << templateName << " does not exist";
EXPECT_TRUE( count > 0 ) << "Boss mobile " << bossName << " in lair template " << templateName << " has a non positive spawn count";
}
// Verify spawn limit is positive
int limit = lair->getSpawnLimit();
EXPECT_TRUE( limit > 0 ) << "Spawn limit in lair template " << templateName << " is not positive";
// Verify any configured buildings exist
int buildingCount = 0;
for(int i=0; i<=4; i++){
Vector<String>* buildings = lair->getBuildings( i );
if( buildings == NULL )
continue;
buildingCount += buildings->size();
for( int j=0; j < buildings->size(); j++ ){
String buildingTemplate = buildings->get(j);
std::string buildingStr = buildingTemplate.toCharArray();
SharedObjectTemplate* templateObject = templateManager->getTemplate(buildingTemplate.hashCode());
EXPECT_TRUE( templateObject != NULL && templateObject->isSharedTangibleObjectTemplate() ) << "Building template " << buildingStr << " in lair template " << templateName << " does not exist";
if( lair->getBuildingType() == LairTemplate::LAIR ){
EXPECT_TRUE( buildingTemplate.beginsWith( "object/tangible/lair/") ) << "Building template " << buildingStr << " in lair template " << templateName << " is not a child of object/tangible/lair/";
}
if( lair->getBuildingType() == LairTemplate::THEATER ){
EXPECT_TRUE( buildingTemplate.beginsWith( "object/building/poi/") ) << "Building template " << buildingStr << " in lair template " << templateName << " is not a child of object/building/poi/";
}
}
}
// Verify mission buildings exist and are lairs
String missionBuilding = lair->getMissionBuilding(10);
if (!missionBuilding.isEmpty()) {
std::string buildingStr = missionBuilding.toCharArray();
SharedObjectTemplate* templateObject = templateManager->getTemplate(missionBuilding.hashCode());
EXPECT_TRUE( templateObject != NULL && templateObject->isSharedTangibleObjectTemplate() ) << "Mission building template " << buildingStr << " in lair template " << templateName << " does not exist";
EXPECT_TRUE( missionBuilding.beginsWith( "object/tangible/lair/") ) << "Mission building template " << buildingStr << " in lair template " << templateName << " is not a child of object/tangible/lair/";
}
if( lair->getBuildingType() == LairTemplate::THEATER ){
EXPECT_TRUE( buildingCount > 0 ) << "There are no buildings configured in theater type lair template " << templateName;
}
if( lair->getBuildingType() == LairTemplate::NONE ){
EXPECT_TRUE( buildingCount == 0 ) << "There are buildings configured in 'none' type lair template " << templateName;
}
if( lair->getBuildingType() == LairTemplate::LAIR ){
EXPECT_TRUE( buildingCount > 0 ) << "There are no buildings configured in lair type lair template " << templateName;
}
}
// Test Spawn Groups
HashTableIterator<uint32, Reference<SpawnGroup*> > spawnIterator = CreatureTemplateManager::instance()->spawnGroupIterator();
while (spawnIterator.hasNext()) {
SpawnGroup* group = spawnIterator.next();
std::string templateName( group->getTemplateName().toCharArray() );
Vector<String> lairTemplates;
// Verify spawn list
Vector<Reference<LairSpawn*> >* spawnList = group->getSpawnList();
for (int i = 0; i < spawnList->size(); i++) {
LairSpawn* spawn = spawnList->get(i);
std::string lairName( spawn->getLairTemplateName().toCharArray() );
// Verify lair template exists and isn't duplicated in the group
String lairTemplateName = spawn->getLairTemplateName();
Reference<LairTemplate*> lairTemplate = CreatureTemplateManager::instance()->getLairTemplate(lairTemplateName.hashCode());
EXPECT_TRUE( lairTemplate != NULL ) << "Lair template " << lairName << " in spawn group " << templateName << " does not exist.";
EXPECT_FALSE( lairTemplates.contains(lairTemplateName) ) << "Lair template " << lairName << " is duplicated in spawn group " << templateName;
lairTemplates.add(lairTemplateName);
// Verify spawn limit is at least -1
float spawnLimit = spawn->getSpawnLimit();
EXPECT_TRUE( spawnLimit >= -1 ) << "SpawnLimit for lairTemplate " << lairName << " in spawn group " << templateName << " is less than -1.";
// Verify difficulties
int minDiff = spawn->getMinDifficulty();
int maxDiff = spawn->getMaxDifficulty();
EXPECT_TRUE( minDiff > 0 ) << "MinDifficulty for lairTemplate " << lairName << " in spawn group " << templateName << " is not positive.";
EXPECT_TRUE( maxDiff >= minDiff ) << "MaxDifficulty for lairTemplate " << lairName << " in spawn group " << templateName << " is less than min difficulty.";
// Verify number to spawn is not negative
int numberToSpawn = spawn->getNumberToSpawn();
EXPECT_TRUE( numberToSpawn >= 0 ) << "NumberToSpawn for lairTemplate " << lairName << " in spawn group " << templateName << " is negative.";
// Verify weighting is positive
int weighting = spawn->getWeighting();
EXPECT_TRUE( weighting > 0 ) << "Weighting for lairTemplate " << lairName << " in spawn group " << templateName << " is not positive.";
// Verify size is at least 1
float size = spawn->getSize();
EXPECT_TRUE( size >= 1 ) << "Size for lairTemplate " << lairName << " in spawn group " << templateName << " is less than 1.";
}
}
// Test Destroy Mission Spawn Groups
HashTableIterator<uint32, Reference<SpawnGroup*> > missionIterator = CreatureTemplateManager::instance()->destroyMissionGroupIterator();
while (missionIterator.hasNext()) {
SpawnGroup* group = missionIterator.next();
std::string templateName( group->getTemplateName().toCharArray() );
Vector<String> lairTemplates;
// Verify spawn list
Vector<Reference<LairSpawn*> >* spawnList = group->getSpawnList();
for (int i = 0; i < spawnList->size(); i++) {
LairSpawn* spawn = spawnList->get(i);
std::string lairName( spawn->getLairTemplateName().toCharArray() );
// Verify lair template exists
String lairTemplateName = spawn->getLairTemplateName();
Reference<LairTemplate*> lairTemplate = CreatureTemplateManager::instance()->getLairTemplate(lairTemplateName.hashCode());
EXPECT_TRUE( lairTemplate != NULL ) << "Lair template " << lairName << " in destroy mission spawn group " << templateName << " does not exist.";
EXPECT_FALSE( lairTemplates.contains(lairTemplateName) ) << "Lair template " << lairName << " is duplicated in destroy mission spawn group " << templateName;
lairTemplates.add(lairTemplateName);
if (lairTemplate != NULL) {
// Verify that lair template has a valid mission building or is of type LAIR
String missionBuilding = lairTemplate->getMissionBuilding(10);
if (!missionBuilding.isEmpty()) {
std::string buildingStr = missionBuilding.toCharArray();
SharedObjectTemplate* templateObject = templateManager->getTemplate(missionBuilding.hashCode());
EXPECT_TRUE( templateObject != NULL && templateObject->isSharedTangibleObjectTemplate() ) << "Mission building template " << buildingStr << " in lair template " << lairName << ", part of destroy mission group " << templateName << " does not exist";
EXPECT_TRUE( missionBuilding.beginsWith( "object/tangible/lair/") ) << "Mission building template " << buildingStr << " in lair template " << lairName << ", part of destroy mission group " << templateName << " is not a child of object/tangible/lair/";
} else {
EXPECT_TRUE( lairTemplate->getBuildingType() == LairTemplate::LAIR ) << "Lair template " << lairName << ", part of destroy mission group " << templateName << " is not of type LAIR";
}
}
// Verify difficulties
int minDiff = spawn->getMinDifficulty();
int maxDiff = spawn->getMaxDifficulty();
EXPECT_TRUE( minDiff > 0 ) << "MinDifficulty for lairTemplate " << lairName << " in destroy mission spawn group " << templateName << " is not positive.";
EXPECT_TRUE( maxDiff >= minDiff ) << "MaxDifficulty for lairTemplate " << lairName << " in destroy mission spawn group " << templateName << " is less than min difficulty.";
// Verify size is at least 1
float size = spawn->getSize();
EXPECT_TRUE( size >= 1 ) << "Size for lairTemplate " << lairName << " in destroy mission spawn group " << templateName << " is less than 1.";
}
}
}
void ChatManagerImplementation::handleSocialInternalMessage(CreatureObject* sender, const UnicodeString& arguments) {
if (sender->isPlayerCreature()) {
ManagedReference<PlayerObject*> senderGhost = sender->getPlayerObject();
if (senderGhost == NULL)
return;
if (senderGhost->isMuted()) {
String reason = senderGhost->getMutedReason();
if (reason != "")
sender->sendSystemMessage("Your chat abilities are currently disabled by Customer Support for '" + reason + "'.");
else
sender->sendSystemMessage("Your chat abilities are currently disabled by Customer Support.");
return;
}
}
Zone* zone = sender->getZone();
if (zone == NULL)
return;
StringTokenizer tokenizer(arguments.toString());
uint64 targetid;
uint32 emoteid, unkint, unkint2;
try {
targetid = tokenizer.getLongToken();
emoteid = tokenizer.getIntToken();
unkint = tokenizer.getIntToken();
unkint2 = tokenizer.getIntToken();
} catch (const Exception& e) {
return;
}
//bool readlock = !zone->isLockedByCurrentThread();
bool showtext = true;
if (unkint2 == 0)
showtext = false;
String firstName;
if (sender->isPlayerCreature())
firstName = (cast<CreatureObject*>(sender))->getFirstName().toLowerCase();
CloseObjectsVector* vec = (CloseObjectsVector*) sender->getCloseObjects();
SortedVector<QuadTreeEntry* > closeEntryObjects(200, 50);
if (vec != NULL) {
vec->safeCopyTo(closeEntryObjects);
} else {
sender->info("Null closeobjects vector in ChatManager::handleSocialInternalMessage", true);
zone->getInRangeObjects(sender->getWorldPositionX(), sender->getWorldPositionX(), 128, &closeEntryObjects, true);
}
float range = defaultSpatialChatDistance;
for (int i = 0; i < closeEntryObjects.size(); ++i) {
SceneObject* object = cast<SceneObject*>(closeEntryObjects.get(i));
if (object->isPlayerCreature()) {
CreatureObject* creature = cast<CreatureObject*>(object);
Reference<PlayerObject*> ghost = creature->getSlottedObject("ghost").castTo<PlayerObject*>();
if (ghost == NULL)
continue;
if (!ghost->isIgnoring(firstName) && creature->isInRange(sender, range)) {
Emote* emsg = new Emote(creature, sender, targetid, emoteid, showtext);
creature->sendMessage(emsg);
}
}
}
}
// Legend of Hondo - aveage value of OQ/DR and amount of resources used in final combine
float SharedLabratory::getJunkValue(ManufactureSchematic* manufactureSchematic) {
float junkValue = 1.0f;
int resQuant = 0;
int statOQ = 0;
int statDR = 0;
int subComps = 0;
for (int i = 0; i < manufactureSchematic->getSlotCount(); ++i) {
Reference<IngredientSlot* > ingredientslot = manufactureSchematic->getSlot(i);
Reference<DraftSlot* > draftslot = manufactureSchematic->getDraftSchematic()->getDraftSlot(i);
/// If resource slot, continue
if(!ingredientslot->isResourceSlot()){
if(ingredientslot->isComponentSlot() && ingredientslot->isFull())
subComps++; // Count component slot if it is being used.
continue;
}
ResourceSlot* resSlot = cast<ResourceSlot*>(ingredientslot.get());
if(resSlot == NULL)
continue;
ManagedReference<ResourceSpawn* > spawn = resSlot->getCurrentSpawn();
if (spawn == NULL) {
error("Spawn object is null when running getJunkValue");
return 0.0f;
}
resQuant += draftslot->getQuantity();
statOQ = spawn->getValueOf(8);
statDR = spawn->getValueOf(2);
if (junkValue == 1 && statOQ != 0) {
junkValue = (statOQ + statDR) / 2;
} else if (junkValue > 1 && statOQ != 0){
junkValue = (junkValue + statOQ + statDR) / 3;
}
}
Logger::console.info("real resQuant: " + String::valueOf(resQuant), true);
Logger::console.info("average of DR and OQ: " + String::valueOf(junkValue), true);
// On low resource items with subs, make the final product worth more than selling the subs seperately
if (subComps > 0 && resQuant < 100)
resQuant = resQuant / 2 + 50;
// Factor sub components as best as possible and reduce resource quality impact for Architect and Shipwright
if (subComps == 1 && resQuant > 449){
resQuant = resQuant + (resQuant / 2 ); // Shipwright (Mk I part in Mk V final is over valued, but whatevs...)
junkValue = junkValue + (1000 - junkValue) / 2;
} else if (subComps > 1 && resQuant > 2500){
resQuant = resQuant + (resQuant * (subComps + 3)); // Architect, large
junkValue = junkValue + (1000 - junkValue) / 2;
} else if (subComps > 1 && resQuant > 499){
resQuant = resQuant + (resQuant * subComps); // Architect, small
junkValue = junkValue + (1000 - junkValue) / 2;
} else if (subComps > 0){
resQuant = resQuant + (resQuant / 3 * subComps); // Everyone else
}
// Cap resource quanity and thus max price
if (resQuant > 29900){
resQuant = 29900 + System::random(100);
}
if (junkValue != 0)
junkValue = resQuant * (junkValue / 1000);
Logger::console.info("subComps: " + String::valueOf(subComps), true);
Logger::console.info("final resQuant: " + String::valueOf(resQuant), true);
Logger::console.info("junkValue: " + String::valueOf(junkValue), true);
return junkValue;
}
void PlanetManagerImplementation::initialize() {
performanceLocations = new MissionTargetMap();
numberOfCities = 0;
info("Loading planet.");
planetTravelPointList->setZoneName(zone->getZoneName());
loadClientRegions();
loadClientPoiData();
loadLuaConfig();
loadTravelFares();
if (zone->getZoneName() == "dathomir") {
Reference<ActiveArea*> area = zone->getZoneServer()->createObject(STRING_HASHCODE("object/fs_village_area.iff"), 0).castTo<ActiveArea*>();
Locker locker(area);
area->setRadius(768.f);
area->initializePosition(5306, 0, -4145);
zone->transferObject(area, -1, true);
ManagedReference<SceneObject*> scenery = zone->getZoneServer()->createObject(STRING_HASHCODE("object/static/structure/general/fs_village_nobuild_768m.iff"), 0);
Locker slocker(scenery, area);
scenery->initializePosition(5306, zone->getHeight(5306, -4145), -4145);
area->attachScenery(scenery);
slocker.release();
locker.release();
Reference<ActiveArea*> sarlaccArea = zone->getZoneServer()->createObject(STRING_HASHCODE("object/sarlacc_area.iff"), 0).castTo<ActiveArea*>();
Locker locker2(sarlaccArea);
sarlaccArea->setRadius(60.f);
sarlaccArea->initializePosition(-2085, 0, 3147);
zone->transferObject(sarlaccArea, -1, true);
locker2.release();
Reference<ActiveArea*> sarlaccPreArea = zone->getZoneServer()->createObject(STRING_HASHCODE("object/sarlacc_area.iff"), 0).castTo<ActiveArea*>();
Locker locker3(sarlaccPreArea);
sarlaccPreArea->setRadius(30.f);
sarlaccPreArea->initializePosition(-2085, 0, 3147);
zone->transferObject(sarlaccPreArea, -1, true);
}
if (zone->getZoneName() == "tatooine") {
Reference<ActiveArea*> area = zone->getZoneServer()->createObject(STRING_HASHCODE("object/sarlacc_area.iff"), 0).castTo<ActiveArea*>();
Locker locker(area);
area->setRadius(30.f);
area->initializePosition(-6174, 0, -3361);
zone->transferObject(area, -1, true);
locker.release();
Reference<ActiveArea*> preArea = zone->getZoneServer()->createObject(STRING_HASHCODE("object/sarlacc_area.iff"), 0).castTo<ActiveArea*>();
Locker locker2(preArea);
preArea->setRadius(60.f);
preArea->initializePosition(-6174, 0, -3361);
zone->transferObject(preArea, -1, true);
}
}
void OnResult(const SQL::Result &r) override
{
SQLOperResultDeleter d(this);
if (!user || !user->Account())
return;
if (r.Rows() == 0)
{
Log(LogType::DEBUG) << "m_sql_oper: Got 0 rows for " << user->nick;
Deoper();
return;
}
Anope::string opertype;
try
{
opertype = r.Get(0, "opertype");
}
catch (const SQL::Exception &)
{
Log(this->owner) << "Expected column named \"opertype\" but one was not found";
return;
}
Log(LogType::DEBUG) << "m_sql_oper: Got result for " << user->nick << ", opertype " << opertype;
Anope::string modes;
try
{
modes = r.Get(0, "modes");
}
catch (const SQL::Exception &) { }
ServiceBot *OperServ = Config->GetClient("OperServ");
if (opertype.empty())
{
Deoper();
return;
}
OperType *ot = OperType::Find(opertype);
if (ot == NULL)
{
Log(this->owner) << "m_sql_oper: Oper " << user->nick << " has type " << opertype << ", but this opertype does not exist?";
return;
}
Oper *oper = user->Account()->GetOper();
if (oper == nullptr || oper->GetType() != ot)
{
Log(this->owner) << "m_sql_oper: Tieing oper " << user->nick << " to type " << opertype;
if (oper)
oper->Delete();
oper = Serialize::New<Oper *>();
oper->SetName(user->Account()->GetDisplay());
oper->SetType(ot);
user->Account()->SetOper(oper);
}
if (!user->HasMode("OPER"))
{
IRCD->SendOper(user);
if (!modes.empty())
user->SetModes(OperServ, "%s", modes.c_str());
}
}
void SkillManager::loadClientData() {
IffStream* iffStream = TemplateManager::instance()->openIffFile("datatables/skill/skills.iff");
if (iffStream == NULL) {
error("Could not load skills.");
return;
}
DataTableIff dtiff;
dtiff.readObject(iffStream);
delete iffStream;
for (int i = 0; i < dtiff.getTotalRows(); ++i) {
DataTableRow* row = dtiff.getRow(i);
Reference<Skill*> skill = new Skill();
skill->parseDataTableRow(row);
Skill* parent = skillMap.get(skill->getParentName().hashCode());
if (parent == NULL)
parent = rootNode;
parent->addChild(skill);
if (skillMap.put(skill->getSkillName().hashCode(), skill) != NULL) {
error("overwriting skill name");
assert(0 && "skill name hashcode error");
}
//Load the abilities of the skill into the ability map.
Vector<String> commands = skill->commands;
for (int i = 0; i < commands.size(); ++i) {
String command = commands.get(i);
if (!abilityMap.containsKey(command)) {
abilityMap.put(command, new Ability(command));
}
}
}
loadFromLua();
//If the admin ability isn't in the ability map, then we want to add it manually.
if (!abilityMap.containsKey("admin"))
abilityMap.put("admin", new Ability("admin"));
// These are not listed in skills.iff and need to be added manually
if (!abilityMap.containsKey("startMusic+western"))
abilityMap.put("startMusic+western", new Ability("startMusic+western"));
if (!abilityMap.containsKey("startDance+theatrical"))
abilityMap.put("startDance+theatrical", new Ability("startDance+theatrical"));
if (!abilityMap.containsKey("startDance+theatrical2"))
abilityMap.put("startDance+theatrical2", new Ability("startDance+theatrical2"));
loadXpLimits();
info("Successfully loaded " + String::valueOf(skillMap.size()) + " skills and " + String::valueOf(abilityMap.size()) + " abilities.", true);
}
bool PetControlDeviceImplementation::canBeTradedTo(CreatureObject* player, CreatureObject* receiver, int numberInTrade) {
ManagedReference<SceneObject*> datapad = receiver->getSlottedObject("datapad");
if (datapad == NULL)
return false;
if (petType == PetManager::FACTIONPET) {
player->sendSystemMessage("@pet/pet_menu:bad_type"); // You cannot trade a pet of that type. Transfer failed.
return false;
} else if (petType == PetManager::DROIDPET) {
ManagedReference<PlayerManager*> playerManager = player->getZoneServer()->getPlayerManager();
int droidsInDatapad = numberInTrade;
int maxStoredDroids = playerManager->getBaseStoredDroids();
for (int i = 0; i < datapad->getContainerObjectsSize(); i++) {
Reference<SceneObject*> obj = datapad->getContainerObject(i).castTo<SceneObject*>();
if (obj != NULL && obj->isPetControlDevice() ){
Reference<PetControlDevice*> petDevice = cast<PetControlDevice*>(obj.get());
if( petDevice != NULL && petDevice->getPetType() == PetManager::DROIDPET){
droidsInDatapad++;
}
}
}
if( droidsInDatapad >= maxStoredDroids){
player->sendSystemMessage("That person has too many droids in their datapad");
return false;
}
return true;
} else if (petType == PetManager::CREATUREPET) {
ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get();
if (controlledObject == NULL || !controlledObject->isCreature())
return false;
ManagedReference<Creature*> pet = cast<Creature*>(controlledObject.get());
ManagedReference<PlayerManager*> playerManager = player->getZoneServer()->getPlayerManager();
int numberStored = numberInTrade;
int maxStoredPets = playerManager->getBaseStoredCreaturePets();
int maxLevelofPets = 10;
int level = pet->getAdultLevel();
bool ch = receiver->hasSkill("outdoors_creaturehandler_novice");
if (ch) {
maxStoredPets += receiver->getSkillMod("stored_pets");
maxLevelofPets = receiver->getSkillMod("tame_level");
}
if (level > maxLevelofPets) {
player->sendSystemMessage("@pet/pet_menu:no_chance"); // That person has no chance of controlling this creature. Transfer failed.
receiver->sendSystemMessage("@pet/pet_menu:cannot_control"); // You have no chance of controlling that creature.
return false;
}
if (pet->isVicious() && (receiver->getSkillMod("tame_aggro") <= 0 || !ch)) {
player->sendSystemMessage("@pet/pet_menu:no_chance"); // That person has no chance of controlling this creature. Transfer failed.
receiver->sendSystemMessage("@pet/pet_menu:cannot_control"); // You have no chance of controlling that creature.
return false;
}
if (numberStored >= maxStoredPets) {
player->sendSystemMessage("@pet/pet_menu:targ_too_many_stored"); // That person has too many stored pets. Transfer failed.
receiver->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 false;
}
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:targ_too_many_stored"); // That person has too many stored pets. Transfer failed.
receiver->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 false;
}
}
}
}
return true;
}
return false;
}
bool ArchHandler_x86_64::isCallSite(const Reference &ref) {
if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
return false;
assert(ref.kindArch() == Reference::KindArch::x86_64);
return (ref.kindValue() == branch32);
}
void ArchHandler_x86_64::applyFixupFinal(
const Reference &ref, uint8_t *loc, uint64_t fixupAddress,
uint64_t targetAddress, uint64_t inAtomAddress, uint64_t imageBaseAddress,
FindAddressForAtom findSectionAddress) {
if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
return;
assert(ref.kindArch() == Reference::KindArch::x86_64);
ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
ulittle64_t *loc64 = reinterpret_cast<ulittle64_t *>(loc);
switch (static_cast<X86_64Kind>(ref.kindValue())) {
case branch32:
case ripRel32:
case ripRel32Anon:
case ripRel32Got:
case ripRel32GotLoad:
case ripRel32Tlv:
*loc32 = targetAddress - (fixupAddress + 4) + ref.addend();
return;
case pointer64:
case pointer64Anon:
*loc64 = targetAddress + ref.addend();
return;
case tlvInitSectionOffset:
*loc64 = targetAddress - findSectionAddress(*ref.target()) + ref.addend();
return;
case ripRel32Minus1:
case ripRel32Minus1Anon:
*loc32 = targetAddress - (fixupAddress + 5) + ref.addend();
return;
case ripRel32Minus2:
case ripRel32Minus2Anon:
*loc32 = targetAddress - (fixupAddress + 6) + ref.addend();
return;
case ripRel32Minus4:
case ripRel32Minus4Anon:
*loc32 = targetAddress - (fixupAddress + 8) + ref.addend();
return;
case delta32:
case delta32Anon:
*loc32 = targetAddress - fixupAddress + ref.addend();
return;
case delta64:
case delta64Anon:
case unwindFDEToFunction:
*loc64 = targetAddress - fixupAddress + ref.addend();
return;
case ripRel32GotLoadNowLea:
// Change MOVQ to LEA
assert(loc[-2] == 0x8B);
loc[-2] = 0x8D;
*loc32 = targetAddress - (fixupAddress + 4) + ref.addend();
return;
case negDelta64:
*loc64 = fixupAddress - targetAddress + ref.addend();
return;
case negDelta32:
*loc32 = fixupAddress - targetAddress + ref.addend();
return;
case lazyPointer:
// Do nothing
return;
case lazyImmediateLocation:
*loc32 = ref.addend();
return;
case imageOffset:
case imageOffsetGot:
*loc32 = (targetAddress - imageBaseAddress) + ref.addend();
return;
case unwindInfoToEhFrame: {
uint64_t val = targetAddress - findSectionAddress(*ref.target()) + ref.addend();
assert(val < 0xffffffU && "offset in __eh_frame too large");
*loc32 = (*loc32 & 0xff000000U) | val;
return;
}
case invalid:
// Fall into llvm_unreachable().
break;
}
llvm_unreachable("invalid x86_64 Reference Kind");
}
CheckOTQuotationsInNT::CheckOTQuotationsInNT(const ustring& project, const vector <unsigned int>& books, bool includetext)
{
// Language and versification system.
extern Settings *settings;
ustring language = settings->projectconfig(project, false)->language_get();
ustring versification = settings->projectconfig(project, false)->versification_get();
Mapping mapping(versification, 0);
// Get a list of the books to check. If no books were given, take them all.
vector < unsigned int >mybooks(books.begin(), books.end());
if (mybooks.empty())
mybooks = project_get_books(project);
set < unsigned int >bookset(mybooks.begin(), mybooks.end());
// Get all quotations in New Testament order, optionally also in OT order.
OTQuotations otquotations(0);
otquotations.read();
bool use_ot_order = settings->session.check_output_in_ot_order;
if (use_ot_order) {
otquotations.produce_in_ot_order();
}
// GUI.
progresswindow = new ProgressWindow(_("Producing passages"), true);
progresswindow->set_iterate(0, 1, use_ot_order ? otquotations.quotations_ot_order.size() : otquotations.quotations_nt_order.size());
// Go through the quotations.
for (unsigned int i = 0; i < (use_ot_order ? otquotations.quotations_ot_order.size() : otquotations.quotations_nt_order.size()); i++) {
progresswindow->iterate();
if (progresswindow->cancel)
return;
// Skip if the reference book is not to be included.
unsigned int reference_book = use_ot_order ? otquotations.quotations_ot_order[i].reference.book_get() :
otquotations.quotations_nt_order[i].reference.book_get();
if (bookset.find(reference_book) == bookset.end())
continue;
// Optionally remapping of verses.
mapping.book_change(reference_book);
if (use_ot_order)
mapping.original_to_me(otquotations.quotations_ot_order[i].reference);
else
mapping.original_to_me(otquotations.quotations_nt_order[i].reference);
// Reference chapter and verse.
unsigned int reference_chapter = use_ot_order ? otquotations.quotations_ot_order[i].reference.chapter_get() : otquotations.quotations_nt_order[i].reference.chapter_get();
ustring reference_verse = use_ot_order ? otquotations.quotations_ot_order[i].reference.verse_get() : otquotations.quotations_nt_order[i].reference.verse_get();
// Store reference, optionally verse text, and comment.
ustring reference = use_ot_order ? otquotations.quotations_ot_order[i].reference.human_readable (language) : otquotations.quotations_nt_order[i].reference.human_readable(language);
nt_refs.push_back(reference);
ustring reference_verse_text;
if (includetext) {
reference_verse_text = project_retrieve_verse(project, reference_book, reference_chapter, reference_verse);
reference_verse_text = usfm_get_verse_text_only (reference_verse_text);
}
nt_texts.push_back (reference_verse_text);
references.push_back(reference);
comments.push_back(_("Quoted in New Testament"));
// Go through the OT quotations processing them.
vector <ustring> refs_store;
vector <ustring> text_store;
unsigned int i2_limit = use_ot_order ? otquotations.quotations_ot_order[i].referents.size() : otquotations.quotations_nt_order[i].referents.size();
for (unsigned i2 = 0; i2 < i2_limit; i2++) {
if (use_ot_order) {
mapping.book_change(otquotations.quotations_ot_order[i].referents[i2].book_get());
mapping.original_to_me(otquotations.quotations_ot_order[i].referents[i2]);
} else {
mapping.book_change(otquotations.quotations_nt_order[i].referents[i2].book_get());
mapping.original_to_me(otquotations.quotations_nt_order[i].referents[i2]);
}
ustring reference = use_ot_order ? otquotations.quotations_ot_order[i].referents[i2].human_readable(language) : otquotations.quotations_nt_order[i].referents[i2].human_readable(language);
ustring verse_text;
if (includetext) {
verse_text = project_retrieve_verse(project,
use_ot_order ? otquotations.quotations_ot_order[i].referents[i2] : otquotations.quotations_nt_order[i].referents[i2]);
verse_text = usfm_get_verse_text_only(verse_text);
}
refs_store.push_back(reference);
text_store.push_back(verse_text);
Reference ref ((use_ot_order ? otquotations.quotations_ot_order[i].referents[i2].book_get() : otquotations.quotations_nt_order[i].referents[i2].book_get()),
(use_ot_order ? otquotations.quotations_ot_order[i].referents[i2].chapter_get() : otquotations.quotations_nt_order[i].referents[i2].chapter_get()),
(use_ot_order ? otquotations.quotations_ot_order[i].referents[i2].verse_get() : otquotations.quotations_nt_order[i].referents[i2].verse_get()));
references.push_back(ref.human_readable (""));
comments.push_back(_("Old Testament verse quoted from"));
}
// Save data.
ot_refs.push_back(refs_store);
ot_texts.push_back(text_store);
}
}
int ConsumableImplementation::handleObjectMenuSelect(CreatureObject* player, byte selectedID) {
if (!isASubChildOf(player))
return 0;
if (selectedID != 20) {
return TangibleObjectImplementation::handleObjectMenuSelect(player, selectedID);
}
if (speciesRestriction == "pets") {
player->sendSystemMessage("@error_message:pets_only"); //That food is only suitable for pets.
return 0;
}
PlayerObject* ghost = player->getPlayerObject();
String raceName = player->getSpeciesName();
if ((speciesRestriction == "2" && raceName != "trandoshan") || (speciesRestriction == "4" && raceName != "wookiee")) {
player->sendSystemMessage("@error_message:race_restriction"); //That food isn't edible by your species.
return 0;
}
if (isSpice() && player->hasSpice()) {
player->sendSystemMessage("@spice/spice:sys_already_spiced"); //You are already under the influence of spices.
return 0;
}
if (player->hasBuff(buffCRC) && (!isAttributeEffect() || isForagedFood())) {
player->sendSystemMessage("@combat_effects:already_affected"); //You are already under the influence of that food. Eating more won't enhance the effect.
return 0;
}
if (player->isDead() || player->isIncapacitated())
return 0;
int availfill = 0;
if (ghost == NULL)
return 1;
if (isFood())
availfill = ghost->getFoodFillingMax() - ghost->getFoodFilling();
if (isDrink())
availfill = ghost->getDrinkFillingMax() - ghost->getDrinkFilling();
if (filling > availfill) {
if (isFood())
player->sendSystemMessage("@error_message:full_food"); //You are too full to eat that.
if (isDrink())
player->sendSystemMessage("@error_message:full_drink"); //You are too full to drink that.
return 1;
}
ManagedReference<Buff*> buff = NULL;
switch (effectType) {
case EFFECT_ATTRIBUTE: {
buff = new Buff(player, buffName.hashCode(), duration, BuffType::FOOD);
setModifiers(buff, false);
break;
}
case EFFECT_SKILL: {
buff = new Buff(player, buffName.hashCode(), duration, BuffType::FOOD);
setModifiers(buff, true);
break;
}
case EFFECT_SPICE: {
buff = new SpiceBuff(player, buffName, String("spice." + buffName + ".up").hashCode(), duration);
setModifiers(buff, false);
//buff->parseAttributeModifierString(modifierString);
player->addBuff(buff);
//useCharge(player);
decreaseUseCount();
return 1;
}
case EFFECT_HEALING: {
int dmghealed = player->healDamage(player, 6, nutrition);
if (dmghealed <= 0) {
player->sendSystemMessage("@healing:no_mind_to_heal_self"); //You have no mind to heal.
return 0;
}
StringIdChatParameter stringId("combat_effects", "food_mind_heal");
stringId.setDI(dmghealed);
player->sendSystemMessage(stringId);
break;
}
case EFFECT_DURATION: {
buff = new DurationBuff(player, buffName.hashCode(), duration);
setModifiers(buff, true);
//buff->parseSkillModifierString(generateModifierString());
break;
}
case EFFECT_DELAYED: {
buff = new DelayedBuff(player, buffName.hashCode(), duration);
setModifiers(buff, true);
DelayedBuff* delayedBuff = cast<DelayedBuff*>(buff.get());
delayedBuff->init(&eventTypes);
break;
}
case EFFECT_INSTANT: {
if (modifiers.isEmpty())
return 0;
//TODO: Handle each instant effect on its own...
String effect = modifiers.elementAt(0).getKey();
if (effect == "burst_run") {
//We need to reduce the cooldown and efficiency.
player->executeObjectControllerAction(String("burstrun").hashCode());
if (player->hasBuff(String("burstrun").hashCode())) {
float reduction = 1.f - ((float)nutrition / 100.f);
player->updateCooldownTimer("burstrun", ((300 * reduction) + duration) * 1000);
player->sendSystemMessage("@combat_effects:instant_burst_run"); //You instantly burst run at increased efficiency!
Reference<Task*> task = player->getPendingTask("burst_run_notify");
if (task != NULL)
task->reschedule(((300 * reduction) + duration) * 1000);
else {
task = new BurstRunNotifyAvailableEvent(player);
player->addPendingTask("burst_run_notify", task, ((300 * reduction) + duration) * 1000);
}
} else {
//Couldnt burst run yet.
return 0;
}
} else if (effect == "food_reduce") {
//Tilla till reduces food stomach filling by a percentage
int currentfilling = ghost->getFoodFilling();
ghost->setFoodFilling(round(currentfilling * (100 - nutrition) / 100.0f), true);
}
}
}
if (buff != NULL)
player->addBuff(buff);
if (isFood())
ghost->setFoodFilling(ghost->getFoodFilling() + filling, true);
if (isDrink())
ghost->setDrinkFilling(ghost->getDrinkFilling() + filling, true);
StringIdChatParameter stringId("base_player", "prose_consume_item");
stringId.setTT(getObjectID());
player->sendSystemMessage(stringId);//player->sendSystemMessage("base_player", "prose_consume_item", objectID);;
// Play the client effect sound depending on species/gender.
// Get the species.
int species = player->getSpecies();
switch (species) {
case 0:
// Human
if (player->getGender() == 0)
player->playEffect("clienteffect/human_male_eat.cef");
else if (player->getGender() == 1)
player->playEffect("clienteffect/human_female_eat.cef");
break;
case 2: // Trandoshan
if (player->getGender() == 0)
player->playEffect("clienteffect/reptile_male_eat.cef");
else if (player->getGender() == 1)
player->playEffect("clienteffect/reptile_female_eat.cef");
break;
case 4: // Wookiee
if (player->getGender() == 0)
player->playEffect("clienteffect/wookiee_male_eat.cef");
else if (player->getGender() == 1)
player->playEffect("clienteffect/wookiee_female_eat.cef");
break;
default:
break;
}
//Consume a charge from the item, destroy it if it reaches 0 charges remaining.
//useCharge(player);
decreaseUseCount();
return 0;
}
int
Extension::foreachCmd (
ClientData,
Tcl_Interp *interp,
int objc,
Tcl_Obj *const objv[])
{
if (objc != 4) {
Tcl_WrongNumArgs(
interp, 1, objv, "varList collectionHandle script");
return TCL_ERROR;
}
Tcl_Obj *pVarList = objv[1];
Tcl_Obj *pBody = objv[3];
Reference *pCollection = referenceHandles.find(interp, objv[2]);
if (pCollection == 0) {
const char *arg = Tcl_GetStringFromObj(objv[2], 0);
Tcl_AppendResult(
interp, "invalid interface pointer handle ", arg, 0);
return TCL_ERROR;
}
// Collections should implement a _NewEnum method which returns an object
// that enumerates the elements.
HRESULT hr;
PositionalArguments arguments;
_variant_t varResult;
hr = pCollection->invoke(
DISPID_NEWENUM,
DISPATCH_METHOD | DISPATCH_PROPERTYGET,
arguments,
&varResult);
if (FAILED(hr) || V_VT(&varResult) != VT_UNKNOWN) {
Tcl_AppendResult(interp, "object is not a collection", NULL);
return TCL_ERROR;
}
IUnknownPtr pUnk(V_UNKNOWN(&varResult));
// Get a specific kind of enumeration.
IEnumVARIANTPtr pEnumVARIANT;
IEnumUnknownPtr pEnumUnknown;
enum EnumKind { ENUM_VARIANT, ENUM_UNKNOWN };
EnumKind enumKind;
hr = pUnk->QueryInterface(
IID_IEnumVARIANT, reinterpret_cast<void **>(&pEnumVARIANT));
if (SUCCEEDED(hr)) {
enumKind = ENUM_VARIANT;
} else {
hr = pUnk->QueryInterface(
IID_IEnumUnknown, reinterpret_cast<void **>(&pEnumUnknown));
if (SUCCEEDED(hr)) {
enumKind = ENUM_UNKNOWN;
}
}
if (FAILED(hr)) {
Tcl_AppendResult(interp,
"Unknown enumerator type: not IEnumVARIANT or IEnumUnknown", NULL);
return TCL_ERROR;
}
int completionCode;
int varc; // number of loop variables
completionCode = Tcl_ListObjLength(interp, pVarList, &varc);
if (completionCode != TCL_OK) {
return TCL_ERROR;
}
if (varc < 1) {
Tcl_AppendResult(interp, "foreach varlist is empty", NULL);
return TCL_ERROR;
}
while (true) {
// If the variable list has been converted to another kind of Tcl
// object, convert it back to a list and refetch the pointer to its
// element array.
Tcl_Obj **varv;
completionCode =
Tcl_ListObjGetElements(interp, pVarList, &varc, &varv);
if (completionCode != TCL_OK) {
return TCL_ERROR;
}
// Assign values to all loop variables.
int v = 0;
for (; v < varc; ++v) {
TclObject value;
ULONG count;
switch (enumKind) {
case ENUM_VARIANT:
{
_variant_t elementVar;
hr = pEnumVARIANT->Next(1, &elementVar, &count);
if (hr == S_OK && count > 0) {
value = TclObject(&elementVar, Type::variant(), interp, 0);
}
}
break;
case ENUM_UNKNOWN:
{
IUnknown *pElement;
hr = pEnumUnknown->Next(1, &pElement, &count);
if (hr == S_OK && count > 0) {
value = referenceHandles.newObj(
interp, Reference::newReference(pElement));
}
}
break;
}
if (FAILED(hr)) {
_com_issue_error(hr);
}
if (hr != S_OK || count == 0) {
break;
}
Tcl_Obj *varValuePtr = Tcl_ObjSetVar2(
interp, varv[v], NULL, value, TCL_LEAVE_ERR_MSG);
if (varValuePtr == NULL) {
return TCL_ERROR;
}
}
if (v == 0) {
completionCode = TCL_OK;
break;
}
if (v < varc) {
TclObject empty;
for (; v < varc; ++v) {
Tcl_Obj *varValuePtr = Tcl_ObjSetVar2(
interp, varv[v], NULL, empty, TCL_LEAVE_ERR_MSG);
if (varValuePtr == NULL) {
return TCL_ERROR;
}
}
}
// Execute the script body.
completionCode =
#if TCL_MINOR_VERSION >= 1
Tcl_EvalObjEx(interp, pBody, 0);
#else
Tcl_EvalObj(interp, pBody);
#endif
if (completionCode == TCL_CONTINUE) {
// do nothing
} else if (completionCode == TCL_BREAK) {
completionCode = TCL_OK;
break;
} else if (completionCode == TCL_ERROR) {
std::ostringstream oss;
oss << "\n (\"foreach\" body line %d)" << interp->errorLine;
Tcl_AddObjErrorInfo(
interp, const_cast<char *>(oss.str().c_str()), -1);
break;
} else if (completionCode != TCL_OK) {
break;
}
}
if (completionCode == TCL_OK) {
Tcl_ResetResult(interp);
}
return completionCode;
}
bool Object::respondsToMessage(Reference<Types::String> message) {
if(!this->functors)
return false;
return &((*this->functors)[message->getValue()]);
}
void Object::attachFunctor(Reference<AbstractFunctor> func, Reference<Types::String> name) {
if(!this->functors)
this->functors = new std::map< std::string, Reference<AbstractFunctor> >();
(*this->functors)[name->getValue()] = func;
}
void
TclObject::toVariant (VARIANT *pDest,
const Type &type,
Tcl_Interp *interp,
bool addRef)
{
VariantClear(pDest);
VARTYPE vt = type.vartype();
Reference *pReference = Extension::referenceHandles.find(interp, m_pObj);
if (pReference != 0) {
// Convert interface pointer handle to interface pointer.
if (addRef) {
// Must increment reference count of interface pointers returned
// from methods.
pReference->unknown()->AddRef();
}
IDispatch *pDispatch = pReference->dispatch();
if (pDispatch != 0) {
V_VT(pDest) = VT_DISPATCH;
V_DISPATCH(pDest) = pDispatch;
} else {
V_VT(pDest) = VT_UNKNOWN;
V_UNKNOWN(pDest) = pReference->unknown();
}
} else if (m_pObj->typePtr == &Extension::unknownPointerType) {
// Convert to interface pointer.
IUnknown *pUnknown = static_cast<IUnknown *>(
m_pObj->internalRep.otherValuePtr);
if (addRef && pUnknown != 0) {
// Must increment reference count of interface pointers returned
// from methods.
pUnknown->AddRef();
}
V_VT(pDest) = VT_UNKNOWN;
V_UNKNOWN(pDest) = pUnknown;
} else if (vt == VT_SAFEARRAY) {
const Type &elementType = type.elementType();
V_VT(pDest) = VT_ARRAY | elementType.vartype();
V_ARRAY(pDest) = getSafeArray(elementType, interp);
} else if (m_pObj->typePtr == TclTypes::listType()) {
// Convert Tcl list to array of VARIANT.
int numElements;
Tcl_Obj **pElements;
if (Tcl_ListObjGetElements(interp, m_pObj, &numElements, &pElements)
!= TCL_OK) {
_com_issue_error(E_INVALIDARG);
}
SAFEARRAYBOUND bounds[2];
bounds[0].cElements = numElements;
bounds[0].lLbound = 0;
unsigned numDimensions;
// Check if the first element of the list is a list.
if (numElements > 0 && pElements[0]->typePtr == TclTypes::listType()) {
int colSize;
Tcl_Obj **pCol;
if (Tcl_ListObjGetElements(interp, pElements[0], &colSize, &pCol)
!= TCL_OK) {
_com_issue_error(E_INVALIDARG);
}
bounds[1].cElements = colSize;
bounds[1].lLbound = 0;
numDimensions = 2;
} else {
numDimensions = 1;
}
SAFEARRAY *psa = SafeArrayCreate(VT_VARIANT, numDimensions, bounds);
std::vector<long> indices(numDimensions);
fillSafeArray(m_pObj, psa, 1, &indices[0], interp, addRef);
V_VT(pDest) = VT_ARRAY | VT_VARIANT;
V_ARRAY(pDest) = psa;
#if TCL_MINOR_VERSION >= 1
} else if (m_pObj->typePtr == TclTypes::byteArrayType()) {
// Convert Tcl byte array to SAFEARRAY of bytes.
V_VT(pDest) = VT_ARRAY | VT_UI1;
V_ARRAY(pDest) = newSafeArray(m_pObj, VT_UI1);
#endif
} else if (m_pObj->typePtr == &Extension::naType) {
// This variant indicates a missing optional argument.
VariantCopy(pDest, &vtMissing);
} else if (m_pObj->typePtr == &Extension::nullType) {
V_VT(pDest) = VT_NULL;
} else if (m_pObj->typePtr == &Extension::variantType) {
VariantCopy(
pDest,
static_cast<_variant_t *>(m_pObj->internalRep.otherValuePtr));
} else if (m_pObj->typePtr == TclTypes::intType()) {
long value;
if (Tcl_GetLongFromObj(interp, m_pObj, &value) != TCL_OK) {
value = 0;
}
V_VT(pDest) = VT_I4;
V_I4(pDest) = value;
if (vt != VT_VARIANT && vt != VT_USERDEFINED) {
VariantChangeType(pDest, pDest, 0, vt);
}
} else if (m_pObj->typePtr == TclTypes::doubleType()) {
double value;
if (Tcl_GetDoubleFromObj(interp, m_pObj, &value) != TCL_OK) {
value = 0.0;
}
V_VT(pDest) = VT_R8;
V_R8(pDest) = value;
if (vt != VT_VARIANT && vt != VT_USERDEFINED) {
VariantChangeType(pDest, pDest, 0, vt);
}
} else if (m_pObj->typePtr == TclTypes::booleanType()) {
int value;
if (Tcl_GetBooleanFromObj(interp, m_pObj, &value) != TCL_OK) {
value = 0;
}
V_VT(pDest) = VT_BOOL;
V_BOOL(pDest) = (value != 0) ? VARIANT_TRUE : VARIANT_FALSE;
if (vt != VT_VARIANT && vt != VT_USERDEFINED) {
VariantChangeType(pDest, pDest, 0, vt);
}
} else if (vt == VT_BOOL) {
V_VT(pDest) = VT_BOOL;
V_BOOL(pDest) = getBool() ? VARIANT_TRUE : VARIANT_FALSE;
} else {
V_VT(pDest) = VT_BSTR;
V_BSTR(pDest) = getBSTR();
// If trying to convert from a string to a date,
// we need to convert to a double (VT_R8) first.
if (vt == VT_DATE) {
VariantChangeType(pDest, pDest, 0, VT_R8);
}
// Try to convert from a string representation.
if (vt != VT_VARIANT && vt != VT_USERDEFINED && vt != VT_LPWSTR) {
VariantChangeType(pDest, pDest, 0, vt);
}
}
}
bool isTLVAccess(const Reference &ref) const override {
assert(ref.kindNamespace() == Reference::KindNamespace::mach_o);
assert(ref.kindArch() == Reference::KindArch::x86_64);
return ref.kindValue() == ripRel32Tlv;
}
void CampSiteActiveAreaImplementation::assumeOwnership(CreatureObject* player) {
if (camp == NULL || player == NULL)
return;
if (player->getSkillMod("camp") < campStructureData->getSkillRequired()) {
player->sendSystemMessage("@camp:error_too_big"); // You cannot assume ownership of this camp. You lack the skill to maintain a camp of this size.
return;
}
PlayerObject* playerGhost = player->getPlayerObject();
if (playerGhost == NULL)
return;
for (int i = 0; i < playerGhost->getTotalOwnedStructureCount(); ++i) {
uint64 oid = playerGhost->getOwnedStructure(i);
ManagedReference<StructureObject*> structure = playerGhost->getZoneServer()->getObject(oid).castTo<StructureObject*>();
if (structure->isCampStructure()) {
player->sendSystemMessage("@camp:sys_already_camping"); // But you already have a camp established elsewhere!
return;
}
}
PlayerObject* ownerGhost = campOwner->getPlayerObject();
if (ownerGhost != NULL) {
ownerGhost->removeOwnedStructure(camp);
}
setOwner(player);
abandoned = false;
currentXp = 0;
visitors.removeAll();
Reference<SortedVector<ManagedReference<QuadTreeEntry*> >*> closeObjects = new SortedVector<ManagedReference<QuadTreeEntry*> >();
zone->getInRangeObjects(camp->getWorldPositionX(), camp->getWorldPositionY(), campStructureData->getRadius(), closeObjects, true);
for (int i = 0; i < closeObjects->size(); ++i) {
SceneObject* scno = cast<SceneObject*>(closeObjects->get(i).get());
if (scno->isPlayerCreature())
visitors.add(scno->getObjectID());
}
playerGhost->addOwnedStructure(camp);
campOwner->registerObserver(ObserverEventType::STARTCOMBAT, campObserver);
Locker locker(&taskMutex);
if(abandonTask != NULL && abandonTask->isScheduled())
abandonTask->cancel();
if(despawnTask != NULL && despawnTask->isScheduled())
despawnTask->cancel();
timeCreated = System::getTime();
despawnTask->schedule(CampSiteActiveArea::DESPAWNTIME);
if(terminal != NULL) {
String campName = campOwner->getFirstName();
if(!campOwner->getLastName().isEmpty())
campName += " " + campOwner->getLastName();
campName += "'s Camp";
terminal->setCustomObjectName(campName, true);
}
player->sendSystemMessage("@camp:assuming_ownership"); //You assume ownership of the camp.
}
void ArchHandler_x86_64::applyFixupRelocatable(const Reference &ref,
uint8_t *loc,
uint64_t fixupAddress,
uint64_t targetAddress,
uint64_t inAtomAddress) {
if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
return;
assert(ref.kindArch() == Reference::KindArch::x86_64);
ulittle32_t *loc32 = reinterpret_cast<ulittle32_t *>(loc);
ulittle64_t *loc64 = reinterpret_cast<ulittle64_t *>(loc);
switch (static_cast<X86_64Kind>(ref.kindValue())) {
case branch32:
case ripRel32:
case ripRel32Got:
case ripRel32GotLoad:
case ripRel32Tlv:
*loc32 = ref.addend();
return;
case ripRel32Anon:
*loc32 = (targetAddress - (fixupAddress + 4)) + ref.addend();
return;
case tlvInitSectionOffset:
case pointer64:
*loc64 = ref.addend();
return;
case pointer64Anon:
*loc64 = targetAddress + ref.addend();
return;
case ripRel32Minus1:
*loc32 = ref.addend() - 1;
return;
case ripRel32Minus1Anon:
*loc32 = (targetAddress - (fixupAddress + 5)) + ref.addend();
return;
case ripRel32Minus2:
*loc32 = ref.addend() - 2;
return;
case ripRel32Minus2Anon:
*loc32 = (targetAddress - (fixupAddress + 6)) + ref.addend();
return;
case ripRel32Minus4:
*loc32 = ref.addend() - 4;
return;
case ripRel32Minus4Anon:
*loc32 = (targetAddress - (fixupAddress + 8)) + ref.addend();
return;
case delta32:
*loc32 = ref.addend() + inAtomAddress - fixupAddress;
return;
case delta32Anon:
// The value we write here should be the the delta to the target
// after taking in to account the difference from the fixup back to the
// last defined label
// ie, if we have:
// _base: ...
// Lfixup: .quad Ltarget - .
// ...
// Ltarget:
//
// Then we want to encode the value (Ltarget + addend) - (LFixup - _base)
*loc32 = (targetAddress + ref.addend()) - (fixupAddress - inAtomAddress);
return;
case delta64:
*loc64 = ref.addend() + inAtomAddress - fixupAddress;
return;
case delta64Anon:
// The value we write here should be the the delta to the target
// after taking in to account the difference from the fixup back to the
// last defined label
// ie, if we have:
// _base: ...
// Lfixup: .quad Ltarget - .
// ...
// Ltarget:
//
// Then we want to encode the value (Ltarget + addend) - (LFixup - _base)
*loc64 = (targetAddress + ref.addend()) - (fixupAddress - inAtomAddress);
return;
case negDelta64:
*loc64 = ref.addend() + fixupAddress - inAtomAddress;
return;
case negDelta32:
*loc32 = ref.addend() + fixupAddress - inAtomAddress;
return;
case ripRel32GotLoadNowLea:
llvm_unreachable("ripRel32GotLoadNowLea implies GOT pass was run");
return;
case lazyPointer:
case lazyImmediateLocation:
llvm_unreachable("lazy reference kind implies Stubs pass was run");
return;
case imageOffset:
case imageOffsetGot:
case unwindInfoToEhFrame:
llvm_unreachable("fixup implies __unwind_info");
return;
case unwindFDEToFunction:
// Do nothing for now
return;
case invalid:
// Fall into llvm_unreachable().
break;
}
llvm_unreachable("unknown x86_64 Reference Kind");
}
void test1() {
Reference r;
(r->method());
}
void ArchHandler_x86_64::appendSectionRelocations(
const DefinedAtom &atom,
uint64_t atomSectionOffset,
const Reference &ref,
FindSymbolIndexForAtom symbolIndexForAtom,
FindSectionIndexForAtom sectionIndexForAtom,
FindAddressForAtom addressForAtom,
normalized::Relocations &relocs) {
if (ref.kindNamespace() != Reference::KindNamespace::mach_o)
return;
assert(ref.kindArch() == Reference::KindArch::x86_64);
uint32_t sectionOffset = atomSectionOffset + ref.offsetInAtom();
switch (static_cast<X86_64Kind>(ref.kindValue())) {
case branch32:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_BRANCH | rPcRel | rExtern | rLength4);
return;
case ripRel32:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_SIGNED | rPcRel | rExtern | rLength4 );
return;
case ripRel32Anon:
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()), 0,
X86_64_RELOC_SIGNED | rPcRel | rLength4 );
return;
case ripRel32Got:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_GOT | rPcRel | rExtern | rLength4 );
return;
case ripRel32GotLoad:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_GOT_LOAD | rPcRel | rExtern | rLength4 );
return;
case ripRel32Tlv:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_TLV | rPcRel | rExtern | rLength4 );
return;
case tlvInitSectionOffset:
case pointer64:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_UNSIGNED | rExtern | rLength8);
return;
case pointer64Anon:
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()), 0,
X86_64_RELOC_UNSIGNED | rLength8);
return;
case ripRel32Minus1:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_SIGNED_1 | rPcRel | rExtern | rLength4 );
return;
case ripRel32Minus1Anon:
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()), 0,
X86_64_RELOC_SIGNED_1 | rPcRel | rLength4 );
return;
case ripRel32Minus2:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_SIGNED_2 | rPcRel | rExtern | rLength4 );
return;
case ripRel32Minus2Anon:
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()), 0,
X86_64_RELOC_SIGNED_2 | rPcRel | rLength4 );
return;
case ripRel32Minus4:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_SIGNED_4 | rPcRel | rExtern | rLength4 );
return;
case ripRel32Minus4Anon:
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()), 0,
X86_64_RELOC_SIGNED_4 | rPcRel | rLength4 );
return;
case delta32:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(atom), 0,
X86_64_RELOC_SUBTRACTOR | rExtern | rLength4 );
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_UNSIGNED | rExtern | rLength4 );
return;
case delta32Anon:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(atom), 0,
X86_64_RELOC_SUBTRACTOR | rExtern | rLength4 );
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()), 0,
X86_64_RELOC_UNSIGNED | rLength4 );
return;
case delta64:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(atom), 0,
X86_64_RELOC_SUBTRACTOR | rExtern | rLength8 );
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_UNSIGNED | rExtern | rLength8 );
return;
case delta64Anon:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(atom), 0,
X86_64_RELOC_SUBTRACTOR | rExtern | rLength8 );
appendReloc(relocs, sectionOffset, sectionIndexForAtom(*ref.target()), 0,
X86_64_RELOC_UNSIGNED | rLength8 );
return;
case unwindFDEToFunction:
case unwindInfoToEhFrame:
return;
case negDelta32:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_SUBTRACTOR | rExtern | rLength4 );
appendReloc(relocs, sectionOffset, symbolIndexForAtom(atom), 0,
X86_64_RELOC_UNSIGNED | rExtern | rLength4 );
return;
case negDelta64:
appendReloc(relocs, sectionOffset, symbolIndexForAtom(*ref.target()), 0,
X86_64_RELOC_SUBTRACTOR | rExtern | rLength8 );
appendReloc(relocs, sectionOffset, symbolIndexForAtom(atom), 0,
X86_64_RELOC_UNSIGNED | rExtern | rLength8 );
return;
case ripRel32GotLoadNowLea:
llvm_unreachable("ripRel32GotLoadNowLea implies GOT pass was run");
return;
case lazyPointer:
case lazyImmediateLocation:
llvm_unreachable("lazy reference kind implies Stubs pass was run");
return;
case imageOffset:
case imageOffsetGot:
llvm_unreachable("__unwind_info references should have been resolved");
return;
case invalid:
// Fall into llvm_unreachable().
break;
}
llvm_unreachable("unknown x86_64 Reference Kind");
}
Reference<SceneObject*> PlanetManagerImplementation::loadSnapshotObject(WorldSnapshotNode* node, WorldSnapshotIff* wsiff, int& totalObjects) {
uint64 objectID = node->getObjectID();
String templateName = wsiff->getObjectTemplateName(node->getNameID());
ZoneServer* zoneServer = server->getZoneServer();
Reference<SceneObject*> object = zoneServer->getObject(objectID);
++totalObjects;
if (ConfigManager::instance()->isProgressMonitorActivated())
printf("\r\tLoading snapshot objects: [%d] / [?]\t", totalObjects);
//Object already exists, exit.
if (object != NULL)
return NULL;
Reference<SceneObject*> parentObject = zoneServer->getObject(node->getParentID());
String serverTemplate = templateName.replaceFirst("shared_", "");
Vector3 position = node->getPosition();
object = zoneServer->createClientObject(serverTemplate.hashCode(), objectID);
Locker locker(object);
object->initializePosition(position.getX(), position.getZ(), position.getY());
object->setDirection(node->getDirection());
if (parentObject != NULL && parentObject->isBuildingObject() && object->isCellObject()) {
CellObject* cell = cast<CellObject*>(object.get());
BuildingObject* building = cast<BuildingObject*>(parentObject.get());
Locker clocker(building, object);
building->addCell(cell, node->getCellID());
}
if (parentObject != NULL)
parentObject->transferObject(object, -1);
else if (node->getParentID() != 0)
error("parent id " + String::valueOf(node->getParentID()));
if (parentObject == NULL) {
//object->insertToZone(zone);
Locker clocker(object);
zone->transferObject(object, -1, true);
}
//Load child nodes
for (int i = 0; i < node->getNodeCount(); ++i) {
WorldSnapshotNode* childNode = node->getNode(i);
if (childNode == NULL)
continue;
loadSnapshotObject(childNode, wsiff, totalObjects);
}
//object->createChildObjects();
return object;
}
int CreatureManagerImplementation::notifyDestruction(TangibleObject* destructor, AiAgent* destructedObject, int condition) {
if (destructedObject->isDead())
return 1;
destructedObject->setPosture(CreaturePosture::DEAD, true);
destructedObject->updateTimeOfDeath();
ManagedReference<PlayerManager*> playerManager = zoneServer->getPlayerManager();
// lets unlock destructor so we dont get into complicated deadlocks
// lets copy the damage map before we remove it all
ThreatMap* threatMap = destructedObject->getThreatMap();
ThreatMap copyThreatMap(*threatMap);
threatMap->removeObservers();
threatMap->removeAll(); // we can clear the original one
if (destructedObject != destructor)
destructor->unlock();
bool shouldRescheduleCorpseDestruction = false;
try {
ManagedReference<CreatureObject*> player = copyThreatMap.getHighestDamageGroupLeader();
uint64 ownerID = 0;
if (player != NULL) {
if(player->isGrouped()) {
ownerID = player->getGroupID();
} else {
ownerID = player->getObjectID();
}
if (player->isPlayerCreature()) {
Locker locker(player, destructedObject);
player->notifyObservers(ObserverEventType::KILLEDCREATURE, destructedObject);
FactionManager* factionManager = FactionManager::instance();
if (!destructedObject->getFactionString().isEmpty() && !destructedObject->isEventMob()) {
int level = destructedObject->getLevel();
if(!player->isGrouped())
factionManager->awardFactionStanding(player, destructedObject->getFactionString(), level);
else
factionManager->awardFactionStanding(copyThreatMap.getHighestDamagePlayer(), destructedObject->getFactionString(), level);
}
}
}
if (playerManager != NULL)
playerManager->disseminateExperience(destructedObject, ©ThreatMap);
SceneObject* creatureInventory = destructedObject->getSlottedObject("inventory");
if (creatureInventory != NULL && player != NULL && player->isPlayerCreature()) {
LootManager* lootManager = zoneServer->getLootManager();
if (destructedObject->isNonPlayerCreatureObject() && !destructedObject->isEventMob())
destructedObject->setCashCredits(lootManager->calculateLootCredits(destructedObject->getLevel()));
Locker locker(creatureInventory);
creatureInventory->setContainerOwnerID(ownerID);
lootManager->createLoot(creatureInventory, destructedObject);
}
CombatManager::instance()->attemptPeace(destructedObject);
// Check to see if we can expedite the despawn of this corpse
// We can expedite the despawn when corpse has no loot, no credits, player cannot harvest, and no group members in range can harvest
shouldRescheduleCorpseDestruction = playerManager->shouldRescheduleCorpseDestruction(player, destructedObject);
} catch (...) {
destructedObject->scheduleDespawn();
// now we can safely lock destructor again
if (destructedObject != destructor)
destructor->wlock(destructedObject);
throw;
}
destructedObject->scheduleDespawn();
if (shouldRescheduleCorpseDestruction) {
Reference<DespawnCreatureTask*> despawn = destructedObject->getPendingTask("despawn").castTo<DespawnCreatureTask*>();
if (despawn != NULL) {
despawn->cancel();
despawn->reschedule(10000);
}
}
// now we can safely lock destructor again
if (destructedObject != destructor)
destructor->wlock(destructedObject);
return 1;
}
int PetMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) const {
if (!sceneObject->isPet() || player == NULL)
return 0;
AiAgent* pet = cast<AiAgent*>(sceneObject);
ManagedReference<CreatureObject*> owner = pet->getLinkedCreature().get();
if (!player->getPlayerObject()->isPrivileged() && owner != 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 (owner != player && owner != NULL) {
Reference<PetControlDeviceStoreObjectTask*> task = new PetControlDeviceStoreObjectTask(petControlDevice, owner, true);
task->execute();
} else {
petControlDevice->storeObject(player);
}
return 0;
}
if (owner != 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_HASHCODE("petrecover"), "");
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_HASHCODE("petrecharge"), "");
} else if (petControlDevice->getPetType() == PetManager::CREATUREPET) {
petManager->enqueueOwnerOnlyPetCommand(player, pet, STRING_HASHCODE("petfeed"), "");
}
break;
case 235: // Train Command: Recharge Other
petControlDevice->setTrainingCommand( PetManager::RECHARGEOTHER );
break;
default:
break;
}
return 0;
}
void CreatureManagerImplementation::droidHarvest(Creature* creature, CreatureObject* droid, int selectedID, int harvestBonus) {
// droid and creature are locked coming in.
ManagedReference<CreatureObject*> owner = droid->getLinkedCreature();
if (owner == NULL) {
return;
}
Locker pLock(owner);
Zone* zone = creature->getZone();
if (zone == NULL || !creature->isCreature()) {
return;
}
// this will perform a range check on the corpse to the droid
if (!creature->canDroidHarvestMe(owner,droid)) {
owner->sendSystemMessage("@pet/droid_modules:cannot_access_corpse");
return;
}
ManagedReference<ResourceManager*> resourceManager = zone->getZoneServer()->getResourceManager();
String restype = "";
float quantity = 0;
if (selectedID == 234) {
restype = creature->getMeatType();
quantity = creature->getMeatMax();
} else if (selectedID == 235) {
restype = creature->getHideType();
quantity = creature->getHideMax();
} else if (selectedID == 236) {
restype = creature->getBoneType();
quantity = creature->getBoneMax();
}
if(quantity == 0 || restype.isEmpty()) {
owner->sendSystemMessage("Tried to harvest something this creature didn't have, please report this error");
return;
}
int ownerSkill = owner->getSkillMod("creature_harvesting");
int quantityExtracted = int(quantity * float(ownerSkill / 100.0f));
// add in droid bonus
quantityExtracted = MAX(quantityExtracted, 3);
ManagedReference<ResourceSpawn*> resourceSpawn = resourceManager->getCurrentSpawn(restype, droid->getZone()->getZoneName());
if (resourceSpawn == NULL) {
owner->sendSystemMessage("Error: Server cannot locate a current spawn of " + restype);
return;
}
float density = resourceSpawn->getDensityAt(droid->getZone()->getZoneName(), droid->getPositionX(), droid->getPositionY());
String creatureHealth = "";
if (density > 0.80f) {
quantityExtracted = int(quantityExtracted * 1.25f);
creatureHealth = "creature_quality_fat";
} else if (density > 0.60f) {
quantityExtracted = int(quantityExtracted * 1.00f);
creatureHealth = "creature_quality_medium";
} else if (density > 0.40f) {
quantityExtracted = int(quantityExtracted * 0.75f);
creatureHealth = "creature_quality_scrawny";
} else {
quantityExtracted = int(quantityExtracted * 0.50f);
creatureHealth = "creature_quality_skinny";
}
float modifier = 1;
int baseAmount = quantityExtracted;
if (owner->isGrouped()) {
modifier = owner->getGroup()->getGroupHarvestModifier(owner);
quantityExtracted = (int)(quantityExtracted * modifier);
if (owner->getGroup()->getGroupSize() > 2 ) {
quantityExtracted -= quantityExtracted * 0.3; // 30% reduction
}
}
if (creature->getParent().get() != NULL)
quantityExtracted = 1;
int droidBonus = DroidMechanics::determineDroidSkillBonus(ownerSkill,harvestBonus,quantityExtracted);
quantityExtracted += droidBonus;
// add to droid inventory if there is space available, otherwise to player
DroidObject* pet = cast<DroidObject*>(droid);
if (pet == NULL) {
error("Incoming droid harvest call didnt include a droid!");
return;
}
if (pet->hasStorage()) {
bool didit = resourceManager->harvestResourceToPlayer(droid, resourceSpawn, quantityExtracted);
if (!didit) {
resourceManager->harvestResourceToPlayer(owner, resourceSpawn, quantityExtracted);
}
} else {
resourceManager->harvestResourceToPlayer(owner, resourceSpawn, quantityExtracted);
}
/// Send System Messages
StringIdChatParameter harvestMessage("skl_use", creatureHealth);
harvestMessage.setDI(quantityExtracted);
harvestMessage.setTU(resourceSpawn->getFinalClass());
owner->sendSystemMessage(harvestMessage);
/// Send bonus message
if (modifier == 1.2f)
owner->sendSystemMessage("@skl_use:group_harvest_bonus");
else if (modifier == 1.3f)
owner->sendSystemMessage("@skl_use:group_harvest_bonus_ranger");
else if (modifier == 1.4f)
owner->sendSystemMessage("@skl_use:group_harvest_bonus_masterranger");
/// Send group spam
if (owner->isGrouped()) {
StringIdChatParameter bonusMessage("group", "notify_harvest_corpse");
bonusMessage.setTU(droid->getDisplayedName());
bonusMessage.setDI(quantityExtracted);
bonusMessage.setTO(resourceSpawn->getFinalClass());
bonusMessage.setTT(creature->getObjectNameStringIdFile(), creature->getObjectNameStringIdName());
ChatSystemMessage* sysMessage = new ChatSystemMessage(bonusMessage);
owner->getGroup()->broadcastMessage(owner, sysMessage, false);
}
ManagedReference<PlayerManager*> playerManager = zoneServer->getPlayerManager();
int xp = creature->getLevel() * 5 + 19;
if(playerManager != NULL)
playerManager->awardExperience(owner, "scout", xp, true);
creature->addAlreadyHarvested(owner);
if (!creature->hasLoot() && creature->getBankCredits() < 1 && creature->getCashCredits() < 1 && !playerManager->canGroupMemberHarvestCorpse(owner, creature)) {
Reference<DespawnCreatureTask*> despawn = creature->getPendingTask("despawn").castTo<DespawnCreatureTask*>();
if (despawn != NULL) {
despawn->cancel();
despawn->reschedule(1000);
}
}
}
/**
* Copy constructor; the copy destination retains an additional reference to the value referenced by @a ref.
*
* @param ref The shared pointer to be copied.
*/
Reference(const Reference &ref) noexcept : Reference(ref.sharedValue(), true) { }
void CreatureManagerImplementation::harvest(Creature* creature, CreatureObject* player, int selectedID) {
Zone* zone = creature->getZone();
if (zone == NULL || !creature->isCreature())
return;
if (!creature->canHarvestMe(player))
return;
if (!player->isInRange(creature, 7))
return;
ManagedReference<ResourceManager*> resourceManager = zone->getZoneServer()->getResourceManager();
String restype = "";
float quantity = 0;
if (selectedID == 112) {
int type = System::random(2);
if (quantity == 0 || type == 0) {
if(creature->getHideMax() > 0) {
restype = creature->getHideType();
quantity = creature->getHideMax();
}
}
if (quantity == 0 || type == 1) {
if(creature->getMeatMax() > 0) {
restype = creature->getMeatType();
quantity = creature->getMeatMax();
}
}
if (quantity == 0 || type == 2) {
if(creature->getBoneMax() > 0) {
restype = creature->getBoneType();
quantity = creature->getBoneMax();
}
}
}
if (selectedID == 234) {
restype = creature->getMeatType();
quantity = creature->getMeatMax();
} else if (selectedID == 235) {
restype = creature->getHideType();
quantity = creature->getHideMax();
} else if (selectedID == 236) {
restype = creature->getBoneType();
quantity = creature->getBoneMax();
}
if(quantity == 0 || restype.isEmpty()) {
player->sendSystemMessage("Tried to harvest something this creature didn't have, please report this error");
return;
}
int quantityExtracted = int(quantity * float(player->getSkillMod("creature_harvesting") / 100.0f));
quantityExtracted = MAX(quantityExtracted, 3);
ManagedReference<ResourceSpawn*> resourceSpawn = resourceManager->getCurrentSpawn(restype, player->getZone()->getZoneName());
if (resourceSpawn == NULL) {
player->sendSystemMessage("Error: Server cannot locate a current spawn of " + restype);
return;
}
float density = resourceSpawn->getDensityAt(player->getZone()->getZoneName(), player->getPositionX(), player->getPositionY());
String creatureHealth = "";
if (density > 0.80f) {
quantityExtracted = int(quantityExtracted * 1.25f);
creatureHealth = "creature_quality_fat";
} else if (density > 0.60f) {
quantityExtracted = int(quantityExtracted * 1.00f);
creatureHealth = "creature_quality_medium";
} else if (density > 0.40f) {
quantityExtracted = int(quantityExtracted * 0.75f);
creatureHealth = "creature_quality_scrawny";
} else {
quantityExtracted = int(quantityExtracted * 0.50f);
creatureHealth = "creature_quality_skinny";
}
float modifier = 1;
int baseAmount = quantityExtracted;
if (player->isGrouped()) {
modifier = player->getGroup()->getGroupHarvestModifier(player);
quantityExtracted = (int)(quantityExtracted * modifier);
}
if (creature->getParent().get() != NULL)
quantityExtracted = 1;
resourceManager->harvestResourceToPlayer(player, resourceSpawn, quantityExtracted);
/// Send System Messages
StringIdChatParameter harvestMessage("skl_use", creatureHealth);
harvestMessage.setDI(quantityExtracted);
harvestMessage.setTU(resourceSpawn->getFinalClass());
player->sendSystemMessage(harvestMessage);
/// Send bonus message
if (modifier == 1.2f)
player->sendSystemMessage("@skl_use:group_harvest_bonus");
else if (modifier == 1.3f)
player->sendSystemMessage("@skl_use:group_harvest_bonus_ranger");
else if (modifier == 1.4f)
player->sendSystemMessage("@skl_use:group_harvest_bonus_masterranger");
/// Send group spam
if (player->isGrouped()) {
StringIdChatParameter bonusMessage("group", "notify_harvest_corpse");
bonusMessage.setTU(player->getFirstName());
bonusMessage.setDI(quantityExtracted);
bonusMessage.setTO(resourceSpawn->getFinalClass());
bonusMessage.setTT(creature->getObjectNameStringIdFile(), creature->getObjectNameStringIdName());
ChatSystemMessage* sysMessage = new ChatSystemMessage(bonusMessage);
player->getGroup()->broadcastMessage(player, sysMessage, false);
}
ManagedReference<PlayerManager*> playerManager = zoneServer->getPlayerManager();
int xp = creature->getLevel() * 5 + 19;
if(playerManager != NULL)
playerManager->awardExperience(player, "scout", xp, true);
creature->addAlreadyHarvested(player);
if (!creature->hasLoot() && creature->getBankCredits() < 1 && creature->getCashCredits() < 1 && !playerManager->canGroupMemberHarvestCorpse(player, creature)) {
Reference<DespawnCreatureTask*> despawn = creature->getPendingTask("despawn").castTo<DespawnCreatureTask*>();
if (despawn != NULL) {
despawn->cancel();
despawn->reschedule(1000);
}
}
}
void ForageManagerImplementation::finishForaging(CreatureObject* player, int forageType, float forageX, float forageY, const String& zoneName) {
if (player == NULL)
return;
Locker playerLocker(player);
Locker forageAreasLocker(_this.get());
player->removePendingTask("foraging");
if (player->getZone() == NULL)
return;
//Check if player moved.
float playerX = player->getPositionX();
float playerY = player->getPositionY();
if ((fabs(playerX - forageX) > 2.0) || (fabs(playerY - forageY) > 2.0) || player->getZone()->getZoneName() != zoneName) {
player->sendSystemMessage("@skl_use:sys_forage_movefail"); //"You fail to forage because you moved."
return;
}
//Check if player is in combat.
if (player->isInCombat()) {
player->sendSystemMessage("@skl_use:sys_forage_combatfail"); //"Combat distracts you from your foraging attempt."
return;
}
//Check if player is allowed to forage in this area.
if (forageType != ForageManager::SHELLFISH) {
Reference<ForageAreaCollection*> forageAreaCollection = forageAreas.get(player->getFirstName());
if (forageAreaCollection != NULL) { //Player has foraged before.
if (!forageAreaCollection->checkForageAreas(forageX, forageY, zoneName, forageType)) {
if( forageType == LAIR ){
player->sendSystemMessage("There is nothing of interest remaining in the lair.");
}
else{
player->sendSystemMessage("@skl_use:sys_forage_empty"); //"There is nothing in this area to forage."
}
return;
}
} else { //Player has not foraged before.
forageAreaCollection = new ForageAreaCollection(player, forageX, forageY, zoneName, forageType);
forageAreas.put(player->getFirstName(), forageAreaCollection);
}
}
//Calculate the player's chance to find an item.
int chance;
int skillMod;
switch(forageType) {
case ForageManager::SCOUT:
case ForageManager::LAIR:
skillMod = player->getSkillMod("foraging");
chance = (int)(15 + (skillMod * 0.8));
break;
case ForageManager::MEDICAL:
skillMod = player->getSkillMod("medical_foraging");
chance = (int)(15 + (skillMod * 0.6));
break;
default:
skillMod = 20;
chance = (int)(15 + (skillMod * 0.6));
break;
}
//Determine if player finds an item.
if (chance > 100) //There could possibly be +foraging skill tapes.
chance = 100;
if (System::random(80) > chance) {
if (forageType == ForageManager::SHELLFISH)
player->sendSystemMessage("@harvesting:found_nothing");
else if (forageType == ForageManager::LAIR)
player->sendSystemMessage("@lair_n:found_nothing");
else
player->sendSystemMessage("@skl_use:sys_forage_fail"); //"You failed to find anything worth foraging."
} else {
forageGiveItems(player, forageType, forageX, forageY, zoneName);
}
return;
}
void SuiManager::handleSuiEventNotification(uint32 boxID, CreatureObject* player, uint32 cancel, Vector<UnicodeString>* args) {
uint16 windowType = (uint16) boxID;
Locker _lock(player);
ManagedReference<PlayerObject*> ghost = player->getPlayerObject();
if (ghost == NULL)
return;
ManagedReference<SuiBox*> suiBox = ghost->getSuiBox(boxID);
if (suiBox == NULL)
return;
//Remove the box from the player, callback can readd it to the player if needed.
ghost->removeSuiBox(boxID);
suiBox->clearOptions(); //TODO: Eventually SuiBox needs to be cleaned up to not need this.
Reference<SuiCallback*> callback = suiBox->getCallback();
if (callback != NULL) {
callback->run(player, suiBox, cancel, args);
return;
}
StringBuffer msg;
msg << "Unknown message callback with SuiWindowType: " << hex << windowType << ". Falling back on old handler system.";
//info(msg, true);
switch (windowType) {
case SuiWindowType::MEDIC_CONSENT:
handleConsentBox(player, suiBox, cancel, args);
break;
case SuiWindowType::DANCING_START:
handleStartDancing(player, suiBox, cancel, args);
break;
case SuiWindowType::DANCING_CHANGE:
handleStartDancing(player, suiBox, cancel, args);
break;
case SuiWindowType::MUSIC_START:
handleStartMusic(player, suiBox, cancel, args);
break;
case SuiWindowType::MUSIC_CHANGE:
handleStartMusic(player, suiBox, cancel, args);
break;
case SuiWindowType::BAND_START:
handleStartMusic(player, suiBox, cancel, args);
break;
case SuiWindowType::BAND_CHANGE:
handleStartMusic(player, suiBox, cancel, args);
break;
case SuiWindowType::BANK_TRANSFER:
handleBankTransfer(player, suiBox, cancel, args);
break;
case SuiWindowType::FISHING:
handleFishingAction(player, suiBox, cancel, args);
break;
case SuiWindowType::CHARACTER_BUILDER_LIST:
handleCharacterBuilderSelectItem(player, suiBox, cancel, args);
break;
case SuiWindowType::MEDIC_DIAGNOSE:
handleDiagnose(player, suiBox, cancel, args);
break;
case SuiWindowType::OBJECT_NAME:
handleSetObjectName(player, suiBox, cancel, args);
break;
}
}
CreatureObject* ThreatMap::getHighestDamageGroupLeader(){
Locker locker(&lockMutex);
VectorMap<uint64,uint32> groupDamageMap;
int64 highestGroupDmg = 0;
//Logger::Logger tlog("Threat");
ManagedReference<CreatureObject*> leaderCreature = NULL;
for (int i = 0; i < size(); ++i) {
ThreatMapEntry* entry = &elementAt(i).getValue();
uint32 totalDamage = entry->getTotalDamage();
CreatureObject* creature = elementAt(i).getKey();
//tlog.info("Group id is " + String::valueOf(creature->getGroupID()),true);
if(creature->isGrouped()){
Reference<CreatureObject*> thisleader = (creature->getGroup()->getLeader()).castTo<CreatureObject*>();
//tlog.info("leader is " + thisleader->getFirstName(),true);
if(thisleader == NULL || !thisleader->isPlayerCreature())
break;
if(!groupDamageMap.contains(creature->getGroupID())){
//tlog.info("first dmg for group " + String::valueOf(creature->getGroupID()) + " dmg: " + String::valueOf(totalDamage), true);
groupDamageMap.put(creature->getGroupID(),totalDamage);
} else {
groupDamageMap.get(creature->getGroupID()) += totalDamage;
//tlog.info("adding to group " + String::valueOf(creature->getGroupID()) + " dmg total: " + String::valueOf(groupDamageMap.get(creature->getGroupID())) + " this player dmg: " + String::valueOf(totalDamage),true);
}
if(groupDamageMap.get(creature->getGroupID()) > highestGroupDmg){
highestGroupDmg = groupDamageMap.get(creature->getGroupID());
leaderCreature = thisleader;
}
} else if (creature->isPet()) {
CreatureObject* owner = creature->getLinkedCreature().get();
if (owner != NULL && owner->isPlayerCreature()) {
if (owner->isGrouped()) {
Reference<CreatureObject*> thisleader = (owner->getGroup()->getLeader()).castTo<CreatureObject*>();
if(thisleader == NULL || !thisleader->isPlayerCreature())
break;
if(!groupDamageMap.contains(owner->getGroupID())){
groupDamageMap.put(owner->getGroupID(),totalDamage);
} else {
groupDamageMap.get(owner->getGroupID()) += totalDamage;
}
if(groupDamageMap.get(owner->getGroupID()) > highestGroupDmg){
highestGroupDmg = groupDamageMap.get(owner->getGroupID());
leaderCreature = thisleader;
}
} else {
if(!groupDamageMap.contains(owner->getObjectID())){
groupDamageMap.put(owner->getObjectID(),totalDamage);
} else {
groupDamageMap.get(owner->getObjectID()) += totalDamage;
}
if(totalDamage > highestGroupDmg) {
highestGroupDmg = totalDamage;
leaderCreature = owner;
}
}
}
} else {
//tlog.info("adding single creature damage " + String::valueOf(totalDamage),true);
groupDamageMap.put(creature->getObjectID(),totalDamage);
if(totalDamage > highestGroupDmg) {
highestGroupDmg = totalDamage;
leaderCreature = creature;
}
}
}
//tlog.info("highest group is " + leaderCreature->getFirstName() + " damage of " + String::valueOf(highestGroupDmg),true);
return leaderCreature;
}
int StructureManager::redeedStructure(CreatureObject* creature) {
ManagedReference<DestroyStructureSession*> session = creature->getActiveSession(SessionFacadeType::DESTROYSTRUCTURE).castTo<DestroyStructureSession*>();
if (session == NULL)
return 0;
ManagedReference<StructureObject*> structureObject =
session->getStructureObject();
if (structureObject == NULL)
return 0;
Locker _locker(structureObject);
ManagedReference<StructureDeed*> deed =
server->getObject(
structureObject->getDeedObjectID()).castTo<StructureDeed*>();
int maint = structureObject->getSurplusMaintenance();
int redeedCost = structureObject->getRedeedCost();
if (deed != NULL && structureObject->isRedeedable()) {
Locker _lock(deed, structureObject);
ManagedReference<SceneObject*> inventory = creature->getSlottedObject(
"inventory");
bool isSelfPoweredHarvester = false;
HarvesterObject* harvester = structureObject.castTo<HarvesterObject*>();
if(harvester != NULL)
isSelfPoweredHarvester = harvester->isSelfPowered();
if (inventory == NULL || inventory->getCountableObjectsRecursive() > (inventory->getContainerVolumeLimit() - (isSelfPoweredHarvester ? 2 : 1))) {
if(isSelfPoweredHarvester) {
//This installation can not be destroyed because there is no room for the Self Powered Harvester Kit in your inventory.
creature->sendSystemMessage("@player_structure:inventory_full_selfpowered");
} else {
//This installation can not be redeeded because your inventory does not have room to put the deed.
creature->sendSystemMessage("@player_structure:inventory_full");
}
creature->sendSystemMessage("@player_structure:deed_reclaimed_failed"); //Structure destroy and deed reclaimed FAILED!
return session->cancelSession();
} else {
if(isSelfPoweredHarvester) {
Reference<SceneObject*> rewardSceno = server->createObject(STRING_HASHCODE("object/tangible/veteran_reward/harvester.iff"), 1);
if( rewardSceno == NULL ){
creature->sendSystemMessage("@player_structure:deed_reclaimed_failed"); //Structure destroy and deed reclaimed FAILED!
return session->cancelSession();
}
// Transfer to player
if( !inventory->transferObject(rewardSceno, -1, false, true) ){ // Allow overflow
creature->sendSystemMessage("@player_structure:deed_reclaimed_failed"); //Structure destroy and deed reclaimed FAILED!
rewardSceno->destroyObjectFromDatabase(true);
return session->cancelSession();
}
harvester->setSelfPowered(false);
inventory->broadcastObject(rewardSceno, true);
creature->sendSystemMessage("@player_structure:selfpowered");
}
deed->setSurplusMaintenance(maint - redeedCost);
deed->setSurplusPower(structureObject->getSurplusPower());
structureObject->setDeedObjectID(0); //Set this to 0 so the deed doesn't get destroyed with the structure.
destroyStructure(structureObject);
inventory->transferObject(deed, -1, true);
inventory->broadcastObject(deed, true);
creature->sendSystemMessage("@player_structure:deed_reclaimed"); //Structure destroyed and deed reclaimed.
}
} else {
destroyStructure(structureObject);
creature->sendSystemMessage("@player_structure:structure_destroyed"); //Structured destroyed.
}
return session->cancelSession();
}
