BOOL CWebInterfaceDlg::OnInitDialog()
{
CDialog::OnInitDialog();
SetIcon(m_hIcon, TRUE);
SetIcon(m_hIcon, FALSE);
UINT nIdIcon = IDR_MAINFRAME;
_TrayMgr.Create (m_hWnd, &nIdIcon, 1, "FDM remote control server", WM_TRAYMSG);
m_http.set_Port (AfxGetApp ()->GetProfileInt ("Network", "Port", 80));
SetDlgItemInt (IDC_PORT, m_http.get_Port ());
m_http.Start ();
UpdateAddress ();
fsAutorunMgr am;
CheckDlgButton (IDC_AUTORUN, am.IsAutoStart () ? BST_CHECKED : BST_UNCHECKED);
CString strU = AfxGetApp ()->GetProfileString ("Network", "Login", "");
CString strP = AfxGetApp ()->GetProfileString ("Network", "Password", "");
if (strU.IsEmpty () == FALSE)
{
CheckDlgButton (IDC_USEPWD, BST_CHECKED);
SetDlgItemText (IDC_USER, strU);
SetDlgItemText (IDC_PWD, strP);
}
UpdateEnabled ();
return TRUE;
}
std::pair<float, float> GameState::Coordinates(int player) {
UpdateAddress(6 + 2 * (player - 1));
//UpdateAddress(7 + 2 * (player - 1));
float x = LongToFloat(raw_input[6 + 2 * (player - 1)]);
float y = LongToFloat(raw_input[7 + 2 * (player - 1)]);
return std::make_pair(x, y);
}
void cTCPLinkImpl::UpdateRemoteAddress(void)
{
sockaddr_storage sa;
socklen_t salen = static_cast<socklen_t>(sizeof(sa));
getpeername(bufferevent_getfd(m_BufferEvent), reinterpret_cast<sockaddr *>(&sa), &salen);
UpdateAddress(reinterpret_cast<const sockaddr *>(&sa), salen, m_RemoteIP, m_RemotePort);
}
void CKadNode::Merge(CKadNode* pNode)
{
for(AddressMap::iterator I = pNode->m_AddressMap.begin(); I != pNode->m_AddressMap.end(); I++)
UpdateAddress(I->second);
if(pNode->m_uFirstSeen < m_uFirstSeen)
m_uFirstSeen = pNode->m_uFirstSeen;
}
cTCPLinkImpl::cTCPLinkImpl(evutil_socket_t a_Socket, cTCPLink::cCallbacksPtr a_LinkCallbacks, cServerHandleImplPtr a_Server, const sockaddr * a_Address, socklen_t a_AddrLen):
super(a_LinkCallbacks),
m_BufferEvent(bufferevent_socket_new(cNetworkSingleton::Get().GetEventBase(), a_Socket, BEV_OPT_CLOSE_ON_FREE | BEV_OPT_THREADSAFE | BEV_OPT_DEFER_CALLBACKS | BEV_OPT_UNLOCK_CALLBACKS)),
m_Server(a_Server),
m_LocalPort(0),
m_RemotePort(0),
m_ShouldShutdown(false)
{
// Update the endpoint addresses:
UpdateLocalAddress();
UpdateAddress(a_Address, a_AddrLen, m_RemoteIP, m_RemotePort);
}
int DeleteElement(NormalType index)
{
if(AddreBookRealSize < index)
{
printf("Function name: DeleteElement!\nindex out of scope!\n");
return -1;
}
pElementType tmp = pltArr[index];
UpdateAddress(NULL, index, DELETE);
FreeSingleNode(tmp);
AddreBookRealSize--;
return 0;
}
bool CPointer::Write(void* _lpValue, size_t tSize)
{
if(_lpValue==0) return false;
if(!UpdateAddress())
{
char* lpBuffer = new char[260];
sprintf_s(lpBuffer, 260, "Process Handle: %d\r\nMemory Address: %d\r\nOffset Pointer: %d", (int)cpInfo->hProcess, (int)_lpAddress, (int)cpInfo->lpOffsets);
DebugOutputHandler::PrintDebugString("Error obtaining memory address", "CPointer::Read", "Update address call failure", lpBuffer);
delete[] lpBuffer;
return false;
}
return WriteProcessMemory(cpInfo->hProcess, (LPVOID)_lpAddress, (LPCVOID)_lpValue, tSize, &_tBytesWritten) != 0;
}
int AddElement(NormalType index, pElementType pnewele)
{
if(IsListFull())
{
printf("List is FULL!\n");
return -1;
}
if(AddreBookRealSize < index)
{
printf("Function name: AddElement!\nindex out of scope!\n");
return -1;
}
UpdateAddress(pnewele, index, ADD);
AddreBookRealSize++;
return 0;
}
int DeleteElement(NormalType index, pListHeader plh)
{
if(index < 0 || plh == NULL)
return -1;
if(plh->AddreBookRealSize < index)
{
printf("Function name: DeleteElement!\nindex out of scope!\n");
return -2;
}
pElementType tmp = plh->pltArr[index];
UpdateAddress(NULL, index, DELETE, plh);
free(tmp);
tmp = NULL;
(plh->AddreBookRealSize)--;
return 0;
}
int AddElement(NormalType index, pElementType pnewele, pListHeader plh)
{
if(index < 0 || pnewele == NULL || plh == NULL)
return -1;
if(IsListFull(plh))
ExtendAddreBook(plh);
if(plh->AddreBookRealSize < index)
{
printf("Function name: AddElement!\nindex out of scope!\n");
return -2;
}
UpdateAddress(pnewele, index, ADD, plh);
(plh->AddreBookRealSize)++;
return 0;
}
bool CPointer::Read(size_t tSize)
{
if(_bIsAllocated) free(lpValue);
lpValue = malloc(tSize);
if(lpValue==0) return false;
_bIsAllocated = true;
if(!UpdateAddress())
{
char* lpBuffer = new char[260];
sprintf_s(lpBuffer, 260, "Process Handle: %d\r\nMemory Address: %d\r\nOffset Pointer: %d", (int)cpInfo->hProcess, (int)_lpAddress, (int)cpInfo->lpOffsets);
DebugOutputHandler::PrintDebugString("Error obtaining memory address", "CPointer::Read", "Update address call failure", lpBuffer);
delete[] lpBuffer;
return false;
}
return ReadProcessMemory(cpInfo->hProcess, (LPCVOID)_lpAddress, (LPVOID)lpValue, tSize, &_tBytesRead) != 0;
}
void CWebInterfaceDlg::OnOK()
{
UINT nPort = GetDlgItemInt (IDC_PORT);
if (nPort > 0xffff)
{
SetDlgItemInt (IDC_PORT, m_http.get_Port (), FALSE);
return;
}
if (nPort != m_http.get_Port ())
{
AfxGetApp ()->WriteProfileInt ("Network", "Port", nPort);
m_http.Shutdown ();
m_http.set_Port (nPort);
m_http.Start ();
UpdateAddress ();
}
fsAutorunMgr am;
am.SetAutoStart (IsDlgButtonChecked (IDC_AUTORUN) == BST_CHECKED);
CString strU, strP;
if (IsDlgButtonChecked (IDC_USEPWD) == BST_CHECKED)
{
GetDlgItemText (IDC_USER, strU);
GetDlgItemText (IDC_PWD, strP);
AfxGetApp ()->WriteProfileString ("Network", "Login", strU);
AfxGetApp ()->WriteProfileString ("Network", "Password", strP);
}
else
{
AfxGetApp ()->WriteProfileString ("Network", "Login", "");
AfxGetApp ()->WriteProfileString ("Network", "Password", "");
}
ShowWindow (SW_HIDE);
}
float GameState::P2ShieldSize() {
UpdateAddress(17);
return LongToFloat(raw_input[17]);
}
int GameState::P2JumpsUsed() {
UpdateAddress(16);
return (Raw(16) & 0xFFFF0000) >> 24;
}
int GameState::P2Hitlag() {
UpdateAddress(15);
return LongToFloat(raw_input[15]);
}
int GameState::Stocks(int player) {
UpdateAddress(player - 1);
return Read8(player - 1);
}
long GameState::P2ActionState() {
UpdateAddress(12);
return raw_input[12];
}
float GameState::P2VerticalVelocity() {
UpdateAddress(13);
return LongToFloat(raw_input[13]);
}
/*******************************************************************************
*
* FUNCTION: ChildWndProc(HWND, unsigned, WORD, LONG)
*
* PURPOSE: Processes messages for the child windows.
*
* WM_COMMAND - process the application menu
* WM_PAINT - Paint the main window
* WM_DESTROY - post a quit message and return
*
*/
LRESULT CALLBACK ChildWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
BOOL Result;
switch (message)
{
case WM_CREATE:
{
WNDPROC oldproc;
HFONT hFont;
WCHAR buffer[MAX_PATH];
/* Load "My Computer" string */
LoadStringW(hInst, IDS_MY_COMPUTER, buffer, COUNT_OF(buffer));
g_pChildWnd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ChildWnd));
if (!g_pChildWnd) return 0;
wcsncpy(g_pChildWnd->szPath, buffer, MAX_PATH);
g_pChildWnd->nSplitPos = 250;
g_pChildWnd->hWnd = hWnd;
g_pChildWnd->hAddressBarWnd = CreateWindowExW(WS_EX_CLIENTEDGE, L"Edit", NULL, WS_CHILD | WS_VISIBLE | WS_CHILDWINDOW | WS_TABSTOP,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
hWnd, (HMENU)0, hInst, 0);
g_pChildWnd->hAddressBtnWnd = CreateWindowExW(0, L"Button", L"»", WS_CHILD | WS_VISIBLE | WS_CHILDWINDOW | WS_TABSTOP | BS_TEXT | BS_CENTER | BS_VCENTER | BS_FLAT | BS_DEFPUSHBUTTON,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
hWnd, (HMENU)0, hInst, 0);
g_pChildWnd->hTreeWnd = CreateTreeView(hWnd, g_pChildWnd->szPath, (HMENU) TREE_WINDOW);
g_pChildWnd->hListWnd = CreateListView(hWnd, (HMENU) LIST_WINDOW/*, g_pChildWnd->szPath*/);
SetFocus(g_pChildWnd->hTreeWnd);
/* set the address bar and button font */
if ((g_pChildWnd->hAddressBarWnd) && (g_pChildWnd->hAddressBtnWnd))
{
hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
SendMessageW(g_pChildWnd->hAddressBarWnd,
WM_SETFONT,
(WPARAM)hFont,
0);
SendMessageW(g_pChildWnd->hAddressBtnWnd,
WM_SETFONT,
(WPARAM)hFont,
0);
}
/* Subclass the AddressBar */
oldproc = (WNDPROC)(LONG_PTR)GetWindowLongPtr(g_pChildWnd->hAddressBarWnd, GWLP_WNDPROC);
SetWindowLongPtr(g_pChildWnd->hAddressBarWnd, GWLP_USERDATA, (DWORD_PTR)oldproc);
SetWindowLongPtr(g_pChildWnd->hAddressBarWnd, GWLP_WNDPROC, (DWORD_PTR)AddressBarProc);
break;
}
case WM_COMMAND:
if(HIWORD(wParam) == BN_CLICKED)
{
PostMessageW(g_pChildWnd->hAddressBarWnd, WM_KEYUP, VK_RETURN, 0);
}
if (!_CmdWndProc(hWnd, message, wParam, lParam))
{
goto def;
}
break;
case WM_PAINT:
OnPaint(hWnd);
return 0;
case WM_SETCURSOR:
if (LOWORD(lParam) == HTCLIENT)
{
POINT pt;
GetCursorPos(&pt);
ScreenToClient(hWnd, &pt);
if (pt.x>=g_pChildWnd->nSplitPos-SPLIT_WIDTH/2 && pt.x<g_pChildWnd->nSplitPos+SPLIT_WIDTH/2+1)
{
SetCursor(LoadCursorW(0, IDC_SIZEWE));
return TRUE;
}
}
goto def;
case WM_DESTROY:
DestroyTreeView();
DestroyListView(g_pChildWnd->hListWnd);
DestroyMainMenu();
HeapFree(GetProcessHeap(), 0, g_pChildWnd);
g_pChildWnd = NULL;
PostQuitMessage(0);
break;
case WM_LBUTTONDOWN:
{
RECT rt;
int x = (short)LOWORD(lParam);
GetClientRect(hWnd, &rt);
if (x>=g_pChildWnd->nSplitPos-SPLIT_WIDTH/2 && x<g_pChildWnd->nSplitPos+SPLIT_WIDTH/2+1)
{
last_split = g_pChildWnd->nSplitPos;
draw_splitbar(hWnd, last_split);
SetCapture(hWnd);
}
break;
}
case WM_LBUTTONUP:
case WM_RBUTTONDOWN:
if (GetCapture() == hWnd)
{
finish_splitbar(hWnd, LOWORD(lParam));
}
break;
case WM_CAPTURECHANGED:
if (GetCapture()==hWnd && last_split>=0)
draw_splitbar(hWnd, last_split);
break;
case WM_KEYDOWN:
if (wParam == VK_ESCAPE)
if (GetCapture() == hWnd)
{
RECT rt;
draw_splitbar(hWnd, last_split);
GetClientRect(hWnd, &rt);
ResizeWnd(rt.right, rt.bottom);
last_split = -1;
ReleaseCapture();
SetCursor(LoadCursorW(0, IDC_ARROW));
}
break;
case WM_MOUSEMOVE:
if (GetCapture() == hWnd)
{
HDC hdc;
RECT rt;
HGDIOBJ OldObj;
int x = LOWORD(lParam);
if(!SizingPattern)
{
const DWORD Pattern[4] = {0x5555AAAA, 0x5555AAAA, 0x5555AAAA, 0x5555AAAA};
SizingPattern = CreateBitmap(8, 8, 1, 1, Pattern);
}
if(!SizingBrush)
{
SizingBrush = CreatePatternBrush(SizingPattern);
}
GetClientRect(hWnd, &rt);
x = (SHORT) min(max(x, SPLIT_MIN), rt.right - SPLIT_MIN);
if(last_split != x)
{
rt.left = last_split-SPLIT_WIDTH/2;
rt.right = last_split+SPLIT_WIDTH/2+1;
hdc = GetDC(hWnd);
OldObj = SelectObject(hdc, SizingBrush);
PatBlt(hdc, rt.left, rt.top, rt.right - rt.left, rt.bottom - rt.top, PATINVERT);
last_split = x;
rt.left = x-SPLIT_WIDTH/2;
rt.right = x+SPLIT_WIDTH/2+1;
PatBlt(hdc, rt.left, rt.top, rt.right - rt.left, rt.bottom - rt.top, PATINVERT);
SelectObject(hdc, OldObj);
ReleaseDC(hWnd, hdc);
}
}
break;
case WM_SETFOCUS:
if (g_pChildWnd != NULL)
{
SetFocus(g_pChildWnd->nFocusPanel? g_pChildWnd->hListWnd: g_pChildWnd->hTreeWnd);
}
break;
case WM_TIMER:
break;
case WM_NOTIFY:
if ((int)wParam == TREE_WINDOW && g_pChildWnd != NULL)
{
switch (((LPNMHDR)lParam)->code)
{
case TVN_ITEMEXPANDING:
return !OnTreeExpanding(g_pChildWnd->hTreeWnd, (NMTREEVIEW*)lParam);
case TVN_SELCHANGED:
UpdateAddress(((NMTREEVIEW*)lParam)->itemNew.hItem, NULL, NULL);
break;
case NM_SETFOCUS:
g_pChildWnd->nFocusPanel = 0;
break;
case TVN_BEGINLABELEDIT:
{
LPNMTVDISPINFO ptvdi;
/* cancel label edit for rootkeys */
ptvdi = (LPNMTVDISPINFO) lParam;
if (!TreeView_GetParent(g_pChildWnd->hTreeWnd, ptvdi->item.hItem) ||
!TreeView_GetParent(g_pChildWnd->hTreeWnd, TreeView_GetParent(g_pChildWnd->hTreeWnd, ptvdi->item.hItem)))
return TRUE;
break;
}
case TVN_ENDLABELEDIT:
{
LPCWSTR keyPath;
HKEY hRootKey;
HKEY hKey = NULL;
LPNMTVDISPINFO ptvdi;
LONG lResult = TRUE;
WCHAR szBuffer[MAX_PATH];
ptvdi = (LPNMTVDISPINFO) lParam;
if (ptvdi->item.pszText)
{
keyPath = GetItemPath(g_pChildWnd->hTreeWnd, TreeView_GetParent(g_pChildWnd->hTreeWnd, ptvdi->item.hItem), &hRootKey);
_snwprintf(szBuffer, COUNT_OF(szBuffer), L"%s\\%s", keyPath, ptvdi->item.pszText);
keyPath = GetItemPath(g_pChildWnd->hTreeWnd, ptvdi->item.hItem, &hRootKey);
if (RegOpenKeyExW(hRootKey, szBuffer, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
lResult = FALSE;
RegCloseKey(hKey);
(void)TreeView_EditLabel(g_pChildWnd->hTreeWnd, ptvdi->item.hItem);
}
else
{
if (RenameKey(hRootKey, keyPath, ptvdi->item.pszText) != ERROR_SUCCESS)
lResult = FALSE;
else
UpdateAddress(ptvdi->item.hItem, hRootKey, szBuffer);
}
return lResult;
}
}
default:
return 0;
}
}
else
{
if ((int)wParam == LIST_WINDOW && g_pChildWnd != NULL)
{
switch (((LPNMHDR)lParam)->code)
{
case NM_SETFOCUS:
g_pChildWnd->nFocusPanel = 1;
break;
default:
if(!ListWndNotifyProc(g_pChildWnd->hListWnd, wParam, lParam, &Result))
{
goto def;
}
return Result;
break;
}
}
}
break;
case WM_CONTEXTMENU:
{
POINT pt;
if((HWND)wParam == g_pChildWnd->hListWnd)
{
int i, cnt;
BOOL IsDefault;
pt.x = (short) LOWORD(lParam);
pt.y = (short) HIWORD(lParam);
cnt = ListView_GetSelectedCount(g_pChildWnd->hListWnd);
i = ListView_GetNextItem(g_pChildWnd->hListWnd, -1, LVNI_FOCUSED | LVNI_SELECTED);
if (pt.x == -1 && pt.y == -1)
{
RECT rc;
if (i != -1)
{
rc.left = LVIR_BOUNDS;
SendMessageW(g_pChildWnd->hListWnd, LVM_GETITEMRECT, i, (LPARAM) &rc);
pt.x = rc.left + 8;
pt.y = rc.top + 8;
}
else
pt.x = pt.y = 0;
ClientToScreen(g_pChildWnd->hListWnd, &pt);
}
if(i == -1)
{
TrackPopupMenu(GetSubMenu(hPopupMenus, PM_NEW), TPM_RIGHTBUTTON, pt.x, pt.y, 0, hFrameWnd, NULL);
}
else
{
HMENU mnu = GetSubMenu(hPopupMenus, PM_MODIFYVALUE);
SetMenuDefaultItem(mnu, ID_EDIT_MODIFY, MF_BYCOMMAND);
IsDefault = IsDefaultValue(g_pChildWnd->hListWnd, i);
if(cnt == 1)
EnableMenuItem(mnu, ID_EDIT_RENAME, MF_BYCOMMAND | (IsDefault ? MF_DISABLED | MF_GRAYED : MF_ENABLED));
else
EnableMenuItem(mnu, ID_EDIT_RENAME, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
EnableMenuItem(mnu, ID_EDIT_MODIFY, MF_BYCOMMAND | (cnt == 1 ? MF_ENABLED : MF_DISABLED | MF_GRAYED));
EnableMenuItem(mnu, ID_EDIT_MODIFY_BIN, MF_BYCOMMAND | (cnt == 1 ? MF_ENABLED : MF_DISABLED | MF_GRAYED));
TrackPopupMenu(mnu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, hFrameWnd, NULL);
}
}
else if ((HWND)wParam == g_pChildWnd->hTreeWnd)
{
TVHITTESTINFO hti;
HMENU hContextMenu;
TVITEMW item;
MENUITEMINFOW mii;
WCHAR resource[256];
WCHAR buffer[256];
LPWSTR s;
LPCWSTR keyPath;
HKEY hRootKey;
int iLastPos;
WORD wID;
pt.x = (short) LOWORD(lParam);
pt.y = (short) HIWORD(lParam);
if (pt.x == -1 && pt.y == -1)
{
RECT rc;
hti.hItem = TreeView_GetSelection(g_pChildWnd->hTreeWnd);
if (hti.hItem != NULL)
{
TreeView_GetItemRect(g_pChildWnd->hTreeWnd, hti.hItem, &rc, TRUE);
pt.x = rc.left + 8;
pt.y = rc.top + 8;
ClientToScreen(g_pChildWnd->hTreeWnd, &pt);
hti.flags = TVHT_ONITEM;
}
else
hti.flags = 0;
}
else
{
hti.pt.x = pt.x;
hti.pt.y = pt.y;
ScreenToClient(g_pChildWnd->hTreeWnd, &hti.pt);
(void)TreeView_HitTest(g_pChildWnd->hTreeWnd, &hti);
}
if (hti.flags & TVHT_ONITEM)
{
hContextMenu = GetSubMenu(hPopupMenus, PM_TREECONTEXT);
(void)TreeView_SelectItem(g_pChildWnd->hTreeWnd, hti.hItem);
memset(&item, 0, sizeof(item));
item.mask = TVIF_STATE | TVIF_CHILDREN;
item.hItem = hti.hItem;
(void)TreeView_GetItem(g_pChildWnd->hTreeWnd, &item);
/* Set the Expand/Collapse menu item appropriately */
LoadStringW(hInst, (item.state & TVIS_EXPANDED) ? IDS_COLLAPSE : IDS_EXPAND, buffer, COUNT_OF(buffer));
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING | MIIM_STATE | MIIM_ID;
mii.fState = (item.cChildren > 0) ? MFS_DEFAULT : MFS_GRAYED;
mii.wID = (item.state & TVIS_EXPANDED) ? ID_TREE_COLLAPSEBRANCH : ID_TREE_EXPANDBRANCH;
mii.dwTypeData = (LPWSTR) buffer;
SetMenuItemInfo(hContextMenu, 0, TRUE, &mii);
/* Remove any existing suggestions */
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_ID;
GetMenuItemInfo(hContextMenu, GetMenuItemCount(hContextMenu) - 1, TRUE, &mii);
if ((mii.wID >= ID_TREE_SUGGESTION_MIN) && (mii.wID <= ID_TREE_SUGGESTION_MAX))
{
do
{
iLastPos = GetMenuItemCount(hContextMenu) - 1;
GetMenuItemInfo(hContextMenu, iLastPos, TRUE, &mii);
RemoveMenu(hContextMenu, iLastPos, MF_BYPOSITION);
}
while((mii.wID >= ID_TREE_SUGGESTION_MIN) && (mii.wID <= ID_TREE_SUGGESTION_MAX));
}
/* Come up with suggestions */
keyPath = GetItemPath(g_pChildWnd->hTreeWnd, NULL, &hRootKey);
SuggestKeys(hRootKey, keyPath, Suggestions, COUNT_OF(Suggestions));
if (Suggestions[0])
{
AppendMenu(hContextMenu, MF_SEPARATOR, 0, NULL);
LoadStringW(hInst, IDS_GOTO_SUGGESTED_KEY, resource, COUNT_OF(resource));
s = Suggestions;
wID = ID_TREE_SUGGESTION_MIN;
while(*s && (wID <= ID_TREE_SUGGESTION_MAX))
{
_snwprintf(buffer, COUNT_OF(buffer), resource, s);
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING | MIIM_ID;
mii.wID = wID++;
mii.dwTypeData = buffer;
InsertMenuItem(hContextMenu, GetMenuItemCount(hContextMenu), TRUE, &mii);
s += wcslen(s) + 1;
}
}
TrackPopupMenu(hContextMenu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, g_pChildWnd->hWnd, NULL);
}
}
break;
}
case WM_SIZE:
if (wParam != SIZE_MINIMIZED && g_pChildWnd != NULL)
{
ResizeWnd(LOWORD(lParam), HIWORD(lParam));
}
/* fall through */
default:
def:
return DefWindowProcW(hWnd, message, wParam, lParam);
}
return 0;
}
bool GameState::P2InAir() {
UpdateAddress(14);
return raw_input[14];
}
int GameState::CharacterID(int player) {
UpdateAddress(4 + (player - 1));
return (raw_input[4 + (player - 1)] & 0x0000FFFF) >> 8;
}
int GameState::Percent(int player) {
UpdateAddress(2 + (player - 1));
return Read16(2 + (player - 1));
}
uint32_t GameState::Raw(int n) {
UpdateAddress(n);
return raw_input[n];
}
int GameState::FrameCount() {
UpdateAddress(11);
return Read16(11);
}
int GameState::StageID() {
UpdateAddress(10);
return Read16(10);
}
int GameState::P2Hitstun() {
UpdateAddress(18);
return LongToFloat(raw_input[18]);
}
