Skip to content

Instantly share code, notes, and snippets.

@kizernis

kizernis/MapsEx.c

Last active May 21, 2023 05:58
Show Gist options
  • Save kizernis/ccf23781d15a93514b1578a144d6e2e9 to your computer and use it in GitHub Desktop.
Save kizernis/ccf23781d15a93514b1578a144d6e2e9 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
MapsEx.c
#include <windows.h>
#include <commctrl.h>
#include <shlobj.h>
#include "resource.h"
#include "md5.h"
#ifndef _DEBUG
#pragma comment(linker, "/entry:_WinMain /nodefaultlib /subsystem:windows /filealign:512 /stack:65536,65536")
#pragma comment(linker, "/merge:.data=.text /merge:.rdata=.text /section:.text,ewrx /ignore:4078")
#endif
typedef struct {
PSTR psName;
UINT nNameLen;
PSTR psType;
UINT nTypeLen;
} LOGGED_GAMES_ARRAY;
#define LG_DATA_CHUNK_SIZE (1024 * 50)
LOGGED_GAMES_ARRAY * g_pLoggedGames;
UINT g_nLoggedGames = 0;
UINT g_nLoggedGamesMax;
PUCHAR g_pucLoggedGamesData;
PUCHAR g_pucLoggedGamesDataPtr;
UINT g_nLoggedGamesBufferSize;
BOOL g_bLogsPathChanged = FALSE;
void LoggedGames_Reset() {
if (g_nLoggedGames)
{ g_nLoggedGames = 0; free(g_pLoggedGames); free(g_pucLoggedGamesData); }
g_nLoggedGamesMax = 100;
g_pLoggedGames = (LOGGED_GAMES_ARRAY *)malloc(sizeof(LOGGED_GAMES_ARRAY) * g_nLoggedGamesMax);
g_nLoggedGamesBufferSize = LG_DATA_CHUNK_SIZE;
g_pucLoggedGamesData = (PUCHAR)malloc(g_nLoggedGamesBufferSize);
g_pucLoggedGamesDataPtr = g_pucLoggedGamesData;
}
void LoggedGames_Add(PSTR psName, UINT nNameLen, PSTR psType, UINT nTypeLen) {
UINT nRequiredSize, i;
g_nLoggedGames++;
if (g_nLoggedGames > g_nLoggedGamesMax)
{ g_nLoggedGamesMax += 100; g_pLoggedGames = (LOGGED_GAMES_ARRAY *)realloc(g_pLoggedGames, sizeof(LOGGED_GAMES_ARRAY) * g_nLoggedGamesMax); }
nRequiredSize = g_pucLoggedGamesDataPtr + nNameLen + 1 + nTypeLen + 1 - g_pucLoggedGamesData;
while (nRequiredSize > g_nLoggedGamesBufferSize) {
PUCHAR pucOldAddress = g_pucLoggedGamesData;
g_nLoggedGamesBufferSize += LG_DATA_CHUNK_SIZE;
g_pucLoggedGamesData = (PUCHAR)realloc(g_pucLoggedGamesData, g_nLoggedGamesBufferSize);
if (g_pucLoggedGamesData != pucOldAddress) {
int nDiff = g_pucLoggedGamesData - pucOldAddress;
for (i = 0; i < g_nLoggedGames - 1; i++)
{ g_pLoggedGames[i].psName += nDiff; g_pLoggedGames[i].psType += nDiff; }
g_pucLoggedGamesDataPtr += nDiff;
}
}
i = g_nLoggedGames - 1;
g_pLoggedGames[i].psName = (PSTR)g_pucLoggedGamesDataPtr;
g_pLoggedGames[i].nNameLen = nNameLen;
strcpy(g_pucLoggedGamesDataPtr, psName);
g_pucLoggedGamesDataPtr += nNameLen + 1;
g_pLoggedGames[i].psType = (PSTR)g_pucLoggedGamesDataPtr;
g_pLoggedGames[i].nTypeLen = nTypeLen;
strcpy(g_pucLoggedGamesDataPtr, psType);
g_pucLoggedGamesDataPtr += nTypeLen + 1;
}
#define GAME_NOT_FOUND 0xFFFFFFFF
UINT LoggedGames_Find(PSTR psName) {
UINT i;
for (i = 0; i < g_nLoggedGames; i++)
if (0 == strcmp(psName, g_pLoggedGames[i].psName))
return i;
return GAME_NOT_FOUND;
}
typedef struct { UCHAR ucMD[16]; } MD_ARRAY;
MD_ARRAY * g_pHashes;
UINT g_nHashes = 0;
UINT g_nHashesMax;
UCHAR g_ucMD5Sum[16];
void Hashes_Reset() {
if (g_nHashes)
{ g_nHashes = 0; free(g_pHashes); }
g_nHashesMax = 100;
g_pHashes = (MD_ARRAY *)malloc(16 * g_nHashesMax);
}
void Hashes_Add() {
if (++g_nHashes > g_nHashesMax)
{ g_nHashesMax += 100; g_pHashes = (MD_ARRAY *)realloc(g_pHashes, 16 * g_nHashesMax); }
memcpy(g_pHashes[g_nHashes - 1].ucMD, g_ucMD5Sum, 16);
}
BOOL Hashes_IsStored() {
PUCHAR p1 = g_pHashes[0].ucMD;
PUCHAR p2 = p1 + 16 * g_nHashes;
for (; p1 < p2; p1 += 16)
if (p1[ 0] == g_ucMD5Sum[ 0] && p1[ 1] == g_ucMD5Sum[ 1] && p1[ 2] == g_ucMD5Sum[ 2] && p1[ 3] == g_ucMD5Sum[ 3]
&& p1[ 4] == g_ucMD5Sum[ 4] && p1[ 5] == g_ucMD5Sum[ 5] && p1[ 6] == g_ucMD5Sum[ 6] && p1[ 7] == g_ucMD5Sum[ 7]
&& p1[ 8] == g_ucMD5Sum[ 8] && p1[ 9] == g_ucMD5Sum[ 9] && p1[10] == g_ucMD5Sum[10] && p1[11] == g_ucMD5Sum[11]
&& p1[12] == g_ucMD5Sum[12] && p1[13] == g_ucMD5Sum[13] && p1[14] == g_ucMD5Sum[14] && p1[15] == g_ucMD5Sum[15])
return TRUE;
return FALSE;
}
// TODO: use Unicode APIs with \\?\ path prefix and 32768 max path length (and 256 file or directory name length)
#define PATH_BUFFER_SIZE (MAX_PATH * 2)
#define LOG_BUFFER_SIZE (1024 * 30)
HWND g_hDlg, g_hBtnExtract, g_hLblStatus, g_hPgbProgress;
BOOL g_bProcessing;
PSTR g_psPathLogs, g_psPathReplays, g_psPathMaps;
UINT g_nPathLogsLen, g_nPathReplaysLen, g_nPathMapsLen;
BOOL g_bWarned_WA, g_bWarned_Maps;
PCSTR g_pcsAlert_WA, g_pcsAlert_Replays, g_pcsAlert_Maps;
#define STATE_NORMAL 0
#define STATE_WARNING 1
#define STATE_ALERT 2
#define NORMAL_STATUS_BGCOLOR RGB(0, 255, 115)
#define WARNING_STATUS_BGCOLOR RGB(255, 224, 4)
#define ALERT_STATUS_BGCOLOR RGB(255, 128, 0)
HBRUSH g_hNormalBrush, g_hWarningBrush, g_hAlertBrush;
UINT g_nState = STATE_NORMAL;
PCSTR g_csCurrentStatus;
int g_nMessageLength, g_nPos;
char g_sMsgTmp[256];
char g_sMsgFinal[256];
typedef void (* SEARCH_CALLBACK_PROC)(PSTR, PCSTR, UINT);
typedef unsigned char uch;
typedef unsigned short ush;
typedef unsigned long ulg;
#define SH(p) ((ush)(uch)((p)[1]) | ((ush)(uch)((p)[0]) << 8))
#define LG(p) ((ulg)(SH((p) + 2)) | ((ulg)(SH(p)) << 16))
// 8 - signature
// + 4 + 4 + 13 + 4 - IHDR
// + 4 + 4 + 40 + 4 - waLV
// + 4 + 4 + 0 + 4 - IEND
// #define MIN_PNG_FILE_SIZE 97
#define MAP_TYPE_BIT 1
#define MAP_TYPE_LEV 2
#define MAP_TYPE_PNG 3
#define TIMER_PROCESSING 0
#define TIMER_TYPING 1
#define TIMER_BLINKING 2
#ifndef _DEBUG
PVOID malloc(UINT nSize) {
return HeapAlloc(GetProcessHeap(), 0, nSize);
}
PVOID realloc(PVOID pBuf, UINT nSize) {
return HeapReAlloc(GetProcessHeap(), 0, pBuf, nSize);
}
void free(PVOID pBuf) {
HeapFree(GetProcessHeap(), 0, pBuf);
}
UINT strlen(PCSTR pcsStr) {
PCSTR p1;
for (p1 = pcsStr; *p1; ++p1);
return p1 - pcsStr;
}
int memcmp(const void * s1, const void * s2, size_t n) {
const unsigned char *p1 = s1, *p2 = s2;
while (n--)
if (*p1 != *p2)
return *p1 - *p2;
else
*p1++, *p2++;
return 0;
}
PSTR strstr(PCSTR pcsStr1, PCSTR pcsStr2) {
UINT nLen = strlen(pcsStr2);
while (*pcsStr1)
if (!memcmp(pcsStr1++, pcsStr2, nLen))
return (PSTR)pcsStr1 - 1;
return NULL;
}
PVOID memcpy(PVOID pDst, const PVOID pSrc, UINT nCnt) {
PUCHAR pucDst = pDst;
const unsigned char * pucSrc = pSrc;
while (nCnt--)
*pucDst++ = *pucSrc++;
return pDst;
}
PSTR strcpy(PSTR psDst, PCSTR pcsSrc) {
PSTR psSave = psDst;
while (*psDst++ = *pcsSrc++);
return psSave;
}
int strcmp(PCSTR pcsStr1, PCSTR pcsStr2) {
for(; *pcsStr1 == *pcsStr2; ++pcsStr1, ++pcsStr2)
if (*pcsStr1 == 0)
return 0;
return *(const unsigned char *)pcsStr1 - *(const unsigned char *)pcsStr2;
}
PSTR strchr(PCSTR pcsStr, int nChar) {
while (*pcsStr != (char)nChar)
if (!*pcsStr++)
return NULL;
return (PSTR)pcsStr;
}
PSTR strrchr(PCSTR pcsStr, int nChar) {
PSTR psRet = NULL;
do {
if (*pcsStr == (char)nChar) (PCSTR)psRet = pcsStr;
} while (*pcsStr++);
return psRet;
}
#endif
void CALLBACK BlinkingTimerProc(HWND hWnd, UINT nMsg, UINT nEventID, DWORD dwTime) {
char sTmp[256];
int nLen = GetWindowText(g_hLblStatus, sTmp, sizeof(sTmp) - 2);
if (sTmp[nLen - 1] == '_')
sTmp[nLen - 1] = '\0';
else
{ sTmp[nLen] = '_'; sTmp[nLen + 1] = '\0'; }
SetWindowText(g_hLblStatus, sTmp);
}
void CALLBACK TypingTimerProc(HWND hWnd, UINT nMsg, UINT nEventID, DWORD dwTime) {
g_sMsgTmp[g_nPos - 1] = g_csCurrentStatus[g_nPos - 1];
g_sMsgTmp[g_nPos] = '_';
g_sMsgTmp[g_nPos + 1] = '\0';
SetWindowText(g_hLblStatus, g_sMsgTmp);
if (++g_nPos > g_nMessageLength)
KillTimer(g_hDlg, TIMER_TYPING);
}
void TypeStatusMessage(PCSTR csMessage, UINT nState) {
g_nState = nState;
g_csCurrentStatus = csMessage;
lstrcpy(&g_sMsgTmp[1], &csMessage[1]);
g_nMessageLength = strlen(csMessage);
g_nPos = 1;
SetTimer(g_hDlg, TIMER_TYPING, 20, TypingTimerProc);
}
BOOL ExtractMapToFile(HANDLE hSrcFile, DWORD dwMapDataSize) {
UCHAR ucBuffer[1024];
DWORD i, j, dwRemainder, dwActual;
HANDLE hDstFile = CreateFile(g_psPathMaps, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hDstFile == INVALID_HANDLE_VALUE)
return FALSE;
j = dwMapDataSize / sizeof(ucBuffer);
if (dwRemainder = dwMapDataSize % sizeof(ucBuffer)) {
if (!ReadFile(hSrcFile, ucBuffer, dwRemainder, &dwActual, NULL) || !dwActual) { CloseHandle(hDstFile); return FALSE; }
if (!WriteFile(hDstFile, ucBuffer, dwRemainder, &dwActual, NULL)) { CloseHandle(hDstFile); return FALSE; }
}
for (i = 0; i < j; i++) {
if (!ReadFile(hSrcFile, ucBuffer, sizeof(ucBuffer), &dwActual, NULL) || !dwActual) { CloseHandle(hDstFile); return FALSE; }
if (!WriteFile(hDstFile, ucBuffer, sizeof(ucBuffer), &dwActual, NULL)) { CloseHandle(hDstFile); return FALSE; }
}
CloseHandle(hDstFile);
return TRUE;
}
#define MAX_IDAT_TAGS_TO_FIND 2
BOOL GetColourMapHash(HANDLE hFile) { // размер карты не нужен
md5_context ctx;
UCHAR ucBuffer[4];
DWORD dwActual, dwSize, nIDATsFound;
BOOL bClose = FALSE;
if (hFile == INVALID_HANDLE_VALUE) {
bClose = TRUE;
hFile = CreateFile(g_psPathMaps, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE)
return FALSE;
}
if (0xFFFFFFFF == SetFilePointer(hFile, 33, NULL, FILE_CURRENT)) { if (bClose) CloseHandle(hFile); return FALSE; }
if (!ReadFile(hFile, ucBuffer, 4, &dwActual, NULL) || !dwActual) { if (bClose) CloseHandle(hFile); return FALSE; }
dwSize = LG(ucBuffer);
if (!ReadFile(hFile, ucBuffer, 4, &dwActual, NULL) || !dwActual) { if (bClose) CloseHandle(hFile); return FALSE; }
if ((ucBuffer[0] != 'w' || ucBuffer[1] != 'a' || ucBuffer[2] != 'L' || ucBuffer[3] != 'V')
&& (ucBuffer[0] != 'w' || ucBuffer[1] != '2' || ucBuffer[2] != 'l' || ucBuffer[3] != 'v'))
{ if (bClose) CloseHandle(hFile); return FALSE; }
if (0xFFFFFFFF == SetFilePointer(hFile, dwSize + 4, NULL, FILE_CURRENT)) { if (bClose) CloseHandle(hFile); return FALSE; }
md5_starts(&ctx);
nIDATsFound = 0;
for (;;) {
if (!ReadFile(hFile, ucBuffer, 4, &dwActual, NULL) || !dwActual) { if (bClose) CloseHandle(hFile); return FALSE; }
dwSize = LG(ucBuffer);
if (!ReadFile(hFile, ucBuffer, 4, &dwActual, NULL) || !dwActual) { if (bClose) CloseHandle(hFile); return FALSE; }
if (ucBuffer[0] == 'I' && ucBuffer[1] == 'E' && ucBuffer[2] == 'N' && ucBuffer[3] == 'D')
{ if (nIDATsFound) break; else { if (bClose) CloseHandle(hFile); return FALSE; }}
if (ucBuffer[0] == 'I' && ucBuffer[1] == 'D' && ucBuffer[2] == 'A' && ucBuffer[3] == 'T') {
if (0xFFFFFFFF == SetFilePointer(hFile, dwSize, NULL, FILE_CURRENT)) { if (bClose) CloseHandle(hFile); return FALSE; }
if (!ReadFile(hFile, ucBuffer, 4, &dwActual, NULL) || !dwActual) { if (bClose) CloseHandle(hFile); return FALSE; }
md5_update(&ctx, ucBuffer, sizeof(ucBuffer));
if (++nIDATsFound == MAX_IDAT_TAGS_TO_FIND)
break;
} else if (0xFFFFFFFF == SetFilePointer(hFile, dwSize + 4, NULL, FILE_CURRENT)) { if (bClose) CloseHandle(hFile); return FALSE; }
}
if (bClose)
CloseHandle(hFile);
md5_finish(&ctx, g_ucMD5Sum);
return TRUE;
}
BOOL GetMonochromeMapHash(HANDLE hFile, DWORD dwMapDataSize) {
md5_context ctx;
UCHAR ucBuffer[1024];
DWORD i, j, dwRemainder, dwActual;
BOOL bClose = FALSE;
if (hFile == INVALID_HANDLE_VALUE) {
bClose = TRUE;
hFile = CreateFile(g_psPathMaps, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE)
return FALSE;
}
md5_starts(&ctx);
if (!dwMapDataSize)
dwMapDataSize = GetFileSize(hFile, NULL);
j = dwMapDataSize / sizeof(ucBuffer);
if (dwRemainder = dwMapDataSize % sizeof(ucBuffer)) {
if (!ReadFile(hFile, ucBuffer, dwRemainder, &dwActual, NULL) || !dwActual) { if (bClose) CloseHandle(hFile); return FALSE; }
md5_update(&ctx, ucBuffer, dwActual);
}
for (i = 0; i < j; i++) {
if (!ReadFile(hFile, ucBuffer, sizeof(ucBuffer), &dwActual, NULL) || !dwActual) { if (bClose) CloseHandle(hFile); return FALSE; }
md5_update(&ctx, ucBuffer, dwActual);
}
if (bClose) CloseHandle(hFile);
md5_finish(&ctx, g_ucMD5Sum);
return TRUE;
}
void FileSearch(PSTR psPathBuffer, PSTR psDirOffset, PCSTR * ppcsExtensions, UINT nExtensionsCount, SEARCH_CALLBACK_PROC pfnCallbackProc) {
HANDLE hSearch;
WIN32_FIND_DATA wfd;
UINT i, nLen;
PSTR p1, p2;
p1 = psDirOffset;
p1[0] = '*';
p1[1] = '.';
p1[2] = '*';
p1[3] = '\0';
hSearch = FindFirstFile(psPathBuffer, &wfd);
if (hSearch == INVALID_HANDLE_VALUE)
return;
if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY && wfd.cFileName[0] == '.' && wfd.cFileName[1] == '\0') {
FindNextFile(hSearch, &wfd);
if (!FindNextFile(hSearch, &wfd))
{ FindClose(hSearch); return; }
}
do {
if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
nLen = strlen(wfd.cFileName);
memcpy(p1, wfd.cFileName, nLen);
p1[nLen] = '\\';
p1[nLen + 1] = '\0';
FileSearch(psPathBuffer, p1 + nLen + 1, ppcsExtensions, nExtensionsCount, pfnCallbackProc);
} else {
p2 = strrchr(wfd.cFileName, '.');
if (!p2)
p2 = "";
else
p2++;
for (i = 0; i < nExtensionsCount; i++)
if (lstrcmpi(p2, ppcsExtensions[i]) == 0)
{ pfnCallbackProc(p1, wfd.cFileName, i); break; }
}
} while (FindNextFile(hSearch, &wfd));
FindClose(hSearch);
}
UINT g_nFilesFound;
void CountingFileSearchCallback(PSTR psDir, PCSTR pcsFileName, UINT nExtensionIndex) {
g_nFilesFound++;
}
void HashExistingMaps__FSCallback(PSTR psDir, PCSTR pcsFileName, UINT nExtensionIndex) {
SendMessage(g_hPgbProgress, PBM_STEPIT, 0, 0);
strcpy(psDir, pcsFileName);
if (MAP_TYPE_PNG == nExtensionIndex + 1)
{ if (!GetColourMapHash(INVALID_HANDLE_VALUE)) return; }
else
{ if (!GetMonochromeMapHash(INVALID_HANDLE_VALUE, 0)) return; }
if (!Hashes_IsStored())
Hashes_Add();
}
void HashExistingMaps() {
PCSTR ppcsExtensions[] = { "bit", "lev", "png" };
PSTR p1 = g_psPathMaps + g_nPathMapsLen;
Hashes_Reset();
g_nFilesFound = 0;
FileSearch(g_psPathMaps, p1, ppcsExtensions, 3, CountingFileSearchCallback);
if (!g_nFilesFound)
return;
SendMessage(g_hPgbProgress, PBM_SETRANGE, 0, MAKELPARAM(0, g_nFilesFound));
FileSearch(g_psPathMaps, p1, ppcsExtensions, 3, HashExistingMaps__FSCallback);
SendMessage(g_hPgbProgress, PBM_SETPOS, 0, 0);
}
DWORD g_dwLogBufSize;
PSTR g_psLogBuffer;
void GuessGameTypes__FSCallback(PSTR psDir, PCSTR pcsFileName, UINT nExtensionIndex) {
HANDLE hFile;
DWORD dwFileSize, dwActual;
PSTR p1, p2;
PSTR psGameFileName, psGameType, psGameAuthor;
UINT nGameFileNameLen;
SendMessage(g_hPgbProgress, PBM_STEPIT, 0, 0);
if (strstr(pcsFileName, "DirectIP - Direct IP")
|| strstr(pcsFileName, "DirectIP - - Direct IP"))
return;
strcpy(psDir, pcsFileName);
hFile = CreateFile(g_psPathLogs, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
dwFileSize = GetFileSize(hFile, NULL);
if (dwFileSize < 30)
{ CloseHandle(hFile); return; }
if (dwFileSize + 1 > g_dwLogBufSize)
{ g_dwLogBufSize = dwFileSize + 1; g_psLogBuffer = (PSTR)realloc(g_psLogBuffer, g_dwLogBufSize); }
if (!ReadFile(hFile, g_psLogBuffer, dwFileSize, &dwActual, NULL) || !dwActual) { CloseHandle(hFile); return; }
CloseHandle(hFile);
g_psLogBuffer[dwActual] = '\0';
if (!(p1 = strstr(g_psLogBuffer, "recorded as file \"User\\Games\\")))
return;
psGameFileName = p1 + 29;
p1 = strchr(psGameFileName + 32, '"');
*p1 = '\0';
nGameFileNameLen = p1 - psGameFileName;
psGameType = strstr(psDir + 23, " - ") + 3;
if (!(p1 = strchr(psGameType, '+')))
p1 = strrchr(psGameType, '.');
else
p1--;
*p1 = '\0';
psGameAuthor = strrchr(psGameType, ' ') + 1;
*(psGameAuthor - 3) = '\0';
if (strcmp(psGameAuthor, "HostingBuddy") == 0) {
if (p1 = strstr(psGameType, "#039"))
psGameType = p1 + (*(p1 + 4) == 's' ? 6 : 5); // #039s_ #039_
else {
if (p1 = strstr(psGameType, "_for_")) {
while (p2 = strstr(p1 + 5, "_for_"))
p1 = p2;
*p1 = '\0';
}
}
} else if (*psGameType == 'Я' || *psGameType == '_')
psGameType++;
LoggedGames_Add(psGameFileName, nGameFileNameLen, psGameType, strlen(psGameType));
}
void GuessGameTypes() {
PCSTR ppcsExtensions[] = { "log" };
PSTR p1;
if (!g_nPathLogsLen)
return;
LoggedGames_Reset();
p1 = g_psPathLogs + g_nPathLogsLen;
g_nFilesFound = 0;
FileSearch(g_psPathLogs, p1, ppcsExtensions, 1, CountingFileSearchCallback);
if (!g_nFilesFound)
return;
SendMessage(g_hPgbProgress, PBM_SETRANGE, 0, MAKELPARAM(0, g_nFilesFound));
g_dwLogBufSize = LOG_BUFFER_SIZE;
g_psLogBuffer = (PSTR)malloc(LOG_BUFFER_SIZE);
FileSearch(g_psPathLogs, p1, ppcsExtensions, 1, GuessGameTypes__FSCallback);
free(g_psLogBuffer);
SendMessage(g_hPgbProgress, PBM_SETPOS, 0, 0);
}
UINT g_nDuplicates, g_nMapsExtracted;
void ExtractMaps__FSCallback(PSTR psDir, PCSTR pcsFileName, UINT nExtensionIndex) {
HANDLE hFile;
PSTR p1, p2;
int nLen, i;
unsigned char ucTmp[4 * 3];
DWORD dwMapSize, dwMapType, dwActual, dwPointer;
SendMessage(g_hPgbProgress, PBM_STEPIT, 0, 0);
strcpy(psDir, pcsFileName);
hFile = CreateFile(g_psPathReplays, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (!ReadFile(hFile, ucTmp, sizeof(ucTmp), &dwActual, NULL) || dwActual != sizeof(ucTmp) || ucTmp[0] != 'W' || ucTmp[1] != 'A')
{ CloseHandle(hFile); return; }
dwMapSize = *((DWORD *)(ucTmp + 4)) - 4;
dwMapType = *((DWORD *)(ucTmp + 8));
if (dwMapType != MAP_TYPE_BIT && dwMapType != MAP_TYPE_LEV && dwMapType != MAP_TYPE_PNG)
{ CloseHandle(hFile); return; }
dwPointer = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
if (dwMapType == MAP_TYPE_PNG)
{ if (!GetColourMapHash(hFile)) { CloseHandle(hFile); return; } }
else
{ if (!GetMonochromeMapHash(hFile, dwMapSize)) { CloseHandle(hFile); return; } }
SetFilePointer(hFile, dwPointer, NULL, FILE_BEGIN);
if (Hashes_IsStored())
{ g_nDuplicates++; CloseHandle(hFile); return; }
Hashes_Add();
i = LoggedGames_Find(psDir);
p2 = g_psPathMaps + g_nPathMapsLen;
if (i != GAME_NOT_FOUND) {
if (p1 = strchr(psDir, '[')) {
nLen = p1 - psDir + 1;
memcpy(p2, psDir, nLen);
p2 += nLen;
strcpy(p2, g_pLoggedGames[i].psType);
p2 += g_pLoggedGames[i].nTypeLen;
p1 = strchr(p1 + 1, ']');
nLen = strrchr(p1 + 1, '.') - p1 + 1;
memcpy(p2, p1, nLen);
p2 += nLen;
} else {
// how can this happen?
nLen = strrchr(psDir, '.') - psDir;
memcpy(p2, psDir, nLen);
p2 += nLen;
p2[0] = ' ';
p2[1] = '[';
p2 += 2;
strcpy(p2, g_pLoggedGames[i].psType);
nLen = g_pLoggedGames[i].nTypeLen;
p2[nLen] = ']';
p2[nLen + 1] = '.';
p2 += nLen + 2;
}
} else {
nLen = strrchr(psDir, '.') - psDir + 1;
memcpy(p2, psDir, nLen);
p2 += nLen;
}
switch (dwMapType) {
case MAP_TYPE_BIT:
strcpy(p2, "bit");
break;
case MAP_TYPE_LEV:
strcpy(p2, "lev");
break;
default:
strcpy(p2, "png");
}
if (ExtractMapToFile(hFile, dwMapSize))
g_nMapsExtracted++;
CloseHandle(hFile);
}
void ExtractMaps() {
PCSTR ppcsExtensions[] = { "WAgame" };
PSTR p1 = g_psPathReplays + g_nPathReplaysLen;
g_nFilesFound = 0;
g_nDuplicates = 0;
g_nMapsExtracted = 0;
FileSearch(g_psPathReplays, p1, ppcsExtensions, 1, CountingFileSearchCallback);
if (!g_nFilesFound)
return;
SendMessage(g_hPgbProgress, PBM_SETRANGE, 0, MAKELPARAM(0, g_nFilesFound));
FileSearch(g_psPathReplays, p1, ppcsExtensions, 1, ExtractMaps__FSCallback);
SendMessage(g_hPgbProgress, PBM_SETPOS, 0, 0);
}
DWORD WINAPI ProcessingThreadProc(PVOID pDummy) {
PSTR p1;
UINT nNotExportable;
TypeStatusMessage("Hashing existing maps...", STATE_NORMAL);
HashExistingMaps();
if (!g_nLoggedGames || g_bLogsPathChanged) {
TypeStatusMessage("Guessing game types (reading \"User\\Logs\")...", STATE_NORMAL);
GuessGameTypes();
g_bLogsPathChanged = FALSE;
}
TypeStatusMessage("Extracting maps...", STATE_NORMAL);
ExtractMaps();
p1 = g_sMsgFinal;
p1 += wsprintf(p1, "%d maps extracted", g_nMapsExtracted);
if (g_nDuplicates)
{ p1 += wsprintf(p1, " (%d duplicates skipped", g_nDuplicates); }
if (nNotExportable = g_nFilesFound - g_nDuplicates - g_nMapsExtracted)
{ p1 += wsprintf(p1, "%s%d not exportable maps).", g_nDuplicates ? ", " : " (", nNotExportable); }
else
strcpy(p1, g_nDuplicates ? ")." : ".");
TypeStatusMessage(g_sMsgFinal, STATE_NORMAL);
g_bProcessing = FALSE;
return 0;
}
int CALLBACK BrowseCallbackProc(HWND hWnd, UINT nMsg, LPARAM lParam, LPARAM lpData) {
char sDir[MAX_PATH];
switch(nMsg) {
case BFFM_INITIALIZED:
if (GetDlgItemText(g_hDlg, (int)lpData, sDir, sizeof(sDir)))
SendMessage(hWnd, BFFM_SETSELECTION, TRUE, (LPARAM)sDir);
break;
}
return 0;
}
// CoInitialize() call is needed
void ChooseFolder(int nControlId, PCSTR pcsTitle) {
BROWSEINFO bi = { 0 };
char sPath[MAX_PATH];
LPITEMIDLIST p_iil;
LPMALLOC pMalloc;
if (NOERROR != SHGetMalloc(&pMalloc))
return;
bi.hwndOwner = g_hDlg;
bi.lpszTitle = pcsTitle;
bi.ulFlags = BIF_RETURNONLYFSDIRS;
/*
if (nControlId == ID_EDT_MAPS)
bi.ulFlags |= 0x0040;
*/
bi.lpfn = BrowseCallbackProc;
bi.lParam = (LPARAM)nControlId;
if (p_iil = SHBrowseForFolder(&bi)) {
if (SHGetPathFromIDList(p_iil, sPath)) {
if (sPath[1] == ':' && sPath[0] >= 'A' && sPath[0] <= 'Z')
sPath[0] += 32;
SetDlgItemText(g_hDlg, nControlId, sPath);
}
pMalloc->lpVtbl->Free(pMalloc, p_iil);
}
pMalloc->lpVtbl->Release(pMalloc);
}
BOOL DirectoryExists(PCSTR pcsPath) {
DWORD dwAttrib = GetFileAttributes(pcsPath);
return (dwAttrib != 0xFFFFFFFF && dwAttrib & FILE_ATTRIBUTE_DIRECTORY);
}
BOOL ValidatePath(PSTR psPath, UINT nPathLen) {
UINT nFirstBSPos, i, nStartFrom;
UINT * pnFoundBSPos;
UINT nFoundBSCount;
if (nPathLen <= 3)
return FALSE;
nFirstBSPos = (psPath[0] == '\\' && psPath[2] != '\\') ? 1 : 2;
pnFoundBSPos = (UINT *)malloc((nPathLen - 3) * sizeof(UINT));
nFoundBSCount = 0;
for (i = nFirstBSPos + 2; i < nPathLen; i++) {
if (psPath[i] == '\\') {
if (psPath[i - 1] == '.')
{ free(pnFoundBSPos); return FALSE; }
else
pnFoundBSPos[nFoundBSCount++] = i;
}
}
nStartFrom = (nFirstBSPos == 1 || psPath[0] == '\\') ? 1 : 0;
if (nStartFrom == 1 && nFoundBSCount < 2)
{ free(pnFoundBSPos); return FALSE; }
if (nFoundBSCount) {
i = nFoundBSCount - 1;
for (;;) {
psPath[pnFoundBSPos[i]] = '\0';
if (DirectoryExists(psPath))
{ psPath[pnFoundBSPos[i++]] = '\\'; break; }
if (i == nStartFrom)
break;
i--;
}
}
if (nStartFrom == 1 && i == nStartFrom)
{ free(pnFoundBSPos); return FALSE; }
if (!nFoundBSCount) {
if (!CreateDirectory(psPath, NULL))
{ free(pnFoundBSPos); return FALSE; }
} else
for(;;) {
if (!CreateDirectory(psPath, NULL))
{ free(pnFoundBSPos); return FALSE; }
if (i == nFoundBSCount)
break;
psPath[pnFoundBSPos[i++]] = '\\';
}
free(pnFoundBSPos);
return TRUE;
}
#define PATH_GOOD 0
#define PATH_NOT_EXISTING 1
#define PATH_INCORRECT 2
UINT CheckEnteredPath(int nControlId) {
char sTmpPath[MAX_PATH];
PSTR psPath;
PSTR psFilePart;
UINT * pnPathLen;
UINT nFirstBSPos, i;
switch (nControlId) {
case ID_EDT_WA:
psPath = g_psPathLogs;
pnPathLen = &g_nPathLogsLen;
break;
case ID_EDT_REPLAYS:
psPath = g_psPathReplays;
pnPathLen = &g_nPathReplaysLen;
break;
default:
psPath = g_psPathMaps;
pnPathLen = &g_nPathMapsLen;
}
if (!GetDlgItemText(g_hDlg, nControlId, sTmpPath, sizeof(sTmpPath)))
{ *pnPathLen = 0; return PATH_INCORRECT; }
*pnPathLen = GetFullPathName(sTmpPath, PATH_BUFFER_SIZE, psPath, &psFilePart);
if (*pnPathLen > PATH_BUFFER_SIZE || *pnPathLen < 3)
return PATH_INCORRECT;
if (psPath[*pnPathLen - 1] == '\\' && *pnPathLen != 3)
{ (*pnPathLen)--; psPath[*pnPathLen] = '\0';}
if (psPath[*pnPathLen - 1] == '.')
return PATH_INCORRECT;
if (psPath[1] == ':' && psPath[0] >= 'A' && psPath[0] <= 'Z')
psPath[0] += 32;
nFirstBSPos = (psPath[0] == '\\' && psPath[2] != '\\') ? 1 : 2;
for (i = nFirstBSPos + 1; i < *pnPathLen; i++)
if (psPath[i] == ':' || psPath[i] == '*' || psPath[i] == '?'
|| psPath[i] == '"' || psPath[i] == '<' || psPath[i] == '>' || psPath[i] == '|')
return PATH_INCORRECT;
if (!DirectoryExists(psPath))
return PATH_NOT_EXISTING;
SetDlgItemText(g_hDlg, nControlId, psPath);
return PATH_GOOD;
}
BOOL PathsAreGood() {
if (!g_nLoggedGames || g_bLogsPathChanged) {
if (g_pcsAlert_WA)
{ TypeStatusMessage(g_pcsAlert_WA, STATE_ALERT); return FALSE; }
if (g_bWarned_WA)
{ g_bWarned_WA = FALSE; SetDlgItemText(g_hDlg, ID_EDT_WA, ""); g_nPathLogsLen = 0; }
else {
if (PATH_GOOD != CheckEnteredPath(ID_EDT_WA))
{ if (g_nPathLogsLen) { g_pcsAlert_WA = "Incorrect path to WA! Leave the field empty if WA is not installed."; TypeStatusMessage(g_pcsAlert_WA, STATE_ALERT); return FALSE; } }
else {
strcpy(g_psPathLogs + g_nPathLogsLen, "\\User\\Logs");
g_nPathLogsLen += 10;
if (!DirectoryExists(g_psPathLogs)) {
g_bWarned_WA = TRUE;
TypeStatusMessage("\"User\\Logs\" not found. You can continue, but game types won't be defined.", STATE_WARNING);
return FALSE;
}
}
if (g_nPathLogsLen)
{ g_psPathLogs[g_nPathLogsLen++] = '\\'; g_psPathLogs[g_nPathLogsLen] = '\0'; }
}
}
if (g_pcsAlert_Replays)
{ TypeStatusMessage(g_pcsAlert_Replays, STATE_ALERT); return FALSE; }
if (PATH_GOOD != CheckEnteredPath(ID_EDT_REPLAYS))
{ g_pcsAlert_Replays = "Incorrect replays (saved games) path!"; TypeStatusMessage(g_pcsAlert_Replays, STATE_ALERT); return FALSE; }
g_psPathReplays[g_nPathReplaysLen++] = '\\';
g_psPathReplays[g_nPathReplaysLen] = '\0';
if (g_pcsAlert_Maps)
{ TypeStatusMessage(g_pcsAlert_Maps, STATE_ALERT); return FALSE; }
if (g_bWarned_Maps) {
g_bWarned_Maps = FALSE;
if (!ValidatePath(g_psPathMaps, g_nPathMapsLen))
{ g_pcsAlert_Maps = "Can't create directory for maps. Please specify a valid path."; TypeStatusMessage(g_pcsAlert_Maps, STATE_ALERT); return FALSE; }
} else {
UINT nResult = CheckEnteredPath(ID_EDT_MAPS);
if (nResult == PATH_INCORRECT)
{ g_pcsAlert_Maps = "Incorrect maps (saved levels) path!"; TypeStatusMessage(g_pcsAlert_Maps, STATE_ALERT); return FALSE; }
else if (nResult == PATH_NOT_EXISTING) {
SetDlgItemText(g_hDlg, ID_EDT_MAPS, g_psPathMaps);
g_bWarned_Maps = TRUE;
TypeStatusMessage("Specified maps directory does not exist. Push the button again to create it.", STATE_WARNING);
return FALSE;
}
}
g_psPathMaps[g_nPathMapsLen++] = '\\';
g_psPathMaps[g_nPathMapsLen] = '\0';
return TRUE;
}
BOOL CALLBACK DialogProc(HWND hDlg, UINT nMsg, WPARAM wParam, LPARAM lParam) {
switch (nMsg) {
case WM_INITDIALOG:
{
HKEY hKey;
g_hDlg = hDlg;
SendMessage(hDlg, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(ID_ICO_MAIN)));
g_hNormalBrush = CreateSolidBrush(NORMAL_STATUS_BGCOLOR);
g_hWarningBrush = CreateSolidBrush(WARNING_STATUS_BGCOLOR);
g_hAlertBrush = CreateSolidBrush(ALERT_STATUS_BGCOLOR);
g_hBtnExtract = GetDlgItem(hDlg, IDOK);
g_hLblStatus = GetDlgItem(hDlg, ID_LBL_STATUS);
g_hPgbProgress = GetDlgItem(hDlg, ID_PGB_PROGRESS);
SendMessage(g_hPgbProgress, PBM_SETSTEP, 1, 0);
SetTimer(hDlg, TIMER_BLINKING, 500, BlinkingTimerProc);
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, "Software\\Team17SoftwareLTD\\WormsArmageddon", 0, KEY_QUERY_VALUE, &hKey)) {
char sPath[MAX_PATH];
DWORD dwBufSize = sizeof(sPath);
LONG nResult = RegQueryValueEx(hKey, "PATH", NULL, NULL, (PUCHAR)sPath, &dwBufSize);
RegCloseKey(hKey);
if (nResult == ERROR_SUCCESS && dwBufSize != 0 && dwBufSize <= MAX_PATH - 1 - 17) {
PSTR psOffset = sPath + dwBufSize - 1;
if (*(psOffset - 1) == '\\')
*(--psOffset) = '\0';
SetDlgItemText(hDlg, ID_EDT_WA, sPath);
strcpy(psOffset, "\\User\\Games");
SetDlgItemText(hDlg, ID_EDT_REPLAYS, sPath);
strcpy(psOffset + 6, "SavedLevels");
SetDlgItemText(hDlg, ID_EDT_MAPS, sPath);
TypeStatusMessage("Specify the paths and click on that button ----->", STATE_NORMAL);
break;
}
}
TypeStatusMessage("Specify the paths. Leave WA path field empty if you don't have WA installed.", STATE_NORMAL);
}
break;
case WM_CTLCOLORSTATIC:
if ((HWND)lParam == g_hLblStatus)
switch (g_nState) {
case STATE_WARNING :
SetBkColor((HDC)wParam, WARNING_STATUS_BGCOLOR);
return (BOOL)g_hWarningBrush;
case STATE_ALERT:
SetBkColor((HDC)wParam, ALERT_STATUS_BGCOLOR);
return (BOOL)g_hAlertBrush;
default:
SetBkColor((HDC)wParam, NORMAL_STATUS_BGCOLOR);
return (BOOL)g_hNormalBrush;
}
else
return FALSE;
case WM_TIMER:
if (!g_bProcessing) {
KillTimer(hDlg, 0);
EnableWindow(g_hBtnExtract, TRUE);
}
break;
case WM_COMMAND:
if (HIWORD(wParam) == EN_CHANGE) {
switch (LOWORD(wParam)) {
case ID_EDT_WA:
if (g_bWarned_WA) g_bWarned_WA = FALSE;
if (g_pcsAlert_WA) g_pcsAlert_WA = NULL;
if (!g_bLogsPathChanged) g_bLogsPathChanged = TRUE;
return FALSE;
case ID_EDT_REPLAYS:
if (g_pcsAlert_Replays) g_pcsAlert_Replays = NULL;
return FALSE;
case ID_EDT_MAPS:
if (g_bWarned_Maps) g_bWarned_Maps = FALSE;
if (g_pcsAlert_Maps) g_pcsAlert_Maps = NULL;
return FALSE;
}
}
switch (LOWORD(wParam)) {
case IDOK:
if (!g_bProcessing && PathsAreGood()) {
DWORD dwThreadId;
g_bProcessing = TRUE;
EnableWindow(g_hBtnExtract, FALSE);
SetTimer(hDlg, TIMER_PROCESSING, 25, NULL);
CreateThread(NULL, 0, ProcessingThreadProc, NULL, 0, &dwThreadId);
return FALSE;
}
return FALSE;
case ID_BTN_WA:
ChooseFolder(ID_EDT_WA, "Select Worms Armageddon root folder:");
return FALSE;
case ID_BTN_REPLAYS:
ChooseFolder(ID_EDT_REPLAYS, "Select the saved games (replays) folder:");
return FALSE;
case ID_BTN_MAPS:
ChooseFolder(ID_EDT_MAPS, "Select the saved levels (maps) folder:");
return FALSE;
}
break;
case WM_CLOSE:
EndDialog(hDlg, 0);
break;
default:
return FALSE;
}
return TRUE;
}
#ifdef _DEBUG
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR psCmdLine, int nShowCmd) {
#else
void _WinMain() {
HINSTANCE hInst = GetModuleHandle(NULL);
#endif
g_psPathLogs = (PSTR)malloc(PATH_BUFFER_SIZE * 3);
g_psPathReplays = g_psPathLogs + PATH_BUFFER_SIZE;
g_psPathMaps = g_psPathLogs + PATH_BUFFER_SIZE * 2;
InitCommonControls();
CoInitialize(NULL);
DialogBox(hInst, MAKEINTRESOURCE(ID_DLG_MAIN), HWND_DESKTOP, DialogProc);
free(g_psPathLogs);
if (g_nLoggedGames)
{ free(g_pLoggedGames); free(g_pucLoggedGamesData); }
if (g_nHashes)
free(g_pHashes);
#ifdef _DEBUG
return 0;
#else
ExitProcess(0);
#endif
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment