C++ ZoneServer类代码示例

void ZoneServer::ProcessServerOP_ZoneShutdown(ServerPacket* pack)
{
	ServerZoneStateChange_struct* s = (ServerZoneStateChange_struct *) pack->pBuffer;
	ZoneServer* zs = 0;
	if (s->ZoneServerID != 0)
	{
		zs = zoneserver_list.FindByID(s->ZoneServerID);
	}
	else if (s->zoneid != 0)
	{
		zs = zoneserver_list.FindByZoneID(s->zoneid);
	}
	else
	{
		zoneserver_list.SendEmoteMessage(s->adminname, 0, 0, "Error: SOP_ZoneShutdown: neither ID nor name specified");
	}

	if (zs == 0)
	{
		zoneserver_list.SendEmoteMessage(s->adminname, 0, 0, "Error: SOP_ZoneShutdown: zoneserver not found");
	}
	else
	{
		zs->SendPacket(pack);
	}
}

Vector3 BountyMissionObjectiveImplementation::getTargetPosition() {
	Locker locker(&syncMutex);

	ManagedReference<MissionObject* > mission = this->mission.get();

	if (isPlayerTarget()) {
		uint64 targetId = mission->getTargetObjectId();

		ZoneServer* zoneServer = getPlayerOwner().get()->getZoneServer();
		if (zoneServer != NULL) {
			ManagedReference<CreatureObject*> creature = zoneServer->getObject(targetId).castTo<CreatureObject*>();

			if (creature != NULL) {
				return creature->getWorldPosition();
			}
		}
	} else {
		if (targetTask != NULL) {
			return targetTask->getTargetPosition();
		}
	}

	Vector3 empty;
	return empty;
}

void RingObjectMenuComponent::fillObjectMenuResponse(SceneObject* sceneObject, ObjectMenuResponse* menuResponse, CreatureObject* player) const {
	if (!sceneObject->isTangibleObject())
		return;

	WearableObject* wearable = cast<WearableObject*>(sceneObject);
	if (wearable == NULL)
		return;

	ZoneServer* server = player->getZoneServer();
	PlayerObject* ghost = player->getPlayerObject();

	if (server == NULL || ghost == NULL)
		return;

	if (!wearable->isEquipped() && !wearable->isNoTrade()) {
		if (ghost->isMarried()) {
			menuResponse->addRadialMenuItem(234, 3, "@unity:mnu_divorce"); // Divorce
		} else {
			uint64 targetID = player->getTargetID();
			ManagedReference<CreatureObject*> target = server->getObject(targetID, true).castTo<CreatureObject*>();

			if (target != NULL && target->isPlayerCreature())
				menuResponse->addRadialMenuItem(22, 3, "@unity:mnu_propose"); // Propose Unity
		}
	}

	TangibleObjectMenuComponent::fillObjectMenuResponse(sceneObject, menuResponse, player);

}

