WeakPtr<IPCClass> IPCManager::createClass(const char* name)
{
if (!g_pmIPCClassList)
throw gcException(ERR_IPC, "Class list is NULL");
uint32 hash = UTIL::MISC::RSHash_CSTR(name);
std::map<uint32, newClassFunc>::iterator it = g_pmIPCClassList->find(hash);
if (it == g_pmIPCClassList->end())
throw gcException(ERR_IPC, "Cant find class to create");
uint32 id = 0;
SmartPtr<IPCClass> ipcc;
{
Thread::AutoLock al(&m_ClassMutex);
id = m_mClassId;
if (m_bServer)
m_mClassId++;
else
m_mClassId--;
ipcc = SmartPtr<IPCClass>(it->second(this, id, m_uiItemId));
}
IPCScopedLock<IPCManager> lock(this, newLock());
IPCCreateClass cc;
cc.hash = hash;
cc.id = id;
cc.lock = lock->id;
sendMessage( (const char*)&cc, sizeofStruct(&cc), 0, MT_CREATECLASS);
lock->timedWait();
SmartPtr<IPCParameterI> ret(lock->result);
if (ret.get() == NULL)
{
throw gcException(ERR_IPC, "Return is NULL");
}
else if (ret->getType() == PException::getTypeS())
{
throw gcException((gcException*)getParameterValue<gcException*>(ret.get()));
}
else if (!ret->getValue()) //should be bool
{
throw gcException(ERR_IPC, "Return value is false");
}
Thread::AutoLock al(&m_ClassMutex);
m_vClassList.push_back(ipcc);
return ipcc;
}
void Thread::start()
{
MutexLock newLock( m_Mutex );
m_Handle = ( HANDLE )_beginthreadex( NULL, 0, ThreadWrapper, ( LPVOID )this, CREATE_SUSPENDED, &m_ID );
SetThreadPriority( m_Handle, ConvertPriorityToNT_Priority( m_Priority ) );
ResumeThread( m_Handle );
m_State = RUNNING;
}
IPCParameterI* IPCClass::callFunction(const char* name, bool async, std::vector<IPCParameterI*> &pList)
{
IPCFunctionCall *fch;
uint32 tsize;
char* data = serializeList(pList, tsize);
char* buff = new char[tsize + IPCFunctionCallSIZE];
fch = (IPCFunctionCall*)buff;
fch->size = tsize;
fch->functionHash = UTIL::MISC::RSHash_CSTR(name);
fch->numP = pList.size();
memcpy(&fch->data, data, tsize );
safe_delete(data);
IPCParameterI* ret = NULL;
if (async)
{
fch->id = 0;
this->sendMessage(MT_FUNCTIONCALL_ASYNC, (const char*)fch, sizeofStruct(fch) );
safe_delete(buff);
ret = new PVoid();
}
else
{
IPCScopedLock<IPCClass> lock(this, newLock());
fch->id = lock->id;
this->sendMessage(MT_FUNCTIONCALL, (const char*)fch, sizeofStruct(fch) );
safe_delete(buff);
//wait on mutex
if (lock->wait(30, 0))
throw gcException(ERR_IPC, "Waited too long with no response");
ret = lock->result;
}
return ret;
}
int StructureManager::declareResidence(CreatureObject* player,
StructureObject* structureObject) {
if (!structureObject->isBuildingObject()) {
player->sendSystemMessage(
"@player_structure:residence_must_be_building"); //Your declared residence must be a building.
return 1;
}
PlayerObject* ghost = player->getPlayerObject();
if (!player->checkCooldownRecovery("declare_residence") && !ghost->isPrivileged()) {
Time* timeremaining = player->getCooldownTime("declare_residence");
StringIdChatParameter params("player_structure",
"change_residence_time"); //You cannot change residence for %NO hours.
params.setTO(
String::valueOf(
ceil(timeremaining->miliDifference() / -3600000.f)));
player->sendSystemMessage(params);
return 1;
}
ManagedReference<BuildingObject*> buildingObject =
cast<BuildingObject*>(structureObject);
if (!buildingObject->isOwnerOf(player)) {
player->sendSystemMessage("@player_structure:declare_must_be_owner"); //You must be the owner of the building to declare residence.
return 1;
}
uint64 objectid = player->getObjectID();
uint64 declaredOidResidence = ghost->getDeclaredResidence();
ManagedReference<BuildingObject*> declaredResidence =
server->getObject(declaredOidResidence).castTo<BuildingObject*>();
ManagedReference<CityRegion*> cityRegion = buildingObject->getCityRegion();
CityManager* cityManager = server->getCityManager();
if (declaredResidence != NULL) {
if (declaredResidence == buildingObject) {
player->sendSystemMessage("@player_structure:already_residence"); //This building is already your residence.
return 1;
}
ManagedReference<CityRegion*> residentCity =
declaredResidence->getCityRegion();
if (residentCity != NULL) {
Locker lock(residentCity, player);
if (residentCity->isMayor(objectid)) {
player->sendSystemMessage("@city/city:mayor_residence_change"); //As a city Mayor, your residence is always the city hall of the city in which you are mayor. You cannot declare a new residence.
return 1;
}
cityManager->unregisterCitizen(residentCity, player);
}
player->sendSystemMessage("@player_structure:change_residence"); //You change your residence to this building.
} else {
player->sendSystemMessage("@player_structure:declared_residency"); //You have declared your residency here.
}
if (cityRegion != NULL) {
Locker lock(cityRegion, player);
if (cityRegion->isMayor(objectid) && structureObject != cityRegion->getCityHall()) {
player->sendSystemMessage("@city/city:mayor_residence_change"); //As a city Mayor, your residence is always the city hall of the city in which you are mayor. You cannot declare a new residence.
return 1;
}
cityManager->registerCitizen(cityRegion, player);
}
//Set the characters home location to this structure.
ghost->setDeclaredResidence(buildingObject);
if(declaredResidence != NULL){
Locker oldLock(declaredResidence, player);
declaredResidence->setResidence(false);
}
Locker newLock(buildingObject,player);
buildingObject->setResidence(true);
player->addCooldown("declare_residence", 24 * 3600 * 1000); //1 day
return 0;
}
void Thread::setState( ThreadState newState )
{
MutexLock newLock( m_Mutex );
m_State = newState;
}
gh::ThreadState Thread::getCurrentState()
{
MutexLock newLock( m_Mutex );
return m_State;
}
