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(); }