void pyVault::RegisterMTStation( const char * stationName, const char * backLinkSpawnPtObjName )
{
wchar_t wStationName[256];
wchar_t wSpawnPt[256];
StrToUnicode(wStationName, stationName, arrsize(wStationName));
StrToUnicode(wSpawnPt, backLinkSpawnPtObjName, arrsize(wSpawnPt));
// Note: This doesn't actually block (~Hoikas)
VaultRegisterMTStationAndWait( wStationName, wSpawnPt);
}
void VaultAgeInfoNode::CopyFrom (const plAgeInfoStruct * info) {
wchar_t str[MAX_PATH];
// age filename
if (info->HasAgeFilename()) {
StrToUnicode(str, info->GetAgeFilename(), arrsize(str));
SetAgeFilename(str);
}
else {
SetAgeFilename(nil);
}
// age instance name
if (info->HasAgeInstanceName()) {
StrToUnicode(str, info->GetAgeInstanceName(), arrsize(str));
SetAgeInstanceName(str);
}
else {
SetAgeInstanceName(nil);
}
// age user-defined name
if (info->HasAgeUserDefinedName()) {
StrToUnicode(str, info->GetAgeUserDefinedName(), arrsize(str));
SetAgeUserDefinedName(str);
}
else {
SetAgeUserDefinedName(nil);
}
// age description
// TODO
if (info->HasAgeDescription()) {
// StrToUnicode(str, info->GetAgeDescription(), arrsize(str));
// SetAgeDescription(str);
}
else {
// SetAgeDescription(nil);
}
// age sequence number
SetAgeSequenceNumber(info->GetAgeSequenceNumber());
// age instance guid
SetAgeInstanceGuid(*info->GetAgeInstanceGuid());
// age language
SetAgeLanguage(info->GetAgeLanguage());
}
void pyVault::UpdatePsnlAgeSDL( pySDLStateDataRecord & pyrec )
{
plStateDataRecord * rec = pyrec.GetRec();
if ( !rec )
return;
NetVaultNode * templateNode = new NetVaultNode;
templateNode->IncRef();
if (RelVaultNode * rvnFldr = VaultGetAgesIOwnFolderIncRef()) {
templateNode->ClearFieldFlags();
templateNode->SetNodeType(plVault::kNodeType_AgeInfo);
VaultAgeInfoNode ageInfo(templateNode);
wchar_t str[MAX_PATH];
StrToUnicode(str, kPersonalAgeFilename, arrsize(str));
ageInfo.SetAgeFilename(str);
if (RelVaultNode * rvnInfo = rvnFldr->GetChildNodeIncRef(templateNode, 2)) {
templateNode->ClearFieldFlags();
templateNode->SetNodeType(plVault::kNodeType_SDL);
if (RelVaultNode * rvnSdl = rvnInfo->GetChildNodeIncRef(templateNode, 1)) {
VaultSDLNode sdl(rvnSdl);
sdl.SetStateDataRecord(rec, plSDL::kDirtyOnly | plSDL::kTimeStampOnRead);
rvnSdl->DecRef();
}
rvnInfo->DecRef();
}
rvnFldr->DecRef();
}
templateNode->DecRef();
}
// True if device exists in age.
bool pyAgeVault::HasDevice( const char * deviceName )
{
wchar_t wStr[MAX_PATH];
StrToUnicode(wStr, deviceName, arrsize(wStr));
return VaultAgeHasDevice(wStr);
}
// Remove a device.
void pyAgeVault::RemoveDevice( const char * deviceName )
{
wchar_t wStr[MAX_PATH];
StrToUnicode(wStr, deviceName, arrsize(wStr));
VaultAgeRemoveDevice(wStr);
}
PyObject* pyVault::GetPsnlAgeSDL() const
{
PyObject * result = nil;
hsRef<NetVaultNode> templateNode = new NetVaultNode;
if (hsRef<RelVaultNode> rvnFldr = VaultGetAgesIOwnFolder()) {
templateNode->ClearFieldFlags();
templateNode->SetNodeType(plVault::kNodeType_AgeInfo);
VaultAgeInfoNode ageInfo(templateNode);
wchar_t str[MAX_PATH];
StrToUnicode(str, kPersonalAgeFilename, arrsize(str));
ageInfo.SetAgeFilename(str);
if (hsRef<RelVaultNode> rvnInfo = rvnFldr->GetChildNode(templateNode, 2)) {
templateNode->ClearFieldFlags();
templateNode->SetNodeType(plVault::kNodeType_SDL);
if (hsRef<RelVaultNode> rvnSdl = rvnInfo->GetChildNode(templateNode, 1)) {
VaultSDLNode sdl(rvnSdl);
plStateDataRecord * rec = new plStateDataRecord;
if (sdl.GetStateDataRecord(rec, plSDL::kKeepDirty))
result = pySDLStateDataRecord::New(rec);
else
delete rec;
}
}
}
if (!result)
PYTHON_RETURN_NONE;
return result;
}
// This function makes an entry into the application event log
void CNTService::LogEvent(WORD wType, DWORD dwID,
const char* pszS1,
const char* pszS2,
const char* pszS3)
{
wchar_t *p1 = pszS1 ? StrToUnicode( pszS1 ) : NULL;
wchar_t *p2 = pszS2 ? StrToUnicode( pszS2 ) : NULL;
wchar_t *p3 = pszS3 ? StrToUnicode( pszS3 ) : NULL;
LogEvent( wType, dwID, p1, p2, p3 );
if ( p1 )
free( p1 );
if ( p2 )
free( p2 );
if ( p3 )
free( p3 );
}
// Sets the inbox associated with a device.
void pyAgeVault::SetDeviceInbox( const char * deviceName, const char * inboxName, PyObject * cbObject, uint32_t cbContext )
{
pyVaultNode::pyVaultNodeOperationCallback * cb = new pyVaultNode::pyVaultNodeOperationCallback( cbObject );
cb->VaultOperationStarted( cbContext );
wchar_t wDev[MAX_PATH];
StrToUnicode(wDev, deviceName, arrsize(wDev));
wchar_t wInb[MAX_PATH];
StrToUnicode(wInb, inboxName, arrsize(wInb));
if (RelVaultNode * rvn = VaultAgeSetDeviceInboxAndWaitIncRef(wDev, wInb)) {
cb->SetNode(rvn);
rvn->UnRef();
}
cb->VaultOperationComplete( cbContext, cb->GetNode() ? hsOK : hsFail ); // cbHolder deletes itself here.
}
void pyVaultNode::SetCreateAgeName( const char * v )
{
free(fCreateAgeName);
fCreateAgeName = nil;
ASSERT(fNode);
wchar_t str[MAX_PATH];
StrToUnicode(str, v, arrsize(str));
fNode->SetCreateAgeName(str);
}
void pyVault::SendToDevice( pyVaultNode& node, const char * deviceName )
{
if (!node.GetNode())
return;
wchar_t wDevName[256];
StrToUnicode(wDevName, deviceName, arrsize(wDevName));
// Note: This actually blocks (~Hoikas)
VaultPublishNode(node.GetNode()->GetNodeId(), wDevName);
}
///////////////
// Chronicle
PyObject* pyVault::FindChronicleEntry( const char * entryName )
{
wchar_t wEntryName[kMaxVaultNodeStringLength];
StrToUnicode(wEntryName, entryName, arrsize(wEntryName));
if (hsRef<RelVaultNode> rvn = VaultFindChronicleEntry(wEntryName))
return pyVaultChronicleNode::New(rvn);
// just return a None object
PYTHON_RETURN_NONE;
}
//==================================================================
// class RelVaultNode : public plVaultNode
//
void pyVaultTextNoteNode::Note_SetTitle( const char * text )
{
if (!fNode)
return;
wchar_t wStr[MAX_PATH] = L"";
if (text)
StrToUnicode(wStr, text, arrsize(wStr));
VaultTextNoteNode textNote(fNode);
textNote.SetNoteTitle(wStr);
}
PyObject * pyAgeVault::GetDeviceInbox( const char * deviceName )
{
wchar_t wStr[MAX_PATH];
StrToUnicode(wStr, deviceName, arrsize(wStr));
if (RelVaultNode * rvn = VaultAgeGetDeviceInboxIncRef(wStr)) {
PyObject * result = pyVaultTextNoteNode::New(rvn);
rvn->UnRef();
return result;
}
PYTHON_RETURN_NONE;
}
///////////////
// Chronicle
PyObject* pyVault::FindChronicleEntry( const char * entryName )
{
wchar_t wEntryName[kMaxVaultNodeStringLength];
StrToUnicode(wEntryName, entryName, arrsize(wEntryName));
if (RelVaultNode * rvn = VaultFindChronicleEntryIncRef(wEntryName)) {
PyObject * result = pyVaultChronicleNode::New(rvn);
rvn->DecRef();
return result;
}
// just return a None object
PYTHON_RETURN_NONE;
}
// AGE DEVICES. AKA IMAGERS, WHATEVER.
// Add a new device.
void pyAgeVault::AddDevice( const char * deviceName, PyObject * cbObject, uint32_t cbContext )
{
pyVaultNode::pyVaultNodeOperationCallback * cb = NEWZERO(pyVaultNode::pyVaultNodeOperationCallback)( cbObject );
cb->VaultOperationStarted( cbContext );
wchar_t wStr[MAX_PATH];
StrToUnicode(wStr, deviceName, arrsize(wStr));
if (RelVaultNode * rvn = VaultAgeAddDeviceAndWaitIncRef(wStr)) {
cb->SetNode(rvn);
rvn->DecRef();
}
cb->VaultOperationComplete( cbContext, cb->GetNode() ? hsOK : hsFail); // cbHolder deletes itself here.
}
void pyVaultTextNoteNode::SetDeviceInbox( const char * devName, PyObject * cbObject, uint32_t cbContext )
{
if (!fNode)
return;
pyVaultNode::pyVaultNodeOperationCallback * cb = NEWZERO(pyVaultNode::pyVaultNodeOperationCallback)( cbObject );
cb->VaultOperationStarted( cbContext );
wchar_t wDev[MAX_PATH];
StrToUnicode(wDev, devName, arrsize(wDev));
if (RelVaultNode * rvn = VaultAgeSetDeviceInboxAndWaitIncRef(wDev, DEFAULT_DEVICE_INBOX)) {
cb->SetNode(rvn);
rvn->DecRef();
}
cb->VaultOperationComplete( cbContext, cb->GetNode() ? hsOK : hsFail ); // cbHolder deletes itself here.
}
uint8_t plNetLinkingMgr::IPreProcessLink(void)
{
// Grab some stuff we're gonna use extensively
plNetClientMgr* nc = plNetClientMgr::GetInstance();
plAgeLinkStruct* link = GetAgeLink();
plAgeInfoStruct* info = link->GetAgeInfo();
PreProcessResult success = kLinkImmediately;
if ( nc->GetFlagsBit( plNetClientMgr::kNullSend ) )
{
hsLogEntry( nc->DebugMsg( "NetClientMgr nullsend. Not linking." ) );
return kLinkFailed;
}
#if 0
// Appear offline until we're done linking
if (RelVaultNode * rvnInfo = VaultGetPlayerInfoNodeIncRef()) {
VaultPlayerInfoNode accInfo(rvnInfo);
accInfo.SetAgeInstName(nil);
accInfo.SetAgeInstUuid(kNilUuid);
accInfo.SetOnline(false);
rvnInfo->DecRef();
}
#else
// Update our online status
if (RelVaultNode * rvnInfo = VaultGetPlayerInfoNodeIncRef()) {
VaultPlayerInfoNode accInfo(rvnInfo);
wchar_t ageInstName[MAX_PATH];
plUUID ageInstGuid = *GetAgeLink()->GetAgeInfo()->GetAgeInstanceGuid();
StrToUnicode(ageInstName, info->GetAgeInstanceName(), arrsize(ageInstName));
accInfo.SetAgeInstName(ageInstName);
accInfo.SetAgeInstUuid(ageInstGuid);
accInfo.SetOnline(true);
rvnInfo->DecRef();
}
#endif
//------------------------------------------------------------------------
// Fixup empty fields
if (info->HasAgeFilename())
{
info->SetAgeFilename(plNetLinkingMgr::GetProperAgeName(info->GetAgeFilename()).c_str());
if (!info->HasAgeInstanceName())
{
info->SetAgeInstanceName(info->GetAgeFilename());
}
}
hsLogEntry(nc->DebugMsg( "plNetLinkingMgr: Pre-Process: Linking with %s rules...",
plNetCommon::LinkingRules::LinkingRuleStr(link->GetLinkingRules())));
//------------------------------------------------------------------------
// SPECIAL CASE: StartUp: force basic link
if (info->GetAgeFilename().CompareI(kStartUpAgeFilename) == 0)
link->SetLinkingRules( plNetCommon::LinkingRules::kBasicLink );
//------------------------------------------------------------------------
// SPECIAL CASE: Nexus: force original link
if (info->GetAgeFilename().CompareI(kNexusAgeFilename) == 0)
link->SetLinkingRules(plNetCommon::LinkingRules::kOriginalBook);
//------------------------------------------------------------------------
// SPECIAL CASE: ACA: force original link
if (info->GetAgeFilename().CompareI(kAvCustomizationFilename) == 0)
link->SetLinkingRules(plNetCommon::LinkingRules::kOriginalBook);
hsLogEntry(nc->DebugMsg("plNetLinkingMgr: Process: Linking with %s rules...",
plNetCommon::LinkingRules::LinkingRuleStr(link->GetLinkingRules())));
switch (link->GetLinkingRules())
{
//--------------------------------------------------------------------
// BASIC LINK. Link to a unique instance of the age, if no instance specified.
case plNetCommon::LinkingRules::kBasicLink:
if (!info->HasAgeInstanceGuid()) {
plUUID newuuid = plUUID::Generate();
info->SetAgeInstanceGuid(&newuuid);
}
break;
//--------------------------------------------------------------------
// ORIGINAL BOOK. Become an owner of the age, if not already one.
case plNetCommon::LinkingRules::kOriginalBook:
{
// create a new ageinfo struct with the filename of the age because
// we just want to find out if we own *any* link to the age, not the specific
// link that we're linking through
plAgeInfoStruct ageInfo;
ageInfo.SetAgeFilename(info->GetAgeFilename());
plAgeLinkStruct ownedLink;
if (!VaultGetOwnedAgeLink(&ageInfo, &ownedLink)) {
// Fill in fields for new age create.
if (!info->HasAgeUserDefinedName())
{
// set user-defined name
plString title;
unsigned nameLen = nc->GetPlayerName().GetSize();
if (nc->GetPlayerName().ToLower().CharAt(nameLen - 1) == 's')
title = plString::Format("%s'", nc->GetPlayerName().c_str());
else
title = plString::Format("%s's", nc->GetPlayerName().c_str());
info->SetAgeUserDefinedName(title.c_str());
}
if (!info->HasAgeDescription())
{
// set description
plString desc;
unsigned nameLen = nc->GetPlayerName().GetSize();
if (nc->GetPlayerName().ToLower().CharAt(nameLen - 1) == 's')
desc = plString::Format("%s' %s", nc->GetPlayerName().c_str(), info->GetAgeInstanceName().c_str());
else
desc = plString::Format("%s's %s", nc->GetPlayerName().c_str(), info->GetAgeInstanceName().c_str());
info->SetAgeDescription(desc.c_str());
}
if (!info->HasAgeInstanceGuid()) {
plUUID newuuid = plUUID::Generate();
info->SetAgeInstanceGuid(&newuuid);
}
// register this as an owned age now before we link to it.
// Note: We MUST break or the OwnedBook code will fail!
VaultRegisterOwnedAge(link);
success = kLinkDeferred;
break;
}
else if (RelVaultNode* linkNode = VaultGetOwnedAgeLinkIncRef(&ageInfo)) {
// We have the age in our AgesIOwnFolder. If its volatile, dump it for the new one.
VaultAgeLinkNode linkAcc(linkNode);
if (linkAcc.GetVolatile()) {
if (VaultUnregisterOwnedAgeAndWait(&ageInfo)) {
// Fill in fields for new age create.
if (!info->HasAgeUserDefinedName())
{
// set user-defined name
plString title;
unsigned nameLen = nc->GetPlayerName().GetSize();
if (nc->GetPlayerName().ToLower().CharAt(nameLen - 1) == 's')
title = plString::Format("%s'", nc->GetPlayerName().c_str());
else
title = plString::Format("%s's", nc->GetPlayerName().c_str());
info->SetAgeUserDefinedName(title.c_str());
}
if (!info->HasAgeDescription())
{
// set description
plString desc;
unsigned nameLen = nc->GetPlayerName().GetSize();
if (nc->GetPlayerName().ToLower().CharAt(nameLen - 1) == 's')
desc = plString::Format("%s' %s", nc->GetPlayerName().c_str(), info->GetAgeInstanceName().c_str());
else
desc = plString::Format("%s's %s", nc->GetPlayerName().c_str(), info->GetAgeInstanceName().c_str());
info->SetAgeDescription( desc.c_str() );
}
if (!info->HasAgeInstanceGuid()) {
plUUID newuuid = plUUID::Generate();
info->SetAgeInstanceGuid(&newuuid);
}
VaultRegisterOwnedAge(link);
// Note: We MUST break or the OwnedBook code will fail!
success = kLinkDeferred;
break;
}
}
else {
if (info->GetAgeFilename().CompareI(kNeighborhoodAgeFilename) == 0) {
// if we get here then it's because we're linking to a neighborhood that we don't belong to
// and our own neighborhood book is not volatile, so really we want to basic link
link->SetLinkingRules(plNetCommon::LinkingRules::kBasicLink);
success = kLinkImmediately;
break;
}
}
linkNode->DecRef();
}
}
link->SetLinkingRules(plNetCommon::LinkingRules::kOwnedBook);
// falls thru to OWNED BOOK case...
//--------------------------------------------------------------------
// OWNED BOOK. Look for the book in our AgesIOwn folder
case plNetCommon::LinkingRules::kOwnedBook:
{
plAgeLinkStruct ownedLink;
if (VaultGetOwnedAgeLink(info, &ownedLink)) {
info->CopyFrom(ownedLink.GetAgeInfo());
// Remember spawn point (treasure book support)
plSpawnPointInfo theSpawnPt = link->SpawnPoint();
VaultAddOwnedAgeSpawnPoint(*info->GetAgeInstanceGuid(), theSpawnPt);
}
else {
success = kLinkFailed;
}
}
break;
//--------------------------------------------------------------------
// VISIT BOOK. Look for the book in our AgesICanVisit folder
case plNetCommon::LinkingRules::kVisitBook:
{
plAgeLinkStruct visitLink;
if (VaultGetVisitAgeLink(info, &visitLink))
info->CopyFrom(visitLink.GetAgeInfo());
else
success = kLinkFailed;
}
break;
//--------------------------------------------------------------------
// SUB-AGE BOOK: Look for an existing sub-age in this age's SubAges folder and use it if found.
// plNetClientTaskHandler will add a SubAge back link to our current age once we arrive there.
case plNetCommon::LinkingRules::kSubAgeBook:
{
plAgeLinkStruct subAgeLink;
if (VaultAgeFindOrCreateSubAgeLink(info, &subAgeLink, NetCommGetAge()->ageInstId))
info->CopyFrom(subAgeLink.GetAgeInfo());
else
success = kLinkDeferred;
}
break;
//--------------------------------------------------------------------
// CHILD-AGE BOOK: Look for an existing child-age in this parent ageinfo ChildAges folder and use it if found.
// plNetClientTaskHandler will add a ChildAge back link to our current age once we arrive there.
case plNetCommon::LinkingRules::kChildAgeBook:
{
plAgeLinkStruct childLink;
wchar_t parentAgeName[MAX_PATH];
if (link->HasParentAgeFilename())
StrToUnicode(parentAgeName, link->GetParentAgeFilename(), arrsize(parentAgeName));
switch(VaultAgeFindOrCreateChildAgeLink(
(link->HasParentAgeFilename() ? parentAgeName : nil),
info,
&childLink))
{
case static_cast<uint8_t>(hsFail):
success = kLinkFailed;
break;
case false:
success = kLinkDeferred;
break;
case true:
success = kLinkImmediately;
}
if (success == kLinkImmediately)
info->CopyFrom(childLink.GetAgeInfo());
}
break;
//--------------------------------------------------------------------
// ???
DEFAULT_FATAL(link->GetLinkingRules());
}
hsLogEntry(nc->DebugMsg( "plNetLinkingMgr: Post-Process: Linking with %s rules...",
plNetCommon::LinkingRules::LinkingRuleStr(link->GetLinkingRules())));
hsAssert(info->HasAgeFilename(), "AgeLink has no AgeFilename. Link will fail.");
return success;
}
void plNetLinkingMgr::IPostProcessLink( void )
{
// Grab some useful things...
plAgeLinkStruct* link = GetAgeLink();
plAgeInfoStruct* info = link->GetAgeInfo();
bool city = (info->GetAgeFilename().CompareI(kCityAgeFilename) == 0);
bool hood = (info->GetAgeFilename().CompareI(kNeighborhoodAgeFilename) == 0);
bool psnl = (info->GetAgeFilename().CompareI(kPersonalAgeFilename) == 0);
// Update our online status
if (RelVaultNode* rvnInfo = VaultGetPlayerInfoNodeIncRef()) {
VaultPlayerInfoNode accInfo(rvnInfo);
wchar_t ageInstName[MAX_PATH];
plUUID ageInstGuid = *info->GetAgeInstanceGuid();
StrToUnicode(ageInstName, info->GetAgeInstanceName(), arrsize(ageInstName));
accInfo.SetAgeInstName(ageInstName);
accInfo.SetAgeInstUuid(ageInstGuid);
accInfo.SetOnline(true);
rvnInfo->DecRef();
}
switch (link->GetLinkingRules()) {
case plNetCommon::LinkingRules::kOwnedBook: {
// SPECIAL CASE: City: Every player ever created would be in the list; avoid that.
if (city)
break;
{ // Ensure we're in the AgeOwners folder
RelVaultNode* fldr = VaultGetAgeAgeOwnersFolderIncRef();
RelVaultNode* info = VaultGetPlayerInfoNodeIncRef();
if (fldr && info)
if (!fldr->IsParentOf(info->GetNodeId(), 1))
VaultAddChildNode(
fldr->GetNodeId(),
info->GetNodeId(),
NetCommGetPlayer()->playerInt,
nil,
nil
);
if (fldr)
fldr->DecRef();
if (info)
info->DecRef();
}
}
break;
case plNetCommon::LinkingRules::kVisitBook: {
// SPECIAL CASE: City: Every player ever created would be in the list; avoid that.
if (city)
break;
{ // Ensure we're in the CanVisit folder
RelVaultNode* fldr = VaultGetAgeCanVisitFolderIncRef();
RelVaultNode* info = VaultGetPlayerInfoNodeIncRef();
if (fldr && info)
if (!fldr->IsParentOf(info->GetNodeId(), 1))
VaultAddChildNode(
fldr->GetNodeId(),
info->GetNodeId(),
NetCommGetPlayer()->playerInt,
nil,
nil
);
if (fldr)
fldr->DecRef();
if (info)
info->DecRef();
}
}
break;
case plNetCommon::LinkingRules::kSubAgeBook: {
// Register the previous age as a sub age of the current one so that we can link back to that instance
plAgeLinkStruct subAgeLink;
VaultAgeFindOrCreateSubAgeLink(GetPrevAgeLink()->GetAgeInfo(), &subAgeLink, NetCommGetAge()->ageInstId);
}
break;
}
}
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
PF_CONSOLE_INIT_ALL()
// Set global handle
gHInst = hInst;
CCmdParser cmdParser(s_cmdLineArgs, arrsize(s_cmdLineArgs));
cmdParser.Parse();
bool doIntroDialogs = true;
#ifndef PLASMA_EXTERNAL_RELEASE
if (cmdParser.IsSpecified(kArgSkipLoginDialog))
doIntroDialogs = false;
if (cmdParser.IsSpecified(kArgLocalData))
{
gDataServerLocal = true;
gSkipPreload = true;
}
if (cmdParser.IsSpecified(kArgSkipPreload))
gSkipPreload = true;
#endif
plFileName serverIni = "server.ini";
if (cmdParser.IsSpecified(kArgServerIni))
serverIni = plString::FromWchar(cmdParser.GetString(kArgServerIni));
// check to see if we were launched from the patcher
bool eventExists = false;
// we check to see if the event exists that the patcher should have created
HANDLE hPatcherEvent = CreateEventW(nil, TRUE, FALSE, L"UruPatcherEvent");
if (hPatcherEvent != NULL)
{
// successfully created it, check to see if it was already created
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
// it already existed, so the patcher is waiting, signal it so the patcher can die
SetEvent(hPatcherEvent);
eventExists = true;
}
}
#ifdef PLASMA_EXTERNAL_RELEASE
// if the client was started directly, run the patcher, and shutdown
STARTUPINFOW si;
PROCESS_INFORMATION pi;
memset(&si, 0, sizeof(si));
memset(&pi, 0, sizeof(pi));
si.cb = sizeof(si);
const char** addrs;
if (!eventExists) // if it is missing, assume patcher wasn't launched
{
plStringStream cmdLine;
GetAuthSrvHostnames(&addrs);
if (strlen(addrs[0]))
cmdLine << " /AuthSrv=" << addrs[0];
GetFileSrvHostnames(&addrs);
if (strlen(addrs[0]))
cmdLine << " /FileSrv=" << addrs[0];
GetGateKeeperSrvHostnames(&addrs);
if (strlen(addrs[0]))
cmdLine << " /GateKeeperSrv=" << addrs[0];
if(!CreateProcessW(s_patcherExeName, (LPWSTR)cmdLine.GetString().ToUtf16().GetData(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
{
hsMessageBox("Failed to launch patcher", "Error", hsMessageBoxNormal);
}
CloseHandle( pi.hThread );
CloseHandle( pi.hProcess );
return PARABLE_NORMAL_EXIT;
}
#endif
// Load an optional general.ini
plFileName gipath = plFileName::Join(plFileSystem::GetInitPath(), "general.ini");
FILE *generalini = plFileSystem::Open(gipath, "rb");
if (generalini)
{
fclose(generalini);
pfConsoleEngine tempConsole;
tempConsole.ExecuteFile(gipath);
}
#ifdef PLASMA_EXTERNAL_RELEASE
// If another instance is running, exit. We'll automatically release our
// lock on the mutex when our process exits
HANDLE hOneInstance = CreateMutex(nil, FALSE, "UruExplorer");
if (WaitForSingleObject(hOneInstance,0) != WAIT_OBJECT_0)
{
switch (plLocalization::GetLanguage())
{
case plLocalization::kFrench:
hsMessageBox("Une autre copie d'URU est déjà en cours d'exécution", "Erreur", hsMessageBoxNormal);
break;
case plLocalization::kGerman:
hsMessageBox("URU wird bereits in einer anderen Instanz ausgeführt", "Fehler", hsMessageBoxNormal);
break;
case plLocalization::kSpanish:
hsMessageBox("En estos momentos se está ejecutando otra copia de URU", "Error", hsMessageBoxNormal);
break;
case plLocalization::kItalian:
hsMessageBox("Un'altra copia di URU è già aperta", "Errore", hsMessageBoxNormal);
break;
// default is English
default:
hsMessageBox("Another copy of URU is already running", "Error", hsMessageBoxNormal);
break;
}
return PARABLE_NORMAL_EXIT;
}
#endif
FILE *serverIniFile = plFileSystem::Open(serverIni, "rb");
if (serverIniFile)
{
fclose(serverIniFile);
pfConsoleEngine tempConsole;
tempConsole.ExecuteFile(serverIni);
}
else
{
hsMessageBox("No server.ini file found. Please check your URU installation.", "Error", hsMessageBoxNormal);
return PARABLE_NORMAL_EXIT;
}
NetCliAuthAutoReconnectEnable(false);
NetCommSetReadIniAccountInfo(!doIntroDialogs);
InitNetClientComm();
curl_global_init(CURL_GLOBAL_ALL);
bool needExit = false;
LoginDialogParam loginParam;
memset(&loginParam, 0, sizeof(loginParam));
LoadUserPass(&loginParam);
if (!doIntroDialogs && loginParam.remember) {
ENetError auth;
wchar_t wusername[kMaxAccountNameLength];
StrToUnicode(wusername, loginParam.username, arrsize(wusername));
NetCommSetAccountUsernamePassword(wusername, loginParam.namePassHash);
bool cancelled = AuthenticateNetClientComm(&auth, NULL);
if (IS_NET_ERROR(auth) || cancelled) {
doIntroDialogs = true;
loginParam.authError = auth;
if (cancelled)
{
NetCommDisconnect();
}
}
}
if (doIntroDialogs) {
needExit = ::DialogBoxParam( hInst, MAKEINTRESOURCE( IDD_URULOGIN_MAIN ), NULL, UruLoginDialogProc, (LPARAM)&loginParam ) <= 0;
}
if (doIntroDialogs && !needExit) {
HINSTANCE hRichEdDll = LoadLibrary("RICHED20.DLL");
INT_PTR val = ::DialogBoxParam( hInst, MAKEINTRESOURCE( IDD_URULOGIN_EULA ), NULL, UruTOSDialogProc, (LPARAM)hInst);
FreeLibrary(hRichEdDll);
if (val <= 0) {
DWORD error = GetLastError();
needExit = true;
}
}
curl_global_cleanup();
if (needExit) {
DeInitNetClientComm();
return PARABLE_NORMAL_EXIT;
}
NetCliAuthAutoReconnectEnable(true);
// VERY VERY FIRST--throw up our splash screen
HWND splashDialog = ::CreateDialog( hInst, MAKEINTRESOURCE( IDD_LOADING ), NULL, SplashDialogProc );
// Install our unhandled exception filter for trapping all those nasty crashes in release build
#ifndef HS_DEBUGGING
LPTOP_LEVEL_EXCEPTION_FILTER oldFilter;
oldFilter = SetUnhandledExceptionFilter( plCustomUnhandledExceptionFilter );
#endif
//
// Set up to log errors by using hsDebugMessage
//
DebugInit();
DebugMsgF("Plasma 2.0.%i.%i - %s", PLASMA2_MAJOR_VERSION, PLASMA2_MINOR_VERSION, plProduct::ProductString().c_str());
for (;;) {
// Create Window
if (!WinInit(hInst, nCmdShow) || gClient->GetDone())
break;
// We don't have multiplayer localized assets for Italian or Spanish, so force them to English in that case.
/* if (!plNetClientMgr::GetInstance()->InOfflineMode() &&
(plLocalization::GetLanguage() == plLocalization::kItalian ||
plLocalization::GetLanguage() == plLocalization::kSpanish))
{
plLocalization::SetLanguage(plLocalization::kEnglish);
}
*/
// Done with our splash now
::DestroyWindow( splashDialog );
if (!gClient)
break;
// Show the main window
ShowWindow(gClient->GetWindowHandle(), SW_SHOW);
gHasMouse = GetSystemMetrics(SM_MOUSEPRESENT);
// Be really REALLY forceful about being in the front
BringWindowToTop( gClient->GetWindowHandle() );
// Update the window
UpdateWindow(gClient->GetWindowHandle());
//
// Init Application here
//
if( !gClient->StartInit() )
break;
// I want it on top! I mean it!
BringWindowToTop( gClient->GetWindowHandle() );
// initialize dinput here:
if (gClient && gClient->GetInputManager())
gClient->GetInputManager()->InitDInput(hInst, (HWND)gClient->GetWindowHandle());
// Seriously!
BringWindowToTop( gClient->GetWindowHandle() );
//
// Main loop
//
MSG msg;
do
{
gClient->MainLoop();
if( gClient->GetDone() )
break;
// Look for a message
while (PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ))
{
// Handle the message
TranslateMessage( &msg );
DispatchMessage( &msg );
}
} while (WM_QUIT != msg.message);
break;
}
//
// Cleanup
//
if (gClient)
{
gClient->Shutdown(); // shuts down PhysX for us
gClient = nil;
}
hsAssert(hsgResMgr::ResMgr()->RefCnt()==1, "resMgr has too many refs, expect mem leaks");
hsgResMgr::Shutdown(); // deletes fResMgr
DeInitNetClientComm();
// Uninstall our unhandled exception filter, if we installed one
#ifndef HS_DEBUGGING
SetUnhandledExceptionFilter( oldFilter );
#endif
// Exit WinMain and terminate the app....
// return msg.wParam;
return PARABLE_NORMAL_EXIT;
}
//===========================================================================
unsigned StrToUnicode (wchar_t * dest, const char source[], unsigned destChars) {
return StrToUnicode(dest, source, destChars, CP_ACP);
}
void VaultTextNoteNode::SetVisitInfo (const plAgeInfoStruct & info) {
ARRAY(wchar_t) buf;
for (unsigned i = 0; i < kNumAgeInfoFields; ++i) {
switch (i) {
case kAgeFilename: {
wchar_t src[128];
StrToUnicode(src, info.GetAgeFilename(), arrsize(src));
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break;
case kAgeInstName: {
wchar_t src[128];
StrToUnicode(src, info.GetAgeInstanceName(), arrsize(src));
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break;
case kAgeUserName: {
wchar_t src[128];
StrToUnicode(src, info.GetAgeUserDefinedName(), arrsize(src));
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break;
case kAgeDesc: {
wchar_t src[128];
StrToUnicode(src, info.GetAgeDescription(), arrsize(src));
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break;
case kAgeInstGuid: {
plUUID guid = *info.GetAgeInstanceGuid();
wchar_t src[64];
wcsncpy(src, guid.AsString().ToWchar(), 64);
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break;
case kAgeLanguage: {
wchar_t src[32];
StrPrintf(src, arrsize(src), L"%u", info.GetAgeLanguage());
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break;
case kAgeSequence: {
wchar_t src[32];
StrPrintf(src, arrsize(src), L"%u", info.GetAgeSequenceNumber());
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break;
DEFAULT_FATAL(i);
}
wchar_t * sep = buf.New(1);
*sep = L'|';
}
wchar_t * term = buf.New(1);
*term = 0;
SetNoteText(buf.Ptr());
}