void ZoneServer::ProcessServerOP_ZoneToZoneRequest(ServerPacket* pack)
{
	if (pack->size != sizeof(ZoneToZone_Struct)) 
	{
		cout << "Wrong size on ServerOP_ZoneToZoneRequest. Got: " << pack->size << ", Expected: " << sizeof(ZoneToZone_Struct) << endl;
		return;
	}
	ZoneToZone_Struct* ztz = (ZoneToZone_Struct*) pack->pBuffer;
	ZoneServer* zsc = 0;
	if (GetZoneID() == ztz->current_zone_id)
	{
		zsc = this;
	}
	else
		zsc = zoneserver_list.FindByZoneID(ztz->current_zone_id);
	if(zsc == 0)
		return;
	
	if(GetZoneID() == ztz->current_zone_id) 
	{
		/*if (ztz->admin < 80 && ztz->ignorerestrictions < 2 && zoneserver_list.IsZoneLocked(ztz->requested_zone_id))
		{
			ztz->response = 0;
			zsc->SendPacket(pack);
			return;
		}*/
		ZoneServer* zs = zoneserver_list.FindByZoneID(ztz->requested_zone_id);
		if(zs) 
		{
			// send to the zoneserver hosting the zone for further processing
			EQC::Common::PrintF(CP_WORLDSERVER, "Found a zone already booted for %s\n", ztz->name);
			zs->SendPacket(pack);
		}
		else 
		{
			char zonename[16];
			strcpy(zonename,Database::Instance()->GetZoneName(ztz->requested_zone_id,true));
			if (zoneserver_list.TriggerBootup(zonename)) 
			{
				EQC::Common::PrintF(CP_WORLDSERVER, "Successfully booted a zone for %s\n", ztz->name);
				// bootup successful, ready to rock
				ztz->response = 1;
			}
			else 
			{
				EQC::Common::PrintF(CP_WORLDSERVER, "FAILED to boot a zone for %s\n", ztz->name);
				// bootup failed, send back error code 0
				ztz->response = 0;
			}
			zsc->SendPacket(pack);
		}
	}
	else 
	{
		EQC::Common::PrintF(CP_WORLDSERVER, "Processing ZTZ for ingress to zone for client %s\n", ztz->name);
		// Send the response back to the original zoneserver
		zsc->SendPacket(pack);
	}
	return;
}

void CityHallZoneComponent::destroyObjectFromWorld(SceneObject* sceneObject, bool sendSelfDestroy) const {
	ZoneServer* zoneServer = sceneObject->getZoneServer();

	if (zoneServer == NULL || zoneServer->isServerShuttingDown()) {
		ZoneComponent::destroyObjectFromWorld(sceneObject, sendSelfDestroy);
		return;
	}

	ManagedReference<CityRegion*> cityRegion = sceneObject->getCityRegion().get();

	if (cityRegion != NULL ) {
		Locker clocker(cityRegion, sceneObject);

		if (cityRegion->getCityHall() == sceneObject) {
			cityRegion->setCityHall(NULL);
		}

		clocker.release();

		CityManager* cityManager = zoneServer->getCityManager();

		cityManager->destroyCity(cityRegion);
	}

	ZoneComponent::destroyObjectFromWorld(sceneObject, sendSelfDestroy);
}

bool ZSList::SendPacket(uint32 ZoneID, uint16 instanceID, ServerPacket* pack) {
	LinkedListIterator<ZoneServer*> iterator(list);

	iterator.Reset();
	if(instanceID != 0)
	{
		while(iterator.MoreElements()) {
			if(iterator.GetData()->GetInstanceID() == instanceID) {
				ZoneServer* tmp = iterator.GetData();
				return(tmp->SendPacket(pack));
			}
			iterator.Advance();
		}
	}
	else
	{
		while(iterator.MoreElements()) {
			if (iterator.GetData()->GetZoneID() == ZoneID
				&& iterator.GetData()->GetInstanceID() == 0) {
				ZoneServer* tmp = iterator.GetData();
				return(tmp->SendPacket(pack));
			}
			iterator.Advance();
		}
	}
	return(false);
}

void LootkitObjectImplementation::createItem() {
    for (int i = 0; i<comps.size(); ++i) {
        if (components.get(comps.get(i)) == 0) {
            return; // Still missing pieces
        }
    }
    ManagedReference<CreatureObject*>  player = getPlayer();
    if (player != NULL) {

        player->sendSystemMessage("@loot_kit:new_item_created");

        ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
        ZoneServer* zoneServer = server->getZoneServer();

        ManagedReference<SceneObject*> rewardObject = zoneServer->createObject(reward.get(System::random(reward.size()-1)), 2);

        Locker clocker(inventory, player);
        rewardObject->sendTo(player, true);
        if (inventory->transferObject(rewardObject, -1, true)) {
            //getParent()->removeObject(_this, true);
            destroyObjectFromWorld(true);

            if (isPersistent())
                destroyObjectFromDatabase(true);
        }
    }
}

