int CraftingSessionImplementation::clearSession() {
Locker slocker(_this.get());
ManagedReference<CraftingTool*> craftingTool = this->craftingTool.get();
ManagedReference<CreatureObject*> crafter = this->crafter.get();
ManagedReference<PlayerObject*> crafterGhost = this->crafterGhost.get();
ManagedReference<CraftingStation*> craftingStation = this->craftingStation.get();
ManagedReference<ManufactureSchematic*> manufactureSchematic = this->manufactureSchematic.get();
ManagedReference<TangibleObject*> prototype = this->prototype.get();
if (manufactureSchematic != NULL) {
Locker locker(manufactureSchematic);
if (manufactureSchematic->getParent() == craftingTool) {
manufactureSchematic->setDraftSchematic(NULL);
manufactureSchematic->cleanupIngredientSlots(crafter);
manufactureSchematic->destroyObjectFromWorld(true);
}
this->manufactureSchematic = NULL;
}
if (craftingTool != NULL) {
Locker locker2(craftingTool);
// Remove all items that aren't the prototype
while (craftingTool->getContainerObjectsSize() > 1) {
craftingTool->getContainerObject(1)->destroyObjectFromWorld(true);
}
craftingTool->dropSlottedObject("crafted_components");
if (prototype != NULL) {
Locker locker3(prototype);
if (craftingTool->isReady()) {
if (prototype->getParent() == craftingTool) {
prototype->destroyObjectFromWorld(true);
}
this->prototype = NULL;
}
}
}
if(crafterGhost != NULL && crafterGhost->getDebug()) {
crafter->sendSystemMessage("*** Clearing crafting session ***");
}
return 0;
}
void CityRegionImplementation::removeAllDecorations() {
Locker slocker(&structureListMutex);
for (int i = cityDecorations.size() - 1; i >= 0 ; --i) {
ManagedReference<SceneObject*> dec = cityDecorations.get(i);
if(dec->isStructureObject()) {
StructureManager::instance()->destroyStructure(cast<StructureObject*>(dec.get()));
} else {
dec->destroyObjectFromWorld(false);
dec->destroyObjectFromDatabase(true);
}
}
cityDecorations.removeAll();
}
int vnc_Pre_Process::start_chrome()
{
// if(1 == starting_chrome)
// return 0;
starting_chrome = 1;
PRE_CHROME tmp_chrome;
int index;
int i;
LOG_INFO_FORMAT("INFO - [VNCMC]:pre start chrome started %d, pre_queue %d\n",get_pre_open_amount(),pre_open_queue.size());
for(i=0;i<(Rsm_Config::instance()->pre_amount - pre_opened_set.size());i++)
{
if(0 >= pre_open_queue.size())
{
starting_chrome = 0;
LOG_INFO("INFO - [VNCMC]: pre open thread exit\n");
return -1;
}
/*启动chrome,并设置键值不超时*/
ThreadLocker locker(add_user_lock);
index = pre_open_queue.front();
pre_open_queue.pop();
pre_openning_set.insert(index);//注册预启动中池
if(0 == send_vncms_msg("pre",10000,Rsm_Config::instance()->pre_web, index,1))
{
usleep(10*1000);
//sleep(1);
send_vncms_msg("NOTIMEOUT",5,Rsm_Config::instance()->pre_web, index,0);
LOG_INFO_FORMAT("INFO - [CHROME]: start chrome %d\n",index);
}
else
{
LOG_ERROR_FORMAT("ERROR - [RSM]: pre open chrome failed No. %d\n",index);
}
ThreadLocker slocker(pre_open_map[index].user_lock);
gettimeofday(&(pre_open_map[index].last_connect),NULL);
pre_open_map[index].inuse = true;
}
starting_chrome = 0;
LOG_INFO("INFO - [VNCMC]: pre open thread exit\n");
return 0;
}
void CityRegionImplementation::cleanupCitizens() {
Locker slocker(&structureListMutex);
SortedVector<uint64> ownerIds;
ownerIds.setNoDuplicateInsertPlan();
for (int i = 0; i < completeStructureList.size(); ++i) {
uint64 oid = completeStructureList.get(i);
ManagedReference<BuildingObject*> building = Core::getObjectBroker()->lookUp(oid).castTo<BuildingObject*>();
if (building != NULL) {
if (building->isResidence()) {
uint64 owner = building->getOwnerObjectID();
ownerIds.put(owner);
}
}
}
SortedVector<uint64> removeIds;
removeIds.setNoDuplicateInsertPlan();
for (int i = 0; i < citizenList.size(); ++i) {
uint64 id = citizenList.get(i);
if (!ownerIds.contains(id))
removeIds.put(id);
else if (isBanned(id))
removeBannedPlayer(id);
}
for (int i = 0; i < removeIds.size(); ++i) {
removeCitizen(removeIds.get(i));
}
if(getMayorID() != 0 && !isCitizen(getMayorID()))
addCitizen(getMayorID());
}
void DroidStimpackModuleDataComponent::handleInsertStimpack(CreatureObject* player, StimPack* pack) {
// we need to send the invalid stimpack message just where is a good question
countUses();
if (player == NULL)
return;
if (!player->hasSkill("science_medic_ability_04")) {
return;
}
ManagedReference<DroidObject*> droid = getDroidObject();
if (droid == NULL) {
return;
}
if (pack == NULL) {
player->sendSystemMessage("@pet/droid_modules:invalid_stimpack");
return;
}
if (!pack->isClassA()) {
player->sendSystemMessage("@pet/droid_modules:invalid_stimpack");
return;
}
if (droid->getLinkedCreature().get() != player) {
return;
}
// we have the player and the stim to add to ourselves.
// code should goes as follow, count total use of all stims, then deduct amount form capacity
DroidComponent* droidComponent = cast<DroidComponent*>(getParent());
if (droidComponent == NULL) {
return;
}
ManagedReference<SceneObject*> craftingComponents = droidComponent->getSlottedObject("crafted_components");
if (craftingComponents == NULL) {
return;
}
SceneObject* satchel = craftingComponents->getContainerObject(0);
if (satchel == NULL) {
return;
}
int allowedAmount = capacity - loaded;
if (allowedAmount <= 0) {
player->sendSystemMessage("@pet/droid_modules:stimpack_capacity_full");
return;
}
Locker plocker(pack);
int amountOnStim = pack->getUseCount();
StimPack* targetStim = compatibleStimpack(pack->getEffectiveness());
if (targetStim != NULL) {
Locker tlocker(targetStim);
if (allowedAmount > amountOnStim) {
targetStim->setUseCount(targetStim->getUseCount() + amountOnStim, true);
pack->decreaseUseCount(pack->getUseCount());
} else {
targetStim->setUseCount(targetStim->getUseCount() + allowedAmount, true);
pack->decreaseUseCount(allowedAmount);
}
} else {
// can we take it all?
if (allowedAmount > amountOnStim) {
pack->destroyObjectFromWorld(true);
// transfer to the droid and broadcast, then send the satchel to the player
satchel->transferObject(pack, -1, true);
satchel->broadcastObject(pack, true);
pack->sendTo(player, true);
droid->sendTo(player, true);
player->sendSystemMessage("@pet/droid_modules:stimpack_loaded");
} else {
// we cant load it all so split the diff
StimPack* newStim = pack->split(allowedAmount);
if (newStim != NULL) {
Locker slocker(newStim);
satchel->transferObject(newStim, -1, true);
satchel->broadcastObject(newStim, true);
player->sendSystemMessage("@pet/droid_modules:stimpack_loaded");
}
}
}
countUses();
}
void PlanetManagerImplementation::loadClientRegions() {
TemplateManager* templateManager = TemplateManager::instance();
IffStream* iffStream = templateManager->openIffFile("datatables/clientregion/" + zone->getZoneName() + ".iff");
Reference<PlanetMapCategory*> cityCat = TemplateManager::instance()->getPlanetMapCategoryByName("city");
if (iffStream == NULL) {
info("No client regions found.");
return;
}
DataTableIff dtiff;
dtiff.readObject(iffStream);
for (int i = 0; i < dtiff.getTotalRows(); ++i) {
String regionName;
float x, y, radius;
DataTableRow* row = dtiff.getRow(i);
row->getValue(0, regionName);
row->getValue(1, x);
row->getValue(2, y);
row->getValue(3, radius);
ManagedReference<CityRegion*> cityRegion = regionMap.getRegion(regionName);
if (cityRegion == NULL) {
cityRegion = new CityRegion();
Locker locker(cityRegion);
cityRegion->deploy();
cityRegion->setRegionName(regionName);
cityRegion->setZone(zone);
regionMap.addRegion(cityRegion);
}
Locker locker(cityRegion);
ManagedReference<Region*> region = cityRegion->addRegion(x, y, radius, false);
locker.release();
if (region != NULL) {
Locker rlocker(region);
if (cityRegion->getRegionsCount() == 1) {//Register the first region only.
region->setPlanetMapCategory(cityCat);
zone->registerObjectWithPlanetaryMap(region);
}
region->setMunicipalZone(true);
ManagedReference<SceneObject*> scenery = NULL;
if (gcwManager != NULL) {
int strongholdFaction = gcwManager->isStrongholdCity(regionName);
if (strongholdFaction == GCWManager::IMPERIALHASH || regionName.contains("imperial")) {
scenery = zone->getZoneServer()->createObject(STRING_HASHCODE("object/static/particle/particle_distant_ships_imperial.iff"), 0);
} else if (strongholdFaction == GCWManager::REBELHASH || regionName.contains("rebel")) {
scenery = zone->getZoneServer()->createObject(STRING_HASHCODE("object/static/particle/particle_distant_ships_rebel.iff"), 0);
} else {
scenery = zone->getZoneServer()->createObject(STRING_HASHCODE("object/static/particle/particle_distant_ships.iff"), 0);
}
} else {
scenery = zone->getZoneServer()->createObject(STRING_HASHCODE("object/static/particle/particle_distant_ships.iff"), 0);
}
Locker slocker(scenery, region);
scenery->initializePosition(x, zone->getHeight(x, y) + 100, y);
region->attachScenery(scenery);
}
ManagedReference<ActiveArea*> noBuild = zone->getZoneServer()->createObject(STRING_HASHCODE("object/active_area.iff"), 0).castTo<ActiveArea*>();
Locker areaLocker(noBuild);
noBuild->initializePosition(x, 0, y);
ManagedReference<CircularAreaShape*> areaShape = new CircularAreaShape();
Locker shapeLocker(areaShape);
areaShape->setRadius(radius * 2);
areaShape->setAreaCenter(x, y);
noBuild->setAreaShape(areaShape);
noBuild->setRadius(radius * 2);
noBuild->setNoBuildArea(true);
// Cities already have "Municipal" protection so the structure no-build should not apply to camps
noBuild->setCampingPermitted(true);
Locker zoneLocker(zone);
zone->transferObject(noBuild, -1, true);
}
info("Added " + String::valueOf(regionMap.getTotalRegions()) + " client regions.");
delete iffStream;
}
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 CityRegionImplementation::notifyExit(SceneObject* object) {
//pre: no 2 different city regions should ever overlap, only 2 Regions of the same city region
if (object->isTangibleObject()) {
TangibleObject* tano = cast<TangibleObject*>(object);
ManagedReference<Region*> activeRegion = tano->getActiveRegion().castTo<Region*>();
if (activeRegion != NULL) {
ManagedReference<CityRegion*> city = activeRegion->getCityRegion();
object->setCityRegion(city);
if (city == _this.getReferenceUnsafeStaticCast()) // if its the same city we wait till the object exits the last region
return;
} else {
object->setCityRegion(NULL);
}
} else {
object->setCityRegion(NULL);
}
if (object->isBazaarTerminal() || object->isVendor()) {
if (object->isBazaarTerminal())
bazaars.drop(object->getObjectID());
AuctionTerminalDataComponent* terminalData = NULL;
DataObjectComponentReference* data = object->getDataObjectComponent();
if(data != NULL && data->get() != NULL && data->get()->isAuctionTerminalData())
terminalData = cast<AuctionTerminalDataComponent*>(data->get());
if(terminalData != NULL)
terminalData->updateUID();
}
if (object->isPlayerCreature())
currentPlayers.decrement();
if (isClientRegion())
return;
if (object->isCreatureObject()) {
CreatureObject* creature = cast<CreatureObject*>(object);
StringIdChatParameter params("city/city", "city_leave_city"); //You have left %TO.
params.setTO(getRegionName());
creature->sendSystemMessage(params);
removeSpecializationModifiers(creature);
}
if (object->isStructureObject()) {
float x = object->getWorldPositionX();
float y = object->getWorldPositionY();
StructureObject* structure = cast<StructureObject*>(object);
Locker slocker(&structureListMutex);
if (structure->isBuildingObject()) {
BuildingObject* building = cast<BuildingObject*>(object);
uint64 ownerID = structure->getOwnerObjectID();
ZoneServer* zoneServer = building->getZoneServer();
if (zoneServer != NULL) {
ManagedReference<CreatureObject*> owner = zoneServer->getObject(ownerID).castTo<CreatureObject*>();
if(owner != NULL && owner->isPlayerCreature() && building->isResidence() && isCitizen(ownerID)) {
CityManager* cityManager = zoneServer->getCityManager();
cityManager->unregisterCitizen(_this.getReferenceUnsafeStaticCast(), owner);
}
}
}
completeStructureList.drop(structure->getObjectID());
if (structure->isCivicStructure()) {
removeStructure(structure);
} else if (structure->isCommercialStructure()) {
removeCommercialStructure(structure);
}
}
if (object->isDecoration() && object->getParent().get() == NULL) {
removeDecoration(object);
}
}
void CityRegionImplementation::notifyEnter(SceneObject* object) {
if (object->getCityRegion().get() != _this.getReferenceUnsafeStaticCast() && object->isPlayerCreature())
currentPlayers.increment();
object->setCityRegion(_this.getReferenceUnsafeStaticCast());
if (object->isBazaarTerminal() || object->isVendor()) {
if (object->isBazaarTerminal())
bazaars.put(object->getObjectID(), cast<TangibleObject*>(object));
AuctionTerminalDataComponent* terminalData = NULL;
DataObjectComponentReference* data = object->getDataObjectComponent();
if(data != NULL && data->get() != NULL && data->get()->isAuctionTerminalData())
terminalData = cast<AuctionTerminalDataComponent*>(data->get());
if(terminalData != NULL)
terminalData->updateUID();
}
if (isClientRegion())
return;
if (object->isCreatureObject()) {
CreatureObject* creature = cast<CreatureObject*>(object);
StringIdChatParameter params("city/city", "city_enter_city"); //You have entered %TT (%TO).
params.setTT(getRegionName());
UnicodeString strRank = StringIdManager::instance()->getStringId(String("@city/city:rank" + String::valueOf(cityRank)).hashCode());
if (citySpecialization.isEmpty()) {
params.setTO(strRank);
}
else {
UnicodeString citySpec = StringIdManager::instance()->getStringId(citySpecialization.hashCode());
params.setTO(strRank + ", " + citySpec);
}
creature->sendSystemMessage(params);
applySpecializationModifiers(creature);
}
if (object->isStructureObject()) {
StructureObject* structure = cast<StructureObject*>(object);
CityManager* cityManager = getZone()->getZoneServer()->getCityManager();
Locker slocker(&structureListMutex);
if (isLoaded() && !completeStructureList.contains(structure->getObjectID()) && structure->getBaseMaintenanceRate() > 0) {
cityManager->sendAddStructureMails(_this.getReferenceUnsafeStaticCast(), structure);
}
if (structure->isBuildingObject()) {
BuildingObject* building = cast<BuildingObject*>(object);
uint64 ownerID = structure->getOwnerObjectID();
ManagedReference<CreatureObject*> owner = zone->getZoneServer()->getObject(ownerID).castTo<CreatureObject*>();
if(owner != NULL && owner->isPlayerCreature() && building->isResidence() && !isCitizen(ownerID)) {
cityManager->registerCitizen(_this.getReferenceUnsafeStaticCast(), owner);
}
}
completeStructureList.put(structure->getObjectID());
if (structure->isCivicStructure() && !structure->isDecoration()) {
addStructure(structure);
} else if (structure->isCommercialStructure()) {
addCommercialStructure(structure);
}
if (registered) {
zone->registerObjectWithPlanetaryMap(structure);
}
}
if (object->isDecoration() && object->getParent().get() == NULL) {
addDecoration(object);
}
if (registered && cityMissionTerminals.contains(object)) {
zone->registerObjectWithPlanetaryMap(object);
}
if (!registered && citySkillTrainers.contains(object)) {
zone->unregisterObjectWithPlanetaryMap(object);
}
}
void CraftingSessionImplementation::selectDraftSchematic(int index) {
ManagedReference<CreatureObject*> crafter = this->crafter.get();
ManagedReference<PlayerObject*> crafterGhost = this->crafterGhost.get();
ManagedReference<CraftingTool*> craftingTool = this->craftingTool.get();
if (index >= currentSchematicList.size()) {
crafter->sendSystemMessage("Invalid Schematic Index");
closeCraftingWindow(1);
cancelSession();
return;
}
DraftSchematic* draftschematic = currentSchematicList.get(index);
if (draftschematic == NULL) {
crafter->sendSystemMessage("@ui_craft:err_no_draft_schematic");
closeCraftingWindow(1);
cancelSession();
return;
}
clearSession();
Locker slocker(_this.get());
if(crafterGhost != NULL && crafterGhost->getDebug()) {
crafter->sendSystemMessage("Selected DraftSchematic: " + draftschematic->getCustomName());
}
state = 2;
if (craftingTool != NULL) {
Locker locker(craftingTool);
if (createSessionObjects(draftschematic)) {
if (prototype == NULL) {
crafter->sendSystemMessage("@ui_craft:err_no_prototype");
closeCraftingWindow(1);
cancelSession();
return;
}
// Dplay9 ********************************************************
// Sets the Crafting state to 2, which is the Resource screen
PlayerObjectDeltaMessage9* dplay9 = new PlayerObjectDeltaMessage9(
crafter->getPlayerObject());
dplay9->setExperimentationPoints(0xFFFFFFFF);
dplay9->setCraftingState(2);
dplay9->close();
crafter->sendMessage(dplay9);
// End Dplay9 *****************************************************
} else {
crafter->sendSystemMessage("This type of object has not yet been implemented");
}
} else {
crafter->sendSystemMessage("@ui_craft:err_no_crafting_tool");
closeCraftingWindow(1);
cancelSession();
}
}
