MessageQueue::Data *MessageQueueShowFlyTextArchive::get(Archive::ReadIterator & source)
{
NetworkId emitterId;
StringId outputTextId;
Unicode::String outputTextOOB;
float scale;
uint8 red;
uint8 green;
uint8 blue;
uint32 flags;
Archive::get(source, emitterId);
Archive::get(source, outputTextId);
Archive::get(source, outputTextOOB);
Archive::get(source, scale);
Archive::get(source, red);
Archive::get(source, green);
Archive::get(source, blue);
Archive::get(source, flags);
if(outputTextId.isValid())
return new MessageQueueShowFlyText(emitterId, outputTextId, scale, static_cast<int>(red), static_cast<int>(green), static_cast<int>(blue), static_cast<int>(flags));
else
return new MessageQueueShowFlyText(emitterId, outputTextOOB, scale, static_cast<int>(red), static_cast<int>(green), static_cast<int>(blue), static_cast<int>(flags));
}
//! (static)
ObjRef callMemberFunction(Runtime & runtime, ObjPtr obj, StringId fnNameId, const ParameterValues & params) {
if(obj.isNull())
runtime.throwException("Can not call member '"+fnNameId.toString()+"' function without object.");
const Attribute & fun = obj->getAttribute(fnNameId).getValue();
if(fun.isNull())
runtime.throwException("No member to call "+obj.toDbgString()+".'"+fnNameId.toString()+"'(...).");
return runtime.executeFunction(fun.getValue(), obj.get(), params);
}
void DeliverMissionObjectiveImplementation::updateMissionStatus(CreatureObject* player) {
ManagedReference<MissionObject* > mission = this->mission.get();
if(mission == NULL)
return;
StringBuffer itemEntry;
itemEntry << "m" << mission->getMissionNumber();
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
StringId itemName;
Locker lock(player);
if (objectiveStatus == 0) {
itemEntry << "l";
item = NULL;
//TODO: create correct item.
item = (player->getZoneServer()->createObject(STRING_HASHCODE("object/tangible/mission/mission_datadisk.iff"), 2)).castTo<TangibleObject*>();
if (item == NULL) {
abort();
return;
}
Locker clocker(item, player);
itemName.setStringId("mission/mission_deliver_neutral_easy", itemEntry.toString());
item->setObjectName(itemName, false);
//Give player the item to deliver
if (inventory->transferObject(item, -1, true)) {
item->sendTo(player, true);
} else {
abort();
item->destroyObjectFromDatabase(true);
return;
}
updateMissionTarget(player);
objectiveStatus = PICKEDUPSTATUS;
} else if (objectiveStatus == 1) {
// check for item, then remove item
if (item == NULL || !inventory->hasObjectInContainer(item->getObjectID())) {
return;
}
Locker clocker2(item, player);
item->destroyObjectFromWorld(true);
item->destroyObjectFromDatabase(true);
complete();
objectiveStatus = DELIVEREDSTATUS;
}
}
double StringVector::decode(StringId id)
{
double d;
uint8_t *p = (uint8_t *)&d;
uint32_t i = id.getPage();
memcpy(p, &i, sizeof(uint32_t));
p += sizeof(uint32_t);
i = id.getOffset();
memcpy(p, &i, sizeof(uint32_t));
return d;
}
void GameStateManager::SetState(StringId newState)
{
// Leave current state
if (stateInstance_)
{
delete stateInstance_;
stateInstance_=0;
state_=StringId(0);
}
// If there's no new state, we're done
if (newState.GetString()==0)
{
return;
}
// Change current state
typedef GameState* (*CreateFunction)();
HashTableIterator<HashTableKey_StringId,CreateFunction> it(gameStates_);
CreateFunction createFunction=0;
if (it.Find(HashTableKey_StringId(newState)))
{
createFunction=it.GetCurrent();
}
Assert(createFunction,"State not recognized!");
if (!createFunction)
{
return;
}
state_=newState;
stateInstance_=createFunction();
}
StringId GetFilename(StringId filename)
{
const char* str=filename.GetString();
const char* lastDelimiter=StrRChr(str,'/');
const char* lastDelimiter2=StrRChr(str,'\\');
if (lastDelimiter && lastDelimiter2)
{
if (lastDelimiter>lastDelimiter2)
{
return StringId(lastDelimiter+1);
}
else
{
return StringId(lastDelimiter2+1);
}
}
if (lastDelimiter)
{
return StringId(lastDelimiter+1);
}
if (lastDelimiter2)
{
return StringId(lastDelimiter2+1);
}
return filename;
}
SceneObject* ObjectManager::getObject(const UnicodeString& customName) {
Locker _locker(this);
HashTableIterator<uint64, Reference<SceneObject*> > iterator(objectMap);
while (iterator.hasNext()) {
SceneObject* object = iterator.next();
StringId name = object->getObjectName();
UnicodeString cust = name.getCustomString();
if (cust.toString() == customName.toString())
return object;
}
return NULL;
}
//! (static)
std::pair<bool, ObjRef> eval(Runtime & runtime, const StringData & code,const StringId & fileId) {
try {
ObjRef result = _eval(runtime,CodeFragment( (fileId.empty() ? Consts::FILENAME_INLINE : fileId), code));
return std::make_pair(true,std::move(result));
} catch (Object * error) {
std::ostringstream os;
os << "Error occurred while evaluating '" << code.str() << "':\n" << error->toString();
runtime.log(Logger::LOG_ERROR,os.str());
return std::make_pair(false, error);
}
}
StringId GetPath(StringId filename)
{
char* path=StrDup(filename.GetString());
int len=StrLen(path);
// Remove trailing '/' or '\' (if any)
if (path[len-1]=='\\' || path[len-1]=='/')
{
path[len-1]=0;
len--;
}
// Get the path (strip away the filename)
const char* fileStart=StrRChr(path,'\\');
const char* fileStart2=StrRChr(path,'/');
if (fileStart==0 || (fileStart2 && fileStart2>fileStart))
{
fileStart=fileStart2;
}
if (fileStart>0)
{
fileStart++;
}
else
{
fileStart=path;
}
*(char*)fileStart=0;
if (StrLen(path)==0)
{
Free(path);
return ".";
}
StringId returnValue(path);
Free(path);
return returnValue;
}
int PetDeedImplementation::handleObjectMenuSelect(CreatureObject* player, byte selectedID) {
if (selectedID == 21) {
if(generated || !player->hasSkill("outdoors_bio_engineer_novice") || !isASubChildOf(player))
return 1;
if (player->isRidingMount()) {
player->sendSystemMessage("You cannot sample DNA while mounted");
return 1;
}
if(player->getPendingTask("sampledeed") != NULL) {
player->sendSystemMessage("@bio_engineer:harvest_dna_already_harvesting");
return 1;
}
int skillMod = player->getSkillMod("dna_harvesting");
if (skillMod < 1 || level > skillMod + 15) {
player->sendSystemMessage("@bio_engineer:harvest_dna_skill_too_low");
return 1;
}
Locker clocker(_this.get());
ManagedReference<SampleDeedTask*> task = new SampleDeedTask(_this.get(), player);
player->addPendingTask("sampledeed",task,0);
return 0;
}
if (selectedID == 20) {
if (generated || !isASubChildOf(player))
return 1;
if (player->isInCombat() || player->getParentRecursively(SceneObjectType::BUILDING) != NULL) {
player->sendSystemMessage("@pet/pet_menu:cant_call"); //You can only unpack vehicles while Outside and not in Combat.
return 1;
}
ManagedReference<SceneObject*> datapad = player->getSlottedObject("datapad");
if (datapad == NULL) {
player->sendSystemMessage("Datapad doesn't exist when trying to call pet");
return 1;
}
if (datapad->getContainerObjectsSize() >= datapad->getContainerVolumeLimit()) {
player->sendSystemMessage("@faction_recruiter:datapad_full"); // Your datapad is full. You must first free some space.
return 1;
}
// Does the player have room
ManagedReference<PlayerManager*> playerManager = player->getZoneServer()->getPlayerManager();
int numberStored = 0;
int maxStoredPets = playerManager->getBaseStoredCreaturePets() + player->getSkillMod("stored_pets");
for (int i = 0; i < datapad->getContainerObjectsSize(); ++i) {
ManagedReference<SceneObject*> object = datapad->getContainerObject(i);
if (object != NULL && object->isPetControlDevice()) {
PetControlDevice* device = cast<PetControlDevice*>( object.get());
if (device->getPetType() == PetManager::CREATUREPET) {
if (++numberStored >= maxStoredPets) {
player->sendSystemMessage("@pet/pet_menu:sys_too_many_stored"); // There are too many pets stored in this container. Release some of them to make room for more.
return 1;
}
}
}
}
// Can the player control it
ManagedReference<PlayerObject*> ghost = player->getPlayerObject();
int currentlySpawned = 0;
int spawnedLevel = 0;
int cLevel = level;
int maxPets = player->getSkillMod("keep_creature");
int maxLevelofPets = player->getSkillMod("tame_level");
for (int i = 0; i < ghost->getActivePetsSize(); ++i) {
ManagedReference<AiAgent*> object = ghost->getActivePet(i);
if (object != NULL && object->isCreature()) {
if (++currentlySpawned >= maxPets) {
player->sendSystemMessage("@pet/pet_menu:too_many"); // You can't control any more pets. Store one first
return 1;
}
spawnedLevel += object->getLevel();
if ((spawnedLevel + cLevel) > maxLevelofPets) {
player->sendSystemMessage("Taming this pet would exceed your control level ability.");
return 1;
}
}
}
Reference<CreatureManager*> creatureManager = player->getZone()->getCreatureManager();
if( creatureManager == NULL ){
player->sendSystemMessage("Internal Pet Deed Error #307");
return 1;
}
CreatureTemplateManager* creatureTemplateManager = CreatureTemplateManager::instance();
ManagedReference<CreatureTemplate*> petTemplate = creatureTemplateManager->getTemplate( mobileTemplate.hashCode() );
if (petTemplate == NULL) {
player->sendSystemMessage("wrong pet template;mobileTemplate=[" + mobileTemplate + "]" );
return 1;
}
bool isVicious = petTemplate->getPvpBitmask() & CreatureFlag::AGGRESSIVE;
if (level > 10 || isVicious) {
if (!player->hasSkill("outdoors_creaturehandler_novice") || (level > maxLevelofPets)) {
player->sendSystemMessage("@pet/pet_menu:sys_lack_skill"); // You lack the skill to be able to tame that creature.
return 1;
}
if (isVicious && player->getSkillMod("tame_aggro") < 1) {
player->sendSystemMessage("@pet/pet_menu:sys_lack_skill"); // You lack the skill to be able to tame that creature.
return 1;
}
}
// All checks complete, lets setup the control device and do it.
ManagedReference<PetControlDevice*> controlDevice = (server->getZoneServer()->createObject(controlDeviceObjectTemplate.hashCode(), 1)).castTo<PetControlDevice*>();
if (controlDevice == NULL) {
player->sendSystemMessage("wrong pet control device;controlDevice=[" + controlDeviceObjectTemplate + "]" );
return 1;
}
Locker locker(controlDevice);
String templateToSpawn = creatureManager->getTemplateToSpawn(mobileTemplate.hashCode());
ManagedReference<CreatureObject*> creatureObject = creatureManager->createCreature(templateToSpawn.hashCode(), true, 0 );
if( creatureObject == NULL ) {
controlDevice->destroyObjectFromDatabase(true);
player->sendSystemMessage("wrong pet template;mobileTemplate=[" + mobileTemplate + "]" );
return 1;
}
Locker clocker(creatureObject, player);
ManagedReference<Creature*> pet = creatureObject.castTo<Creature*>();
if( pet == NULL ) {
controlDevice->destroyObjectFromDatabase(true);
creatureObject->destroyObjectFromDatabase(true);
player->sendSystemMessage("Internal Pet Deed Error #348" );
return 1;
}
ObjectManager* objectManager = server->getZoneServer()->getObjectManager();
pet->setPetDeed(_this.get());
pet->loadTemplateData( petTemplate );
pet->setCustomObjectName(StringIdManager::instance()->getStringId(*pet->getObjectName()), true);
pet->createChildObjects();
pet->setBaby(false);
// update base stats on the pet now
// We will store the deed pointer to the aiagent before serialization
// Copy color customization from deed to pet
CustomizationVariables* customVars = getCustomizationVariables();
if( customVars != NULL ){
for (int i = 0; i < customVars->size(); ++i) {
uint8 id = customVars->elementAt(i).getKey();
int16 val = customVars->elementAt(i).getValue();
String name = CustomizationIdManager::instance()->getCustomizationVariable(id);
pet->setCustomizationVariable( name, val, true );
}
}
// then this is complete
StringId s;
s.setStringId(pet->getObjectName()->getFullPath());
controlDevice->setControlledObject(pet);
controlDevice->setObjectName(s);
controlDevice->setPetType(PetManager::CREATUREPET);
controlDevice->setMaxVitality(100);
controlDevice->setVitality(100);
controlDevice->setGrowthStage(1);
controlDevice->updateStatus(1);
if (!datapad->transferObject(controlDevice, -1)) {
controlDevice->destroyObjectFromDatabase(true);
return 1;
}
datapad->broadcastObject(controlDevice, true);
controlDevice->growPet(player,true);
controlDevice->callObject(player);
//Remove the deed from it's container.
ManagedReference<SceneObject*> deedContainer = getParent().get();
if (deedContainer != NULL) {
destroyObjectFromWorld(true);
}
generated = true;
player->sendSystemMessage("@pet/pet_menu:device_added"); // "A control device has been added to your datapad."
return 0;
}
return DeedImplementation::handleObjectMenuSelect(player, selectedID);
}
bool BinaryWriter::WriteStringId(StringId value) {
BASE_ASSERT(sizeof(StringId::Type) == sizeof(u32));
const StringId::Type val = value.GetValue();
return m_stream.Write(&val, 4);
}
void PixieIST::Main(const char* commandLineString)
{
ImageFormat_PNG::Register();
ImageFormat_JPG::Register();
ImageFormat_GIF::Register();
ImageFormat_TGA::Register();
printf("Pixie Image Slicing Tool %s\n\n", PixieIST::version);
// handle the command line
CommandLine cmd(commandLineString);
// PixieIST sheetfilename cellwidth cellheight
if (cmd.GetCommandLineStringCount() < 4)
{
DisplayProgramUsage();
return;
}
// get params
StringId sheetFilename = cmd.GetCommandLineString(1);
int sliceWidth = StringToInt(cmd.GetCommandLineString(2).GetString());
int sliceHeight = StringToInt(cmd.GetCommandLineString(3).GetString());
// validate params
Asset sheetAsset(sheetFilename);
if (!sheetAsset.Open())
{
printf("Unable to open %s\n", sheetFilename.GetString());
return;
}
sheetAsset.Close();
Image sheetImage(sheetFilename);
int sheetWidth = sheetImage.GetWidth();
int sheetHeight = sheetImage.GetHeight();
if (sliceWidth <= 0)
{
printf("Error: Invalid Slice Width %d\n", sliceWidth);
return;
}
if (sliceHeight <= 0)
{
printf("Error: Invalid Slice Height %d\n", sliceHeight);
return;
}
printf(
"Proceeding with the following settings:\n"
" sheet: %s (%dx%d)\n"
" slice width: %d\n"
" slice height: %d\n\n",
sheetFilename.GetString(),
sheetWidth,
sheetHeight,
sliceWidth,
sliceHeight);
int xSlices = sheetWidth / sliceWidth;
int ySlices = sheetHeight / sliceHeight;
int sliceCount = xSlices * ySlices;
printf("Slicing %s into %d %dx%d images...\n", sheetFilename.GetString(), sliceCount, sliceWidth, sliceHeight);
int baseLen = StrLen(sheetFilename.GetString()) - 4;
char* baseName = new char[baseLen + 1];
StrNCpy(baseName, sheetFilename.GetString(), baseLen);
baseName[baseLen] = 0;
char countBuffer[5];
for (int i = 0; i < sliceCount; i++)
{
SNPrintF(countBuffer, 5, "%04d", (i + 1));
char* sliceName = new char[StrLen(countBuffer) + StrLen(baseName) + 7];
StrCpy(sliceName, baseName);
StrCat(sliceName, "_");
StrCat(sliceName, countBuffer);
StrCat(sliceName, ".tga");
Image sliceImage(sliceWidth, sliceHeight);
// copy pixel data
int fromX = sliceWidth * (i % xSlices);
int fromY = sliceHeight * (i / xSlices);
for (int y = 0; y < sliceHeight; y++)
{
int y2 = fromY + y;
for (int x = 0; x < sliceWidth; x++)
{
unsigned pixel = sheetImage.GetPixel(fromX + x, y2);
sliceImage.SetPixel(x, y, pixel);
}
}
//printf("*** Slicing from %6d, %6d\n", fromX, fromY);
printf(" Saving %s\n", sliceName);
sliceImage.Save<ImageFormat_TGA>(sliceName);
delete [] sliceName;
}
delete [] baseName;
}
void DnaManager::generateSample(Creature* creature, CreatureObject* player,int quality){
if (quality < 0 || quality > 7) {
return;
}
Locker lock(creature,player);
CreatureTemplate* creatureTemplate = dynamic_cast<CreatureTemplate*>(creature->getCreatureTemplate());
int ferocity = creatureTemplate->getFerocity();
int cl = creature->getLevel();
int cle = instance()->generateScoreFor(DnaManager::CLEVERNESS,cl,quality);
int cou = instance()->generateScoreFor(DnaManager::COURAGE,cl,quality);
int dep = instance()->generateScoreFor(DnaManager::DEPENDABILITY,cl,quality);
int dex = instance()->generateScoreFor(DnaManager::DEXTERITY,cl,quality);
int end = instance()->generateScoreFor(DnaManager::ENDURANCE,cl,quality);
int fie = instance()->generateScoreFor(DnaManager::FIERCENESS,ferocity,quality);
int frt = instance()->generateScoreFor(DnaManager::FORTITUDE,cl,quality);
int har = instance()->generateScoreFor(DnaManager::HARDINESS,cl,quality);
int ite = instance()->generateScoreFor(DnaManager::INTELLIGENCE,cl,quality);
int pow = instance()->generateScoreFor(DnaManager::POWER,cl,quality);
// We should now have enough to generate a sample
ManagedReference<DnaComponent*> prototype = player->getZoneServer()->createObject(qualityTemplates.get(quality), 1).castTo<DnaComponent*>();
if (prototype == NULL) {
return;
}
Locker clocker(prototype);
// Check Here for unique npcs
StringId* nameId = creature->getObjectName();
if (nameId->getFile().isEmpty() || nameId->getStringID().isEmpty()) {
prototype->setSource(creature->getCreatureName().toString());
} else {
prototype->setSource(nameId->getFullPath());
}
prototype->setQuality(quality);
prototype->setLevel(cl);
String serial = player->getZoneServer()->getCraftingManager()->generateSerial();
prototype->setSerialNumber(serial);
prototype->setStats(cle,end,fie,pow,ite,cou,dep,dex,frt,har);
prototype->setStun(creatureTemplate->getStun());
prototype->setKinetic(creatureTemplate->getKinetic());
prototype->setEnergy(creatureTemplate->getEnergy());
prototype->setBlast(creatureTemplate->getBlast());
prototype->setHeat(creatureTemplate->getHeat());
prototype->setCold(creatureTemplate->getCold());
prototype->setElectric(creatureTemplate->getElectricity());
prototype->setAcid(creatureTemplate->getAcid());
prototype->setSaber(creatureTemplate->getLightSaber());
prototype->setRanged(creatureTemplate->getWeapons().size() > 0);
prototype->setArmorRating(creatureTemplate->getArmor());
CreatureAttackMap* attackMap = creatureTemplate->getAttacks();
if (attackMap->size() > 0) {
prototype->setSpecialAttackOne(String(attackMap->getCommand(0)));
if(attackMap->size() > 1) {
prototype->setSpecialAttackTwo(String(attackMap->getCommand(1)));
}
}
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
if (inventory->hasFullContainerObjects()) {
StringIdChatParameter err("survey", "no_inv_space");
player->sendSystemMessage(err);
player->setPosture(CreaturePosture::UPRIGHT, true);
return;
}
Locker locker(inventory);
inventory->transferObject(prototype, -1, true,false);
inventory->broadcastObject(prototype, true);
}
void SwgSnapshot::decodeStringId(Archive::ReadIterator &data,DB::BufferString &table,DB::BufferString &text) const
{
StringId temp;
Archive::get(data,temp);
temp.packToDatabase(table,text);
}
void DnaManager::generateSample(Creature* creature, CreatureObject* player,int quality){
if (quality < 0 || quality > 7) {
return;
}
Locker lock(creature,player);
CreatureTemplate* creatureTemplate = dynamic_cast<CreatureTemplate*>(creature->getCreatureTemplate());
int ferocity = creatureTemplate->getFerocity();
int cl = creature->getLevel();
int cle = Genetics::hitChanceToValue(creature->getChanceHit(),quality);
int cou = Genetics::meatTypeToValue(creature->getMeatType(),quality);
int dep = Genetics::dietToValue(creature->getDiet(),quality);
int dex = Genetics::hamToValue(creature->getMaxHAM(3),quality);
int end = Genetics::accelerationToValue(creature->getWalkAcceleration(),quality);
int fie = Genetics::ferocityToValue(ferocity,quality);
int frt = Genetics::resistanceToValue(creature->getEffectiveResist(),creature->getArmor(),quality);
int har = Genetics::hamToValue(creature->getMaxHAM(0),quality);
int ite = Genetics::hamToValue(creature->getMaxHAM(6),quality);
int pow = Genetics::damageToValue((creature->getDamageMax() + creature->getDamageMin())/2,quality);
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
if (inventory->hasFullContainerObjects()) {
StringIdChatParameter err("survey", "no_inv_space");
player->sendSystemMessage(err);
player->setPosture(CreaturePosture::UPRIGHT, true);
return;
}
// We should now have enough to generate a sample
ManagedReference<DnaComponent*> prototype = player->getZoneServer()->createObject(qualityTemplates.get(quality), 1).castTo<DnaComponent*>();
if (prototype == NULL) {
return;
}
Locker clocker(prototype);
// Check Here for unique npcs
StringId* nameId = creature->getObjectName();
if (nameId->getFile().isEmpty() || nameId->getStringID().isEmpty()) {
prototype->setSource(creature->getCreatureName().toString());
} else {
prototype->setSource(nameId->getFullPath());
}
prototype->setQuality(quality);
prototype->setLevel(cl);
String serial = player->getZoneServer()->getCraftingManager()->generateSerial();
prototype->setSerialNumber(serial);
prototype->setStats(cle,end,fie,pow,ite,cou,dep,dex,frt,har);
prototype->setStun(creatureTemplate->getStun());
prototype->setKinetic(creatureTemplate->getKinetic());
prototype->setEnergy(creatureTemplate->getEnergy());
prototype->setBlast(creatureTemplate->getBlast());
prototype->setHeat(creatureTemplate->getHeat());
prototype->setCold(creatureTemplate->getCold());
prototype->setElectric(creatureTemplate->getElectricity());
prototype->setAcid(creatureTemplate->getAcid());
prototype->setSaber(creatureTemplate->getLightSaber());
prototype->setRanged(creatureTemplate->getWeapons().size() > 0);
prototype->setArmorRating(creatureTemplate->getArmor());
if (creatureTemplate->isSpecialProtection(WeaponObject::STUN))
prototype->setSpecialResist(WeaponObject::STUN);
if (creatureTemplate->isSpecialProtection(WeaponObject::KINETIC))
prototype->setSpecialResist(WeaponObject::KINETIC);
if (creatureTemplate->isSpecialProtection(WeaponObject::ENERGY))
prototype->setSpecialResist(WeaponObject::ENERGY);
if (creatureTemplate->isSpecialProtection(WeaponObject::BLAST))
prototype->setSpecialResist(WeaponObject::BLAST);
if (creatureTemplate->isSpecialProtection(WeaponObject::HEAT))
prototype->setSpecialResist(WeaponObject::HEAT);
if (creatureTemplate->isSpecialProtection(WeaponObject::COLD))
prototype->setSpecialResist(WeaponObject::COLD);
if (creatureTemplate->isSpecialProtection(WeaponObject::ELECTRICITY))
prototype->setSpecialResist(WeaponObject::ELECTRICITY);
if (creatureTemplate->isSpecialProtection(WeaponObject::ACID))
prototype->setSpecialResist(WeaponObject::ACID);
if (creatureTemplate->isSpecialProtection(WeaponObject::LIGHTSABER))
prototype->setSpecialResist(WeaponObject::LIGHTSABER);
CreatureAttackMap* attackMap = creatureTemplate->getAttacks();
if (attackMap->size() > 0) {
prototype->setSpecialAttackOne(String(attackMap->getCommand(0)));
if(attackMap->size() > 1) {
prototype->setSpecialAttackTwo(String(attackMap->getCommand(1)));
}
}
Locker locker(inventory);
if (inventory->transferObject(prototype, -1, true, false)) {
inventory->broadcastObject(prototype, true);
} else {
prototype->destroyObjectFromDatabase(true);
}
}
void SwgSnapshot::encodeStringId(Archive::ByteStream &data, const DB::BufferString &table, const DB::BufferString &text) const
{
StringId temp;
temp.unpackFromDatabase(table,text);
Archive::put(data,temp);
}
void CentralServerConnection::onReceive(const Archive::ByteStream & message)
{
Archive::ReadIterator ri = message.begin();
GameNetworkMessage msg(ri);
ri = message.begin();
if(msg.isType("ConGenericMessage"))
{
// dispatch to CentralCommandParser
ConGenericMessage con(ri);
Unicode::String wideResult;
m_centralCommandParser->parse(NetworkId(static_cast<NetworkId::NetworkIdType>(con.getMsgId())), Unicode::narrowToWide(con.getMsg()), wideResult);
ConGenericMessage response(Unicode::wideToNarrow(wideResult), con.getMsgId());
send(response, true);
}
else if(msg.isType("CharacterTransferStatusMessage"))
{
CharacterTransferStatusMessage c(ri);
CreatureObject * character = safe_cast<CreatureObject *>(NetworkIdManager::getObjectById(c.getToCharacterId()));
if(character)
{
if(character->getClient())
{
character->receiveCharacterTransferStatusMessage(c.getStatusMessage());
}
}
}
else if(msg.isType("TransferRequestNameValidation"))
{
const GenericValueTypeMessage<TransferCharacterData> requestNameValidation(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferRequestNameValidation from CentralServer : %s", requestNameValidation.getValue().toString().c_str()));
std::string name = requestNameValidation.getValue().getDestinationCharacterName();
if(name.empty())
{
name = requestNameValidation.getValue().getSourceCharacterName();
}
// call the same name validation code that gets called for normal character creation
std::string templateName = requestNameValidation.getValue().getObjectTemplateName();
if (templateName.empty())
{
uint32 const templateCrc = requestNameValidation.getValue().getObjectTemplateCrc();
if (templateCrc != 0)
{
templateName = ObjectTemplateList::lookUp(templateCrc).getString();
}
}
VerifyAndLockNameRequest const verifyRequest(requestNameValidation.getValue().getDestinationStationId(), NetworkId::cms_invalid, templateName, Unicode::narrowToWide(name), 0xFFFFFFFF);
StringId const verifyResult = GameServer::getInstance().handleVerifyAndLockNameRequest(verifyRequest, false, false);
TransferCharacterData replyData(requestNameValidation.getValue());
replyData.setIsValidName(verifyResult == NameErrors::nameApproved);
GenericValueTypeMessage<std::pair<std::string, TransferCharacterData> > reply("TransferReplyNameValidation", std::make_pair(std::string("@") + verifyResult.getCanonicalRepresentation(), replyData));
send(reply, true);
}
else if(msg.isType("TransferReplyCharacterList"))
{
const TransferReplyCharacterList reply(ri);
const AvatarList & oldAl = reply.getAvatarList();
// remove any characters from the list that would qualify for free CTS; characters that
// qualify for free CTS should/must use the in-game free CTS to transfer the character;
AvatarList newAl;
std::string const & clusterName = GameServer::getInstance().getClusterName();
for (AvatarList::const_iterator iter = oldAl.begin(); iter != oldAl.end(); ++iter)
{
if (!FreeCtsDataTable::getFreeCtsInfoForCharacter(static_cast<time_t>(NameManager::getInstance().getPlayerCreateTime(iter->m_networkId)), clusterName, false))
newAl.push_back(*iter);
else
LOG("CustomerService", ("CharacterTransfer: removing (%s, %s, %s) from paid CTS character list for station id %u because the character qualifies for free CTS", clusterName.c_str(), Unicode::wideToNarrow(iter->m_name).c_str(), iter->m_networkId.getValueString().c_str(), reply.getStationId()));
}
// send updated character list back to CentralServer
const TransferReplyCharacterList updatedReply(reply.getTrack(), reply.getStationId(), newAl);
send(updatedReply, true);
}
else if(msg.isType("CtsCompletedForcharacter"))
{
const GenericValueTypeMessage<std::pair<std::string, NetworkId> > msg(ri);
MessageToQueue::getInstance().sendMessageToJava(msg.getValue().second, "ctsCompletedForCharacter", std::vector<int8>(), 0, false);
}
else if( msg.isType( "GameServerCSRequest" ) )
{
GameServerCSRequestMessage request( ri );
GameServer::getInstance().handleCSRequest( request );
}
else if( msg.isType( "CSFindAuthObject" ) )
{
// see if we have the object.
GenericValueTypeMessage< std::pair<NetworkId, unsigned int> > msg( ri );
ServerObject * object = safe_cast<ServerObject *>( NetworkIdManager::getObjectById( msg.getValue().first ) );
// return an appropriate response.
if( object && object->isAuthoritative() )
{
GenericValueTypeMessage< std::pair< unsigned int, bool > > rmsg( "CSFindAuthObjectReply", std::make_pair( msg.getValue().second, true ) );
GameServer::getInstance().sendToCentralServer( rmsg );
}
else
{
GenericValueTypeMessage< std::pair< unsigned int, bool > > rmsg( "CSFindAuthObjectReply", std::make_pair( msg.getValue().second, false ) );
GameServer::getInstance().sendToCentralServer( rmsg );
}
}
else
{
ServerConnection::onReceive(message);
}
}
int DroidDeedImplementation::handleObjectMenuSelect(CreatureObject* player, byte selectedID) {
if (selectedID == 20) {
if (generated || !isASubChildOf(player))
return 1;
if (player->isInCombat() || player->isRidingMount() || player->isSwimming() || player->isDead() || player->isIncapacitated() ){
player->sendSystemMessage("@pet/pet_menu:cant_call"); // "You cannot call this pet right now."
return 1;
}
ManagedReference<SceneObject*> datapad = player->getSlottedObject("datapad");
if (datapad == NULL) {
player->sendSystemMessage("Datapad doesn't exist when trying to generate droid");
return 1;
}
// Check if this will exceed maximum number of droids allowed
ManagedReference<PlayerManager*> playerManager = player->getZoneServer()->getPlayerManager();
int droidsInDatapad = 0;
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("You have too many droids in your datapad");
return 1;
}
Reference<CreatureManager*> creatureManager = player->getZone()->getCreatureManager();
if( creatureManager == NULL )
return 1;
CreatureTemplateManager* creatureTemplateManager = CreatureTemplateManager::instance();
Reference<CreatureTemplate*> creatureTemplate = creatureTemplateManager->getTemplate( mobileTemplate.hashCode() );
if( creatureTemplate == NULL ){
player->sendSystemMessage("wrong droid template;mobileTemplate=[" + mobileTemplate + "]" );
return 1;
}
Reference<PetControlDevice*> controlDevice = (server->getZoneServer()->createObject(controlDeviceObjectTemplate.hashCode(), 1)).castTo<PetControlDevice*>();
if( controlDevice == NULL ){
player->sendSystemMessage("wrong droid control device template " + controlDeviceObjectTemplate);
return 1;
}
Locker locker(controlDevice);
Reference<CreatureObject*> creatureObject = creatureManager->createCreature(generatedObjectTemplate.hashCode(), true, mobileTemplate.hashCode() );
if( creatureObject == NULL ){
controlDevice->destroyObjectFromDatabase(true);
player->sendSystemMessage("wrong droid templates;mobileTemplate=[" + mobileTemplate + "];generatedObjectTemplate=[" + generatedObjectTemplate + "]" );
return 1;
}
Locker clocker(creatureObject, player);
Reference<DroidObject*> droid = creatureObject.castTo<DroidObject*>();
if( droid == NULL ) {
controlDevice->destroyObjectFromDatabase(true);
creatureObject->destroyObjectFromDatabase(true);
return 1;
}
droid->loadTemplateData( creatureTemplate );
droid->setCustomObjectName(StringIdManager::instance()->getStringId(*droid->getObjectName()), true);
// Transfer crafting components from deed to droid
ManagedReference<SceneObject*> craftingComponents = getSlottedObject("crafted_components");
if(craftingComponents != NULL) {
SceneObject* satchel = craftingComponents->getContainerObject(0);
// remove all items form satchel and add int he new items
Vector<ManagedReference<SceneObject*> > toRemove;
for (int i = 0; i < satchel->getContainerObjectsSize(); ++i) {
ManagedReference<SceneObject*> sceno = satchel->getContainerObject(i);
if (sceno != NULL) {
toRemove.add(sceno);
}
}
satchel->removeAllContainerObjects();
for(int i=0;i<toRemove.size();i++) {
SceneObject* component = toRemove.get(i);
Locker componenetLocker(component);
component->destroyObjectFromWorld(true);
}
// this will change to use stacked modules. we wont care about non droid modules as they arent needed.
String key;
ManagedReference<DroidComponent*> comp = NULL;
HashTableIterator<String, ManagedReference<DroidComponent*> > iterator = modules.iterator();
droid->setResists(0);
droid->setHitChance(0);
for(int i = 0; i < modules.size(); ++i) {
iterator.getNextKeyAndValue(key, comp);
if (comp) {
satchel->transferObject(comp, -1, false);
DataObjectComponentReference* data = comp->getDataObjectComponent();
BaseDroidModuleComponent* module = NULL;
if(data != NULL && data->get() != NULL && data->get()->isDroidModuleData()) {
module = cast<BaseDroidModuleComponent*>(data->get());
module->initialize(droid);
}
}
}
droid->transferObject(craftingComponents, 4, false);
craftingComponents->setSendToClient(false);
}
// Copy color customization from deed to droid
CustomizationVariables* customVars = getCustomizationVariables();
if( customVars != NULL ){
for (int i = 0; i < customVars->size(); ++i) {
uint8 id = customVars->elementAt(i).getKey();
int16 val = customVars->elementAt(i).getValue();
String name = CustomizationIdManager::instance()->getCustomizationVariable(id);
if( name.contains( "color" ) ){
droid->setCustomizationVariable( name, val, true );
}
}
droid->refreshPaint();
}
StringId s;
s.setStringId(droid->getObjectName()->getFullPath());
controlDevice->setObjectName(s);
controlDevice->setPetType(PetManager::DROIDPET);
controlDevice->setMaxVitality(100);
controlDevice->setVitality(100);
droid->createChildObjects();
controlDevice->setControlledObject(droid);
controlDevice->setDefaultCommands();
if (!datapad->transferObject(controlDevice, -1)) {
controlDevice->destroyObjectFromDatabase(true);
return 1;
}
datapad->broadcastObject(controlDevice, true);
controlDevice->callObject(player);
droid->initDroidModules(true);
float maxHam = DroidMechanics::determineHam(overallQuality,species);
for (int i = 0; i < 9; ++i) {
if (i % 3 == 0) {
droid->setBaseHAM(i,maxHam,true);
droid->setHAM(i,maxHam,true);
} else {
droid->setBaseHAM(i,maxHam/100,true);
droid->setHAM(i,maxHam/100,true);
}
}
//Remove the deed from its container.
ManagedReference<SceneObject*> deedContainer = getParent().get();
if (deedContainer != NULL) {
destroyObjectFromWorld(true);
}
generated = true;
destroyObjectFromDatabase(true);
player->sendSystemMessage("@pet/pet_menu:device_added"); // "A control device has been added to your datapad."
return 0;
}
return DeedImplementation::handleObjectMenuSelect(player, selectedID);
}
void SpriteManager::Update(float deltaTime)
{
float x=siInputManager->GetCursorX();
float y=siInputManager->GetCursorY();
bool button=siInputManager->IsKeyDown(KEY_LBUTTON);
bool clicked=siInputManager->WasKeyReleased(KEY_LBUTTON) || activatedHighlighted_;
bool foundMouseOver = false;
for (int i=sprites_.GetItemCount()-1; i>=0; i--)
{
Sprite* sprite=sprites_.Get(i);
StringId eventId;
void* userData=0;
bool mouseOver=sprite->OnMouseOver((int)(x-originX_),(int)(y-originY_),button,eventId,userData, false);
if( mouseOver )
{
foundMouseOver = true;
}
if (mouseOver && clicked && eventId.GetString())
{
if (SpriteSystem::IsInstanceCreated() && siSpriteSystem->HasSpriteManager(this))
{
siSpriteSystem->SendEvent(this,eventId,userData);
}
else
{
SendEvent(eventId,userData);
}
break;
}
}
if( !foundMouseOver )
{
for (int i=sprites_.GetItemCount()-1; i>=0; i--)
{
Sprite* sprite=sprites_.Get(i);
StringId eventId;
void* userData=0;
if( currentHighlighted_ && currentHighlighted_->GetSelectionIndex() == sprite->GetSelectionIndex() )
{
bool mouseOver=sprite->OnMouseOver((int)(sprite->GetX()+1.0f-originX_),(int)(sprite->GetY()+1.0f-originY_),button,eventId,userData, true);
if (mouseOver && activatedHighlighted_ && eventId.GetString())
{
activatedHighlighted_ = false;
if (SpriteSystem::IsInstanceCreated() && siSpriteSystem->HasSpriteManager(this))
{
siSpriteSystem->SendEvent(this,eventId,userData);
}
else
{
SendEvent(eventId,userData);
}
return;
}
}
}
}
else if( currentHighlighted_ )
{
StringId eventId;
void* userData=0;
currentHighlighted_->OnMouseOver(0,0,button,eventId,userData, false);
currentHighlighted_=0;
}
activatedHighlighted_ = false;
}