void WeaponObjectImplementation::createChildObjects() {
	// Create any child objects in a weapon.

	ZoneServer* zoneServer = server->getZoneServer();

		for (int i = 0; i < templateObject->getChildObjectsSize(); ++i) {
			ChildObject* child = templateObject->getChildObject(i);

			if (child == NULL)
				continue;

			ManagedReference<SceneObject*> obj = zoneServer->createObject(
					child->getTemplateFile().hashCode(), getPersistenceLevel());

			if (obj == NULL)
				continue;

			ContainerPermissions* permissions = obj->getContainerPermissions();
			permissions->setOwner(getObjectID());
			permissions->setInheritPermissionsFromParent(true);
			permissions->setDefaultDenyPermission(ContainerPermissions::MOVECONTAINER);
			permissions->setDenyPermission("owner", ContainerPermissions::MOVECONTAINER);

			if (!transferObject(obj, child->getContainmentType())) {
				obj->destroyObjectFromDatabase(true);
				continue;
			}

			childObjects.put(obj);

			obj->initializeChildObject(_this.getReferenceUnsafeStaticCast());
		}

}

void handle_rc_get_zone_info(const std::string &method, const std::string &connection_id, const std::string &request_id, const std::vector<std::string> &params) {
	std::string error;
	std::map<std::string, std::string> res;
	if(params.size() != 1) {
		error = "Expected only one zone_id.";
		RemoteCallResponse(connection_id, request_id, res, error);
		return;
	}

	ZoneServer *zs = zoneserver_list.FindByID(atoi(params[0].c_str()));
	if(zs == nullptr) {
		error = "Invalid zone";
		RemoteCallResponse(connection_id, request_id, res, error);
		return;
	}

	res["type"] = zs->IsStaticZone() ? "static" : "dynamic";
	res["zone_id"] = itoa(zs->GetZoneID());
	res["instance_id"] = itoa(zs->GetInstanceID());
	res["launch_name"] = zs->GetLaunchName();
	res["launched_name"] = zs->GetLaunchedName();
	res["short_name"] = zs->GetZoneName();
	res["long_name"] = zs->GetZoneLongName();
	res["port"] = itoa(zs->GetCPort());
	res["player_count"] = itoa(zs->NumPlayers());
	RemoteCallResponse(connection_id, request_id, res, error);
}

void BountyMissionObjectiveImplementation::handlePlayerKilled(ManagedObject* arg1) {
	CreatureObject* killer = NULL;

	killer = cast<CreatureObject*>(arg1);

	ManagedReference<MissionObject* > mission = this->mission.get();
	ManagedReference<CreatureObject*> owner = getPlayerOwner();

	if (owner != NULL && killer != NULL) {
		if (owner->getObjectID() == killer->getObjectID()) {
			//Target killed by player, complete mission.
			ZoneServer* zoneServer = owner->getZoneServer();
			if (zoneServer != NULL) {
				ManagedReference<CreatureObject*> target = zoneServer->getObject(mission->getTargetObjectId()).castTo<CreatureObject*>();
				if (target != NULL) {
					VisibilityManager::instance()->clearVisibility(target);
					owner->getZoneServer()->getPlayerManager()->awardExperience(target, "jedi_general", -30000, true);

				}
			}

			complete();
		} else if (mission->getTargetObjectId() == killer->getObjectID() ||
				(npcTarget != NULL && npcTarget->getObjectID() == killer->getObjectID())) {
			//Player killed by target, fail mission.
			owner->sendSystemMessage("@mission/mission_generic:failed"); // Mission failed
			killer->sendSystemMessage("You have defeated a bounty hunter, ruining his mission against you!");
			fail();
		}
	}
}

