bool LoadJsonFromFile(const char * filePath, Json::Value &jsonData)
{
IFileStream currentFile;
if (!currentFile.Open(filePath))
{
_ERROR("%s: couldn't open file (%s) Error (%d)", __FUNCTION__, filePath, GetLastError());
return true;
}
char buf[512];
std::string jsonString;
while (!currentFile.HitEOF()){
currentFile.ReadString(buf, sizeof(buf) / sizeof(buf[0]));
jsonString.append(buf);
}
currentFile.Close();
Json::Features features;
features.all();
Json::Reader reader(features);
bool parseSuccess = reader.parse(jsonString, jsonData);
if (!parseSuccess) {
_ERROR("%s: Error occured parsing json for %s.", __FUNCTION__, filePath);
return true;
}
return false;
}
bool WriteDisplayData(Json::Value jDisplayList)
{
Json::StyledWriter writer;
std::string jsonString = writer.write(jDisplayList);
if (!jsonString.length()) {
return true;
}
char filePath[MAX_PATH];
sprintf_s(filePath, "%s/DBM_MuseumData.json", GetUserDirectory().c_str());
IFileStream currentFile;
IFileStream::MakeAllDirs(filePath);
if (!currentFile.Create(filePath))
{
_ERROR("%s: couldn't create preset file (%s) Error (%d)", __FUNCTION__, filePath, GetLastError());
return true;
}
currentFile.WriteBuf(jsonString.c_str(), jsonString.length());
currentFile.Close();
return false;
}
void EditorHookWindow::OnButtonHit(void)
{
char text[256];
GetWindowText(m_editText, text, sizeof(text));
char comment[256];
GetWindowText(m_editText2, comment, sizeof(comment));
UInt32 id;
if(sscanf_s(text, "%x", &id) == 1)
{
void * ptr = LookupFormByID(id);
sprintf_s(text, sizeof(text), "%08X = %08X (%s)", id, (UInt32)ptr, GetObjectClassName(ptr));
_MESSAGE("%s", text);
MessageBox(m_window, text, "receive bacon", MB_OK);
static int idx = 0;
char fileName[256];
if(comment[0])
sprintf_s(fileName, sizeof(fileName), "mem%08X_%08X_%08X_%s", idx, id, (UInt32)ptr, comment);
else
sprintf_s(fileName, sizeof(fileName), "mem%08X_%08X_%08X", idx, id, (UInt32)ptr);
idx++;
IFileStream dst;
if(dst.Create(fileName))
dst.WriteBuf(ptr, 0x200);
}
else
{
MessageBox(m_window, "couldn't read text box", "receive bacon", MB_OK);
}
};
bool ReadModListFromSaveGame(const char* path)
{
_MESSAGE("Reading mod list from savegame");
IFileStream savefile;
if (!savefile.Open(path)) {
_MESSAGE("Couldn't open .ess file when attempting to read plugin list");
return false;
}
else {
static const UInt32 kSaveHeaderSizeOffset = 34;
savefile.SetOffset(kSaveHeaderSizeOffset);
UInt32 headerSize = savefile.Read32();
savefile.SetOffset(headerSize + kSaveHeaderSizeOffset + sizeof(UInt32));
s_numPreloadMods = savefile.Read8();
char pluginName[0x100];
for (UInt32 i = 0; i < s_numPreloadMods; i++) {
UInt8 nameLen = savefile.Read8();
savefile.ReadBuf(pluginName, nameLen);
pluginName[nameLen] = 0;
_MESSAGE("Save file contains plugin %s", pluginName);
s_preloadModRefIDs[i] = (*g_dataHandler)->GetModIndex(pluginName);
}
savefile.Close();
}
return true;
}
void Tensor<XPU, DT>::load (const string file, const int did)
{ Shape sb = shape;
IFileStream fs (file, ios::binary);
fs.read (&shape, sizeof(shape));
if (sb != shape && sb.size)
{ LOG (WARNING) << "\tTensor loaded shapes not equal";
sb.print (); shape.print ();
}
mem_free ();
mem_alloc();
fs.read (dptr, size_d());
cherry = true;
did_ = did;
}
void ImportTranslationFiles(BSScaleformTranslator * translator)
{
char appdataPath[MAX_PATH];
ASSERT(SUCCEEDED(SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, appdataPath)));
std::string modlistPath = appdataPath;
modlistPath += "\\Skyrim Special Edition\\plugins.txt";
// Parse mod list file to acquire translation filenames
IFileStream modlistFile;
if(modlistFile.Open(modlistPath.c_str()))
{
while(!modlistFile.HitEOF())
{
char buf[512];
modlistFile.ReadString(buf, 512, '\n', '\r');
// skip comments
if(buf[0] == '#')
continue;
// Determine extension type
std::string line = buf;
// SE: added this
if (line.length() > 0)
{
if (line.front() != '*')
continue; // Skip not enabled files
line = line.substr(1); // Remove the * from name
}
std::string::size_type lastDelim = line.rfind('.');
if(lastDelim != std::string::npos)
{
std::string ext = line.substr(lastDelim);
if(_stricmp(ext.c_str(), ".ESM") == 0 || _stricmp(ext.c_str(),".ESP") == 0)
{
std::string name = line.substr(0, lastDelim);
ParseTranslation(translator, name);
}
}
}
}
modlistFile.Close();
}
bool FOResourceStream::openArchived()
{
FOResourceManager *manager = FOResourceManager::getSingleton();
std::string archivePath = manager->getArchive(m_fileInfo->getArchive());
if (archivePath.empty())
return false;
IFileStream *archiveStream = new IFileStream(archivePath.c_str());
if (archiveStream->GetHandle() == NULL) {
delete archiveStream;
return false;
}
m_rawStream.Attach(archiveStream, m_fileInfo->getOffset(), m_fileInfo->getRawFileSize());
if (m_fileInfo->isCompressed()) {
// Create buffers
ASSERT(m_inBuffer == NULL && m_outBuffer == NULL);
m_inBuffer = new UInt8[CHUNK];
m_outBuffer = new UInt8[CHUNK];
// Create zlib state
m_zstream = new z_stream;
m_zstream->next_in = m_inBuffer;
m_zstream->avail_in = 0;
m_zstream->zalloc = Z_NULL;
m_zstream->zfree = Z_NULL;
m_zstream->opaque = Z_NULL;
m_zstream->next_out = m_outBuffer;
m_zstream->avail_out = CHUNK;
// Fill the input buffers
fillInBuffer();
// Init zlib
int result = inflateInit(m_zstream);
if (result != Z_OK) {
close();
_ERROR("Could not init ZLIB inflate: %s(%d)", m_zstream->msg, result);
return false;
}
}
else {
}
streamLength = m_fileInfo->getFileSize();
streamOffset = 0;
m_open = true;
return true;
}
bool FOResourceStream::openNormal()
{
if (m_fileInfo->getPath().empty())
return false;
IFileStream *fileStream = new IFileStream(m_fileInfo->getPath().c_str());
if (fileStream->GetHandle() == NULL) {
delete fileStream;
return false;
}
m_rawStream.Attach(fileStream, 0, fileStream->GetLength());
streamLength = fileStream->GetLength();
streamOffset = 0;
m_open = true;
return true;
}
int main(int argc, char ** argv)
{
gLog.SetPrintLevel(IDebugLog::kLevel_Error);
gLog.SetLogLevel(IDebugLog::kLevel_DebugMessage);
if(!g_options.Read(argc, argv))
{
PrintError("Couldn't read arguments.");
g_options.PrintUsage();
return -1;
}
if(g_options.m_optionsOnly)
{
g_options.PrintUsage();
return 0;
}
if(g_options.m_launchCS)
_MESSAGE("launching editor");
if(g_options.m_loadOldblivion)
_MESSAGE("loading oldblivion");
// create the process
STARTUPINFO startupInfo = { 0 };
PROCESS_INFORMATION procInfo = { 0 };
bool dllHasFullPath = false;
startupInfo.cb = sizeof(startupInfo);
const char * procName = g_options.m_launchCS ? "TESConstructionSet.exe" : "Oblivion.exe";
const char * baseDllName = g_options.m_launchCS ? "obse_editor" : "obse";
if(g_options.m_altEXE.size())
{
procName = g_options.m_altEXE.c_str();
_MESSAGE("launching alternate exe (%s)", procName);
}
if(g_options.m_altDLL.size())
{
baseDllName = g_options.m_altDLL.c_str();
_MESSAGE("launching alternate dll (%s)", baseDllName);
dllHasFullPath = true;
}
std::string dllSuffix;
ProcHookInfo procHookInfo;
if(!TestChecksum(procName, &dllSuffix, &procHookInfo))
{
_ERROR("checksum not found");
return -1;
}
if(procHookInfo.steamVersion)
{
// ### maybe check for the loader DLL and just CreateProcess("oblivion.exe") if we can?
PrintError("You are trying to use a Steam version of Oblivion. Steam users should launch the game through Steam, not by running obse_loader.exe. If OBSE fails to load, go to Steam > Settings > In Game and check the box marked \"Enable Steam community in game\". Please see the instructions in obse_readme.txt for more information.");
return 0;
}
if(g_options.m_crcOnly)
return 0;
// build dll path
std::string dllPath;
if(dllHasFullPath)
{
dllPath = baseDllName;
}
else
{
dllPath = GetCWD() + "\\" + baseDllName + "_" + dllSuffix + ".dll";
}
_MESSAGE("dll = %s", dllPath.c_str());
// check to make sure the dll exists
{
IFileStream tempFile;
if(!tempFile.Open(dllPath.c_str()))
{
PrintError("Couldn't find OBSE DLL (%s). Please make sure you have installed OBSE correctly and are running it from your Oblivion folder.", dllPath.c_str());
return -1;
}
}
bool result = CreateProcess(
procName,
NULL, // no args
NULL, // default process security
NULL, // default thread security
TRUE, // don't inherit handles
CREATE_SUSPENDED,
NULL, // no new environment
NULL, // no new cwd
&startupInfo, &procInfo) != 0;
// check for Vista failing to create the process due to elevation requirements
if(!result && (GetLastError() == ERROR_ELEVATION_REQUIRED))
{
// in theory we could figure out how to UAC-prompt for this process and then run CreateProcess again, but I have no way to test code for that
PrintError("Vista has decided that launching Oblivion requires UAC privilege elevation. There is no good reason for this to happen, but to fix it, right-click on obse_loader.exe, go to Properties, pick the Compatibility tab, then turn on \"Run this program as an administrator\".");
return -1;
}
ASSERT_STR_CODE(result, "Launching Oblivion failed", GetLastError());
if(g_options.m_setPriority)
{
if(!SetPriorityClass(procInfo.hProcess, g_options.m_priority))
_WARNING("couldn't set process priority");
}
result = false;
if(g_options.m_launchCS)
{
if(g_options.m_oldInject)
{
_MESSAGE("using old editor injection method");
// start the process
ResumeThread(procInfo.hThread);
// CS needs to run its crt0 code before the DLL is attached, this delays until the message pump is running
// note that this method makes it impossible to patch the startup code
// this is better than Sleep(1000) but still ugly
WaitForInputIdle(procInfo.hProcess, 1000 * 10);
// too late if this fails
result = InjectDLL(&procInfo, dllPath.c_str(), !g_options.m_noSync);
if(!result)
PrintError("Couldn't inject dll.");
}
else
{
_MESSAGE("using new editor injection method");
result = DoInjectDLL_New(&procInfo, dllPath.c_str(), &procHookInfo);
if(!result)
PrintError("Couldn't inject dll.");
// start the process either way
ResumeThread(procInfo.hThread);
}
}
else
{
result = InjectDLL(&procInfo, dllPath.c_str(), !g_options.m_noSync);
if(result)
{
// try to load oldblivion if requested
if(g_options.m_loadOldblivion)
{
result = LoadOldblivion(&procInfo);
if(!result)
PrintError("Couldn't load oldblivion.");
}
}
else
PrintError("Couldn't inject dll.");
if(result)
{
_MESSAGE("launching oblivion");
// start the process
ResumeThread(procInfo.hThread);
}
else
{
_ERROR("terminating oblivion process");
// kill the partially-created process
TerminateProcess(procInfo.hProcess, 0);
g_options.m_waitForClose = false;
}
}
// wait for the process to close if requested
if(g_options.m_waitForClose)
{
WaitForSingleObject(procInfo.hProcess, INFINITE);
}
// clean up
CloseHandle(procInfo.hProcess);
CloseHandle(procInfo.hThread);
return 0;
}