HRESULT KG3DAnimationWarper::Helper_LoadBipExtraInfo(IFile *pFile)
{
HRESULT hr = E_FAIL;
unsigned long uSize = 0;
KG3DSkeleton::SerializeData Data;
m_BoneMatchTable.clear();
KG_PROCESS_ERROR(pFile);
uSize = pFile->Read(&Data, sizeof(KG3DSkeleton::SerializeData));
KGLOG_PROCESS_ERROR(uSize == sizeof(KG3DSkeleton::SerializeData));
KG_PROCESS_ERROR(Data.dwMask == KG3DSkeleton::SerializeData::cdwMask);
KG_PROCESS_ERROR(Data.dwNumBones == static_cast<DWORD>(m_Skeleton.GetNumBones()));
m_BoneMatchTable.resize(Data.dwNumBones);
for (size_t i = 0; i < m_BoneMatchTable.size(); i++)
{
TCHAR strBoneName[MAX_BONE_NAME_LENGTH];
uSize = pFile->Read(strBoneName, sizeof(TCHAR) * MAX_BONE_NAME_LENGTH);
KGLOG_PROCESS_ERROR(uSize == sizeof(TCHAR) * MAX_BONE_NAME_LENGTH);
_strlwr_s(strBoneName, MAX_BONE_NAME_LENGTH);
int nIndex = m_Skeleton.FindBone(strBoneName);
m_BoneMatchTable[i] = nIndex;
}
hr = S_OK;
Exit0:
return hr;
}
DWORD GetModuleSize(LPSTR strModuleName) {
MODULEENTRY32 lpme = { 0 };
DWORD dwSize = 0;
DWORD PID = GetCurrentProcessId();
BOOL isMod = 0;
char chModName[256];
strcpy_s(chModName, 255, strModuleName);
_strlwr_s(chModName, 255);
HANDLE hSnapshotModule = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, PID);
if (hSnapshotModule)
{
lpme.dwSize = sizeof(lpme);
isMod = Module32First(hSnapshotModule, &lpme);
while (isMod)
{
if (strcmp(_strlwr(lpme.szExePath), chModName))
{
dwSize = (DWORD)lpme.modBaseSize;
CloseHandle(hSnapshotModule);
return dwSize;
}
isMod = Module32Next(hSnapshotModule, &lpme);
}
}
CloseHandle(hSnapshotModule);
return 0;
}
//---------------------------------------------------------------------------
void FullPathFileName::init (char * dir_path, const char * name, char * ext)
{
destroy();
size_t total_length = strlen(dir_path);
total_length += strlen(name);
total_length += strlen(ext);
total_length++;
fullName = (char *)systemHeap->Malloc(total_length);
gosASSERT(fullName != NULL);
if (fullName == NULL)
return;
fullName[0] = 0;
if ( strstr( name, dir_path ) != name )
strcpy_s(fullName, total_length, dir_path);
if (name)
strcat_s(fullName, total_length, name);
// don't append if its already there
if (ext && _stricmp( fullName + strlen( fullName ) - strlen( ext ), ext ) != 0)
strcat_s(fullName, total_length, ext);
// CharLowerA(fullName);
_strlwr_s(fullName, total_length);
}
BOOL UnloadMQ2Plugin(const PCHAR pszFilename)
{
DebugSpew("UnloadMQ2Plugin");
CHAR Filename[MAX_PATH]={0};
strcpy_s(Filename,pszFilename);
_strlwr_s(Filename);
PCHAR Temp=strstr(Filename,".dll");
if (Temp)
Temp[0]=0;
// find plugin in list
CAutoLock Lock(&gPluginCS);
//work in progress, move on, nothing to see here need to test this, but they keep patching on me...
//well after messing with this for a while, I realized I couldn't bypass it by just deleting the registry key
//need to check if we can just bypass the GetprocAddress hook and call the nt version which isnt hooked by the shim engine...
/*if (pLdrGetProcedureAddress = (fLdrGetProcedureAddress)GetProcAddress(GetModuleHandle("ntdll.dll"), "LdrGetProcedureAddress")) {
if (HMODULE h = GetModuleHandle("Kernel32.dll")) {
CHAR szFreeLib[32] = { 0 };
strcpy_s(szFreeLib, "FreeLibrary");
FAKEGPSTRING as = { 0 };
as.Buffer = szFreeLib;
as.Length = 11;
as.MaximumLength = 11;
DWORD addr = 0;
BOOL ret = pLdrGetProcedureAddress(h, &as, NULL, (PVOID)&pFreeLibrary);
Sleep(0);
//pFreeLibrary = (fFreeLibrary)addr;
}
}*/
PMQPLUGIN pPlugin=pPlugins;
while(pPlugin)
{
if (!_stricmp(Filename,pPlugin->szFilename))
{
if (pPlugin->pLast)
pPlugin->pLast->pNext=pPlugin->pNext;
else
pPlugins=pPlugin->pNext;
if (pPlugin->pNext)
pPlugin->pNext->pLast=pPlugin->pLast;
if (pPlugin->CleanUI)
pPlugin->CleanUI();
if (pPlugin->Shutdown)
pPlugin->Shutdown();
//DeleteLayers(pPlugin);
if (pFreeLibrary)
pFreeLibrary(pPlugin->hModule);
else
FreeLibrary(pPlugin->hModule);
delete pPlugin;
return 1;
}
pPlugin=pPlugin->pNext;
}
return 0;
}
bool RunningEditor(void)
{
// ### this is not a good method of detection
char pathBuffer[MAX_PATH] = {0};
strcpy_s(pathBuffer, sizeof(pathBuffer), GetAppPath().c_str());
_strlwr_s(pathBuffer, sizeof(pathBuffer));
return strstr(pathBuffer, "creationkit.exe") != NULL;
}
void CSettingDlg::OnAddfile()
{
CFileDialog dlg(TRUE);
std::string addfilename, addfullpath, defaultpath;
char tempstr1[_MAX_PATH];
memset( tempstr1, 0x00, _MAX_PATH );
char szFileName[512000];
int strsize = 0;
UpdateData(TRUE);
if( m_bAllFileAdd ) {
if( AfxMessageBox("All files of Base Path will be inserted.", MB_OKCANCEL) == IDCANCEL )
return;
BeginWaitCursor();
FolderRecurse( m_strDefaultPath );
EndWaitCursor();
return;
}
::SetCurrentDirectory( m_strDefaultPath );
szFileName[0] = 0x00;
dlg.m_ofn.lpstrInitialDir = m_strDefaultPath;
dlg.m_ofn.Flags |= OFN_ALLOWMULTISELECT | OFN_EXPLORER;
dlg.m_ofn.lpstrFile = (LPTSTR)szFileName;
dlg.m_ofn.nMaxFile = 512000;
if( dlg.DoModal() == IDOK ) {
POSITION pos = dlg.GetStartPosition ();
while (pos)
{
strcpy_s( tempstr1, sizeof(tempstr1), dlg.GetNextPathName (pos) );
addfullpath = _strlwr_s(tempstr1, sizeof(tempstr1));
defaultpath = _strlwr_s(m_strDefaultPath, sizeof(m_strDefaultPath));
strsize = defaultpath.size();
addfilename = addfullpath.substr(strsize);
if( InsertProcess( &addfilename[0] ) )
m_FileList.AddString( &addfilename[0] );
}
}
}
void
HttpRequest::FetchGravatarForEmail()
{
unsigned char ehash[MD5LEN];
{
char email[1024];
DWORD d;
size_t len;
if (WideCharToMultiByte(CP_UTF8, 0, m_target.c_str(), -1,
email, sizeof(email), NULL, NULL) == 0) {
ReportStatus(KHERR_ERROR,
L"Can't convert email address to UTF-8",
L"%s", GetLastErrorString().c_str());
return;
}
_strlwr_s(email, sizeof(email));
if (FAILED(StringCbLengthA(email, sizeof(email), &len))) {
ReportStatus(KHERR_ERROR,
L"UTF-8 email address too long",
L"The email address can't be longer than 1024 characters");
return;
}
d = sizeof(ehash);
if (KHM_FAILED(hash_data((BYTE *) email, (DWORD)len, CALG_MD5, (BYTE *) ehash, &d))) {
ReportStatus(KHERR_ERROR, L"Failed to hash email address", NULL);
return;
}
}
{
wchar_t resource[60];
wchar_t * tail;
size_t len;
int i;
static const wchar_t hexdigits[] = L"0123456789abcdef";
StringCbCopyEx(resource, sizeof(resource), L"/avatar/", &tail, &len, STRSAFE_NO_TRUNCATION);
for (i = 0; i < sizeof(ehash); i++) {
*tail++ = hexdigits[ehash[i] >> 4];
*tail++ = hexdigits[ehash[i] & 0xf];
len -= sizeof(wchar_t) * 2;
}
*tail++ = L'\0';
StringCbCat(resource, sizeof(resource), L".jpg?d=404&s=128");
FetchResource(L"www.gravatar.com", resource, jpg_mimetypes);
}
}
void ProgramUsage()
{
char text[512]=PROG_NAME;
printf(PROG_NAME " v" VER_NAME " - by Cyber Warrior X (c)" COPYRIGHT_YEAR "\n");
_strlwr_s(text, sizeof(text));
printf("usage: %s [options] <tbl filename> <data filename> <output directory>\n\n", text);
printf("options:\n"
"\t-s\tAssume input file data is scenario event data that's normally in D00.DAT(default)\n"
"\t-p\tAssume input file data is plot text data that's normally in PLOT.DAT\n");
exit(1);
}
void KG3DAnimationSoundTagInfo::Init()
{
int nHeight = 0;
ITabFile *pTabFile = NULL;
IIniFile *pIniFile = NULL;
pTabFile = g_OpenTabFile(s_strConfigTabFile);
KG_PROCESS_ERROR(pTabFile);
m_SoundType.clear();
m_AnimationSoundTagInfo.clear();
for (size_t i = 0 ; i < sizeof(s_strSoundType) / sizeof(TCHAR *) ; i ++)
{
std::string strFirst = s_strSoundType[i];
m_SoundType[strFirst] = i;
}
nHeight = pTabFile->GetHeight();
for (int i = 2 ; i <= nHeight ; i ++)
{
AnimationSoundTagInfo Info;
TCHAR strSoundType[MAX_PATH];
std::string SoundTypetemp;
iter it = m_SoundType.begin();
int nSoundType = 0;
pTabFile->GetString(i,COL_SOUNDTYPE,"",strSoundType,MAX_PATH);
pTabFile->GetString(i,COL_FILENAME,"",Info.strFileName,MAX_PATH);
pTabFile->GetFloat(i,COL_RATE,0.0f,&Info.fRate);
_strlwr_s(strSoundType,MAX_PATH);
SoundTypetemp = strSoundType;
KG_PROCESS_ERROR(m_SoundType.find(SoundTypetemp) != m_SoundType.end());
Info.soundType = static_cast<SoundType>(m_SoundType[SoundTypetemp]);
nSoundType = m_SoundType[SoundTypetemp];
if(m_AnimationSoundTagInfo.find(nSoundType)
!= m_AnimationSoundTagInfo.end())
{
m_AnimationSoundTagInfo[nSoundType].push_back(Info);
}
else
{
std::vector<AnimationSoundTagInfo> vec;
vec.push_back(Info);
m_AnimationSoundTagInfo[nSoundType] = vec;
}
}
Adjust();
pIniFile = g_OpenIniFile(s_strConfigIniFile);
KG_PROCESS_ERROR(pIniFile);
pIniFile->GetInteger("ROOT","SaveVersion3Data",0,&m_nSaveVersion3Data);
m_bInit = TRUE;
Exit0:
SAFE_RELEASE(pTabFile);
SAFE_RELEASE(pIniFile);
;
}
LCID ISOLang::ISO6391ToLcid(LPCSTR code)
{
CHAR tmp[2 + 1];
strncpy_s(tmp, code, 2);
tmp[2] = 0;
_strlwr_s(tmp);
for (size_t i = 0, cnt = _countof(s_isolangs); i < cnt; i++) {
if (!strcmp(s_isolangs[i].iso6391, tmp)) {
return s_isolangs[i].lcid;
}
}
return 0;
}
std::string ISO6392To6391(LPCSTR code)
{
CHAR tmp[3+1];
strncpy_s(tmp, code, 3);
tmp[3] = 0;
_strlwr_s(tmp);
for(size_t i = 0, j = countof(s_isolangs); i < j; i++) {
if((s_isolangs[i].iso6392 && !strcmp(s_isolangs[i].iso6392, tmp)) || (s_isolangs[i].iso6392_2 && !strcmp(s_isolangs[i].iso6392_2, tmp))) {
return s_isolangs[i].iso6391;
}
}
return std::string();
}
std::string ISO6391To6392(LPCSTR code)
{
CHAR tmp[2+1];
strncpy_s(tmp, code, 2);
tmp[2] = 0;
_strlwr_s(tmp);
for(size_t i = 0, j = countof(s_isolangs); i < j; i++) {
if(s_isolangs[i].iso6391 && !strcmp(s_isolangs[i].iso6391, tmp)) {
return s_isolangs[i].iso6392;
}
}
return std::string(code);
}
CStringA ISOLang::ISO6391To6392(LPCSTR code)
{
CHAR tmp[2 + 1];
strncpy_s(tmp, code, 2);
tmp[2] = 0;
_strlwr_s(tmp);
for (size_t i = 0, cnt = _countof(s_isolangs); i < cnt; i++) {
if (!strcmp(s_isolangs[i].iso6391, tmp)) {
return CStringA(s_isolangs[i].iso6392);
}
}
return "";
}
ISOLang ISOLang::ISO6392ToISOLang(LPCSTR code)
{
CHAR tmp[3 + 1];
strncpy_s(tmp, code, 3);
tmp[3] = 0;
_strlwr_s(tmp);
for (size_t i = 0, cnt = _countof(s_isolangs); i < cnt; i++) {
if (!strcmp(s_isolangs[i].iso6392, tmp)) {
return s_isolangs[i];
}
}
return ISOLang();
}
void ProgramUsage()
{
char text[512]=PROG_NAME;
printf(PROG_NAME " v" VER_NAME " - by Cyber Warrior X (c)" COPYRIGHT_YEAR "\n");
_strlwr_s(text, sizeof(text));
printf("usage: %s <table filename> <original D00.DAT filename> <input files wildcard> <output filename>\n", text);
printf(" Ex: %s -s table.tbl d00.dat script%%64.txt new-d00.dat\n", text);
printf("options:\n"
"\t-s\tAssume input file data is scenario event data that's normally in D00.DAT(default)\n"
"\t-p\tAssume input file data is plot text data that's normally in PLOT.DAT\n");
exit(1);
}
void CSettingDlg::FolderRecurse(const char *foldername, bool b_test)
{
CFileFind ff;
std::string addfilename, addfullpath, defaultpath;
char tempstr1[_MAX_PATH];
memset( tempstr1, 0x00, _MAX_PATH );
int strsize = 0;
::SetCurrentDirectory( foldername );
BOOL bFind = ff.FindFile();
while( bFind ) {
bFind = ff.FindNextFile();
strcpy_s( tempstr1, _MAX_PATH, ff.GetFilePath() );
if( ff.IsDots() ) continue;
if( ff.IsDirectory() ) {
FolderRecurse( tempstr1, b_test );
continue;
}
if( b_test ) { // 단순 검사만 수행...
if( IsDBCSString( tempstr1 ) ) {
CString errmsg;
errmsg.Format("%s include DBCS character", tempstr1 );
AfxMessageBox(errmsg);
}
continue;
}
addfullpath = _strlwr_s(tempstr1, _MAX_PATH);
defaultpath = _strlwr_s(m_strDefaultPath, _MAX_PATH);
strsize = defaultpath.size();
addfilename = addfullpath.substr(strsize);
if( InsertProcess( &addfilename[0] ) )
m_FileList.AddString( &addfilename[0] );
}
}
void KSceneEditorDialogAutoGrass::OnLbnSelchangeListPattern()
{
HRESULT hRetCode = E_FAIL;
int nCount = 0;
int nSelCount = 0;
int* pSelPatterns = NULL;
TCHAR strPatternPathName[MAX_PATH];
KG_PROCESS_ERROR(m_lpSceneSceneEditor);
KG_PROCESS_ERROR(m_lpOutDoorSpaceMgr);
nSelCount = m_ListBoxPattern.GetSelCount();
KG_PROCESS_ERROR(nSelCount > 0);
pSelPatterns = new int[nSelCount];
KG_PROCESS_ERROR(pSelPatterns);
for(int n = 0;n< 8;n++ )
m_pbyPatternIndex[n] = 255;
nCount = 0;
for (int i = 0; i < m_ListBoxPattern.GetCount(); i++)
{
int nSel = m_ListBoxPattern.GetSel(i);
if ( nSel > 0)
{
CString strGrassPatternName;
m_ListBoxPattern.GetText(i, strGrassPatternName);
sprintf(strPatternPathName, "Data\\public\\GrassPattern\\%s.mesh",strGrassPatternName);
_strlwr_s(strPatternPathName, sizeof(TCHAR) * MAX_PATH);
int nPatternIndex = -1;
hRetCode = m_lpOutDoorSpaceMgr->FindPattern(strPatternPathName,&nPatternIndex,MAP_GRASS);
KGLOG_COM_PROCESS_ERROR(hRetCode);
ASSERT(nPatternIndex != -1);
pSelPatterns[nCount] = nPatternIndex;
if(nCount < 8)
m_pbyPatternIndex[nCount] = (BYTE)i;
nCount++;
}
}
m_lpSceneSceneEditor->UpdatePatternList(pSelPatterns, nSelCount);
Exit0:
SAFE_DELETE_ARRAY(pSelPatterns);
//OnBnClickedButtonAddgrass();
return;
}
bool name_copy(array<u8>& d, const char* s) {
const char* p = s;
const char* e = sz_find_last_or_end(s, '.');
if (!d.set_size(e - s + 1))
return false;
memcpy(d.begin(), s, e - s);
d[e - s] = '\0';
_strlwr_s((char*)d.begin(), d.size());
return true;
}
static std::string ISO6392Check(LPCSTR lang)
{
CHAR tmp[3+1];
strncpy_s(tmp, lang, 3);
tmp[3] = 0;
_strlwr_s(tmp);
for(size_t i = 0, j = countof(s_isolangs); i < j; i++) {
if((s_isolangs[i].iso6392 && !strcmp(s_isolangs[i].iso6392, tmp)) || (s_isolangs[i].iso6392_2 && !strcmp(s_isolangs[i].iso6392_2, tmp)))
{
return std::string(s_isolangs[i].iso6392);
}
}
return std::string(tmp);
}
String String::ToLower() const
{
MUTEX_LOCK(str_mutex);
String strRet(this->str_szBuffer);
#ifdef SCRATCH_NO_UTF8
#if WINDOWS
int len = strlen(this->str_szBuffer);
_strlwr_s(strRet.str_szBuffer, len + 1);
#else
strlwr(strRet.str_szBuffer);
#endif
#else
utf8lwr(strRet.str_szBuffer);
#endif
return strRet;
}
void PMLoggerEventChatMessageReceived( char *User, char *Msg )
{
if( Msg == NULL )
return;
if( GlobalStore.fMyPMs == NULL )
return;
char Buff[ DEFAULT_BUFLEN ];
strcpy_s( Buff, DEFAULT_BUFLEN, Msg );
errno_t ret = _strlwr_s( Buff, DEFAULT_BUFLEN );
if( strstr( Buff, GlobalStore.cMyPMNick ) != NULL )
{
time_t t = time(NULL);
tm aTm;
errno_t ret = localtime_s( &aTm, &t);
fprintf( GlobalStore.fMyPMs, "[%-4d-%02d-%02d %02d:%02d:%02d] %s %s\n",aTm.tm_year+1900,aTm.tm_mon+1,aTm.tm_mday,aTm.tm_hour,aTm.tm_min,aTm.tm_sec, User, Msg );
}
}
_TCHAR* _WINAPI_ _AvpStrlwr(_TCHAR* str_)
{
#ifdef _MBCS
_strlwr_s(str_, strlen(str_)+1);
return str_;
#else
if(str_)
{
_TCHAR* c=str_;
while(*c){
*c|=0x20;
c++;
}
}
return str_;
#endif
}
CString ISOLang::ISO6392ToLanguage(LPCSTR code)
{
CHAR tmp[3 + 1];
strncpy_s(tmp, code, 3);
tmp[3] = 0;
_strlwr_s(tmp);
for (size_t i = 0, cnt = _countof(s_isolangs); i < cnt; i++) {
if (!strcmp(s_isolangs[i].iso6392, tmp)) {
CString ret = CString(CStringA(s_isolangs[i].name));
int k = ret.Find(';');
if (k > 0) {
ret = ret.Left(k);
}
return ret;
}
}
return CString(code);
}
BOOL WINAPI CNdiskd::IsNdisHook(ULONG64 PtrHandler)
{
CHAR moduleName[MAX_MODULE_NAME] = { 0 };
BOOL boolIsHooked, boolWhitelisted = false;
do
{
if (utils::getNameByOffset(PtrHandler, moduleName) == NULL)
break;
if (strlen(moduleName) > 0)
{
// Convert to lower case
_strlwr_s(moduleName, sizeof(moduleName));
#if VVERBOSE_MODE
DbgPrint("DEBUG: %s:%d:%s Checking integrity of module name \"%s\"\n", __FILE__, __LINE__, __FUNCTION__, moduleName);
#endif
// Check white-listed NDIS module name
if (CNdiskd::IsWhitelistedNdisModule(moduleName))
{
boolWhitelisted = true;
}
else
{
DbgPrint("DEBUG: %s:%d:%s Module name %s is not whitelisted!\n", __FILE__, __LINE__, __FUNCTION__, moduleName);
}
}
} while (false);
if (boolWhitelisted)
boolIsHooked = false;
else
boolIsHooked = (PtrHandler < m_ndisBaseAddress) && (m_ndisEndAddress > PtrHandler);
#if VVERBOSE_MODE
DbgPrint("DEBUG: %s:%d:%s %#I64x vs (%#I64x-%#I64x)\n", __FILE__, __LINE__, __FUNCTION__, PtrHandler, m_ndisBaseAddress, m_ndisEndAddress);
#endif
if (boolIsHooked)
return true;
else
return false;
}
HRESULT KG3DTerrainRepresentInfo::Init()
{
HRESULT hResult = E_FAIL;
HRESULT hRetCode = E_FAIL;
int nHeight = 0;
m_TerrainRepresentInfo.clear();
ITabFile *pTabFile = g_OpenTabFile(s_strConfigFile);
KG_PROCESS_ERROR(pTabFile);
nHeight = pTabFile->GetHeight();
for (int i = 2; i <= nHeight; i++)
{
TerrainRepresentInfo Info;
int nGroundType = 0;
TCHAR strLower[MAX_PATH];
pTabFile->GetString(i, COL_FILENAME, "", Info.strFileName, MAX_PATH);
strcpy_s(strLower, MAX_PATH, Info.strFileName);
_strlwr_s(strLower, MAX_PATH);
DWORD dwHash = g_FileNameHash(strLower);
pTabFile->GetString(i, COL_ANNOTATE, "", Info.strAnnotate, MAX_PATH);
pTabFile->GetInteger(i, COL_TYPE, INVALID_GROUNDTYPE, &nGroundType);
Info.dwType = static_cast<DWORD>(nGroundType);
pTabFile->GetString(i,COL_SFX,"",Info.strSfx[COL_SFX-COL_SFX],MAX_PATH);
pTabFile->GetString(i,COL_SFX1,"",Info.strSfx[COL_SFX1-COL_SFX],MAX_PATH);
pTabFile->GetString(i,COL_SFX2,"",Info.strSfx[COL_SFX2-COL_SFX],MAX_PATH);
pTabFile->GetString(i,COL_SFX3,"",Info.strSfx[COL_SFX3-COL_SFX],MAX_PATH);
pTabFile->GetString(i,COL_SFXTERRAIN,"",Info.strSfxTerrain,MAX_PATH);
pTabFile->GetFloat(i, COL_SFX_RATE, 1.0f, &Info.fSfxPlayRate);//不填默认100%
m_TerrainRepresentInfo[dwHash] = Info;
}
hRetCode = InitDis();
KG_COM_PROCESS_ERROR(hRetCode);
hRetCode = InitDefaultSfx();
KG_COM_PROCESS_ERROR(hRetCode);
hResult = S_OK;
Exit0:
SAFE_RELEASE(pTabFile);
return hResult;
}
/* construct username from the HTTP header */
static void construct_username(sspi_auth_ctx* ctx)
{
/* removing the domain part from the username */
if (ctx->crec->sspi_omitdomain) {
char *s = strchr(ctx->scr->username, '\\');
if (s)
ctx->scr->username = s+1;
}
if (ctx->crec->sspi_usernamecase == NULL) {
}
else if (!lstrcmpi(ctx->crec->sspi_usernamecase, "Lower")) {
_strlwr_s(ctx->scr->username, strlen(ctx->scr->username)+1);
}
else if (!lstrcmpi(ctx->crec->sspi_usernamecase, "Upper")) {
_strupr_s(ctx->scr->username, strlen(ctx->scr->username)+1);
};
}
std::string ISO6392ToLanguage(LPCSTR code)
{
CHAR tmp[3+1];
strncpy_s(tmp, code, 3);
tmp[3] = 0;
_strlwr_s(tmp);
for(size_t i = 0, j = countof(s_isolangs); i < j; i++) {
if((s_isolangs[i].iso6392 && !strcmp(s_isolangs[i].iso6392, tmp)) || (s_isolangs[i].iso6392_2 && !strcmp(s_isolangs[i].iso6392_2, tmp)))
{
std::string ret = std::string(s_isolangs[i].name);
size_t i = ret.find(';');
if(i != std::string::npos) {
ret = ret.substr(0, i);
}
return ret;
}
}
return std::string();
}
int KGTestLoadMaterial::CheckFilter(const char cszMtlFile[], const char cszTexFile[])
{
int nRetCode = false;
int nResult = false;
char szMtlName[MAX_PATH] = {0};
char szTexFile[MAX_PATH] = {0};
char* pszResult = NULL;
_ASSERTE(cszMtlFile);
_ASSERTE(cszTexFile);
//过滤材质文件F1，F2，M2相关的贴图加载错误
nRetCode = _splitpath_s(cszMtlFile, NULL, 0, NULL, 0, szMtlName, sizeof(szMtlName), NULL, 0);
KG_PROCESS_ERROR(nRetCode == 0);
nRetCode = _strlwr_s(szMtlName, sizeof(szMtlName));
KG_PROCESS_ERROR(nRetCode == 0);
pszResult = strstr(szMtlName, "f1");
KG_PROCESS_ERROR(pszResult == NULL);
pszResult = strstr(szMtlName, "f2");
KG_PROCESS_ERROR(pszResult == NULL);
pszResult = strstr(szMtlName, "m2");
KG_PROCESS_ERROR(pszResult == NULL);
//过滤光照图相关的贴图加载错误
nRetCode = strncpy_s(szTexFile, sizeof(szTexFile), cszTexFile, strlen(cszTexFile));
KG_PROCESS_ERROR(nRetCode == 0);
pszResult = strstr(szTexFile, "光照图");
KG_PROCESS_ERROR(pszResult == NULL);
nResult = true;
Exit0:
if (!nResult)
{
m_vecFilterMtl.push_back(cszMtlFile);
}
return nResult;
}
bool ISOLang::IsISO639Language(LPCSTR code)
{
size_t nLen = strlen(code) + 1;
LPSTR tmp = DEBUG_NEW CHAR[nLen];
strncpy_s(tmp, nLen, code, nLen);
_strlwr_s(tmp, nLen);
tmp[0] = (CHAR)toupper(tmp[0]);
bool bFound = false;
for (size_t i = 0, cnt = _countof(s_isolangs); i < cnt; i++) {
if (!strcmp(s_isolangs[i].name, tmp)) {
bFound = true;
break;
}
}
delete[] tmp;
return bFound;
}
static Enums::version_result_code GetVersionResultCode()
{
Enums::version_result_code result_code = Enums::_version_result_code_invalid;
char dir[MAX_PATH];
GetCurrentDirectory(NUMBEROF(dir), dir);
char name[64];
GetModuleBaseName(GetCurrentProcess(), GetModuleHandle(nullptr), name, NUMBEROF(name));
_strlwr_s(name);
// Ok, the warning message will get annoying after a while for sapien (and tool) users
if ( strstr(name,"sapien") != nullptr || strstr(name,"hobo") != nullptr ||
strstr(name,"tool") != nullptr )
return Enums::_version_result_code_dx9_app;
// Enable OS if the exe name is haloce/OS_ded
_main_globals.enabled = (strcmp(name, PLATFORM_VALUE("haloce.exe","os_haloceded.exe")) == 0);
return Enums::_version_result_code_valid;
}