void handle_rc_relay(const std::string &method, const std::string &connection_id, const std::string &request_id, const std::vector<std::string> &params) {
	std::string error;
	std::map<std::string, std::string> res;
	uint32 zone_id = 0;
	uint32 instance_id = 0;
	ZoneServer *zs = nullptr;
	
	if(params.size() < 2) {
		error = "Missing zone relay params";
		RemoteCallResponse(connection_id, request_id, res, error);
		return;
	}
	
	zone_id = (uint32)atoi(params[0].c_str());
	instance_id = (uint32)atoi(params[1].c_str());
	if(!zone_id && !instance_id) {
		error = "Zone not booted";
		RemoteCallResponse(connection_id, request_id, res, error);
		return;
	}
	
	
	if(instance_id) {
		zs = zoneserver_list.FindByInstanceID(instance_id);
	} else {
		zs = zoneserver_list.FindByZoneID(zone_id);
	}
	
	if(!zs) {
		error = "Zone server not found";
		RemoteCallResponse(connection_id, request_id, res, error);
		return;
	}
	
	uint32 sz = (uint32)(request_id.size() + connection_id.size() + method.size() + 3 + 16);
	uint32 p_sz = (uint32)params.size() - 2;
	for(uint32 i = 0; i < p_sz; ++i) {
		auto &param = params[i + 2];
		sz += (uint32)param.size();
		sz += 5;
	}
	
	ServerPacket *pack = new ServerPacket(ServerOP_WIRemoteCall, sz);
	pack->WriteUInt32((uint32)request_id.size());
	pack->WriteString(request_id.c_str());
	pack->WriteUInt32((uint32)connection_id.size());
	pack->WriteString(connection_id.c_str());
	pack->WriteUInt32((uint32)method.size());
	pack->WriteString(method.c_str());
	pack->WriteUInt32(p_sz);
	
	for(uint32 i = 0; i < p_sz; ++i) {
		auto &param = params[i + 2];
		pack->WriteUInt32((uint32)param.size());
		pack->WriteString(param.c_str());
	}
	
	zs->SendPacket(pack);
	safe_delete(pack);
}

bool ClientList::SendPacket(const char* to, ServerPacket* pack) {
	if (to == 0 || to[0] == 0) {
		zoneserver_list.SendPacket(pack);
		return true;
	}
	else if (to[0] == '*') {
		// Cant send a packet to a console....
		return false;
	}
	else {
		ClientListEntry* cle = FindCharacter(to);
		if (cle != nullptr) {
			if (cle->Server() != nullptr) {
				cle->Server()->SendPacket(pack);
				return true;
			}
			return false;
		} else {
			ZoneServer* zs = zoneserver_list.FindByName(to);
			if (zs != nullptr) {
				zs->SendPacket(pack);
				return true;
			}
			return false;
		}
	}
	return false;
}

void StructureObjectImplementation::notifyLoadFromDatabase() {
	TangibleObjectImplementation::notifyLoadFromDatabase();

	if (structurePermissionList.getOwner() != getOwnerObjectID()) {
		structurePermissionList.setOwner(getOwnerObjectID());
	} 

	if (permissionsFixed == false) {
		ManagedReference<StructureObject*> structure = _this.getReferenceUnsafeStaticCast();

		EXECUTE_TASK_1(structure, {
				ZoneServer* zoneServer = structure_p->getZoneServer();

				if (zoneServer == NULL) {
					return;
				}

				if (zoneServer->isServerLoading()) {
					this->reschedule(5000);
					return;
				}

				Locker locker(structure_p);

				structure_p->migratePermissions();
		});

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

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

void DeliverMissionObjectiveImplementation::despawnNpcs() {
	ZoneServer* zoneServer = ServerCore::getZoneServer();
	MissionManager* missionManager = zoneServer->getMissionManager();

	if (targetSpawnPoint != NULL)
		missionManager->freeMissionNpc(targetSpawnPoint);

	if (destinationSpawnPoint != NULL)
		missionManager->freeMissionNpc(destinationSpawnPoint);
}