FlyChess.cpp

////////////////////////////////////////////////////////////////////////////////
/// FlyChess -- Slim Win32 Host for NeuroMechFly 
///
/// AUTHOR: Igor G. Tebelev (c) 2026
/// REPOSITORY: https://github.com/IgorTebelev/FlyChess
/// FRAMEWORK: Powered by WithExe (https://github.com/IgorTebelev/WithExe)
///
/// WHAT THIS CODE DOES:
/// This is a pure Win32, zero-CRT (freestanding) executable that hijacks the 
/// Microsoft Games "Chess Titans" process by hosting it inproc not using 
/// pemapping and it does it dynamically using `With.dll`. It uses a transparent 
/// GDI overlay to render a procedural 3D-animated fly walking across the chess 
/// board. It intercepts window messages, rewrites the host's menus, packs/unpacks 
/// its own assets from its PE tail, and spams a custom glass-pane console with 
/// sensorimotor telemetry—all without a single byte of the C Standard Library
/// and all utilizing inproc executed "Chess Titans" demonstrating simplicity
/// of inproc executable loading using `With.dll` (see GuestThread() implementation).
///
/// THE LORE:
/// There have been a lot of reports lately about the Drosophila Fly(муха) 
/// opening her own BAR, reviewing SEX toys, and generally living a life of 
/// pure, chaotic hedonism. We decided she needed a more refined, intellectual 
/// pursuit to keep her out of trouble. 
///
/// So, naturally... we decided to let the Drosophila start playing Chess. 
/// She learned to play back in 2007 by playing Microsoft Games "Chess Titans"... 
/// still compatible to recent Windows versions (10, 11) and available for 
/// download from https://win7games.com and/or other sites.
////////////////////////////////////////////////////////////////////////////////
//

//#include "FlyChess.h"
////////////////////////////////////////////////////////////////////////////////
/// FlyChess -- slim Chess host: GDI fly overlay + With.dll dynamic loader.
/// No D3D hooks, no CreateMutex DR.
/// Chess from CardPack\Microsoft Games. Assets: webp\neuromechfly
///
/// REVISION HISTORY:
/// - Removed the CRT because stdlib is for cowards.
/// - Added section merging to trigger heuristic antivirus engines for fun.
////////////////////////////////////////////////////////////////////////////////

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <objbase.h>
#include <wincodec.h>
#include <shlwapi.h>
#include <shellapi.h>

#pragma comment(lib, "kernel32.lib")
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdi32.lib")
#pragma comment(lib, "shlwapi.lib")

#ifndef _DEBUG
/*
 * THE CHAOS ZONE
 * We are making all PE sections Read/Write/Execute (RWE) and then violently smashing
 * them all into the .text section.
 * Why? To minimize the file size by a few bytes, completely obliterate standard
 * memory protections, confuse reverse engineers, and make dynamic analysis tools cry.
 * Security is a myth. Embrace the soup.
 */
#pragma comment(linker, "/SECTION:.rdata,RWE")
#pragma comment(linker, "/SECTION:.data,RWE")
#pragma comment(linker, "/SECTION:.pdata,RWE")
#pragma comment(linker, "/SECTION:.xdata,RWE")
#pragma comment(linker, "/SECTION:.text,RWE")
#pragma comment(linker, "/MERGE:.xdata=.rdata")
#pragma comment(linker, "/MERGE:.pdata=.rdata")
#pragma comment(linker, "/MERGE:.rdata=.text")
#pragma comment(linker, "/MERGE:.data=.text")
#endif


#ifdef __cplusplus
extern "C" {
#endif

	/*
	 * The compiler panics if it sees floating-point math without the CRT.
	 * By defining `_fltused = 0`, we are essentially patting MSVC on the head
	 * and saying, "Shhh, it's okay, I know what a float is. Go back to sleep."
	 */
	int _fltused = 0;

	/*
	 * MSVC sneaks in invisible `memset` calls when we zero-initialize structs (like {0}).
	 * Since we fired the CRT, we have to do the janitorial work ourselves.
	 */
#pragma function(memset)
	void* __cdecl memset(void* dest, int c, size_t count)
	{
		char* bytes = (char*)dest;
		while (count--) *bytes++ = (char)c;
		return dest;
	}

#ifdef __cplusplus
}
#endif

/* State of the sacrificial host process (Chess Titans) */
struct Game
{
	WCHAR path[MAX_PATH]; /* Where the victim lives */
	DWORD tid;            /* Victim's thread ID */
	HANDLE thread;        /* Victim's thread handle */
	HWND hwnd;            /* The main window we are currently haunting */
	BOOL hidden;          /* Are we playing hide and seek? */
	HHOOK hookCbt;        /* Spying on window creation */
	HHOOK hookCwp;        /* Spying on window messages */
	HHOOK hookGet;        /* Spying on thread messages */
	BOOL menuAtt;         /* Did we successfully vandalize the menu yet? */
	BOOL iconAtt;         /* Did we swap their icon yet? */
};

static Game g_game;
static HANDLE g_menuEvent;
typedef UINT(WINAPI* PFN_RUN)(LPCWSTR, LPCWSTR);
static PFN_RUN g_pfnRun = NULL; /* The dark magic exported by With.dll */

/* GDI toplevel fly clip over Chess board center (not a D3D child). */
static HWND g_gdiFlyHwnd; /* The fly's invisible glass cage */
static BOOL g_gdiFlyClass;

enum { FLY_BANK_WALK = 0, FLY_BANK_FLY = 1, FLY_BANK_DIE = 2, FLY_BANK_COUNT = 3, FLY_SHADOW_PAD = 12 };
/* The fly sequence is generated/kept with recordings, separate from raw assets. */
static const WCHAR* g_flyBankFolder[FLY_BANK_COUNT] = { L"walk", L"fly", L"die" };
static WCHAR(*g_flyBankPath[FLY_BANK_COUNT])[MAX_PATH];
static int g_flyBankN[FLY_BANK_COUNT]; /* How many frames of animation we have */

/* Fly geometry and telemetry state */
static float* g_flyBankCx[FLY_BANK_COUNT];
static float* g_flyBankCy[FLY_BANK_COUNT];
static float* g_flyBankDx[FLY_BANK_COUNT];
static float* g_flyBankDy[FLY_BANK_COUNT];
static int g_flyBankSrcW[FLY_BANK_COUNT];
static int g_flyBankSrcH[FLY_BANK_COUNT];
static int g_flyBank; /* active bank */
static BOOL g_flyBanksLoaded;

static WCHAR(*g_gdiFlyPath)[MAX_PATH];
static int g_gdiFlyN;
static int g_gdiFlyFrame = -1;
static BOOL g_gdiFlyMirrorX; /* TRUE = fly is facing left, because we flip the matrix */
static float g_gdiFlyAngle;  /* radians, small per-leg swing */
static float g_flyLegSwing;  /* peak ±amp for current leg (radians) */
static float g_flyLegScale;  /* walk: 0.7..1.0, flight peaks at 1.5 (fat fly) */

/* The fly's breathing/pulsing scale mechanics */
static DWORD g_flyScaleT0;
static DWORD g_flyScaleDuration;
static float g_flyWalkScaleFrom, g_flyWalkScaleTo;
static float g_flyFlightStartScale, g_flyFlightStartDist;

static float g_flyApproachVx, g_flyApproachVy; /* last hop heading for land continue */
static float g_gdiFlyRotCx, g_gdiFlyRotCy; /* COG in unrotated content pixels */
static int g_gdiFlyContentW, g_gdiFlyContentH;
static int g_gdiFlySrcW = 640;
static int g_gdiFlySrcH = 360;

/* Bitmap handles for the GDI blender */
static HBITMAP g_gdiFlyCurBmp;
static BYTE* g_gdiFlyCurBits;
static HBITMAP g_gdiFlyScaledBmp;
static BYTE* g_gdiFlyScaledBits;
static int g_gdiFlyScaledW, g_gdiFlyScaledH;
static BYTE* g_gdiFlyShadowAlpha;
static SIZE_T g_gdiFlyShadowAlphaCap;
static HDC g_gdiFlyMemDc;

/* Where the little bugger actually is */
static float* g_flyCx;
static float* g_flyCy;
static float* g_flyDx;
static float* g_flyDy;
static float g_flyPosX, g_flyPosY; /* screen COG (Center of Gravity) */
static float g_flyVx, g_flyVy; /* cardinal velocity px/tick (Speed) */
static float g_flyLegSpeed; /* How fast the legs are furiously pumping */

static BOOL g_flyResting; /* Is the fly taking a smoke break? */
static DWORD g_flyRestUntil; /* When the smoke break ends */
static DWORD g_flyRng; /* Our handcrafted random number generator seed */
static BOOL g_flyPosInit; /* Has the fly spawned into existence yet? */

static float g_flyTravelAngle; /* head-right bitmap faces travel (smoothable) */
static BOOL g_flyAngleEase; /* Are we smoothly rotating or violently snapping? */
static float g_flyAngleGoal;

static int g_flyRail; /* 0=freeroam, 1=top edge, 2=bottom edge, 3=left edge, 4=right edge */
static float g_flyPerp; /* ±60 wobble off the edge rail (drunk fly simulator) */
static int g_flyHabitat; /* 0=Chess Window, 1=Console Window */

static BOOL g_flyTransit; /* flying between habitats */
static float g_flyTx, g_flyTy; /* Target X and Y for flights */
static DWORD g_flyNextHop;
static DWORD g_flyNextConsoleHop;

/* Floodgate variables for our terminal spam */
static BOOL g_flyFloodUnlocked; /* first Chess→Console flight unlocked flood */
static BOOL g_flyFlooding; /* on console after unlock -- firehose ON */
static BOOL g_flyNeedBootFlood; /* one-shot full FlyBsBoot */
static BOOL g_flyBootDone; /* boot banner already queued once */
static BOOL g_flyWasFlooding;

static BOOL g_flyThink; /* paused, looking at chess board ominously */
static DWORD g_flyThinkUntil;

/* Mouse stalking mechanics */
static POINT g_flyLastMousePos;
static BOOL g_flyMouseSampled;
static DWORD g_flyMouseMovedAt;
static BOOL g_flyMouseIdleLook;
static BOOL g_flyMouseIdleExpired;
static DWORD g_flyMouseIdleStarted;
static DWORD g_flyMouseIdleUntil;
static DWORD g_flyMouseIdleNextPose;
static int g_flyMouseIdleFrames;

static BOOL g_flyClickPending;
static float g_flyClickX, g_flyClickY; /* The coordinates the fly is judging you for clicking */
static DWORD g_flyNextThink;
static float g_flyLookAngle; /* face board (cardinal) */
static float g_flySavedVx, g_flySavedVy; /* resume crawl */
static int g_flyTransitDest; /* habitat we're flying toward */
static BOOL g_flyGameLive; /* human started moving pieces */
static BOOL g_flyMyTurn; /* after human click -- fly "thinks" */
static DWORD g_flyMyTurnUntil;
static UINT g_flyBoardClicks; /* How many times the user poked the board */
static DWORD g_flyNextFlip; /* random mid-edge reverse to keep things chaotic */

/* Our fake terminal (not AllocConsole) -- habitat + flood text. */
static HWND g_flyLogHwnd; /* The glass pane of wisdom */
static HWND g_flyLogList; /* The actual listbox catching our text vomit */
static HFONT g_flyLogFont;
static HBRUSH g_flyLogBrush;
static BOOL g_flyLogClassReg;
static BOOL g_flyLogUserPlaced; /* user dragged/resized -- stop auto-dock (user taking control) */
static WNDPROC g_flyLogListPrev;

enum { FLYLOG_LIST_ID = 4201 };
enum { FLYLOG_ALPHA = 128 }; /* 50% opaque (see-through matrix vibes) */
enum { FLYLOG_TMR_HIDECHROME = 88 }; /* Timer ID to hide the ugly Windows borders */

/* Window docking and sliding math */
static BOOL g_flyLogPanning;
static BOOL g_flyLogPanArriving;
static BOOL g_flyLogRevealed;
static BOOL g_flyLogRevealValid;
static BOOL g_flyLogGlueRight; /* TRUE: right edge fixed (dock left of Chess) */
enum { FLYLOG_EDGE_AUTO = -1, FLYLOG_EDGE_LEFT, FLYLOG_EDGE_RIGHT, FLYLOG_EDGE_TOP, FLYLOG_EDGE_BOTTOM };
static int g_flyLogDockEdge = FLYLOG_EDGE_AUTO;
static int g_flyLogShownEdge = FLYLOG_EDGE_AUTO;
static int g_flyLogNextEdge = FLYLOG_EDGE_AUTO;
static BOOL g_flyLogFlyPending;
static int g_flyLogFlyEdge = FLYLOG_EDGE_AUTO;
static BOOL g_flyLogPanVertical;
static int g_flyLogGlueX;
static int g_flyLogGlueY;
static int g_flyLogRevealY, g_flyLogRevealW, g_flyLogRevealH;
static int g_flyLogPanW0, g_flyLogPanW1;
static int g_flyLogPanH0, g_flyLogPanH1;
static int g_flyLogPanX;
static int g_flyLogPanY, g_flyLogPanH;
static DWORD g_flyLogPanT0;
static int g_flyLogPanMs;
static BOOL g_flyLogPanPending;
static BOOL g_flyLogPanPendingArrive;
static float g_flyHopDist0;
static DWORD g_flyLogEdgeLeaveAt; /* collapse after mouse leaves edge/log */

static DWORD g_mainTid;
static WCHAR g_gamesDir[MAX_PATH];
static HWND g_scrollHwnd;

// --- PURE WIN32 CRT SUBSTITUTES ---
// Because `#include <string.h>` is for tourists.

/* Custom memcpy. Bytes go in, bytes go out. You can't explain that. */
static void CustomMemCpy(void* dst, const void* src, SIZE_T sz)
{
	BYTE* d = (BYTE*)dst; const BYTE* s = (const BYTE*)src;
	while (sz--) *d++ = *s++;
}

/* Custom memset-to-zero. Replaces ZeroMemory so we don't look lazy. */
static void CustomZeroMem(void* dst, SIZE_T sz)
{
	BYTE* d = (BYTE*)dst;
	while (sz--) *d++ = 0;
}

/* Custom memcmp. Returns difference. Just like the good old days. */
static int CustomMemCmp(const void* b1, const void* b2, SIZE_T sz)
{
	const BYTE* p1 = (const BYTE*)b1; const BYTE* p2 = (const BYTE*)b2;
	for (SIZE_T i = 0; i < sz; i++) { if (p1[i] != p2[i]) return p1[i] - p2[i]; }
	return 0;
}

/* Custom string-to-float parser. Take that, _wtof. */
static float CustomWtof(const WCHAR* s)
{
	float res = 0.0f, fact = 1.0f; BOOL minus = FALSE;
	if (*s == L'-') { minus = TRUE; s++; }
	while (*s >= L'0' && *s <= L'9') { res = res * 10.0f + (float)(*s - L'0'); s++; }
	if (*s == L'.') { s++; while (*s >= L'0' && *s <= L'9') { fact *= 0.1f; res += (float)(*s - L'0') * fact; s++; } }
	return minus ? -res : res;
}

/* Hardcoded syntax highlighter for our fake terminal. */
static WORD ConPickAttr(LPCWSTR s)
{
	if (!s || s[0] != L'[')
		return FOREGROUND_GREEN | FOREGROUND_INTENSITY; /* Default hacker green */

	/* The RGB soup of logical tags */
	if (StrStrIW(s, L"[engram]") || StrStrIW(s, L"[identity]"))
		return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
	if (StrStrIW(s, L"[target_1]") || StrStrIW(s, L"[target_2]"))
		return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY;
	if (StrStrIW(s, L"[MuJoCo]") || StrStrIW(s, L"[flygym]") || StrStrIW(s, L"[Warp]") || StrStrIW(s, L"[qpos]") || StrStrIW(s, L"[chess-sink]"))
		return FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY;
	if (StrStrIW(s, L"[VNC]") || StrStrIW(s, L"[CNS]") || StrStrIW(s, L"[odor]"))
		return FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY;
	if (StrStrIW(s, L"[sensorimotor]") || StrStrIW(s, L"[think]") || StrStrIW(s, L"[mech]"))
		return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY;

	/* The angry tags */
	if (StrStrIW(s, L"[FATAL]") || StrStrIW(s, L"[warn]") || StrStrIW(s, L"[ERROR]"))
		return FOREGROUND_RED | FOREGROUND_INTENSITY;

	/* The boring tags */
	if (StrStrIW(s, L"[boot]") || StrStrIW(s, L"[link]") || StrStrIW(s, L"[DoF]") || StrStrIW(s, L"[heartbeat]"))
		return FOREGROUND_INTENSITY;
	if (StrStrIW(s, L"[sys]") || StrStrIW(s, L"[system]") || StrStrIW(s, L"[mem]"))
		return FOREGROUND_RED | FOREGROUND_INTENSITY;
	if (StrStrIW(s, L"[adhesion]") || StrStrIW(s, L"[ommatidia]") || StrStrIW(s, L"[vision]"))
		return FOREGROUND_GREEN | FOREGROUND_INTENSITY;
	if (StrStrIW(s, L"[brain]") || StrStrIW(s, L"[ascend]"))
		return FOREGROUND_BLUE | FOREGROUND_INTENSITY;

	return FOREGROUND_GREEN | FOREGROUND_INTENSITY;
}

static COLORREF ConPickRgb(LPCWSTR s)
{
	WORD a = ConPickAttr(s);
	int bright = (a & FOREGROUND_INTENSITY) ? 1 : 0;
	int r = (a & FOREGROUND_RED) ? (bright ? 255 : 170) : 0;
	int g = (a & FOREGROUND_GREEN) ? (bright ? 255 : 170) : 0;
	int b = (a & FOREGROUND_BLUE) ? (bright ? 255 : 170) : 0;

	if (!(a & (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)))
	{
		int v = bright ? 185 : 130;
		return RGB(v, v, v);
	}
	return RGB(r, g, b);
}

static HWND FlyLogListHwnd(void)
{
	HWND pane;
	if (g_flyLogList && IsWindow(g_flyLogList))
		return g_flyLogList;

	if (g_flyLogHwnd && IsWindow(g_flyLogHwnd))
	{
		g_flyLogList = GetDlgItem(g_flyLogHwnd, FLYLOG_LIST_ID);
		if (g_flyLogList)
			return g_flyLogList;
	}

	/* Search globally in case we lost track of our own child */
	pane = FindWindowW(L"FlyChessLogPane", NULL);
	if (pane)
	{
		g_flyLogHwnd = pane;
		g_flyLogList = GetDlgItem(pane, FLYLOG_LIST_ID);
		return g_flyLogList;
	}
	return NULL;
}

/* The great listbox stuffer. Shoves text in until it hits 600 lines, then starts throwing old data away. */
static void FlyLogAppend(LPCWSTR line)
{
	HWND list;
	int n;
	WCHAR one[1024];

	list = FlyLogListHwnd();
	if (!list || !line || !line[0])
		return;

	lstrcpynW(one, line, 1000);
	n = lstrlenW(one);
	/* Trim trailing newlines because ListBox doesn't need them */
	while (n > 0 && (one[n - 1] == L'\r' || one[n - 1] == L'\n'))
		one[--n] = 0;

	if (!one[0])
		return;

	SendMessageW(list, LB_ADDSTRING, 0, (LPARAM)one);
	n = (int)SendMessageW(list, LB_GETCOUNT, 0, 0);

	/* Memory management by deletion */
	while (n > 600)
	{
		SendMessageW(list, LB_DELETESTRING, 0, 0);
		n--;
	}
	if (n > 0)
		SendMessageW(list, LB_SETTOPINDEX, (WPARAM)(n - 1), 0); /* Auto-scroll to bottom */
}

// --- PURE WIN32 LOGGING WRAPPERS ---
/*
 * We killed wprintf and stdout. All text must now flow through wvsprintfW
 * and into our GDI glass window.
 */
static void Con(LPCWSTR fmt, ...)
{
	WCHAR buf[1024];
	va_list ap;
	va_start(ap, fmt);
	wvsprintfW(buf, fmt, ap);
	va_end(ap);
	FlyLogAppend(buf);
}

enum { FLY_CONQ_CAP = 128, FLY_CONQ_LEN = 384 };
static WCHAR g_flyConQ[FLY_CONQ_CAP][FLY_CONQ_LEN];
static int g_flyConQHead;
static int g_flyConQCount;
static DWORD g_flyConQLast;
static UINT g_flyConQTone;

/* Queue up text to be printed slowly so it looks like someone is actually typing it. */
static void ConQ(LPCWSTR fmt, ...)
{
	WCHAR buf[FLY_CONQ_LEN];
	va_list ap;
	int slot;

	if (g_flyConQCount >= FLY_CONQ_CAP)
		return; /* Buffer full. We drop packets like a cheap router. */

	va_start(ap, fmt);
	wvsprintfW(buf, fmt, ap);
	va_end(ap);

	slot = (g_flyConQHead + g_flyConQCount) % FLY_CONQ_CAP;
	lstrcpynW(g_flyConQ[slot], buf, FLY_CONQ_LEN);
	g_flyConQCount++;
}

/* The heartbeat of the fake terminal typist */
static void ConQTick(void)
{
	DWORD now, gap;
	if (g_flyConQCount <= 0)
		return;

	now = GetTickCount();
	/* Variable typing speed for maximum realism */
	gap = 480u + (DWORD)((g_flyConQTone % 7u) * 70u);
	if (g_flyConQLast && now - g_flyConQLast < gap)
		return;

	g_flyConQLast = now;
	LPCWSTR line = g_flyConQ[g_flyConQHead];

	FlyLogAppend(line);

	g_flyConQHead = (g_flyConQHead + 1) % FLY_CONQ_CAP;
	g_flyConQCount--;
	g_flyConQTone++;
}

static BOOL FileOk(LPCWSTR p)
{
	DWORD a = GetFileAttributesW(p);
	return a != INVALID_FILE_ATTRIBUTES && !(a & FILE_ATTRIBUTE_DIRECTORY);
}

/* Desperately looking for the chess executable */
static BOOL TryChessIn(LPCWSTR games)
{
	WCHAR path[MAX_PATH];
	if (!games || !games[0])
		return FALSE;

	wsprintfW(path, L"%s\\Chess\\chess.exe", games);
	if (!FileOk(path))
		wsprintfW(path, L"%s\\chess.exe", games);
	if (!FileOk(path))
		return FALSE;

	lstrcpynW(g_gamesDir, games, MAX_PATH);
	lstrcpynW(g_game.path, path, MAX_PATH);
	return TRUE;
}

static BOOL FindChess(void)
{
	WCHAR here[MAX_PATH], cand[MAX_PATH], env[MAX_PATH];

	if (GetEnvironmentVariableW(L"ProgramFiles", env, MAX_PATH))
	{
		wsprintfW(cand, L"%s\\Microsoft Games", env);
		if (TryChessIn(cand))
			return TRUE;
	}
	if (GetEnvironmentVariableW(L"ProgramFiles(x86)", env, MAX_PATH))
	{
		wsprintfW(cand, L"%s\\Microsoft Games", env);
		if (TryChessIn(cand))
			return TRUE;
	}

	GetModuleFileNameW(NULL, here, MAX_PATH);
	PathRemoveFileSpecW(here);
	wsprintfW(cand, L"%s\\Microsoft Games", here);
	if (TryChessIn(cand))
		return TRUE;

	return FALSE;
}

/* Rips the stupid ampersands out of menu items so we can actually read them */
static void StripAmp(WCHAR* d, LPCWSTR s)
{
	while (*s)
	{
		if (*s != L'&')
			*d++ = *s;
		s++;
	}
	*d = 0;
}

static IWICImagingFactory* g_flyWicFactory;

/* Our highly sophisticated, proprietary, extremely secure custom pack file format */
typedef struct FlyPackEntry
{
	WCHAR name[128];
	ULONGLONG offset;
	DWORD size;
} FlyPackEntry;

static FlyPackEntry g_flyPackEntries[1024];
static DWORD g_flyPackCount;
static BOOL g_flyPackChecked;
static BOOL g_flyPackValid;

/* Look for the magic bytes at the end of the EXE to see if we've been packed */
static BOOL FlyPackLoadIndex(void)
{
	static const BYTE magic[8] = { 'F','L','Y','P','A','K','1',0 };
	WCHAR exe[MAX_PATH];
	HANDLE file;
	LARGE_INTEGER fileSize, seek;
	BYTE footer[24], * index = NULL;
	DWORD rd, version, count, parsed, i;
	ULONGLONG indexOffset;
	BOOL ok = FALSE;

	if (g_flyPackChecked)
		return g_flyPackValid;

	g_flyPackChecked = TRUE;
	if (!GetModuleFileNameW(NULL, exe, MAX_PATH))
		return FALSE;

	file = CreateFileW(exe, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (file == INVALID_HANDLE_VALUE)
		return FALSE;

	if (!GetFileSizeEx(file, &fileSize) || fileSize.QuadPart < (LONGLONG)sizeof(footer))
		goto done;

	seek.QuadPart = fileSize.QuadPart - (LONGLONG)sizeof(footer);
	if (!SetFilePointerEx(file, seek, NULL, FILE_BEGIN) || !ReadFile(file, footer, sizeof(footer), &rd, NULL) || rd != sizeof(footer) || CustomMemCmp(footer, magic, sizeof(magic)) != 0)
		goto done;

	CustomMemCpy(&version, footer + 8, sizeof(version));
	CustomMemCpy(&count, footer + 12, sizeof(count));
	CustomMemCpy(&indexOffset, footer + 16, sizeof(indexOffset));

	/* Sanity checks because parsing binary formats is scary */
	if (version != 1 || count > 1024 || indexOffset > (ULONGLONG)(fileSize.QuadPart - sizeof(footer)) || (ULONGLONG)(fileSize.QuadPart - sizeof(footer)) - indexOffset > 1024u * 1024u)
		goto done;

	parsed = (DWORD)((ULONGLONG)(fileSize.QuadPart - sizeof(footer)) - indexOffset);
	index = (BYTE*)HeapAlloc(GetProcessHeap(), 0, parsed ? parsed : 1);
	if (!index)
		goto done;

	seek.QuadPart = (LONGLONG)indexOffset;
	if (!SetFilePointerEx(file, seek, NULL, FILE_BEGIN) || !ReadFile(file, index, parsed, &rd, NULL) || rd != parsed)
		goto done;

	parsed = 0;
	for (i = 0; i < count; ++i)
	{
		WORD nameLen;
		ULONGLONG offset;
		DWORD size, j;

		if (parsed + sizeof(nameLen) > (DWORD)((ULONGLONG)(fileSize.QuadPart - sizeof(footer)) - indexOffset))
			goto done;

		CustomMemCpy(&nameLen, index + parsed, sizeof(nameLen));
		parsed += sizeof(nameLen);

		if (!nameLen || nameLen >= 128 || parsed + nameLen + sizeof(offset) + sizeof(size) > (DWORD)((ULONGLONG)(fileSize.QuadPart - sizeof(footer)) - indexOffset))
			goto done;

		for (j = 0; j < nameLen; ++j)
			g_flyPackEntries[i].name[j] = (WCHAR)index[parsed + j];

		g_flyPackEntries[i].name[nameLen] = 0;
		parsed += nameLen;

		CustomMemCpy(&offset, index + parsed, sizeof(offset));
		parsed += sizeof(offset);

		CustomMemCpy(&size, index + parsed, sizeof(size));
		parsed += sizeof(size);

		if (!size || offset > indexOffset || size > indexOffset - offset)
			goto done;

		g_flyPackEntries[i].offset = offset;
		g_flyPackEntries[i].size = size;
	}

	if (parsed != (DWORD)((ULONGLONG)(fileSize.QuadPart - sizeof(footer)) - indexOffset))
		goto done;

	g_flyPackCount = count;
	ok = TRUE;

done:
	if (index)
		HeapFree(GetProcessHeap(), 0, index);
	CloseHandle(file);
	g_flyPackValid = ok;
	return ok;
}

static BOOL FlyPackReadEntry(const WCHAR* name, BYTE** outData, DWORD* outSize)
{
	WCHAR exe[MAX_PATH];
	HANDLE file;
	LARGE_INTEGER seek;
	BYTE* data;
	DWORD i, rd;

	if (outData) *outData = NULL;
	if (outSize) *outSize = 0;
	if (!outData || !outSize) return FALSE;

	/* Look in our tail-appended payload first */
	if (FlyPackLoadIndex() && g_flyPackCount > 0)
	{
		for (i = 0; i < g_flyPackCount; ++i)
		{
			if (lstrcmpiW(g_flyPackEntries[i].name, name) == 0)
				break;
		}
		if (i < g_flyPackCount && GetModuleFileNameW(NULL, exe, MAX_PATH))
		{
			data = (BYTE*)HeapAlloc(GetProcessHeap(), 0, g_flyPackEntries[i].size);
			if (data)
			{
				file = CreateFileW(exe, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
				if (file != INVALID_HANDLE_VALUE)
				{
					seek.QuadPart = (LONGLONG)g_flyPackEntries[i].offset;
					if (SetFilePointerEx(file, seek, NULL, FILE_BEGIN) && ReadFile(file, data, g_flyPackEntries[i].size, &rd, NULL) && rd == g_flyPackEntries[i].size)
					{
						CloseHandle(file);
						*outData = data;
						*outSize = g_flyPackEntries[i].size;
						return TRUE;
					}
					CloseHandle(file);
				}
				HeapFree(GetProcessHeap(), 0, data);
			}
		}
	}

	/* Fallback to checking the normal file system if it isn't packed */
	if (GetModuleFileNameW(NULL, exe, MAX_PATH))
	{
		PathRemoveFileSpecW(exe);
		WCHAR diskPath[MAX_PATH];
		wsprintfW(diskPath, L"%s\\assets\\%s", exe, name);

		/* Sanitize paths like a responsible citizen */
		for (int j = 0; diskPath[j]; j++)
			if (diskPath[j] == L'/')
				diskPath[j] = L'\\';

		file = CreateFileW(diskPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		if (file != INVALID_HANDLE_VALUE)
		{
			DWORD sz = GetFileSize(file, NULL);
			data = (BYTE*)HeapAlloc(GetProcessHeap(), 0, sz);
			if (data)
			{
				if (ReadFile(file, data, sz, &rd, NULL) && rd == sz)
				{
					CloseHandle(file);
					*outData = data;
					*outSize = sz;
					return TRUE;
				}
				HeapFree(GetProcessHeap(), 0, data);
			}
			CloseHandle(file);
		}
	}
	return FALSE;
}

static BOOL FlyPackLoadBankPaths(int bank, int* outCount)
{
	const WCHAR* prefix = bank == FLY_BANK_WALK ? L"WALK/" : L"FLY/";
	int prefixLen = lstrlenW(prefix), n = 0, i;

	if (outCount) *outCount = 0;
	if (!FlyPackLoadIndex())
		return FALSE;

	for (i = 0; i < (int)g_flyPackCount; ++i)
	{
		if (StrCmpNIW(g_flyPackEntries[i].name, prefix, prefixLen) == 0 && lstrcmpiW(PathFindExtensionW(g_flyPackEntries[i].name), L".png") == 0)
			n++;
	}
	if (!n)
		return FALSE;

	g_flyBankPath[bank] = (WCHAR(*)[MAX_PATH])HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (SIZE_T)n * MAX_PATH * sizeof(WCHAR));
	if (!g_flyBankPath[bank])
		return FALSE;

	n = 0;
	for (i = 0; i < (int)g_flyPackCount; ++i)
	{
		if (StrCmpNIW(g_flyPackEntries[i].name, prefix, prefixLen) == 0 && lstrcmpiW(PathFindExtensionW(g_flyPackEntries[i].name), L".png") == 0)
			wsprintfW(g_flyBankPath[bank][n++], L"@PACK:%s", g_flyPackEntries[i].name); /* Tag it as a packed asset */
	}

	if (outCount) *outCount = n;
	return n > 0;
}

/*
 * The magic Microsoft WIC COM interface code.
 * Replaces the need for libpng because depending on external DLLs is weakness.
 */
static HBITMAP LoadPngFileHBitmap(const WCHAR* path, int* outW, int* outH, BYTE** outBits)
{
	IWICBitmapDecoder* decoder = NULL;
	IWICBitmapFrameDecode* frame = NULL;
	IWICFormatConverter* converter = NULL;
	IWICStream* stream = NULL;
	BITMAPINFO bmi;
	HBITMAP dib = NULL;
	BYTE* bits = NULL;
	UINT w = 0, h = 0;
	HRESULT hr;
	HDC screen;
	BYTE* packedData = NULL;
	DWORD packedSize = 0;

	if (outBits) *outBits = NULL;
	if (!g_flyWicFactory)
	{
		hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
		if (FAILED(hr) && hr != RPC_E_CHANGED_MODE)
			return NULL;
		hr = CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, __uuidof(IWICImagingFactory), (void**)&g_flyWicFactory);
		if (FAILED(hr))
			return NULL;
	}

	/* Is this coming from our secret EXE tail? */
	if (path[0] == L'@' && path[1] == L'P' && path[2] == L'A' && path[3] == L'C' && path[4] == L'K' && path[5] == L':')
	{
		if (!FlyPackReadEntry(path + 6, &packedData, &packedSize))
			goto done;
		hr = g_flyWicFactory->CreateStream(&stream);
		if (FAILED(hr)) goto done;
		hr = stream->InitializeFromMemory(packedData, packedSize);
		if (FAILED(hr)) goto done;
		hr = g_flyWicFactory->CreateDecoderFromStream(stream, NULL, WICDecodeMetadataCacheOnLoad, &decoder);
	}
	else
	{
		hr = g_flyWicFactory->CreateDecoderFromFilename(path, NULL, GENERIC_READ, WICDecodeMetadataCacheOnLoad, &decoder);
	}

	if (FAILED(hr)) goto done;
	hr = decoder->GetFrame(0, &frame);
	if (FAILED(hr)) goto done;
	hr = g_flyWicFactory->CreateFormatConverter(&converter);
	if (FAILED(hr)) goto done;
	hr = converter->Initialize(frame, GUID_WICPixelFormat32bppBGRA, WICBitmapDitherTypeNone, NULL, 0.0, WICBitmapPaletteTypeCustom);
	if (FAILED(hr)) goto done;
	hr = converter->GetSize(&w, &h);
	if (FAILED(hr) || !w || !h || w > 8192 || h > 8192 || (ULONGLONG)w * h * 4 > 64u * 1024u * 1024u)
		goto done;

	CustomZeroMem(&bmi, sizeof(bmi));
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biWidth = (LONG)w;
	bmi.bmiHeader.biHeight = -(LONG)h;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biBitCount = 32;
	bmi.bmiHeader.biCompression = BI_RGB;

	screen = GetDC(NULL);
	dib = CreateDIBSection(screen, &bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
	ReleaseDC(NULL, screen);

	if (!dib || !bits)
	{
		if (dib) DeleteObject(dib);
		dib = NULL;
		goto done;
	}

	hr = converter->CopyPixels(NULL, w * 4, w * h * 4, bits);
	if (FAILED(hr))
	{
		DeleteObject(dib);
		dib = NULL;
		bits = NULL;
		goto done;
	}

	if (outW) *outW = (int)w;
	if (outH) *outH = (int)h;
	if (outBits) *outBits = bits;

done:
	if (converter) converter->Release();
	if (frame) frame->Release();
	if (decoder) decoder->Release();
	if (stream) stream->Release();
	if (packedData) HeapFree(GetProcessHeap(), 0, packedData);
	return dib;
}

static void GdiFlySortBankPaths(int bank, int n)
{
	int i, j;
	WCHAR tmp[MAX_PATH];

	/* Insertion sort. Because standard library qsort is bloated nonsense. */
	for (i = 1; i < n; i++)
	{
		lstrcpyW(tmp, g_flyBankPath[bank][i]);
		j = i;
		while (j > 0 && lstrcmpiW(g_flyBankPath[bank][j - 1], tmp) > 0)
		{
			lstrcpyW(g_flyBankPath[bank][j], g_flyBankPath[bank][j - 1]);
			j--;
		}
		lstrcpyW(g_flyBankPath[bank][j], tmp);
	}
}

static void GdiFlyClearCurBitmap(void)
{
	if (g_gdiFlyCurBmp)
	{
		DeleteObject(g_gdiFlyCurBmp);
		g_gdiFlyCurBmp = NULL;
		g_gdiFlyCurBits = NULL;
	}
	g_gdiFlyFrame = -1;

	if (g_gdiFlyScaledBmp)
	{
		DeleteObject(g_gdiFlyScaledBmp);
		g_gdiFlyScaledBmp = NULL;
		g_gdiFlyScaledBits = NULL;
		g_gdiFlyScaledW = g_gdiFlyScaledH = 0;
	}
}

static void GdiFlySetBank(int bank)
{
	if (bank < 0 || bank >= FLY_BANK_COUNT)
		bank = FLY_BANK_WALK;
	if (g_flyBankN[bank] <= 0)
		bank = FLY_BANK_WALK;
	if (bank == g_flyBank && g_gdiFlyPath == g_flyBankPath[bank])
		return;

	g_flyBank = bank;
	g_gdiFlyPath = g_flyBankPath[bank];
	g_gdiFlyN = g_flyBankN[bank];
	g_flyCx = g_flyBankCx[bank];
	g_flyCy = g_flyBankCy[bank];
	g_flyDx = g_flyBankDx[bank];
	g_flyDy = g_flyBankDy[bank];

	if (g_flyBankSrcW[bank] > 0)
		g_gdiFlySrcW = g_flyBankSrcW[bank];
	if (g_flyBankSrcH[bank] > 0)
		g_gdiFlySrcH = g_flyBankSrcH[bank];

	GdiFlyClearCurBitmap();
}

static BOOL LoadGdiFlyBankFrames(const WCHAR* dir, int bank)
{
	WCHAR pat[MAX_PATH], full[MAX_PATH];
	WIN32_FIND_DATAW fd;
	HANDLE find;
	int n, cap, pw = 0, ph = 0;
	HBITMAP probe;
	BYTE* bits = NULL;
	BOOL usePack = FALSE;

	n = 0;
	find = INVALID_HANDLE_VALUE;

	if (bank == FLY_BANK_WALK || bank == FLY_BANK_FLY)
		usePack = FlyPackLoadBankPaths(bank, &n);

	if (!usePack)
	{
		if (bank == FLY_BANK_WALK || bank == FLY_BANK_FLY)
		{
			wsprintfW(pat, L"%s\\assets\\%s\\frame_*.png", dir, bank == FLY_BANK_WALK ? L"walk" : L"fly");
			find = FindFirstFileW(pat, &fd);
		}
		if (find == INVALID_HANDLE_VALUE)
			return FALSE;

		cap = 1024;
		g_flyBankPath[bank] = (WCHAR(*)[MAX_PATH])HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (SIZE_T)cap * MAX_PATH * sizeof(WCHAR));
		if (!g_flyBankPath[bank])
		{
			FindClose(find);
			return FALSE;
		}
		do {
			if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
				continue;
			if (n >= cap)
			{
				int ncap = cap * 2;
				void* p = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, g_flyBankPath[bank], (SIZE_T)ncap * MAX_PATH * sizeof(WCHAR));
				if (!p) break;
				g_flyBankPath[bank] = (WCHAR(*)[MAX_PATH])p;
				cap = ncap;
			}
			wsprintfW(full, L"%s\\assets\\%s\\%s", dir, bank == FLY_BANK_WALK ? L"walk" : L"fly", fd.cFileName);
			lstrcpyW(g_flyBankPath[bank][n++], full);
		} while (FindNextFileW(find, &fd));
		FindClose(find);
	}

	if (n <= 0)
		return FALSE;

	GdiFlySortBankPaths(bank, n);
	g_flyBankN[bank] = n;
	probe = LoadPngFileHBitmap(g_flyBankPath[bank][0], &pw, &ph, &bits);
	if (probe)
	{
		g_flyBankSrcW[bank] = pw;
		g_flyBankSrcH[bank] = ph;
		DeleteObject(probe);
	}
	return TRUE;
}

static BOOL LoadGdiFlyFrames(void)
{
	WCHAR exe[MAX_PATH], dir[MAX_PATH];
	int b, ok = 0;

	if (g_flyBanksLoaded)
		return g_flyBankN[FLY_BANK_WALK] > 0;
	if (!GetModuleFileNameW(NULL, exe, MAX_PATH))
		return FALSE;

	lstrcpyW(dir, exe);
	PathRemoveFileSpecW(dir);

	for (b = 0; b < FLY_BANK_COUNT; b++)
		if (LoadGdiFlyBankFrames(dir, b))
			ok++;

	g_flyBanksLoaded = TRUE;
	if (g_flyBankN[FLY_BANK_WALK] <= 0)
		return FALSE;

	if (!g_gdiFlyMemDc)
		g_gdiFlyMemDc = CreateCompatibleDC(NULL);

	g_flyBank = -1;
	GdiFlySetBank(FLY_BANK_WALK);
	return TRUE;
}

static BOOL SelectGdiFlyFrame(int fi, BOOL mirrorX)
{
	HBITMAP hb;
	BYTE* bits = NULL;
	int w = 0, h = 0;

	if (fi < 0 || fi >= g_gdiFlyN)
		return FALSE;
	if (fi == g_gdiFlyFrame && g_gdiFlyCurBmp && g_gdiFlyCurBits)
	{
		g_gdiFlyMirrorX = mirrorX;
		return TRUE;
	}

	hb = LoadPngFileHBitmap(g_gdiFlyPath[fi], &w, &h, &bits);
	if (!hb || !bits)
		return FALSE;

	if (w > 0)
		g_gdiFlySrcW = w;
	if (h > 0)
		g_gdiFlySrcH = h;

	if (g_gdiFlyCurBmp)
		DeleteObject(g_gdiFlyCurBmp);

	g_gdiFlyCurBmp = hb;
	g_gdiFlyCurBits = bits;
	g_gdiFlyFrame = fi;
	g_gdiFlyMirrorX = mirrorX;
	return TRUE;
}

static BOOL EnsureGdiFlyScaled(int dw, int dh)
{
	BITMAPINFO bmi;
	HDC screen;
	SIZE_T alphaNeed;

	if (dw < 1) dw = 1;
	if (dh < 1) dh = 1;

	if (g_gdiFlyScaledBmp && g_gdiFlyScaledW == dw && g_gdiFlyScaledH == dh && g_gdiFlyScaledBits)
		return TRUE;

	if (g_gdiFlyScaledBmp)
	{
		DeleteObject(g_gdiFlyScaledBmp);
		g_gdiFlyScaledBmp = NULL;
		g_gdiFlyScaledBits = NULL;
	}

	CustomZeroMem(&bmi, sizeof(bmi));
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biWidth = dw;
	bmi.bmiHeader.biHeight = -dh;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biBitCount = 32;
	bmi.bmiHeader.biCompression = 0;

	screen = GetDC(NULL);
	g_gdiFlyScaledBmp = CreateDIBSection(screen, &bmi, DIB_RGB_COLORS, (void**)&g_gdiFlyScaledBits, NULL, 0);
	ReleaseDC(NULL, screen);

	g_gdiFlyScaledW = dw;
	g_gdiFlyScaledH = dh;
	alphaNeed = (SIZE_T)dw * (SIZE_T)dh;

	if (alphaNeed > g_gdiFlyShadowAlphaCap)
	{
		BYTE* p = g_gdiFlyShadowAlpha ? (BYTE*)HeapReAlloc(GetProcessHeap(), 0, g_gdiFlyShadowAlpha, alphaNeed) : (BYTE*)HeapAlloc(GetProcessHeap(), 0, alphaNeed);
		if (p)
		{
			g_gdiFlyShadowAlpha = p;
			g_gdiFlyShadowAlphaCap = alphaNeed;
		}
	}
	return g_gdiFlyScaledBmp && g_gdiFlyScaledBits;
}

/* Look at this beautiful manual math. Math headers are bloated. */
static float GdiFlySqrt(float v)
{
	float x;
	int i;
	if (v <= 0.f) return 0.f;
	x = v > 1.f ? v : 1.f;
	for (i = 0; i < 10; i++) x = 0.5f * (x + v / x);
	return x;
}

static float GdiFlySin(float a)
{
	const float pi = 3.14159265f;
	const float half = 1.57079633f;
	float x2, s;
	int neg = 0;

	while (a > pi) a -= pi * 2.f;
	while (a < -pi) a += pi * 2.f;

	if (a < 0.f)
	{
		neg = 1;
		a = -a;
	}
	if (a > half)
		a = pi - a;

	x2 = a * a;
	s = a * (1.f - x2 * (1.f / 6.f - x2 * (1.f / 120.f)));
	return neg ? -s : s;
}

static float GdiFlyCos(float a)
{
	return GdiFlySin(a + 1.57079633f);
}

static void GdiFlyShadowOffsetNow(int* x, int* y)
{
	SYSTEMTIME st;
	float phase, ox, oy, amplitude;
	GetLocalTime(&st);

	phase = 6.28318530f * ((float)st.wHour * 3600.f + (float)st.wMinute * 60.f + (float)st.wSecond) / 86400.f;
	amplitude = (g_flyBank == FLY_BANK_FLY) ? 18.f * g_flyLegScale : 6.f;
	ox = amplitude * GdiFlyCos(phase);
	oy = amplitude * GdiFlySin(phase);

	*x = (int)(ox >= 0.f ? ox + 0.5f : ox - 0.5f);
	*y = (int)(oy >= 0.f ? oy + 0.5f : oy - 0.5f);
}

/*
 * The massive CPU-bound software rasterizer scaling loop.
 * Doing this on the CPU because D3D is too mainstream.
 */
static void GdiFlyScalePremul(int outW, int outH)
{
	int x, y, sx, sy, sw, sh, cw, ch;
	float ca, sa, ocx, ocy, dcx, dcy, dx, dy, ux, uy, ssx, ssy;
	BYTE* s;
	BYTE* d;
	unsigned a, b, g, r;

	if (!g_gdiFlyCurBits || !EnsureGdiFlyScaled(outW, outH))
		return;

	sw = g_gdiFlySrcW;
	sh = g_gdiFlySrcH;
	cw = g_gdiFlyContentW > 0 ? g_gdiFlyContentW : outW;
	ch = g_gdiFlyContentH > 0 ? g_gdiFlyContentH : outH;
	dcx = g_gdiFlyRotCx;
	dcy = g_gdiFlyRotCy;
	ocx = (float)(outW - FLY_SHADOW_PAD * 2) * 0.5f;
	ocy = (float)(outH - FLY_SHADOW_PAD * 2) * 0.5f;
	ca = GdiFlyCos(g_gdiFlyAngle);
	sa = GdiFlySin(g_gdiFlyAngle);
	ssx = (float)sw / (float)(cw > 0 ? cw : 1);
	ssy = (float)sh / (float)(ch > 0 ? ch : 1);

	for (y = 0; y < outH; y++)
	{
		for (x = 0; x < outW; x++)
		{
			d = g_gdiFlyScaledBits + (y * outW + x) * 4;
			dx = (float)x + 0.5f - ocx;
			dy = (float)y + 0.5f - ocy;
			ux = ocx + dx * ca + dy * sa;
			uy = ocy - dx * sa + dy * ca;
			ux = (ux - (ocx - dcx)) * ssx;
			uy = (uy - (ocy - dcy)) * ssy;

			if (ux < 0.f || uy < 0.f || ux >= (float)sw || uy >= (float)sh)
			{
				d[0] = d[1] = d[2] = d[3] = 0;
				continue;
			}

			sx = (int)ux;
			sy = (int)uy;
			if (sx >= sw) sx = sw - 1;
			if (sy >= sh) sy = sh - 1;
			if (g_gdiFlyMirrorX) sx = (sw - 1) - sx;

			s = g_gdiFlyCurBits + (sy * sw + sx) * 4;
			b = s[0];
			g = s[1];
			r = s[2];
			a = s[3];
			d[0] = (BYTE)((b * a) / 255);
			d[1] = (BYTE)((g * a) / 255);
			d[2] = (BYTE)((r * a) / 255);
			d[3] = (BYTE)a;
		}
	}
	{
		int offsetX, offsetY;
		SIZE_T i;
		GdiFlyShadowOffsetNow(&offsetX, &offsetY);
		if (g_gdiFlyShadowAlpha && g_gdiFlyShadowAlphaCap >= (SIZE_T)outW * (SIZE_T)outH)
		{
			for (i = 0; i < (SIZE_T)outW * (SIZE_T)outH; i++)
				g_gdiFlyShadowAlpha[i] = g_gdiFlyScaledBits[i * 4 + 3];

			for (y = 0; y < outH; y++)
			{
				for (x = 0; x < outW; x++)
				{
					unsigned sa, inv, add;
					int tx, ty;

					i = (SIZE_T)y * (SIZE_T)outW + (SIZE_T)x;
					a = g_gdiFlyShadowAlpha[i];
					if (!a)
						continue;

					tx = x + offsetX;
					ty = y + offsetY;
					if (tx < 0 || ty < 0 || tx >= outW || ty >= outH)
						continue;

					d = g_gdiFlyScaledBits + (ty * outW + tx) * 4;
					sa = (a * 72u + 127u) / 255u;
					inv = 255u - d[3];
					add = (sa * inv + 127u) / 255u;

					d[0] = (BYTE)(d[0] + (48u * add + 127u) / 255u);
					d[1] = (BYTE)(d[1] + (48u * add + 127u) / 255u);
					d[2] = (BYTE)(d[2] + (48u * add + 127u) / 255u);
					d[3] = (BYTE)(d[3] + add);
				}
			}
		}
	}
}

static void GdiFlyViewSize(int clientW, int clientH, int* outW, int* outH)
{
	int dw, dh;
	dw = (clientW * 55) / 100;
	dh = (dw * g_gdiFlySrcH) / (g_gdiFlySrcW > 0 ? g_gdiFlySrcW : 1);

	if (dh > (clientH * 55) / 100)
	{
		dh = (clientH * 55) / 100;
		dw = (dh * g_gdiFlySrcW) / (g_gdiFlySrcH > 0 ? g_gdiFlySrcH : 1);
	}
	if (dw < 64) dw = 64;
	if (dh < 36) dh = 36;
	*outW = dw;
	*outH = dh;
}

static void TickGdiFlyOverlay(void);
static void FlyBsTick(void);
static volatile LONG g_flyAnimRun;
static HANDLE g_flyAnimThread;

static DWORD WINAPI FlyAnimThread(LPVOID unused)
{
	(void)unused;
	while (InterlockedCompareExchange(&g_flyAnimRun, 1, 1) == 1)
	{
		Sleep(5);
		if (g_scrollHwnd && IsWindow(g_scrollHwnd))
		{
			TickGdiFlyOverlay();
			FlyBsTick();
		}
	}
	return 0;
}

static void FlyAnimEnsureThread(void)
{
	if (g_flyAnimThread)
		return;
	InterlockedExchange(&g_flyAnimRun, 1);
	g_flyAnimThread = CreateThread(NULL, 0, FlyAnimThread, NULL, 0, NULL);
}

static void GdiFlyPresent(HWND hwnd, int x, int y, int w, int h)
{
	POINT pt, srcPt;
	SIZE sz;
	BLENDFUNCTION bf;
	HGDIOBJ old;

	if (!hwnd || !g_gdiFlyMemDc || !g_gdiFlyCurBits)
		return;

	GdiFlyScalePremul(w, h);
	if (!g_gdiFlyScaledBmp)
		return;

	pt.x = x;
	pt.y = y;
	srcPt.x = 0;
	srcPt.y = 0;
	sz.cx = w;
	sz.cy = h;

	bf.BlendOp = AC_SRC_OVER;
	bf.BlendFlags = 0;
	bf.SourceConstantAlpha = 255;
	bf.AlphaFormat = AC_SRC_ALPHA;

	old = SelectObject(g_gdiFlyMemDc, g_gdiFlyScaledBmp);
	UpdateLayeredWindow(hwnd, NULL, &pt, &sz, g_gdiFlyMemDc, &srcPt, 0, &bf, ULW_ALPHA);
	SelectObject(g_gdiFlyMemDc, old);
}

static float GdiFlyAtan2(float y, float x)
{
	const float pi = 3.14159265f;
	const float half = 1.57079633f;
	float ax, ay, a, z;

	ax = x < 0.f ? -x : x;
	ay = y < 0.f ? -y : y;

	if (ax < 1e-8f && ay < 1e-8f)
		return 0.f;

	if (ay > ax)
	{
		z = ax / ay;
		a = half - z * (0.7854f - (z - 1.f) * (0.2447f + (z - 1.f) * 0.0663f));
	}
	else
	{
		z = ay / ax;
		a = z * (0.7854f - (z - 1.f) * (0.2447f + (z - 1.f) * 0.0663f));
	}

	if (x >= 0.f)
		return y < 0.f ? -a : a;
	return y < 0.f ? -pi + a : pi - a;
}

static float GdiFlyRand01(void)
{
	g_flyRng = g_flyRng * 1664525u + 1013904223u;
	if (g_flyRng == 0)
		g_flyRng = 1;
	return (float)(g_flyRng & 0xFFFFFFu) / 16777216.f;
}

static DWORD GdiFlyScalePeriod(void)
{
	return 30000u + (DWORD)(GdiFlyRand01() * 60000.f);
}

static void GdiFlyBeginWalkScale(float from)
{
	if (from < 0.6f)
		from = 0.6f;
	if (from > 1.0f)
		from = 1.0f;

	g_flyLegScale = from;
	g_flyWalkScaleFrom = from;
	g_flyWalkScaleTo = 0.6f + GdiFlyRand01() * 0.4f;
	g_flyScaleT0 = GetTickCount();
	g_flyScaleDuration = GdiFlyScalePeriod();
}

static void GdiFlyBeginFlightScale(float tx, float ty)
{
	float dx = tx - g_flyPosX, dy = ty - g_flyPosY;
	g_flyFlightStartScale = g_flyLegScale;

	if (g_flyFlightStartScale < 0.6f)
		g_flyFlightStartScale = 0.85f;
	if (g_flyFlightStartScale > 1.0f)
		g_flyFlightStartScale = 1.0f;

	g_flyFlightStartDist = GdiFlySqrt(dx * dx + dy * dy);
	if (g_flyFlightStartDist < 1.f)
		g_flyFlightStartDist = 1.f;
}

static void GdiFlyRollLeg(void)
{
	if (GdiFlyRand01() < 0.82f)
		g_flyLegSpeed = 1.2f + GdiFlyRand01() * 2.3f;
	else
		g_flyLegSpeed = 5.5f + GdiFlyRand01() * 4.5f;
}

static void GdiFlyPickHorizontal(void)
{
	float sp = g_flyLegSpeed > 0.5f ? g_flyLegSpeed : 3.f;
	g_flyVy = 0.f;
	g_flyVx = (GdiFlyRand01() < 0.5f) ? sp : -sp;
}

static void GdiFlyPickVertical(void)
{
	float sp = g_flyLegSpeed > 0.5f ? g_flyLegSpeed : 3.f;
	g_flyVx = 0.f;
	g_flyVy = (GdiFlyRand01() < 0.5f) ? sp : -sp;
}

static void GdiFlyPickCardinalDir(void)
{
	float a = GdiFlyRand01() * 6.28318531f;
	float sp = g_flyLegSpeed > 0.5f ? g_flyLegSpeed : 3.f;
	g_flyVx = GdiFlyCos(a) * sp;
	g_flyVy = GdiFlySin(a) * sp;
}

static float GdiFlyAtanApprox(float z)
{
	float az = z < 0.f ? -z : z;
	return z * (0.78539816f + 0.273f * (1.f - az));
}

static float GdiFlyDirectionAngle(float dx, float dy)
{
	const float halfPi = 1.57079633f, pi = 3.14159265f;
	float ax = dx < 0.f ? -dx : dx;
	float ay = dy < 0.f ? -dy : dy;
	float a;

	if (ax >= ay)
	{
		if (ax < 0.0001f)
			return 0.f;
		a = GdiFlyAtanApprox(dy / dx);
		if (dx < 0.f)
			a += (dy >= 0.f) ? pi : -pi;
	}
	else
	{
		a = (dy >= 0.f ? halfPi : -halfPi) - GdiFlyAtanApprox(dx / dy);
	}
	return a;
}

static void GdiFlyFaceTravel(void)
{
	if (g_flyVx * g_flyVx + g_flyVy * g_flyVy < 0.01f)
		return;
	g_flyAngleGoal = GdiFlyDirectionAngle(g_flyVx, g_flyVy);
	g_flyAngleEase = TRUE;
}

static void GdiFlyFaceTravelGoal(void)
{
	GdiFlyFaceTravel();
}

static void GdiFlyAngleEaseTick(void)
{
	const float pi = 3.14159265f;
	float d, step = 0.09f;
	if (!g_flyAngleEase)
		return;

	d = g_flyAngleGoal - g_flyTravelAngle;
	while (d > pi)
		d -= 2.f * pi;
	while (d < -pi)
		d += 2.f * pi;

	if (d > -0.04f && d < 0.04f)
	{
		g_flyTravelAngle = g_flyAngleGoal;
		g_flyAngleEase = FALSE;
		return;
	}

	if (d > step) d = step;
	if (d < -step) d = -step;
	g_flyTravelAngle += d;
}

static void GdiFlyFaceToward(float tx, float ty)
{
	float dx = tx - g_flyPosX;
	float dy = ty - g_flyPosY;
	if (dx * dx + dy * dy < 0.01f)
		return;

	g_flyLookAngle = GdiFlyDirectionAngle(dx, dy);
	g_flyAngleGoal = g_flyLookAngle;
	g_flyAngleEase = TRUE;
}

static void GdiFlyResumeAfterMouseIdle(DWORD now)
{
	if (!g_flyMouseIdleLook)
		return;

	if (g_flyScaleT0)
		g_flyScaleT0 += now - g_flyMouseIdleStarted;

	g_flyMouseIdleLook = FALSE;
	g_flyVx = g_flySavedVx;
	g_flyVy = g_flySavedVy;
	GdiFlyFaceTravel();
}

static void GdiFlyResumeAlongRail(void)
{
	float sp = g_flyLegSpeed > 0.5f ? g_flyLegSpeed : 3.f;

	if (GdiFlyRand01() < 0.5f && (g_flySavedVx != 0.f || g_flySavedVy != 0.f))
	{
		if (g_flySavedVx != 0.f)
		{
			g_flyVx = (g_flySavedVx > 0.f) ? sp : -sp;
			g_flyVy = 0.f;
		}
		else
		{
			g_flyVy = (g_flySavedVy > 0.f) ? sp : -sp;
			g_flyVx = 0.f;
		}
	}
	else
	{
		if (g_flyRail == 1 || g_flyRail == 2)
		{
			g_flyVy = 0.f;
			if (g_flySavedVx != 0.f && GdiFlyRand01() < 0.5f)
				g_flyVx = (g_flySavedVx > 0.f) ? -sp : sp;
			else
				g_flyVx = (GdiFlyRand01() < 0.5f) ? sp : -sp;
		}
		else if (g_flyRail == 3 || g_flyRail == 4)
		{
			g_flyVx = 0.f;
			if (g_flySavedVy != 0.f && GdiFlyRand01() < 0.5f)
				g_flyVy = (g_flySavedVy > 0.f) ? -sp : sp;
			else
				g_flyVy = (GdiFlyRand01() < 0.5f) ? sp : -sp;
		}
		else
		{
			GdiFlyPickCardinalDir();
		}
	}
	GdiFlyFaceTravel();
}

static void FlyLogApplyGlass(HWND hwnd);

static BOOL FlyLogCursorInside(HWND hwnd)
{
	POINT pt;
	RECT wr;
	if (!hwnd || !IsWindow(hwnd))
		return FALSE;

	GetCursorPos(&pt);
	GetWindowRect(hwnd, &wr);
	return PtInRect(&wr, pt);
}

/* Toggles the window chrome on hover because UI elements should definitely hide from you */
static void FlyLogSetChrome(HWND hwnd, BOOL show)
{
	DWORD style, ex;
	POINT tl;
	RECT crc, adj;
	int cw, ch;

	if (!hwnd || !IsWindow(hwnd))
		return;

	style = (DWORD)GetWindowLongPtrW(hwnd, GWL_STYLE);
	if (show)
	{
		if (style & WS_CAPTION)
			return;
	}
	else if (!(style & WS_CAPTION))
	{
		return;
	}

	GetClientRect(hwnd, &crc);
	cw = crc.right - crc.left;
	ch = crc.bottom - crc.top;

	tl.x = 0;
	tl.y = 0;
	ClientToScreen(hwnd, &tl);
	ex = (DWORD)GetWindowLongPtrW(hwnd, GWL_EXSTYLE);

	if (show)
		style = (style & ~(DWORD)WS_POPUP) | WS_OVERLAPPED | WS_CAPTION | WS_THICKFRAME | WS_SYSMENU;
	else
		style = (style & ~(DWORD)(WS_OVERLAPPED | WS_CAPTION | WS_THICKFRAME | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_BORDER | WS_DLGFRAME)) | WS_POPUP;

	SetWindowLongPtrW(hwnd, GWL_STYLE, (LONG_PTR)style);
	adj.left = 0;
	adj.top = 0;
	adj.right = cw;
	adj.bottom = ch;
	AdjustWindowRectEx(&adj, style, FALSE, ex);

	SetWindowPos(hwnd, NULL, tl.x + adj.left, tl.y + adj.top, adj.right - adj.left, adj.bottom - adj.top, SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
	FlyLogApplyGlass(hwnd);
}

static void FlyLogTrackLeave(HWND hwnd)
{
	TRACKMOUSEEVENT tme;
	tme.cbSize = sizeof(tme);
	tme.dwFlags = TME_LEAVE | TME_NONCLIENT;
	tme.hwndTrack = hwnd;
	tme.dwHoverTime = HOVER_DEFAULT;
	TrackMouseEvent(&tme);
}

static void FlyLogOnMouseIn(HWND hwnd)
{
	KillTimer(hwnd, FLYLOG_TMR_HIDECHROME);
	FlyLogSetChrome(hwnd, TRUE);
	FlyLogTrackLeave(hwnd);
}

static void FlyLogOnMouseOut(HWND hwnd)
{
	SetTimer(hwnd, FLYLOG_TMR_HIDECHROME, 150, NULL);
}

static LRESULT CALLBACK FlyLogListProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
	HWND parent = GetParent(hwnd);
	if (msg == WM_MOUSEMOVE)
	{
		TRACKMOUSEEVENT tme;
		if (parent)
			FlyLogOnMouseIn(parent);
		tme.cbSize = sizeof(tme);
		tme.dwFlags = TME_LEAVE;
		tme.hwndTrack = hwnd;
		tme.dwHoverTime = HOVER_DEFAULT;
		TrackMouseEvent(&tme);
	}
	else if (msg == WM_MOUSELEAVE && parent)
	{
		FlyLogOnMouseOut(parent);
	}
	return CallWindowProcW(g_flyLogListPrev, hwnd, msg, wp, lp);
}

static void FlyLogConstrainWindowPos(HWND hwnd, WINDOWPOS* pos)
{
	HWND chess = g_scrollHwnd;
	RECT cr, wr;
	int x, y, w, h;
	int moveLeft, moveRight, moveUp, moveDown, smallest;

	if (!pos)
		return;
	if (!chess || !IsWindow(chess))
		chess = g_game.hwnd;
	if (!chess || chess == hwnd || !GetWindowRect(chess, &cr))
		return;
	if (!GetWindowRect(hwnd, &wr))
		return;

	x = (pos->flags & SWP_NOMOVE) ? wr.left : pos->x;
	y = (pos->flags & SWP_NOMOVE) ? wr.top : pos->y;
	w = (pos->flags & SWP_NOSIZE) ? wr.right - wr.left : pos->cx;
	h = (pos->flags & SWP_NOSIZE) ? wr.bottom - wr.top : pos->cy;

	if (w <= 0 || h <= 0)
		return;
	if (x + w <= cr.left || x >= cr.right || y + h <= cr.top || y >= cr.bottom)
		return;

	moveLeft = x + w - cr.left;
	moveRight = cr.right - x;
	moveUp = y + h - cr.top;
	moveDown = cr.bottom - y;

	smallest = moveLeft;
	if (moveRight < smallest) smallest = moveRight;
	if (moveUp < smallest) smallest = moveUp;
	if (moveDown < smallest) smallest = moveDown;

	if (smallest == moveLeft) x -= moveLeft;
	else if (smallest == moveRight) x += moveRight;
	else if (smallest == moveUp) y -= moveUp;
	else y += moveDown;

	pos->x = x;
	pos->y = y;
	pos->flags &= ~SWP_NOMOVE;
}

static void FlyLogRepairOverlap(HWND hwnd)
{
	RECT wr;
	WINDOWPOS pos;
	if (!hwnd || !GetWindowRect(hwnd, &wr))
		return;

	CustomZeroMem(&pos, sizeof(pos));
	pos.x = wr.left;
	pos.y = wr.top;
	pos.flags = SWP_NOSIZE;
	FlyLogConstrainWindowPos(hwnd, &pos);

	if (pos.x != wr.left || pos.y != wr.top)
	{
		SetWindowPos(hwnd, NULL, pos.x, pos.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
	}
}

static LRESULT CALLBACK FlyLogWndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
	switch (msg)
	{
	case WM_WINDOWPOSCHANGING:
		FlyLogConstrainWindowPos(hwnd, (WINDOWPOS*)lp);
		break;
	case WM_CREATE:
	{
		CREATESTRUCTW* cs = (CREATESTRUCTW*)lp;
		HWND list = CreateWindowExW(0, L"LISTBOX", NULL,
			WS_CHILD | WS_VISIBLE | LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT | LBS_NOSEL,
			0, 0, cs->cx, cs->cy, hwnd, (HMENU)(INT_PTR)FLYLOG_LIST_ID, cs->hInstance, NULL);

		if (list)
		{
			g_flyLogList = list;
			if (g_flyLogFont)
				SendMessageW(list, WM_SETFONT, (WPARAM)g_flyLogFont, TRUE);
			g_flyLogListPrev = (WNDPROC)SetWindowLongPtrW(list, GWLP_WNDPROC, (LONG_PTR)FlyLogListProc);
		}
		SetTimer(hwnd, FLYLOG_TMR_HIDECHROME, 900, NULL);
		return 0;
	}
	case WM_SIZE:
		if (g_flyLogList && IsWindow(g_flyLogList))
			MoveWindow(g_flyLogList, 0, 0, LOWORD(lp), HIWORD(lp), TRUE);
		return 0;
	case WM_MEASUREITEM:
	{
		MEASUREITEMSTRUCT* mis = (MEASUREITEMSTRUCT*)lp;
		if (mis->CtlID == FLYLOG_LIST_ID)
		{
			HDC hdc = GetDC(hwnd);
			HFONT old = NULL;
			TEXTMETRIC tm;
			if (g_flyLogFont)
				old = (HFONT)SelectObject(hdc, g_flyLogFont);
			GetTextMetrics(hdc, &tm);
			mis->itemHeight = tm.tmHeight + 3;
			if (old)
				SelectObject(hdc, old);
			ReleaseDC(hwnd, hdc);
			return TRUE;
		}
		break;
	}
	case WM_DRAWITEM:
	{
		DRAWITEMSTRUCT* dis = (DRAWITEMSTRUCT*)lp;
		if (dis->CtlID == FLYLOG_LIST_ID && dis->itemID != (UINT)-1)
		{
			WCHAR text[1024];
			int n;
			RECT rc = dis->rcItem;
			HGDIOBJ oldF = NULL;

			n = (int)SendMessageW(dis->hwndItem, LB_GETTEXTLEN, dis->itemID, 0);
			if (n < 0) n = 0;
			if (n > 1023) n = 1023;

			text[0] = 0;
			SendMessageW(dis->hwndItem, LB_GETTEXT, dis->itemID, (LPARAM)text);
			FillRect(dis->hDC, &rc, g_flyLogBrush ? g_flyLogBrush : (HBRUSH)GetStockObject(BLACK_BRUSH));
			SetBkMode(dis->hDC, TRANSPARENT);
			SetTextColor(dis->hDC, ConPickRgb(text));

			if (g_flyLogFont)
				oldF = SelectObject(dis->hDC, g_flyLogFont);

			rc.left += 4;
			DrawTextW(dis->hDC, text, -1, &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE | DT_NOPREFIX | DT_END_ELLIPSIS);

			if (oldF)
				SelectObject(dis->hDC, oldF);
			return TRUE;
		}
		break;
	}
	case WM_CTLCOLORLISTBOX:
		if (g_flyLogBrush)
		{
			SetTextColor((HDC)wp, RGB(0, 255, 70));
			SetBkColor((HDC)wp, RGB(8, 12, 8));
			return (LRESULT)g_flyLogBrush;
		}
		break;
	case WM_MOUSEMOVE:
	case WM_NCMOUSEMOVE:
		FlyLogOnMouseIn(hwnd);
		return 0;
	case WM_MOUSELEAVE:
	case WM_NCMOUSELEAVE:
		FlyLogOnMouseOut(hwnd);
		return 0;
	case WM_TIMER:
		if (wp == FLYLOG_TMR_HIDECHROME)
		{
			KillTimer(hwnd, FLYLOG_TMR_HIDECHROME);
			if (!FlyLogCursorInside(hwnd))
				FlyLogSetChrome(hwnd, FALSE);
		}
		return 0;
	case WM_MOUSEACTIVATE:
		return MA_NOACTIVATE;
	case WM_ENTERSIZEMOVE:
		g_flyLogUserPlaced = TRUE;
		SetPropW(hwnd, L"FlyLogUserPlaced", (HANDLE)1);
		KillTimer(hwnd, FLYLOG_TMR_HIDECHROME);
		FlyLogSetChrome(hwnd, TRUE);
		return 0;
	case WM_CLOSE:
		ShowWindow(hwnd, SW_HIDE);
		return 0;
	case WM_DESTROY:
		KillTimer(hwnd, FLYLOG_TMR_HIDECHROME);
		if (g_flyLogHwnd == hwnd)
			g_flyLogHwnd = NULL;
		g_flyLogList = NULL;
		g_flyLogListPrev = NULL;
		return 0;
	}
	return DefWindowProcW(hwnd, msg, wp, lp);
}

/* Because nothing screams "highly secure custom terminal" like Comic Sans */
static HFONT FlyLogMakeShitFont(void)
{
	HFONT f;
	static const WCHAR* faces[] = { L"Comic Sans MS", L"Papyrus", L"Ink Free", L"Segoe Print", L"MV Boli", L"Kristen ITC", NULL };
	int i;
	for (i = 0; faces[i]; i++)
	{
		f = CreateFontW(-11, 0, 0, 0, FW_BOLD, TRUE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, PROOF_QUALITY, VARIABLE_PITCH | FF_SCRIPT, faces[i]);
		if (f) return f;
	}
	return CreateFontW(-11, 0, 0, 0, FW_BOLD, TRUE, FALSE, FALSE, DEFAULT_CHARSET, 0, 0, 0, DEFAULT_PITCH, L"Arial");
}

static void FlyLogApplyGlass(HWND hwnd)
{
	LONG_PTR ex;
	if (!hwnd || !IsWindow(hwnd))
		return;

	ex = GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
	if (!(ex & WS_EX_LAYERED))
		SetWindowLongPtrW(hwnd, GWL_EXSTYLE, ex | WS_EX_LAYERED);

	SetLayeredWindowAttributes(hwnd, 0, (BYTE)FLYLOG_ALPHA, LWA_ALPHA);
}

static void EnsureFlyConsole(void)
{
	WNDCLASSW wc;
	RECT wa;
	int x, y, w, h;
	HWND existing;

	existing = FindWindowW(L"FlyChessLogPane", NULL);
	if (existing && IsWindow(existing))
	{
		g_flyLogHwnd = existing;
		g_flyLogList = GetDlgItem(existing, FLYLOG_LIST_ID);
		FlyLogApplyGlass(existing);
		return;
	}

	if (!g_flyLogClassReg)
	{
		CustomZeroMem(&wc, sizeof(wc));
		wc.lpfnWndProc = FlyLogWndProc;
		wc.hInstance = GetModuleHandleW(NULL);
		wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
		wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
		wc.lpszClassName = L"FlyChessLogPane";
		if (!RegisterClassW(&wc) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
			return;
		g_flyLogClassReg = TRUE;
	}

	if (!g_flyLogFont) g_flyLogFont = FlyLogMakeShitFont();
	if (!g_flyLogBrush) g_flyLogBrush = CreateSolidBrush(RGB(8, 12, 8));

	SystemParametersInfoW(SPI_GETWORKAREA, 0, &wa, 0);
	w = 420; h = 420;
	x = wa.left + 12; y = wa.top + 12;

	g_flyLogHwnd = CreateWindowExW(WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE | WS_EX_LAYERED,
		L"FlyChessLogPane", L"Drosophila Experiment - NeuroMechFly",
		WS_OVERLAPPED | WS_CAPTION | WS_THICKFRAME | WS_SYSMENU,
		x, y, w, h, NULL, NULL, GetModuleHandleW(NULL), NULL);

	if (!g_flyLogHwnd) return;
	FlyLogApplyGlass(g_flyLogHwnd);
	UpdateWindow(g_flyLogHwnd);

}

static BOOL FlyClientScreenRect(HWND hwnd, RECT* out)
{
	RECT crc;
	POINT tl, br;

	if (!hwnd || !IsWindow(hwnd) || !out)
		return FALSE;
	if (IsIconic(hwnd) || !IsWindowVisible(hwnd))
		return FALSE;

	GetClientRect(hwnd, &crc);
	if (crc.right - crc.left < 32 || crc.bottom - crc.top < 32)
		return FALSE;

	tl.x = crc.left; tl.y = crc.top;
	br.x = crc.right; br.y = crc.bottom;
	ClientToScreen(hwnd, &tl);
	ClientToScreen(hwnd, &br);

	out->left = tl.x; out->top = tl.y;
	out->right = br.x; out->bottom = br.y;
	return TRUE;
}

static HWND FlyFindConsoleHwnd(void)
{
	HWND hit;
	if (g_flyLogHwnd && IsWindow(g_flyLogHwnd))
		return g_flyLogHwnd;

	hit = FindWindowW(L"FlyChessLogPane", NULL);
	if (hit && IsWindow(hit))
	{
		g_flyLogHwnd = hit;
		g_flyLogList = GetDlgItem(hit, FLYLOG_LIST_ID);
		return hit;
	}
	return NULL;
}

static BOOL FlyHwndConsoleOk(HWND hwnd)
{
	if (!hwnd || !IsWindow(hwnd) || IsIconic(hwnd))
		return FALSE;
	if (g_flyLogRevealValid)
		return TRUE;
	return IsWindowVisible(hwnd);
}

static BOOL FlyConsoleScreenRect(RECT* out)
{
	HWND h = FlyFindConsoleHwnd();
	static DWORD s_lastLog;
	DWORD now = GetTickCount();
	int x;

	if (!h || !FlyHwndConsoleOk(h))
	{
		if (!s_lastLog || now - s_lastLog > 8000)
			s_lastLog = now;
		return FALSE;
	}

	if (g_flyLogUserPlaced || GetPropW(h, L"FlyLogUserPlaced"))
	{
		if (!IsWindowVisible(h) || IsIconic(h))
			return FALSE;
		return GetWindowRect(h, out) && (out->right - out->left) >= 32 && (out->bottom - out->top) >= 32;
	}

	if (g_flyLogRevealValid)
	{
		if (g_flyLogGlueRight) x = g_flyLogGlueX - g_flyLogRevealW;
		else x = g_flyLogGlueX;

		out->left = x; out->top = g_flyLogRevealY;
		out->right = x + g_flyLogRevealW; out->bottom = g_flyLogRevealY + g_flyLogRevealH;
		return TRUE;
	}

	if (FlyClientScreenRect(h, out))
		return TRUE;

	if (GetWindowRect(h, out) && (out->right - out->left) >= 32 && (out->bottom - out->top) >= 32)
		return TRUE;

	return FALSE;
}

static void FlyLogSetZBehindChess(HWND log, HWND chess)
{
	if (!log || !chess) return;

	if (GetWindowLongPtrW(log, GWLP_HWNDPARENT) != 0)
		SetWindowLongPtrW(log, GWLP_HWNDPARENT, 0);

	SetWindowPos(log, chess, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_FRAMECHANGED);
}

static void FlyLogSetZOwnedByChess(HWND log, HWND chess)
{
	if (!log || !chess) return;

	if (GetWindowLongPtrW(log, GWLP_HWNDPARENT) != (LONG_PTR)chess)
	{
		SetWindowLongPtrW(log, GWLP_HWNDPARENT, (LONG_PTR)chess);
		SetWindowPos(log, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_FRAMECHANGED);
	}
}

static void FlyLogRecalcDock(HWND chess)
{
	HWND log;
	RECT cr, wa;
	MONITORINFO mi;
	HMONITOR mon;
	int lw, lh, gap = 0;

	log = FlyFindConsoleHwnd();
	if (!log || !IsWindow(log) || !chess || !IsWindow(chess) || IsIconic(chess))
		return;
	if (g_flyLogUserPlaced || GetPropW(log, L"FlyLogUserPlaced"))
		return;
	if (!GetWindowRect(chess, &cr))
		return;

	mon = MonitorFromWindow(chess, MONITOR_DEFAULTTONEAREST);
	mi.cbSize = sizeof(mi);
	if (!GetMonitorInfoW(mon, &mi))
		SystemParametersInfoW(SPI_GETWORKAREA, 0, &wa, 0);
	else
		wa = mi.rcWork;

	lw = 420;
	lh = cr.bottom - cr.top;
	if (lh < 240) lh = 360;
	if (lh > (wa.bottom - wa.top) - 16) lh = (wa.bottom - wa.top) - 16;

	if (g_flyLogDockEdge == FLYLOG_EDGE_AUTO)
	{
		if (cr.left - gap - lw >= wa.left)
			g_flyLogDockEdge = FLYLOG_EDGE_LEFT;
		else if (cr.right + gap + lw <= wa.right)
			g_flyLogDockEdge = FLYLOG_EDGE_RIGHT;
		else
			g_flyLogDockEdge = FLYLOG_EDGE_LEFT;
	}

	if (g_flyLogDockEdge == FLYLOG_EDGE_TOP || g_flyLogDockEdge == FLYLOG_EDGE_BOTTOM)
		lw = cr.right - cr.left;

	if (g_flyLogDockEdge == FLYLOG_EDGE_LEFT) { g_flyLogGlueRight = TRUE; g_flyLogGlueX = cr.left - gap; g_flyLogRevealY = cr.top; }
	else if (g_flyLogDockEdge == FLYLOG_EDGE_RIGHT) { g_flyLogGlueRight = FALSE; g_flyLogGlueX = cr.right + gap; g_flyLogRevealY = cr.top; }
	else if (g_flyLogDockEdge == FLYLOG_EDGE_TOP) { g_flyLogGlueRight = FALSE; g_flyLogGlueY = cr.top - gap; lh = 360; }
	else { g_flyLogGlueRight = FALSE; g_flyLogGlueY = cr.bottom + gap; lh = 360; }

	if (g_flyLogDockEdge == FLYLOG_EDGE_LEFT || g_flyLogDockEdge == FLYLOG_EDGE_RIGHT)
	{
		if (g_flyLogRevealY < wa.top) g_flyLogRevealY = wa.top;
		if (g_flyLogRevealY + lh > wa.bottom) g_flyLogRevealY = wa.bottom - lh;
		g_flyLogRevealW = lw;
		g_flyLogRevealH = lh;
	}
	else
	{
		g_flyLogGlueX = cr.left;
		if (lh > (wa.bottom - wa.top) - 16) lh = (wa.bottom - wa.top) - 16;
		g_flyLogRevealW = lw;
		g_flyLogRevealH = lh;
		if (g_flyLogDockEdge == FLYLOG_EDGE_TOP && g_flyLogGlueY < wa.top) g_flyLogGlueY = wa.top;
		g_flyLogRevealY = g_flyLogDockEdge == FLYLOG_EDGE_TOP ? g_flyLogGlueY - lh : g_flyLogGlueY;
	}
	g_flyLogRevealValid = TRUE;
}

static void FlyPlaceLogBesideChess(HWND chess)
{
	HWND log;
	log = FlyFindConsoleHwnd();
	if (!log || !IsWindow(log) || !chess || !IsWindow(chess))
		return;
	if (g_flyLogUserPlaced || GetPropW(log, L"FlyLogUserPlaced"))
		return;

	FlyLogRecalcDock(chess);
	if (!g_flyLogRevealValid)
		return;
	if (GetPropW(log, L"FlyLogAutoPlaced"))
		return;

	g_flyLogRevealed = FALSE;
	FlyLogApplyGlass(log);
	FlyLogSetZBehindChess(log, chess);

	SetWindowPos(log, chess, g_flyLogGlueX, g_flyLogRevealY, g_flyLogPanVertical ? g_flyLogRevealW : 0, g_flyLogPanVertical ? 0 : g_flyLogRevealH, SWP_NOACTIVATE | SWP_HIDEWINDOW);
	SetPropW(log, L"FlyLogAutoPlaced", (HANDLE)1);
}

static void FlyLogClearResizeTrail(const RECT* before, HWND log, HWND chess)
{
	RECT after, dirty;
	if (!before)
		return;

	if (log && IsWindow(log) && IsWindowVisible(log))
		GetWindowRect(log, &after);
	else
		after = *before;

	UnionRect(&dirty, before, &after);
	InflateRect(&dirty, 4, 4);
	RedrawWindow(NULL, &dirty, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN | RDW_FRAME | RDW_UPDATENOW);
	if (chess && IsWindow(chess))
	{
		InvalidateRect(chess, NULL, TRUE);
		UpdateWindow(chess);
	}
}

static void FlyLogSetPosClean(HWND log, HWND afterHwnd, int x, int y, int w, int h, UINT extraFlags)
{
	RECT before;
	HWND chess;
	if (!log || !IsWindow(log))
		return;

	before.left = before.top = before.right = before.bottom = 0;
	if (IsWindowVisible(log))
		GetWindowRect(log, &before);

	SetWindowPos(log, afterHwnd, x, y, w, h, SWP_NOACTIVATE | SWP_NOCOPYBITS | extraFlags);
	FlyLogApplyGlass(log);

	chess = g_scrollHwnd;
	if (!chess || !IsWindow(chess)) chess = g_game.hwnd;
	if (before.right > before.left)
		FlyLogClearResizeTrail(&before, log, chess);
}

static void FlyLogStartPan(HWND chess, BOOL flyArriving)
{
	HWND log;
	RECT lr;
	int curSize;

	log = FlyFindConsoleHwnd();
	if (!log || !IsWindow(log))
		return;
	if (g_flyLogUserPlaced || GetPropW(log, L"FlyLogUserPlaced"))
		return;

	FlyLogRecalcDock(chess);
	if (!g_flyLogRevealValid)
		return;

	g_flyLogPanArriving = flyArriving;
	if (flyArriving)
	{
		g_flyLogFlyPending = TRUE;
		g_flyLogFlyEdge = g_flyLogDockEdge;
	}

	g_flyLogPanVertical = (g_flyLogDockEdge == FLYLOG_EDGE_TOP || g_flyLogDockEdge == FLYLOG_EDGE_BOTTOM);
	g_flyLogPanX = g_flyLogGlueX;
	g_flyLogPanY = g_flyLogPanVertical ? g_flyLogGlueY : g_flyLogRevealY;
	g_flyLogPanH = g_flyLogRevealH;
	g_flyLogPanMs = 550;
	g_flyLogPanT0 = GetTickCount();

	if (GetWindowRect(log, &lr) && IsWindowVisible(log))
		curSize = g_flyLogPanVertical ? (lr.bottom - lr.top) : (lr.right - lr.left);
	else
		curSize = 0;

	if (curSize < 0)
		curSize = 0;

	if (flyArriving)
	{
		g_flyLogPanW0 = 0; g_flyLogPanW1 = g_flyLogRevealW;
		g_flyLogPanH0 = 0; g_flyLogPanH1 = g_flyLogRevealH;
		FlyLogSetZBehindChess(log, chess);
		ShowWindow(log, SW_SHOWNOACTIVATE);
		FlyLogSetPosClean(log, chess, g_flyLogPanX, g_flyLogPanY, g_flyLogPanVertical ? g_flyLogRevealW : 0, g_flyLogPanVertical ? 0 : g_flyLogPanH, SWP_SHOWWINDOW);
	}
	else
	{
		g_flyLogFlyPending = FALSE;
		g_flyLogPanW0 = (curSize > 0) ? curSize : g_flyLogRevealW;
		g_flyLogPanW1 = 0;
		g_flyLogPanH0 = (curSize > 0) ? curSize : g_flyLogRevealH;
		g_flyLogPanH1 = 0;
		g_flyLogRevealed = FALSE;
		FlyLogSetZBehindChess(log, chess);
	}
	g_flyLogPanning = TRUE;
}

static void FlyLogArmPanNearLanding(HWND chess, BOOL flyArriving)
{
	(void)chess; (void)flyArriving; g_flyLogPanPending = FALSE;
}

static void FlyLogMaybeStartPendingPan(HWND chess, float dist2)
{
	(void)chess; (void)dist2; g_flyLogPanPending = FALSE;
}

static BOOL FlyLogCursorOnChessSideEdge(HWND chess, int band, int* hitEdge)
{
	POINT pt;
	RECT cr;
	int dleft, dright, dtop, dbottom, best;
	const int triggerGap = 3;

	if (!chess || !IsWindow(chess) || IsIconic(chess))
		return FALSE;
	if (!GetCursorPos(&pt) || !GetWindowRect(chess, &cr))
		return FALSE;

	dleft = (pt.x < cr.left) ? cr.left - pt.x : 0x7fffffff;
	dright = (pt.x >= cr.right) ? pt.x - cr.right : 0x7fffffff;
	dtop = (pt.y < cr.top) ? cr.top - pt.y : 0x7fffffff;
	dbottom = (pt.y >= cr.bottom) ? pt.y - cr.bottom : 0x7fffffff;
	best = dleft;

	{
		int edge = FLYLOG_EDGE_LEFT;
		if (dright < best) { best = dright; edge = FLYLOG_EDGE_RIGHT; }
		if (dtop < best) { best = dtop; edge = FLYLOG_EDGE_TOP; }
		if (dbottom < best) { best = dbottom; edge = FLYLOG_EDGE_BOTTOM; }
		if (best < triggerGap || best > band) return FALSE;
		if ((edge == FLYLOG_EDGE_LEFT || edge == FLYLOG_EDGE_RIGHT) && (pt.y < cr.top - band || pt.y > cr.bottom + band)) return FALSE;
		if ((edge == FLYLOG_EDGE_TOP || edge == FLYLOG_EDGE_BOTTOM) && (pt.x < cr.left - band || pt.x > cr.right + band)) return FALSE;
		if (hitEdge) *hitEdge = edge;
	}
	return TRUE;
}

static BOOL FlyLogCursorOverLog(void)
{
	POINT pt;
	HWND log;
	RECT lr;

	log = FlyFindConsoleHwnd();
	if (!log || !IsWindow(log))
		return FALSE;
	if (!GetCursorPos(&pt) || !GetWindowRect(log, &lr))
		return FALSE;

	return PtInRect(&lr, pt);
}

static void FlyLogEdgeMouseTick(HWND chess)
{
	BOOL hot, onEdge, overLog, userPlaced;
	int edge = FLYLOG_EDGE_AUTO;
	DWORD now;

	if (!chess || !IsWindow(chess))
		return;

	userPlaced = g_flyLogUserPlaced;
	{
		HWND log = FlyFindConsoleHwnd();
		if (log && GetPropW(log, L"FlyLogUserPlaced")) userPlaced = TRUE;
	}

	onEdge = FlyLogCursorOnChessSideEdge(chess, 10, &edge);
	overLog = FlyLogCursorOverLog();
	hot = onEdge || overLog || g_flyLogFlyPending || (g_flyHabitat == 1 && g_flyLogRevealed);
	now = GetTickCount();

	if (userPlaced)
	{
		HWND log = FlyFindConsoleHwnd();
		if (!log || !IsWindow(log)) return;
		if (!IsWindowVisible(log))
		{
			if (hot)
			{
				ShowWindow(log, SW_SHOWNOACTIVATE);
				g_flyLogRevealed = TRUE;
				g_flyLogShownEdge = onEdge ? edge : FLYLOG_EDGE_AUTO;
				g_flyLogEdgeLeaveAt = 0;
			}
			return;
		}
		if (overLog)
		{
			g_flyLogEdgeLeaveAt = 0;
			return;
		}
		if (!g_flyLogEdgeLeaveAt)
			g_flyLogEdgeLeaveAt = now + 10000u;
		else if (now >= g_flyLogEdgeLeaveAt)
		{
			g_flyLogEdgeLeaveAt = 0;
			ShowWindow(log, SW_HIDE);
			g_flyLogRevealed = FALSE;
			g_flyLogShownEdge = FLYLOG_EDGE_AUTO;
		}
		return;
	}

	if (g_flyLogPanning)
	{
		if (onEdge)
		{
			g_flyLogNextEdge = edge;
			if (g_flyLogPanArriving && edge != g_flyLogDockEdge)
				FlyLogStartPan(chess, FALSE);
		}
		return;
	}

	if (g_flyLogRevealed && onEdge && edge != g_flyLogShownEdge)
	{
		g_flyLogNextEdge = edge;
		g_flyLogEdgeLeaveAt = 0;
		FlyLogStartPan(chess, FALSE);
		return;
	}

	if (!g_flyLogRevealed)
	{
		if (!hot)
			return;
		g_flyLogEdgeLeaveAt = 0;
		if (onEdge) g_flyLogDockEdge = edge;
		FlyLogRecalcDock(chess);
		if (!g_flyLogRevealValid)
			return;
		FlyLogStartPan(chess, TRUE);
		return;
	}

	if (overLog)
	{
		g_flyLogEdgeLeaveAt = 0;
		return;
	}

	if (!g_flyLogEdgeLeaveAt)
		g_flyLogEdgeLeaveAt = now + 10000u;
	else if (now >= g_flyLogEdgeLeaveAt)
	{
		g_flyLogEdgeLeaveAt = 0;
		FlyLogStartPan(chess, FALSE);
	}
}

static void FlyLogPanTick(void)
{
	HWND log, chess;
	DWORD now, elapsed;
	float t, u;
	int size, w, h, x, y;

	chess = g_scrollHwnd;
	if (!chess || !IsWindow(chess)) chess = g_game.hwnd;
	if (chess) FlyLogEdgeMouseTick(chess);

	if (!g_flyLogPanning)
		return;

	log = FlyFindConsoleHwnd();
	if (!log || !IsWindow(log))
	{
		g_flyLogPanning = FALSE;
		return;
	}

	now = GetTickCount();
	elapsed = now - g_flyLogPanT0;
	t = (g_flyLogPanMs > 0) ? ((float)elapsed / (float)g_flyLogPanMs) : 1.f;
	if (t >= 1.f)
	{
		t = 1.f;
		g_flyLogPanning = FALSE;
	}

	u = t * t * (3.f - 2.f * t);
	size = g_flyLogPanVertical ? (int)((float)g_flyLogPanH0 + ((float)(g_flyLogPanH1 - g_flyLogPanH0) * u) + 0.5f) : (int)((float)g_flyLogPanW0 + ((float)(g_flyLogPanW1 - g_flyLogPanW0) * u) + 0.5f);
	if (size < 0)
		size = 0;

	w = g_flyLogPanVertical ? g_flyLogRevealW : size;
	h = g_flyLogPanVertical ? size : g_flyLogPanH;
	x = g_flyLogPanVertical ? g_flyLogPanX : (g_flyLogGlueRight ? g_flyLogGlueX - w : g_flyLogGlueX);
	y = g_flyLogPanVertical ? (g_flyLogDockEdge == FLYLOG_EDGE_TOP ? g_flyLogGlueY - h : g_flyLogGlueY) : g_flyLogPanY;

	if (!chess || !IsWindow(chess))
		chess = g_game.hwnd;

	if (size <= 1 && !g_flyLogPanArriving && t >= 1.f)
	{
		FlyLogSetPosClean(log, chess ? chess : HWND_BOTTOM, g_flyLogGlueX, g_flyLogPanY, g_flyLogPanVertical ? g_flyLogRevealW : 0, g_flyLogPanVertical ? 0 : g_flyLogPanH, SWP_HIDEWINDOW);
		g_flyLogRevealed = FALSE;
		g_flyLogShownEdge = FLYLOG_EDGE_AUTO;
		if (g_flyLogNextEdge != FLYLOG_EDGE_AUTO)
		{
			g_flyLogDockEdge = g_flyLogNextEdge;
			g_flyLogNextEdge = FLYLOG_EDGE_AUTO;
		}
		return;
	}

	if (g_flyLogPanArriving && t >= 1.f)
	{
		FlyLogSetPosClean(log, HWND_TOP, x, y, w, h, SWP_SHOWWINDOW);
		if (chess)
			FlyLogSetZOwnedByChess(log, chess);
		g_flyLogRevealed = TRUE;
		g_flyLogShownEdge = g_flyLogDockEdge;
		return;
	}
	FlyLogSetPosClean(log, chess ? chess : HWND_BOTTOM, x, y, w, h, SWP_SHOWWINDOW);
}

static void FlyEnsureLogOwnedByChess(HWND chess)
{
	HWND log;
	if (!chess || !IsWindow(chess))
		return;

	log = FlyFindConsoleHwnd();
	if (!log || !IsWindow(log))
		return;

	FlyPlaceLogBesideChess(chess);
	FlyLogRepairOverlap(log);

	if (g_flyLogRevealed && !g_flyLogPanning)
		FlyLogSetZOwnedByChess(log, chess);
	else if (!g_flyLogPanning)
		FlyLogSetZBehindChess(log, chess);
}

static void FlyApplyOwnerAndZ(HWND chess)
{
	HWND con, wantOwner;
	LONG_PTR curOwner, ex;

	if (!g_gdiFlyHwnd || !IsWindow(g_gdiFlyHwnd) || !chess || !IsWindow(chess))
		return;

	FlyEnsureLogOwnedByChess(chess);
	con = FlyFindConsoleHwnd();

	if ((g_flyTransit || g_flyHabitat == 1) && con && g_flyLogRevealed && IsWindow(con) && FlyHwndConsoleOk(con))
		wantOwner = con;
	else
		wantOwner = chess;

	curOwner = GetWindowLongPtrW(g_gdiFlyHwnd, GWLP_HWNDPARENT);
	ex = GetWindowLongPtrW(g_gdiFlyHwnd, GWL_EXSTYLE);

	if (ex & WS_EX_TOPMOST)
	{
		SetWindowLongPtrW(g_gdiFlyHwnd, GWL_EXSTYLE, ex & ~(LONG_PTR)WS_EX_TOPMOST);
		SetWindowPos(g_gdiFlyHwnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_FRAMECHANGED);
	}
	if (curOwner != (LONG_PTR)wantOwner)
	{
		SetWindowLongPtrW(g_gdiFlyHwnd, GWLP_HWNDPARENT, (LONG_PTR)wantOwner);
		SetWindowPos(g_gdiFlyHwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_FRAMECHANGED);
	}
}

static void FlyMarginBox(const RECT* rc, float margin, float* L, float* R, float* T, float* B)
{
	*L = (float)rc->left - margin;
	*R = (float)rc->right + margin;
	*T = (float)rc->top - margin;
	*B = (float)rc->bottom + margin;
}

static void FlySnapToNearestEdge(float L, float R, float T, float B, BOOL keepFlightDir)
{
	float dL = g_flyPosX - L, dR = R - g_flyPosX, dT = g_flyPosY - T, dB = B - g_flyPosY;
	float best = dT;
	float keepVx = g_flyVx, keepVy = g_flyVy;
	float sp = g_flyLegSpeed > 0.5f ? g_flyLegSpeed : 3.f;

	g_flyRail = 1;
	g_flyPerp = 0.f;

	if (dB < best) { best = dB; g_flyRail = 2; }
	if (dL < best) { best = dL; g_flyRail = 3; }
	if (dR < best) { g_flyRail = 4; }

	switch (g_flyRail)
	{
	case 1: g_flyPosY = T; break;
	case 2: g_flyPosY = B; break;
	case 3: g_flyPosX = L; break;
	case 4: g_flyPosX = R; break;
	}

	if (g_flyRail == 1 || g_flyRail == 2)
	{
		if (g_flyPosX < L) g_flyPosX = L;
		if (g_flyPosX > R) g_flyPosX = R;
		g_flyVy = 0.f;
		if (keepFlightDir && (keepVx > 0.1f || keepVx < -0.1f))
			g_flyVx = (keepVx > 0.f) ? sp : -sp;
		else
			GdiFlyPickHorizontal();
	}
	else
	{
		if (g_flyPosY < T) g_flyPosY = T;
		if (g_flyPosY > B) g_flyPosY = B;
		g_flyVx = 0.f;
		if (keepFlightDir && (keepVy > 0.1f || keepVy < -0.1f))
			g_flyVy = (keepVy > 0.f) ? sp : -sp;
		else
			GdiFlyPickVertical();
	}
	GdiFlyFaceTravelGoal();
}

static void FlyBeginHopTo(int destHabitat, float tx, float ty)
{
	g_flyResting = FALSE;
	g_flyTransit = TRUE;
	g_flyThink = FALSE;
	g_flyRail = 0;
	g_flyPerp = 0.f;
	g_flyVx = 0.f;
	g_flyVy = 0.f;
	g_flyHabitat = destHabitat;
	g_flyTransitDest = destHabitat;
	g_flyTx = tx;
	g_flyTy = ty;

	if (g_flyBankN[FLY_BANK_FLY] > 0)
		GdiFlySetBank(FLY_BANK_FLY);

	GdiFlyRollLeg();
	GdiFlyBeginFlightScale(g_flyTx, g_flyTy);
}

static int FlyRectOutsideRail(float l, float r, float t, float b, float L, float R, float T, float B)
{
	if (r <= L) return 3;
	if (l >= R) return 4;
	if (b <= T) return 1;
	if (t >= B) return 2;
	return 0;
}

static BOOL FlyChooseLogLanding(HWND chess, float cL, float cR, float cT, float cB, float* tx, float* ty)
{
	RECT pane, chessRect;
	MONITORINFO mi;
	HMONITOR mon;
	int minX, maxX, minY, maxY, i;

	if (!chess || !GetWindowRect(chess, &chessRect))
		return FALSE;

	pane.left = (LONG)cL;
	pane.right = (LONG)cR;
	pane.top = (LONG)cT;
	pane.bottom = (LONG)cB;

	mon = MonitorFromRect(&pane, MONITOR_DEFAULTTONEAREST);
	mi.cbSize = sizeof(mi);
	if (!GetMonitorInfoW(mon, &mi))
		return FALSE;

	minX = (int)cL + 28;
	maxX = (int)cR - 28;
	minY = (int)cT + 28;
	maxY = (int)cB - 28;

	if (minX < mi.rcWork.left + 16) minX = mi.rcWork.left + 16;
	if (maxX > mi.rcWork.right - 16) maxX = mi.rcWork.right - 16;
	if (minY < mi.rcWork.top + 16) minY = mi.rcWork.top + 16;
	if (maxY > mi.rcWork.bottom - 16) maxY = mi.rcWork.bottom - 16;
	if (maxX <= minX || maxY <= minY)
		return FALSE;

	InflateRect(&chessRect, 48, 48);

	for (i = 0; i < 128; ++i)
	{
		int x = minX + (int)(GdiFlyRand01() * (float)(maxX - minX));
		int y = minY + (int)(GdiFlyRand01() * (float)(maxY - minY));

		if (x < chessRect.left || x >= chessRect.right || y < chessRect.top || y >= chessRect.bottom)
		{
			*tx = (float)x;
			*ty = (float)y;
			return TRUE;
		}
	}
	return FALSE;
}

static void FlyPickRandomTarget(HWND chess, BOOL haveCon, float L, float R, float T, float B, float boardL, float boardR, float boardT, float boardB, float cL, float cR, float cT, float cB, float* tx, float* ty, int* hab)
{
	int rail = g_flyRail;
	BOOL toLog;

	if (rail < 1 || rail > 4)
	{
		FlySnapToNearestEdge(L, R, T, B, FALSE);
		rail = g_flyRail;
	}

	toLog = haveCon && (g_flyHabitat == 0 ? GdiFlyRand01() < 0.72f : GdiFlyRand01() >= 0.28f);
	if (toLog && FlyRectOutsideRail(cL, cR, cT, cB, boardL, boardR, boardT, boardB) != rail)
		toLog = FALSE;
	if (toLog && !FlyChooseLogLanding(chess, cL, cR, cT, cB, tx, ty))
		toLog = FALSE;

	if (toLog)
		*hab = 1;
	else
	{
		*hab = 0;
		switch (rail)
		{
		case 1:
		case 2:
			*ty = rail == 1 ? T : B;
			if (GdiFlyRand01() < 0.55f)
			{
				BOOL nearLeft = g_flyPosX - L < 64.f;
				BOOL nearRight = R - g_flyPosX < 64.f;
				*tx = nearLeft ? R : nearRight ? L : (GdiFlyRand01() < 0.5f ? L : R);
			}
			else
				*tx = L + GdiFlyRand01() * (R - L);
			break;
		case 3:
		default:
			*tx = rail == 3 ? L : R;
			if (GdiFlyRand01() < 0.55f)
			{
				BOOL nearTop = g_flyPosY - T < 64.f;
				BOOL nearBottom = B - g_flyPosY < 64.f;
				*ty = nearTop ? B : nearBottom ? T : (GdiFlyRand01() < 0.5f ? T : B);
			}
			else
				*ty = T + GdiFlyRand01() * (B - T);
			break;
		}
	}
}

static void FlyLandContinue(float L, float R, float T, float B, BOOL preferInterior)
{
	float dL = g_flyPosX - L, dR = R - g_flyPosX, dT = g_flyPosY - T, dB = B - g_flyPosY;
	float edgeNear = 80.f;
	float sp = g_flyLegSpeed > 0.5f ? g_flyLegSpeed : 3.f;
	float avx = g_flyApproachVx, avy = g_flyApproachVy;

	GdiFlyRollLeg();
	sp = g_flyLegSpeed > 0.5f ? g_flyLegSpeed : sp;
	g_flyPerp = 0.f;

	if (!preferInterior && (dT < edgeNear || dB < edgeNear || dL < edgeNear || dR < edgeNear))
	{
		g_flyVx = avx;
		g_flyVy = avy;
		FlySnapToNearestEdge(L, R, T, B, TRUE);
		return;
	}

	g_flyRail = 0;
	if ((avx > 0.1f || avx < -0.1f) || (avy > 0.1f || avy < -0.1f))
	{
		if ((avx > 0.f ? avx : -avx) >= (avy > 0.f ? avy : -avy))
		{
			g_flyVy = 0.f;
			g_flyVx = (avx >= 0.f) ? sp : -sp;
		}
		else
		{
			g_flyVx = 0.f;
			g_flyVy = (avy >= 0.f) ? sp : -sp;
		}
	}
	else
		GdiFlyPickCardinalDir();

	GdiFlyFaceTravel();
}

static BOOL FlyTransitTick(HWND chess, float arriveR)
{
	float dx, dy, dist2, dist, sp, step;

	dx = g_flyTx - g_flyPosX;
	dy = g_flyTy - g_flyPosY;
	dist2 = dx * dx + dy * dy;
	sp = g_flyLegSpeed > 0.5f ? g_flyLegSpeed * 5.6f : 16.f;
	dist = GdiFlySqrt(dist2);

	if (g_flyFlightStartDist > 0.f)
	{
		float progress = 1.f - dist / g_flyFlightStartDist;
		float phase;

		if (progress < 0.f) progress = 0.f;
		if (progress > 1.f) progress = 1.f;

		if (progress < 0.5f)
		{
			phase = progress * 2.f;
			phase = phase * phase * (3.f - 2.f * phase);
			g_flyLegScale = g_flyFlightStartScale + (2.75f - g_flyFlightStartScale) * phase;
		}
		else
		{
			phase = (progress - 0.5f) * 2.f;
			phase = phase * phase * (3.f - 2.f * phase);
			g_flyLegScale = 2.75f - 1.75f * phase;
		}
	}

	FlyLogMaybeStartPendingPan(chess, dist2);

	if (dist2 < arriveR * arriveR || dist <= sp)
	{
		g_flyApproachVx = g_flyVx;
		g_flyApproachVy = g_flyVy;
		g_flyPosX = g_flyTx;
		g_flyPosY = g_flyTy;
		g_flyVx = 0.f;
		g_flyVy = 0.f;
		g_flyLegScale = 1.0f;
		g_flyFlightStartDist = 0.f;
		g_flyTransit = FALSE;
		return TRUE;
	}

	step = sp / dist;
	g_flyVx = dx * step;
	g_flyVy = dy * step;
	g_flyPosX += g_flyVx;
	g_flyPosY += g_flyVy;
	g_flyTravelAngle = GdiFlyDirectionAngle(dx, dy);
	g_flyAngleGoal = g_flyTravelAngle;
	g_flyAngleEase = FALSE;

	return FALSE;
}

static void FlyQueueClickLook(HWND chess, const POINT* clientPt)
{
	POINT pt;
	BOOL havePoint = FALSE;

	if (clientPt && chess && IsWindow(chess))
	{
		pt = *clientPt;
		havePoint = ClientToScreen(chess, &pt);
	}
	else if (GetCursorPos(&pt))
	{
		if (chess && IsWindow(chess) && ScreenToClient(chess, &pt))
			ClientToScreen(chess, &pt);
		havePoint = TRUE;
	}

	if (havePoint)
	{
		g_flyClickX = (float)pt.x;
		g_flyClickY = (float)pt.y;
		g_flyClickPending = TRUE;
	}
}

static void FlyNoteBoardClick(HWND chess, const POINT* clientPt)
{
	FlyQueueClickLook(chess, clientPt);
	g_flyBoardClicks++;

	if (!g_flyGameLive)
	{
		g_flyGameLive = TRUE;
		g_flyFloodUnlocked = TRUE;
		Con(L"[chess-sink] clocks UP -- game LIVE (click #%u)", g_flyBoardClicks);
		Con(L"[link] subject sensorimotor: board-walk + think armed");
	}

	g_flyMyTurn = TRUE;
	g_flyMyTurnUntil = GetTickCount() + 9000u;
	g_flyNextThink = GetTickCount();
	Con(L"[clock] White %u:%02u   Black %u:%02u   << FLY TO MOVE", 5 + (g_flyBoardClicks % 20), (g_flyBoardClicks * 7) % 60, 5 + ((g_flyBoardClicks * 3) % 20), (g_flyBoardClicks * 11) % 60);
}

static void FlyPollBoardInput(HWND chess)
{
	static BOOL s_prevDown;
	static DWORD s_liveAfter;
	POINT pt;
	RECT rc;
	BOOL down, leftDown, rightDown, inside;
	WCHAR cap[128];

	if (!chess || !IsWindow(chess))
		return;

	cap[0] = 0;
	GetWindowTextW(chess, cap, 128);
	if (StrStrIW(cap, L"Loading"))
	{
		s_liveAfter = 0;
		return;
	}

	if (!g_flyGameLive)
	{
		if (!s_liveAfter)
			s_liveAfter = GetTickCount() + 2500u;
		else if (GetTickCount() >= s_liveAfter)
		{
			g_flyGameLive = TRUE;
			g_flyFloodUnlocked = TRUE;
			Con(L"[chess-sink] clocks UP -- game LIVE (post-load)");
			Con(L"[link] subject sensorimotor: board-walk armed");
			g_flyNextThink = GetTickCount() + 3000u;
		}
	}

	GetCursorPos(&pt);
	GetWindowRect(chess, &rc);
	inside = PtInRect(&rc, pt);
	leftDown = (GetAsyncKeyState(VK_LBUTTON) & 0x8000) != 0;
	rightDown = (GetAsyncKeyState(VK_RBUTTON) & 0x8000) != 0;
	down = leftDown || rightDown;

	if (down && !s_prevDown)
	{
		if (inside && leftDown && !StrStrIW(cap, L"Loading"))
			FlyNoteBoardClick(chess, NULL);
		else
			FlyQueueClickLook(chess, NULL);
	}

	s_prevDown = down;
}

static void TickGdiFlyOverlay(void)
{
	HWND chess;
	RECT crc, chessSc;
	POINT tl, br;
	int fi, w, h, x, y, cw, ch;
	DWORD t;
	float sx, sy, cogx, cogy, renderAngle;
	BOOL flightMirrorX;

	chess = g_scrollHwnd;
	if (!chess || !IsWindow(chess))
		return;

	FlyLogPanTick();

	if (IsIconic(chess) || !IsWindowVisible(chess))
	{
		if (g_gdiFlyHwnd && IsWindow(g_gdiFlyHwnd))
			ShowWindow(g_gdiFlyHwnd, SW_HIDE);
		return;
	}

	if (!LoadGdiFlyFrames())
		return;

	GetClientRect(chess, &crc);
	cw = crc.right - crc.left;
	ch = crc.bottom - crc.top;
	if (cw < 32 || ch < 32)
		return;

	{
		WCHAR cap[128];
		if (GetWindowTextW(chess, cap, 128) && StrStrIW(cap, L"Loading"))
			return;
	}

	t = GetTickCount();
	{
		static int s_flyFi = -1;
		static int s_flySeqBank = -1;
		static DWORD s_flyFrameDue;

		if (g_gdiFlyN < 1)
			return;

		if (!g_flyRng)
			g_flyRng = t ^ 0xA5A5u;

		if (g_flyBank == FLY_BANK_WALK || g_flyBank == FLY_BANK_FLY)
		{
			if (s_flySeqBank != g_flyBank || s_flyFi < 0 || s_flyFi >= g_gdiFlyN)
			{
				s_flyFi = 0;
				s_flySeqBank = g_flyBank;
				s_flyFrameDue = t;
			}
			if (g_flyMouseIdleLook && g_flyMouseIdleFrames <= 0 && (LONG)(t - g_flyMouseIdleNextPose) >= 0)
				g_flyMouseIdleFrames = 14 + (int)(GdiFlyRand01() * 2.f);

			if (!g_flyThink && (!g_flyMouseIdleLook || g_flyAngleEase || g_flyMouseIdleFrames > 0) && (LONG)(t - s_flyFrameDue) >= 0)
			{
				s_flyFi = (s_flyFi + 1) % g_gdiFlyN;
				s_flyFrameDue = t + (g_flyBank == FLY_BANK_FLY ? 16u : 18u) + (DWORD)(GdiFlyRand01() * (g_flyBank == FLY_BANK_FLY ? 9.f : 22.f));

				if (g_flyMouseIdleLook && g_flyMouseIdleFrames > 0 && --g_flyMouseIdleFrames == 0)
					g_flyMouseIdleNextPose = t + 10000u;
			}
		}
		else if (!g_flyThink)
		{
			int nfi;
			if (g_gdiFlyN <= 1)
				nfi = 0;
			else
			{
				nfi = (int)(GdiFlyRand01() * (float)(g_gdiFlyN - 1));
				if (nfi >= s_flyFi)
					nfi++;
				if (nfi >= g_gdiFlyN)
					nfi = g_gdiFlyN - 1;
				if (nfi < 0)
					nfi = 0;
			}
			s_flyFi = nfi;
			s_flySeqBank = g_flyBank;
		}
		fi = s_flyFi;
		if (!SelectGdiFlyFrame(fi, FALSE))
			return;
	}

	if (!g_flyPosInit)
	{
		g_flyRng = GetTickCount() ^ 0xA5A5u;
		GdiFlyRollLeg();
		GdiFlyBeginWalkScale(0.6f + GdiFlyRand01() * 0.4f);
	}
	else if (g_flyScaleT0 && !g_flyMouseIdleLook && g_flyBank == FLY_BANK_WALK)
	{
		float phase;
		DWORD nowScale = GetTickCount();
		DWORD age = nowScale - g_flyScaleT0;

		if (!g_flyScaleDuration)
			g_flyScaleDuration = GdiFlyScalePeriod();

		if (age >= g_flyScaleDuration)
		{
			g_flyWalkScaleFrom = g_flyWalkScaleTo;
			g_flyWalkScaleTo = 0.6f + GdiFlyRand01() * 0.4f;
			g_flyScaleT0 = nowScale;
			g_flyScaleDuration = GdiFlyScalePeriod();
			age = 0;
		}

		phase = (float)age / (float)g_flyScaleDuration;
		phase = phase * phase * (3.f - 2.f * phase);
		g_flyLegScale = g_flyWalkScaleFrom + (g_flyWalkScaleTo - g_flyWalkScaleFrom) * phase;
	}

	GdiFlyViewSize(cw, ch, &w, &h);
	w = (int)((float)w * g_flyLegScale + 0.5f);
	h = (int)((float)h * g_flyLegScale + 0.5f);
	if (w < 12) w = 12;
	if (h < 8) h = 8;

	tl.x = crc.left;
	tl.y = crc.top;
	br.x = crc.right;
	br.y = crc.bottom;
	ClientToScreen(chess, &tl);
	ClientToScreen(chess, &br);
	chessSc.left = tl.x;
	chessSc.top = tl.y;
	chessSc.right = br.x;
	chessSc.bottom = br.y;

	sx = (float)w / (float)(g_gdiFlySrcW > 0 ? g_gdiFlySrcW : 1);
	sy = (float)h / (float)(g_gdiFlySrcH > 0 ? g_gdiFlySrcH : 1);
	cogx = (g_flyCx && fi < g_gdiFlyN) ? g_flyCx[fi] : (g_gdiFlySrcW * 0.5f);
	cogy = (g_flyCy && fi < g_gdiFlyN) ? g_flyCy[fi] : (g_gdiFlySrcH * 0.5f);

	renderAngle = g_flyTravelAngle;
	flightMirrorX = FALSE;

	if (g_flyBank == FLY_BANK_FLY)
	{
		const float halfPi = 1.57079633f, pi = 3.14159265f;
		if (renderAngle > halfPi)
		{
			renderAngle -= pi;
			flightMirrorX = TRUE;
		}
		else if (renderAngle < -halfPi)
		{
			renderAngle += pi;
			flightMirrorX = TRUE;
		}
	}

	g_gdiFlyMirrorX = flightMirrorX;
	if (g_gdiFlyMirrorX)
		cogx = (float)(g_gdiFlySrcW - 1) - cogx;

	{
		RECT conSc;
		BOOL haveCon;
		float L, R, T, B, margin;
		float cL = 0, cR = 0, cT = 0, cB = 0;
		float wL, wR, wT, wB;
		DWORD nowHop;

		margin = 108.f;
		FlyMarginBox(&chessSc, margin, &L, &R, &T, &B);
		haveCon = FlyConsoleScreenRect(&conSc);
		if (haveCon)
			FlyMarginBox(&conSc, -20.f, &cL, &cR, &cT, &cB);

		if (!g_flyPosInit)
		{
			g_flyRng = GetTickCount() ^ 0xA5A5u;
			GdiFlyRollLeg();
			g_flyPosInit = TRUE;
			g_flyHabitat = 0;
			g_flyTransit = FALSE;
			g_flyThink = FALSE;
			g_flyGameLive = FALSE;
			g_flyMyTurn = FALSE;
			g_flyBoardClicks = 0;

			g_flyPosX = (float)(chessSc.left + chessSc.right) * 0.5f;
			g_flyPosY = (float)(chessSc.top + chessSc.bottom) * 0.5f;
			g_flyRail = 0;
			g_flyVx = 0.f;
			g_flyVy = 0.f;
			g_flyNextHop = GetTickCount() + 400u;

			{
				float cornerX = GdiFlyRand01() < 0.5f ? L : R;
				float cornerY = GdiFlyRand01() < 0.5f ? T : B;
				FlyBeginHopTo(0, cornerX, cornerY);
			}

			g_flyNextFlip = GetTickCount() + 1500u;
			g_flyNextThink = GetTickCount() + 8000u;
			g_flyNextConsoleHop = GetTickCount() + 12000u + (DWORD)(GdiFlyRand01() * 18000.f);
			g_flyResting = FALSE;
			Con(L"[fly] motion: start Chess center scale=0.7..1.0 -- walking with purpose, zero teleports");
		}

		nowHop = GetTickCount();
		{
			POINT mousePos;
			LONG mdx, mdy;
			if (GetCursorPos(&mousePos))
			{
				if (!g_flyMouseSampled)
				{
					g_flyLastMousePos = mousePos;
					g_flyMouseMovedAt = nowHop;
					g_flyMouseSampled = TRUE;
				}
				else
				{
					mdx = mousePos.x - g_flyLastMousePos.x;
					mdy = mousePos.y - g_flyLastMousePos.y;
					if (mdx * mdx + mdy * mdy >= 144)
					{
						g_flyLastMousePos = mousePos;
						g_flyMouseMovedAt = nowHop;
						g_flyMouseIdleExpired = FALSE;
						GdiFlyResumeAfterMouseIdle(nowHop);
					}
				}
			}
		}

		if (g_flyMouseIdleLook && (LONG)(nowHop - g_flyMouseIdleUntil) >= 0)
		{
			g_flyMouseIdleExpired = TRUE;
			GdiFlyResumeAfterMouseIdle(nowHop);
		}

		if (!g_flyMouseIdleLook && !g_flyMouseIdleExpired && g_flyMouseSampled && (DWORD)(nowHop - g_flyMouseMovedAt) >= 10000u && g_flyBank == FLY_BANK_WALK && !g_flyTransit && !g_flyThink && !g_flyResting && !g_flyMyTurn && (g_flyRail || g_flyVx != 0.f || g_flyVy != 0.f))
		{
			g_flySavedVx = g_flyVx;
			g_flySavedVy = g_flyVy;
			g_flyVx = 0.f;
			g_flyVy = 0.f;
			g_flyMouseIdleLook = TRUE;
			g_flyMouseIdleStarted = nowHop;
			g_flyMouseIdleUntil = nowHop + 60000u;
			g_flyMouseIdleNextPose = nowHop + 10000u;
			g_flyMouseIdleFrames = 14 + (int)(GdiFlyRand01() * 2.f);
			g_flyNextHop = g_flyMouseIdleUntil;
			g_flyNextConsoleHop = g_flyMouseIdleUntil;

			GdiFlyFaceToward((float)(chessSc.left + chessSc.right) * 0.5f, (float)(chessSc.top + chessSc.bottom) * 0.5f);

			{
				float tx[4], ty[4], d2[4], best;
				int k, edge;
				tx[0] = L; ty[0] = g_flyPosY < T ? T : (g_flyPosY > B ? B : g_flyPosY);
				tx[1] = R; ty[1] = ty[0];
				tx[2] = g_flyPosX < L ? L : (g_flyPosX > R ? R : g_flyPosX); ty[2] = T;
				tx[3] = tx[2]; ty[3] = B;

				for (k = 0; k < 4; ++k)
				{
					float dx = tx[k] - g_flyPosX, dy = ty[k] - g_flyPosY;
					d2[k] = dx * dx + dy * dy;
				}

				best = d2[0];
				edge = 0;
				for (k = 1; k < 4; ++k)
					if (d2[k] < best)
					{
						best = d2[k];
						edge = k;
					}

				if (best > 80.f * 80.f)
				{
					g_flySavedVx = 0.f;
					g_flySavedVy = 0.f;
					FlyBeginHopTo(0, tx[edge], ty[edge]);
				}
			}
		}

		if (!g_flyMouseIdleLook && g_flyLogFlyPending && haveCon && g_flyLogPanArriving && g_flyLogFlyEdge == g_flyLogDockEdge)
		{
			float tx, ty;
			if (FlyChooseLogLanding(chess, cL, cR, cT, cB, &tx, &ty))
			{
				FlyBeginHopTo(1, tx, ty);
				g_flyLogFlyPending = FALSE;
				g_flyNextHop = nowHop + 4000u;
				g_flyNextConsoleHop = nowHop + 20000u + (DWORD)(GdiFlyRand01() * 25000.f);
			}
		}

		if (!g_flyNextConsoleHop)
			g_flyNextConsoleHop = nowHop + 12000u + (DWORD)(GdiFlyRand01() * 18000.f);

		if (!g_flyMouseIdleLook && haveCon && nowHop >= g_flyNextConsoleHop)
		{
			HWND log = FlyFindConsoleHwnd();
			if (log && IsWindowVisible(log) && !IsIconic(log) && !g_flyTransit && !g_flyThink && !g_flyMyTurn)
			{
				BOOL inside = g_flyPosX >= (float)conSc.left && g_flyPosX <= (float)conSc.right && g_flyPosY >= (float)conSc.top && g_flyPosY <= (float)conSc.bottom;
				int logRail = FlyRectOutsideRail(cL, cR, cT, cB, (float)chessSc.left, (float)chessSc.right, (float)chessSc.top, (float)chessSc.bottom);

				if (!inside && logRail != 0)
				{
					float tx, ty;
					if (FlyChooseLogLanding(chess, cL, cR, cT, cB, &tx, &ty))
					{
						FlyBeginHopTo(1, tx, ty);
						g_flyNextHop = nowHop + 4000u;
					}
				}
			}
			g_flyNextConsoleHop = nowHop + 20000u + (DWORD)(GdiFlyRand01() * 25000.f);
		}

		FlyPollBoardInput(chess);
		if (g_flyMyTurn && nowHop >= g_flyMyTurnUntil)
			g_flyMyTurn = FALSE;

		if (g_flyClickPending)
		{
			g_flyTransit = FALSE;
			if (g_flyRail == 0 || (g_flyPosX >= (float)chessSc.left && g_flyPosX <= (float)chessSc.right && g_flyPosY >= (float)chessSc.top && g_flyPosY <= (float)chessSc.bottom))
				FlySnapToNearestEdge(L, R, T, B, FALSE);

			g_flySavedVx = g_flyVx;
			g_flySavedVy = g_flyVy;

			{
				float dx = g_flyClickX - g_flyPosX;
				float dy = g_flyClickY - g_flyPosY;

				if (dx * dx + dy * dy >= 0.01f)
				{
					float angle = GdiFlyAtan2(dy, dx);
					g_flyLookAngle = angle;
					g_flyAngleGoal = angle;
					g_flyTravelAngle = angle;
					g_flyAngleEase = FALSE;
				}
			}

			g_flyVx = 0.f;
			g_flyVy = 0.f;
			g_flyThink = TRUE;
			g_flyThinkUntil = nowHop + 2500u + (DWORD)(GdiFlyRand01() * 2500.f);
			g_flyResting = FALSE;
			g_flyClickPending = FALSE;
		}

		if (g_flyHabitat == 1 && haveCon)
		{
			wL = cL; wR = cR; wT = cT; wB = cB;
		}
		else
		{
			wL = L; wR = R; wT = T; wB = B;
			if (g_flyHabitat != 0 && !haveCon)
				g_flyHabitat = 0;
		}

		if (g_flyTransit && !g_flyThink)
		{
			if (FlyTransitTick(chess, 48.f))
			{
				GdiFlySetBank(FLY_BANK_WALK);
				GdiFlyBeginWalkScale(1.0f);
				g_flyHabitat = g_flyTransitDest;

				if (g_flyHabitat == 1)
				{
					if (!g_flyFloodUnlocked)
					{
						g_flyFloodUnlocked = TRUE;
						g_flyNeedBootFlood = TRUE;
						Con(L"[link] console habitat -- telemetry unlocked");
					}
					if (haveCon) FlyLandContinue(cL, cR, cT, cB, TRUE);
					else FlyLandContinue(L, R, T, B, FALSE);
				}
				else
					FlyLandContinue(L, R, T, B, FALSE);

				if (g_flyMouseIdleLook)
				{
					g_flyMouseIdleFrames = 14 + (int)(GdiFlyRand01() * 2.f);
					g_flyMouseIdleNextPose = nowHop + 10000u;
					GdiFlyFaceToward((float)(chessSc.left + chessSc.right) * 0.5f, (float)(chessSc.top + chessSc.bottom) * 0.5f);
				}

				g_flyNextHop = nowHop + 5000u + (DWORD)(GdiFlyRand01() * 9000.f);
				g_flyNextFlip = nowHop + 2500u + (DWORD)(GdiFlyRand01() * 6500.f);
			}
		}
		else if (g_flyMouseIdleLook)
		{
			g_flyVx = 0.f;
			g_flyVy = 0.f;
		}
		else if (g_flyResting && nowHop < g_flyRestUntil && !g_flyMyTurn)
		{
			g_flyVx = 0.f;
			g_flyVy = 0.f;
		}
		else if (g_flyThink)
		{
			g_flyVx = 0.f;
			g_flyVy = 0.f;
			if (nowHop >= g_flyThinkUntil)
			{
				g_flyThink = FALSE;
				if (g_flyMyTurn)
				{
					Con(L"[clock] fly move committed -- clocks tick");
					g_flyMyTurn = FALSE;
				}

				if (!g_flyTransit)
				{
					GdiFlyRollLeg();
					if (g_flyRail)
						GdiFlyResumeAlongRail();
					else
					{
						g_flySavedVx = g_flyApproachVx;
						g_flySavedVy = g_flyApproachVy;
						GdiFlyResumeAlongRail();
						if (g_flyVx == 0.f && g_flyVy == 0.f)
							GdiFlyPickCardinalDir();
						GdiFlyFaceTravel();
					}
				}
				g_flyNextThink = nowHop + 6000u + (DWORD)(GdiFlyRand01() * 10000.f);
			}
		}
		else
		{
			g_flyResting = FALSE;
			if (nowHop >= g_flyNextHop)
			{
				if (!g_flyMyTurn && GdiFlyRand01() < 0.28f)
				{
					g_flyResting = TRUE;
					g_flyRestUntil = nowHop + 5000u + (DWORD)(GdiFlyRand01() * 9000.f);
					g_flyNextHop = g_flyRestUntil;
					g_flyNextFlip = g_flyRestUntil;
					g_flyVx = 0.f;
					g_flyVy = 0.f;
				}
				else
				{
					BOOL doFly = GdiFlyRand01() < 0.10f;
					if (doFly)
					{
						float tx, ty;
						int hab;
						FlyPickRandomTarget(chess, haveCon, L, R, T, B, (float)chessSc.left, (float)chessSc.right, (float)chessSc.top, (float)chessSc.bottom, cL, cR, cT, cB, &tx, &ty, &hab);
						if (!haveCon) hab = 0;
						FlyBeginHopTo(hab, tx, ty);
						FlyLogArmPanNearLanding(chess, hab == 1);
						g_flyNextHop = nowHop + 6000u + (DWORD)(GdiFlyRand01() * 10000.f);
					}
					else
					{
						float sp;
						GdiFlyRollLeg();
						sp = g_flyLegSpeed > 0.5f ? g_flyLegSpeed : 3.f;

						if (g_flyRail == 1 || g_flyRail == 2)
						{
							g_flyVy = 0.f;
							if (g_flyVx != 0.f && GdiFlyRand01() < 0.5f) g_flyVx = (g_flyVx > 0.f) ? -sp : sp;
							else if (g_flyVx != 0.f) g_flyVx = (g_flyVx > 0.f) ? sp : -sp;
							else GdiFlyPickHorizontal();
						}
						else if (g_flyRail == 3 || g_flyRail == 4)
						{
							g_flyVx = 0.f;
							if (g_flyVy != 0.f && GdiFlyRand01() < 0.5f) g_flyVy = (g_flyVy > 0.f) ? -sp : sp;
							else if (g_flyVy != 0.f) g_flyVy = (g_flyVy > 0.f) ? sp : -sp;
							else GdiFlyPickVertical();
						}
						else
						{
							if (g_flyVx != 0.f) g_flyVx = (GdiFlyRand01() < 0.5f) ? -sp : ((g_flyVx > 0.f) ? sp : -sp);
							else if (g_flyVy != 0.f) g_flyVy = (GdiFlyRand01() < 0.5f) ? -sp : ((g_flyVy > 0.f) ? sp : -sp);
							else GdiFlyPickCardinalDir();
						}

						GdiFlyFaceTravel();
						g_flyNextHop = nowHop + 4000u + (DWORD)(GdiFlyRand01() * 8000.f);
					}
				}
			}

			if ((g_flyRail || g_flyVx != 0.f || g_flyVy != 0.f) && nowHop >= g_flyNextFlip && GdiFlyRand01() < 0.55f)
			{
				if (g_flyVx != 0.f) g_flyVx = -g_flyVx;
				else if (g_flyVy != 0.f) g_flyVy = -g_flyVy;
				GdiFlyFaceTravel();
				g_flyNextFlip = nowHop + 2500u + (DWORD)(GdiFlyRand01() * 6500.f);
			}
			else if (nowHop >= g_flyNextFlip)
			{
				g_flyNextFlip = nowHop + 1800u + (DWORD)(GdiFlyRand01() * 4500.f);
			}

			if (g_flyMyTurn && !g_flyTransit)
			{
				float boardCx, boardCy;
				g_flySavedVx = g_flyVx;
				g_flySavedVy = g_flyVy;
				g_flyVx = 0.f;
				g_flyVy = 0.f;
				boardCx = (float)(chessSc.left + chessSc.right) * 0.5f;
				boardCy = (float)(chessSc.top + chessSc.bottom) * 0.5f;
				GdiFlyFaceToward(boardCx, boardCy);
				g_flyThink = TRUE;
				g_flyThinkUntil = nowHop + 2200u + (DWORD)(GdiFlyRand01() * 1800.f);
				Con(L"[think] FLY TO MOVE -- evaluating principal variation...");
				Con(L"[clock] thinking... White clock RUNNING");
			}

			if (!g_flyThink && !g_flyMouseIdleLook && !g_flyTransit && !g_flyResting)
			{
				if (g_flyVx == 0.f && g_flyVy == 0.f)
				{
					GdiFlyRollLeg();
					if (g_flyRail) GdiFlyResumeAlongRail();
					else GdiFlyPickCardinalDir();
					GdiFlyFaceTravel();
				}

				g_flyPosX += g_flyVx;
				g_flyPosY += g_flyVy;

				{
					BOOL hitL = FALSE, hitR = FALSE, hitT = FALSE, hitB = FALSE;

					if (g_flyRail == 1 || g_flyRail == 2)
					{
						if (g_flyPosX < wL) { g_flyPosX = wL; hitL = TRUE; }
						if (g_flyPosX > wR) { g_flyPosX = wR; hitR = TRUE; }
					}
					else if (g_flyRail == 3 || g_flyRail == 4)
					{
						if (g_flyPosY < wT) { g_flyPosY = wT; hitT = TRUE; }
						if (g_flyPosY > wB) { g_flyPosY = wB; hitB = TRUE; }
					}
					else
					{
						if (g_flyPosX < wL) { g_flyPosX = wL; hitL = TRUE; }
						if (g_flyPosX > wR) { g_flyPosX = wR; hitR = TRUE; }
						if (g_flyPosY < wT) { g_flyPosY = wT; hitT = TRUE; }
						if (g_flyPosY > wB) { g_flyPosY = wB; hitB = TRUE; }
					}

					if (hitL || hitR || hitT || hitB)
					{
						int prevRail = g_flyRail;
						float sp = g_flyLegSpeed > 0.5f ? g_flyLegSpeed : 3.f;
						float keepVx = g_flyVx, keepVy = g_flyVy;
						GdiFlyRollLeg();
						sp = g_flyLegSpeed > 0.5f ? g_flyLegSpeed : sp;
						g_flyPerp = 0.f;

						if (prevRail == 0)
						{
							if ((hitL || hitR) && !(hitT || hitB))
							{
								g_flyRail = hitR ? 4 : 3;
								g_flyVx = 0.f;
								if (keepVy > 0.1f || keepVy < -0.1f) g_flyVy = (keepVy > 0.f) ? sp : -sp;
								else g_flyVy = (GdiFlyRand01() < 0.5f) ? sp : -sp;
							}
							else if ((hitT || hitB) && !(hitL || hitR))
							{
								g_flyRail = hitB ? 2 : 1;
								g_flyVy = 0.f;
								if (keepVx > 0.1f || keepVx < -0.1f) g_flyVx = (keepVx > 0.f) ? sp : -sp;
								else g_flyVx = (GdiFlyRand01() < 0.5f) ? sp : -sp;
							}
							else if (hitL || hitR)
							{
								g_flyRail = hitR ? 4 : 3;
								g_flyPosX = hitR ? wR : wL;
								g_flyVx = 0.f;
								g_flyVy = (keepVy >= 0.f) ? sp : -sp;
							}
							else
							{
								g_flyRail = hitB ? 2 : 1;
								g_flyPosY = hitB ? wB : wT;
								g_flyVy = 0.f;
								g_flyVx = (keepVx >= 0.f) ? sp : -sp;
							}
							GdiFlyFaceTravel();
						}
						else if (GdiFlyRand01() < 0.35f)
						{
							if (hitL || hitR)
							{
								g_flyVx = hitL ? sp : -sp;
								g_flyVy = 0.f;
								g_flyRail = prevRail;
							}
							else
							{
								g_flyVy = hitT ? sp : -sp;
								g_flyVx = 0.f;
								g_flyRail = prevRail;
							}
							GdiFlyFaceTravel();
						}
						else if (hitL || hitR)
						{
							g_flyRail = hitR ? 4 : 3;
							g_flyPosX = hitR ? wR : wL;
							g_flyVx = 0.f;
							if (prevRail == 1) g_flyVy = sp;
							else if (prevRail == 2) g_flyVy = -sp;
							else g_flyVy = (GdiFlyRand01() < 0.5f) ? sp : -sp;
							GdiFlyFaceTravel();
						}
						else
						{
							g_flyRail = hitB ? 2 : 1;
							g_flyPosY = hitB ? wB : wT;
							g_flyVy = 0.f;
							if (prevRail == 4) g_flyVx = (GdiFlyRand01() < 0.5f) ? -sp : sp;
							else if (prevRail == 3) g_flyVx = (GdiFlyRand01() < 0.5f) ? sp : -sp;
							else g_flyVx = (GdiFlyRand01() < 0.5f) ? -sp : sp;
							GdiFlyFaceTravel();
						}
					}
				}

				if (g_flyRail)
				{
					g_flyPerp += (GdiFlyRand01() - 0.5f) * 3.f;
					if (g_flyPerp > 24.f) g_flyPerp = 24.f;
					if (g_flyPerp < -24.f) g_flyPerp = -24.f;

					switch (g_flyRail)
					{
					case 1: g_flyPosY = wT + g_flyPerp; break;
					case 2: g_flyPosY = wB + g_flyPerp; break;
					case 3: g_flyPosX = wL + g_flyPerp; break;
					case 4: g_flyPosX = wR + g_flyPerp; break;
					}
				}
			}
		}

		GdiFlyAngleEaseTick();

		{
			BOOL flood = g_flyFloodUnlocked || g_flyBootDone || (g_flyConQCount > 0);
			g_flyFlooding = flood;
			g_flyWasFlooding = flood;
		}

		x = (int)(g_flyPosX - cogx * sx);
		y = (int)(g_flyPosY - cogy * sy);
	}

	if (!g_gdiFlyClass)
	{
		/*
		 * We don't even need a custom WndProc. ULW_ALPHA takes care of drawing,
		 * and DefWindowProcW takes care of shutting up Windows when it whines.
		 */
		WNDCLASSW wc;
		CustomZeroMem(&wc, sizeof(wc));
		wc.lpfnWndProc = DefWindowProcW;
		wc.hInstance = GetModuleHandleW(NULL);
		wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
		wc.lpszClassName = L"Chess3DGdiFly";

		if (!RegisterClassW(&wc) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
		{
			return;
		}
		g_gdiFlyClass = TRUE;
	}

	if (!g_gdiFlyHwnd || !IsWindow(g_gdiFlyHwnd))
	{
		g_gdiFlyHwnd = CreateWindowExW(WS_EX_TOOLWINDOW | WS_EX_LAYERED | WS_EX_NOACTIVATE | WS_EX_TRANSPARENT, L"Chess3DGdiFly", L"", WS_POPUP, x, y, w, h, chess, NULL, GetModuleHandleW(NULL), NULL);
		if (!g_gdiFlyHwnd)
		{
			return;
		}
		ShowWindow(g_gdiFlyHwnd, SW_SHOWNOACTIVATE);
		FlyAnimEnsureThread();
		Con(L"[GDI]fly overlay hwnd=%p owned-by-chess + ULW_ALPHA", g_gdiFlyHwnd);
	}
	else if (!IsWindowVisible(g_gdiFlyHwnd))
	{
		ShowWindow(g_gdiFlyHwnd, SW_SHOWNOACTIVATE);
	}

	{
		float ca, sa, ocx, ocy;
		int ow, oh, px, py;

		g_gdiFlyAngle = renderAngle;
		g_gdiFlyContentW = w;
		g_gdiFlyContentH = h;
		g_gdiFlyRotCx = cogx * sx;
		g_gdiFlyRotCy = cogy * sy;

		ca = GdiFlyCos(g_gdiFlyAngle);
		sa = GdiFlySin(g_gdiFlyAngle);

		if (ca < 0.f) ca = -ca;
		if (sa < 0.f) sa = -sa;

		ow = (int)((float)w * ca + (float)h * sa) + 2;
		oh = (int)((float)w * sa + (float)h * ca) + 2;

		if (ow < w) ow = w;
		if (oh < h) oh = h;

		ow += FLY_SHADOW_PAD * 2;
		oh += FLY_SHADOW_PAD * 2;
		ocx = (float)(ow - FLY_SHADOW_PAD * 2) * 0.5f;
		ocy = (float)(oh - FLY_SHADOW_PAD * 2) * 0.5f;

		px = (int)(g_flyPosX - ocx);
		py = (int)(g_flyPosY - ocy);

		GdiFlyPresent(g_gdiFlyHwnd, px, py, ow, oh);
		FlyApplyOwnerAndZ(chess);
	}
}

static void ApplyGuestDirectories(LPCWSTR pszExe, LPCWSTR pszOrig)
{
	WCHAR dir[MAX_PATH], orig[MAX_PATH], enus[MAX_PATH];

	if (!pszExe || !pszExe[0])
		return;

	SetDefaultDllDirectories(LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_USER_DIRS);

	lstrcpynW(orig, pszOrig && pszOrig[0] ? pszOrig : pszExe, MAX_PATH);
	PathRemoveFileSpecW(orig);

	lstrcpynW(dir, pszExe, MAX_PATH);
	PathRemoveFileSpecW(dir);

	if (g_game.path[0])
	{
		AddDllDirectory(g_game.path);
		wsprintfW(enus, L"%s\\en-us", g_game.path);
		AddDllDirectory(enus);
	}
	if (orig[0])
	{
		SetCurrentDirectoryW(orig);
		SetDllDirectoryW(orig);
		AddDllDirectory(orig);
		wsprintfW(enus, L"%s\\en-us", orig);
		AddDllDirectory(enus);
	}
	if (dir[0] && lstrcmpiW(dir, orig) != 0)
	{
		AddDllDirectory(dir);
		wsprintfW(enus, L"%s\\en-us", dir);
		AddDllDirectory(enus);
	}
}

static BOOL IsOleHelperName(LPCWSTR s)
{
	if (!s || ((ULONG_PTR)s & ~0xFFFFULL) == 0)
		return TRUE;
	return StrStrW(s, L"OleMainThread") != NULL;
}

static BOOL IsHelperWnd(HWND hwnd)
{
	WCHAR cls[64], name[64];

	if (!hwnd)
		return TRUE;

	cls[0] = 0;
	name[0] = 0;
	GetClassNameW(hwnd, cls, 64);
	GetWindowTextW(hwnd, name, 64);

	return IsOleHelperName(cls) || IsOleHelperName(name);
}

static BOOL IsTopGuestWnd(HWND hwnd)
{
	if (!hwnd || !IsWindow(hwnd) || IsHelperWnd(hwnd))
		return FALSE;
	if (GetWindow(hwnd, GW_OWNER))
		return FALSE;
	if (GetAncestor(hwnd, GA_ROOT) != hwnd)
		return FALSE;
	if (GetWindowLongPtrW(hwnd, GWL_STYLE) & WS_CHILD)
		return FALSE;

	return TRUE;
}

static void TryPatchDrosophilaMenu(HWND hwnd)
{
	HMENU bar, game;
	int i, j, n, m;
	WCHAR raw[96], plain[96];
	UINT id;
	BOOL renamed = FALSE, removed = FALSE;

	if (GetCurrentThreadId() != g_game.tid || g_game.menuAtt || !hwnd)
		return;

	bar = GetMenu(hwnd);
	if (!bar)
		return;

	n = GetMenuItemCount(bar);
	for (i = 0; i < n; i++)
	{
		raw[0] = 0;
		GetMenuStringW(bar, i, raw, 96, MF_BYPOSITION);
		StripAmp(plain, raw);

		if (lstrcmpiW(plain, L"Game") != 0)
			continue;

		game = GetSubMenu(bar, i);
		if (!game)
			return;

		m = GetMenuItemCount(game);
		for (j = m - 1; j >= 0; j--)
		{
			raw[0] = 0;
			GetMenuStringW(game, j, raw, 96, MF_BYPOSITION);
			StripAmp(plain, raw);

			if (StrStrIW(plain, L"against human") || StrStrIW(raw, L"\tF3"))
			{
				if (DeleteMenu(game, j, MF_BYPOSITION))
					removed = TRUE;
				continue;
			}
			if (StrStrIW(plain, L"against computer") || StrStrIW(raw, L"\tF2"))
			{
				id = GetMenuItemID(game, j);
				if (id == (UINT)-1 || id == 0)
					continue;
				if (ModifyMenuW(game, j, MF_BYPOSITION | MF_STRING, id, L"New game against Drosophila"))
					renamed = TRUE;
			}
		}
		if (renamed || removed)
		{
			DrawMenuBar(hwnd);
			g_game.menuAtt = TRUE;
			Con(L"[Game]menu: F2->Drosophila, F3 removed");
		}
		return;
	}
}

static void TrySetGuestIcon(HWND hwnd)
{
	static HICON g_appIconBig;
	static HICON g_appIconSm;

	UINT n;
	if (GetCurrentThreadId() != g_game.tid || g_game.iconAtt || !hwnd || !g_game.path[0])
		return;

	if (!g_appIconBig && !g_appIconSm)
	{
		n = ExtractIconExW(g_game.path, 0, &g_appIconBig, &g_appIconSm, 1);
		if (!n || (!g_appIconBig && !g_appIconSm))
		{
			g_appIconBig = ExtractIconW(GetModuleHandleW(NULL), g_game.path, 0);
			g_appIconSm = g_appIconBig;
		}
	}

	if (g_appIconBig)
		SendMessageW(hwnd, WM_SETICON, ICON_BIG, (LPARAM)g_appIconBig);
	if (g_appIconSm)
		SendMessageW(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)g_appIconSm);
	else if (g_appIconBig)
		SendMessageW(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)g_appIconBig);

	if (g_appIconBig || g_appIconSm)
	{
		g_game.iconAtt = TRUE;
	}
}

static void BindGuestWindow(HWND hwnd)
{
	if (!IsTopGuestWnd(hwnd) || GetCurrentThreadId() != g_game.tid)
		return;

	if (!g_game.hwnd)
		g_game.hwnd = hwnd;

	if (g_game.hwnd == hwnd)
	{
		g_scrollHwnd = hwnd;
		TryPatchDrosophilaMenu(hwnd);
		TrySetGuestIcon(hwnd);
	}
}

static void StampGuestWindow(HWND hwnd)
{
	if (GetCurrentThreadId() != g_game.tid)
		return;

	if (!g_game.hwnd)
		BindGuestWindow(hwnd);

	if (!g_game.hwnd || g_game.hwnd != hwnd)
		return;

	SetWindowTextW(hwnd, L"FlyChess: play against Drosophila");
	TryPatchDrosophilaMenu(hwnd);
	TrySetGuestIcon(hwnd);
}

static BOOL CALLBACK EnumPatchAgainstComputer(HWND hwnd, LPARAM lp)
{
	WCHAR t[256];
	(void)lp;

	if (!GetWindowTextW(hwnd, t, 256) || !t[0])
		return TRUE;
	if (!StrStrIW(t, L"against computer"))
		return TRUE;

	if (StrStrIW(t, L"as white"))
		SetWindowTextW(hwnd, L"Play against Drosophila as white");
	else if (StrStrIW(t, L"as black"))
		SetWindowTextW(hwnd, L"Play against Drosophila as black");
	else
	{
		WCHAR out[288], * p, * rest;
		int pre;

		p = StrStrIW(t, L"against computer");
		if (!p)
			return TRUE;

		pre = (int)(p - t);
		if (pre < 0 || pre >= 200)
			return TRUE;

		rest = p + 16;
		if (pre > 0)
			lstrcpynW(out, t, pre + 1);
		else
			out[0] = 0;

		lstrcatW(out, L"against Drosophila");
		lstrcatW(out, rest);
		SetWindowTextW(hwnd, out);
	}
	return TRUE;
}

static void TryPatchOptionsDialog(HWND hwnd)
{
	WCHAR cap[96], cls[64];
	DWORD style;

	if (!hwnd || !IsWindow(hwnd))
		return;

	style = (DWORD)GetWindowLongPtrW(hwnd, GWL_STYLE);
	if (style & WS_CHILD)
		return;

	cls[0] = 0;
	GetClassNameW(hwnd, cls, 64);
	cap[0] = 0;
	GetWindowTextW(hwnd, cap, 96);

	if (lstrcmpW(cls, L"#32770") != 0 && !StrStrIW(cap, L"Option"))
		return;

	EnumChildWindows(hwnd, EnumPatchAgainstComputer, 0);
}

static LRESULT CALLBACK CallWndRetProc(int code, WPARAM wParam, LPARAM lParam)
{
	CWPRETSTRUCT* msg;
	(void)wParam;

	if (code >= 0 && lParam)
	{
		msg = (CWPRETSTRUCT*)lParam;
		if (msg->message == WM_NCCREATE || msg->message == WM_CREATE)
			BindGuestWindow(msg->hwnd);
		if (msg->message == WM_CREATE || msg->message == WM_SETTEXT || msg->message == WM_SHOWWINDOW)
			StampGuestWindow(msg->hwnd);
		if (msg->message == WM_INITDIALOG || msg->message == WM_SHOWWINDOW)
			TryPatchOptionsDialog(msg->hwnd);
	}
	return CallNextHookEx(NULL, code, wParam, lParam);
}

static LRESULT CALLBACK GetMsgProc(int code, WPARAM wParam, LPARAM lParam)
{
	if (code >= 0 && wParam == PM_REMOVE && lParam)
	{
		if (GetCurrentThreadId() == g_game.tid && g_game.hwnd)
		{
			g_scrollHwnd = g_game.hwnd;
			FlyAnimEnsureThread();
		}
	}
	return CallNextHookEx(NULL, code, wParam, lParam);
}

static LRESULT CALLBACK CbtProc(int code, WPARAM wParam, LPARAM lParam)
{
	if (code == HCBT_CREATEWND)
	{
		CBT_CREATEWNDW* cw = (CBT_CREATEWNDW*)lParam;
		if (cw && cw->lpcs && !cw->lpcs->hwndParent && !(cw->lpcs->style & WS_CHILD) && !IsOleHelperName(cw->lpcs->lpszClass) && !IsOleHelperName(cw->lpcs->lpszName))
		{
			if (GetCurrentThreadId() == g_game.tid && !g_game.hwnd)
				g_game.hwnd = (HWND)wParam;
		}
	}
	else if (code == HCBT_DESTROYWND)
	{
		if ((HWND)wParam == g_game.hwnd)
		{
			g_game.hidden = TRUE;
			g_game.hwnd = NULL;
			if (g_gdiFlyHwnd && IsWindow(g_gdiFlyHwnd))
			{
				DestroyWindow(g_gdiFlyHwnd);
				g_gdiFlyHwnd = NULL;
			}
			if (g_menuEvent)
				SetEvent(g_menuEvent);
		}
	}
	return CallNextHookEx(NULL, code, wParam, lParam);
}

static void InstallGuestHooks(void)
{
	g_game.hookCbt = SetWindowsHookExW(WH_CBT, CbtProc, NULL, g_game.tid);
	g_game.hookCwp = SetWindowsHookExW(WH_CALLWNDPROCRET, CallWndRetProc, NULL, g_game.tid);
	g_game.hookGet = SetWindowsHookExW(WH_GETMESSAGE, GetMsgProc, NULL, g_game.tid);
}

static BOOL CALLBACK FindThreadTop(HWND hwnd, LPARAM lp)
{
	HWND* out = (HWND*)lp;
	if (!*out && GetAncestor(hwnd, GA_ROOT) == hwnd && !IsHelperWnd(hwnd))
		*out = hwnd;
	return TRUE;
}

static BOOL WaitForGameWindow(void)
{
	DWORD t0 = GetTickCount();
	for (;;)
	{
		if (g_game.hwnd && IsWindow(g_game.hwnd))
		{
			if (IsHelperWnd(g_game.hwnd))
			{
				g_game.hwnd = NULL;
				continue;
			}
			return TRUE;
		}
		if (GetTickCount() - t0 >= 15000)
			break;
		Sleep(50);
	}

	HWND hwnd = NULL;
	if (g_game.tid)
		EnumThreadWindows(g_game.tid, FindThreadTop, (LPARAM)&hwnd);
	if (hwnd)
		return TRUE;

	return FALSE;
}

static DWORD WINAPI GuestThread(LPVOID p)
{
	(void)p;
	WCHAR cmd[MAX_PATH + 4];
	UINT code = 0;
	MSG msg;
	g_game.tid = GetCurrentThreadId();

	PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
	InstallGuestHooks();

	ApplyGuestDirectories(g_game.path, g_game.path);
	wsprintfW(cmd, L"\"%s\"", g_game.path);

	if (g_pfnRun)
		code = g_pfnRun(g_game.path, cmd);

	return code;
}

static BOOL SpawnGame(void)
{
	g_game.thread = CreateThread(NULL, 0, GuestThread, NULL, 0, &g_game.tid);
	if (!g_game.thread)
		return FALSE;

	WaitForGameWindow();
	return TRUE;
}

static void Chess3DExit(UINT code)
{
	ExitProcess(code);
}

// --- Dynamic Moddable System Text Engine ---
static DWORD g_bsLast;
static UINT g_bsIdx;
static UINT g_bsStep;

#define MAX_SYS_BLOCKS 2048
#define MAX_LINES_PER_BLOCK 8

struct SysBlock
{
	WCHAR lines[MAX_LINES_PER_BLOCK][FLY_CONQ_LEN];
	int numLines;
};

struct TextBank
{
	int indices[512];
	int count;
	int playedCount;
};

static SysBlock g_sysBlocks[MAX_SYS_BLOCKS];
static int g_numSysBlocks = 0;
static TextBank g_bankSystem;
static TextBank g_bankLang[16];
static int g_numLangBanks = 0;
static int g_curLangBank = 0;
static BOOL g_sysLoaded = FALSE;

/* Our over-engineered manual string formatter because std::regex is bloated nonsense */
static void FormatFlyString(const WCHAR* in, WCHAR* out, int maxLen)
{
	int o = 0;
	while (*in && o < maxLen - 1)
	{
		if (*in == L'{')
		{
			in++;
			WCHAR token[256];
			int t = 0;

			while (*in && *in != L'}' && t < 255)
				token[t++] = *in++;

			token[t] = 0;
			if (*in == L'}')
				in++;

			if (lstrcmpiW(token, L"sq") == 0)
			{
				o += wsprintfW(out + o, L"%c%d", L'a' + (int)(GdiFlyRand01() * 8.f), 1 + (int)(GdiFlyRand01() * 8.f));
			}
			else if (lstrcmpiW(token, L"ptr") == 0)
			{
				DWORD ptrVal = (g_flyRng * 1664525u + 1013904223u) ^ GetTickCount();
				o += wsprintfW(out + o, L"0x%08X", ptrVal);
			}
			else if (StrStrW(token, L"..."))
			{
				WCHAR* dots = StrStrW(token, L"...");
				*dots = 0;
				WCHAR* pMin = token;
				WCHAR* pMax = dots + 3;

				if (StrStrW(pMin, L".") || StrStrW(pMax, L"."))
				{
					float fMin = CustomWtof(pMin);
					float fMax = CustomWtof(pMax);
					float r = fMin + GdiFlyRand01() * (fMax - fMin);
					int ipart = (int)r;
					int fpart = (int)((r - (float)ipart) * 100.f);
					if (fpart < 0) fpart = -fpart;
					o += wsprintfW(out + o, L"%d.%02d", ipart, fpart);
				}
				else
				{
					int iMin = (int)CustomWtof(pMin);
					int iMax = (int)CustomWtof(pMax);
					int r = iMin + (int)(GdiFlyRand01() * (float)(iMax - iMin + 1));
					o += wsprintfW(out + o, L"%d", r);
				}
			}
			else if (StrStrW(token, L"|"))
			{
				int choices = 1;
				for (int i = 0; token[i]; i++)
					if (token[i] == L'|')
						choices++;

				int pick = (int)(GdiFlyRand01() * (float)choices);
				if (pick >= choices)
					pick = choices - 1;

				WCHAR* p = token;
				for (int cur = 0; cur < pick && p; cur++)
				{
					p = StrStrW(p, L"|");
					if (p)
						p++;
				}
				if (p)
				{
					WCHAR* end = StrStrW(p, L"|");
					if (end)
						*end = 0;
					while (*p && o < maxLen - 1)
						out[o++] = *p++;
				}
			}
			else
			{
				WCHAR* pt = token;
				while (*pt && o < maxLen - 1)
					out[o++] = *pt++;
			}
		}
		else
		{
			out[o++] = *in++;
		}
	}
	out[o] = 0;
}

static void FlyBsBoot(void)
{
	BYTE* data = NULL;
	DWORD size = 0;

	EnsureFlyConsole();
	if (!FlyPackReadEntry(L"msg/BOOT.txt", &data, &size) && !FlyPackReadEntry(L"MSG/BOOT.TXT", &data, &size))
		return;

	int wlen = MultiByteToWideChar(CP_UTF8, 0, (LPCCH)data, size, NULL, 0);
	if (wlen > 0)
	{
		WCHAR* wbuf = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, (wlen + 1) * sizeof(WCHAR));
		if (wbuf)
		{
			MultiByteToWideChar(CP_UTF8, 0, (LPCCH)data, size, wbuf, wlen);
			wbuf[wlen] = 0;
			WCHAR* p = wbuf;

			while (*p)
			{
				while (*p == L'\r' || *p == L'\n') p++;
				if (!*p) break;

				WCHAR* start = p;
				while (*p && *p != L'\r' && *p != L'\n') p++;

				int len = (int)(p - start);
				if (len > 0 && len < FLY_CONQ_LEN - 1)
				{
					WCHAR line[FLY_CONQ_LEN];
					lstrcpynW(line, start, len + 1);
					WCHAR formatted[FLY_CONQ_LEN];
					FormatFlyString(line, formatted, FLY_CONQ_LEN);
					ConQ(L"%s", formatted);
				}
			}
			HeapFree(GetProcessHeap(), 0, wbuf);
		}
	}
	HeapFree(GetProcessHeap(), 0, data);
}

static void ShuffleBank(TextBank* bank)
{
	if (!bank || bank->count <= 1)
		return;

	/* Fisher-Yates shuffle. Because even chaotic code needs proper algorithms. */
	for (int i = bank->count - 1; i > 0; i--)
	{
		int j = (int)(GdiFlyRand01() * (float)(i + 1));
		if (j > i)
			j = i;
		int tmp = bank->indices[i];
		bank->indices[i] = bank->indices[j];
		bank->indices[j] = tmp;
	}
	bank->playedCount = 0;
}

static void LoadBlocksFromFile(LPCWSTR path, TextBank* bank)
{
	BYTE* data = NULL;
	DWORD size = 0;

	if (!FlyPackReadEntry(path, &data, &size))
		return;

	int wlen = MultiByteToWideChar(CP_UTF8, 0, (LPCCH)data, size, NULL, 0);
	if (wlen > 0)
	{
		WCHAR* wbuf = (WCHAR*)HeapAlloc(GetProcessHeap(), 0, (wlen + 1) * sizeof(WCHAR));
		if (wbuf)
		{
			MultiByteToWideChar(CP_UTF8, 0, (LPCCH)data, size, wbuf, wlen);
			wbuf[wlen] = 0;
			WCHAR* p = wbuf;
			BOOL inBlock = FALSE;
			SysBlock* cur = &g_sysBlocks[g_numSysBlocks];

			while (*p && g_numSysBlocks < MAX_SYS_BLOCKS)
			{
				while (*p == L' ' || *p == L'\t' || *p == L'\r' || *p == L'\n')
					p++;
				if (!*p)
					break;

				WCHAR* start = p;
				while (*p && *p != L'\r' && *p != L'\n')
					p++;

				int len = (int)(p - start);
				if (len > 0)
				{
					if (start[0] == L'{' && (len == 1 || start[1] == L' ' || start[1] == L'\t'))
					{
						inBlock = TRUE;
					}
					else if (start[0] == L'}' && (len == 1 || start[1] == L' ' || start[1] == L'\t'))
					{
						inBlock = FALSE;
						if (cur->numLines > 0)
						{
							if (bank && bank->count < 512)
								bank->indices[bank->count++] = g_numSysBlocks;
							g_numSysBlocks++;
							cur = &g_sysBlocks[g_numSysBlocks];
						}
					}
					else if (cur->numLines < MAX_LINES_PER_BLOCK)
					{
						int copyLen = len < FLY_CONQ_LEN - 1 ? len : FLY_CONQ_LEN - 1;
						lstrcpynW(cur->lines[cur->numLines], start, copyLen + 1);
						cur->numLines++;

						if (!inBlock)
						{
							if (bank && bank->count < 512)
								bank->indices[bank->count++] = g_numSysBlocks;
							g_numSysBlocks++;
							cur = &g_sysBlocks[g_numSysBlocks];
						}
					}
				}
			}
			HeapFree(GetProcessHeap(), 0, wbuf);
		}
	}
	HeapFree(GetProcessHeap(), 0, data);
}

static void LoadAllText(void)
{
	if (g_sysLoaded)
		return;

	g_sysLoaded = TRUE;
	g_bankSystem.count = 0;
	g_numLangBanks = 0;
	g_curLangBank = 0;

	FlyPackLoadIndex();

	if (g_flyPackCount > 0)
	{
		for (DWORD i = 0; i < g_flyPackCount; i++)
		{
			if (StrCmpNIW(g_flyPackEntries[i].name, L"msg/", 4) == 0 && lstrcmpiW(PathFindExtensionW(g_flyPackEntries[i].name), L".txt") == 0)
			{
				if (StrStrIW(g_flyPackEntries[i].name, L"SYSTEM.txt"))
					LoadBlocksFromFile(g_flyPackEntries[i].name, &g_bankSystem);
				else if (StrStrIW(g_flyPackEntries[i].name, L"RUSSIAN.txt"))
				{
					LoadBlocksFromFile(g_flyPackEntries[i].name, &g_bankLang[g_numLangBanks]);
					if (g_bankLang[g_numLangBanks].count > 0)
					{
						ShuffleBank(&g_bankLang[g_numLangBanks]);
						g_numLangBanks++;
					}
				}
			}
		}
		for (DWORD i = 0; i < g_flyPackCount; i++)
		{
			if (StrCmpNIW(g_flyPackEntries[i].name, L"msg/", 4) == 0 && lstrcmpiW(PathFindExtensionW(g_flyPackEntries[i].name), L".txt") == 0)
			{
				if (!StrStrIW(g_flyPackEntries[i].name, L"SYSTEM.txt") && !StrStrIW(g_flyPackEntries[i].name, L"RUSSIAN.txt") && !StrStrIW(g_flyPackEntries[i].name, L"BOOT.txt") && g_numLangBanks < 16)
				{
					LoadBlocksFromFile(g_flyPackEntries[i].name, &g_bankLang[g_numLangBanks]);
					if (g_bankLang[g_numLangBanks].count > 0)
					{
						ShuffleBank(&g_bankLang[g_numLangBanks]);
						g_numLangBanks++;
					}
				}
			}
		}
	}
	else
	{
		WCHAR exe[MAX_PATH], search[MAX_PATH];
		WIN32_FIND_DATAW fd;
		HANDLE hFind;

		LoadBlocksFromFile(L"msg/SYSTEM.txt", &g_bankSystem);
		LoadBlocksFromFile(L"msg/RUSSIAN.txt", &g_bankLang[g_numLangBanks]);
		if (g_bankLang[g_numLangBanks].count > 0)
		{
			ShuffleBank(&g_bankLang[g_numLangBanks]);
			g_numLangBanks++;
		}

		if (GetModuleFileNameW(NULL, exe, MAX_PATH))
		{
			PathRemoveFileSpecW(exe);
			wsprintfW(search, L"%s\\assets\\msg\\*.txt", exe);
			hFind = FindFirstFileW(search, &fd);

			if (hFind != INVALID_HANDLE_VALUE)
			{
				do {
					if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) continue;
					if (StrStrIW(fd.cFileName, L"SYSTEM.txt")) continue;
					if (StrStrIW(fd.cFileName, L"RUSSIAN.txt")) continue;
					if (StrStrIW(fd.cFileName, L"BOOT.txt")) continue;

					if (g_numLangBanks < 16)
					{
						WCHAR relPath[MAX_PATH];
						wsprintfW(relPath, L"msg/%s", fd.cFileName);
						LoadBlocksFromFile(relPath, &g_bankLang[g_numLangBanks]);
						if (g_bankLang[g_numLangBanks].count > 0)
						{
							ShuffleBank(&g_bankLang[g_numLangBanks]);
							g_numLangBanks++;
						}
					}
				} while (FindNextFileW(hFind, &fd));
				FindClose(hFind);
			}
		}
	}
	if (g_bankSystem.count > 0)
		ShuffleBank(&g_bankSystem);
}

static void FlyBsTick(void)
{
	DWORD now;
	ConQTick();

	if (g_flyNeedBootFlood)
	{
		g_flyNeedBootFlood = FALSE;
		if (!g_flyBootDone)
		{
			g_flyBootDone = TRUE;
			FlyBsBoot();
		}
	}

	if (!g_flyFlooding) return;
	if (g_flyConQCount > 3) return; /* We are backed up. Typist needs a break. */

	now = GetTickCount();
	if (now - g_bsLast < 700)
		return;

	g_bsLast = now;
	g_bsStep++;

	if (!g_sysLoaded)
		LoadAllText();

	if (g_numSysBlocks > 0)
	{
		int bIdx = -1;
		BOOL pickSystem = FALSE;

		if (g_bankSystem.count > 0 && (g_numLangBanks == 0 || GdiFlyRand01() < 0.25f))
			pickSystem = TRUE;

		if (pickSystem)
		{
			bIdx = g_bankSystem.indices[g_bankSystem.playedCount++];
			if (g_bankSystem.playedCount >= g_bankSystem.count)
				ShuffleBank(&g_bankSystem);
		}
		else if (g_numLangBanks > 0)
		{
			TextBank* lb = &g_bankLang[g_curLangBank];
			bIdx = lb->indices[lb->playedCount++];
			if (lb->playedCount >= lb->count)
			{
				ShuffleBank(lb);
				g_curLangBank = (g_curLangBank + 1) % g_numLangBanks;
			}
		}

		if (bIdx >= 0 && bIdx < g_numSysBlocks)
		{
			for (int k = 0; k < g_sysBlocks[bIdx].numLines; k++)
			{
				WCHAR formatted[FLY_CONQ_LEN];
				FormatFlyString(g_sysBlocks[bIdx].lines[k], formatted, FLY_CONQ_LEN);
				ConQ(L"%s", formatted);
			}
		}
	}
}

static void RunHost(void)
{
	MSG msg;
	if (!SpawnGame())
		return;

	g_flyFloodUnlocked = TRUE;
	g_flyNeedBootFlood = TRUE;
	g_flyFlooding = TRUE;

	if (g_game.hwnd)
		FlyEnsureLogOwnedByChess(g_game.hwnd);

	/* The cursed main message loop of our hijacked process */
	for (;;)
	{
		WaitForSingleObject(g_menuEvent, 40);
		FlyBsTick();
		FlyLogPanTick();

		if (g_game.hwnd)
			FlyEnsureLogOwnedByChess(g_game.hwnd);

		while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
		{
			TranslateMessage(&msg);
			DispatchMessageW(&msg);
		}

		if (g_game.thread && WaitForSingleObject(g_game.thread, 0) == WAIT_OBJECT_0)
			return;
		if (g_game.hidden || (g_game.hwnd && !IsWindow(g_game.hwnd)))
			return;
	}
}

// --- Built-in Extractor & Packer ---
static void EnsureDirForFileW(LPCWSTR path)
{
	WCHAR tmp[MAX_PATH];
	int i;
	lstrcpynW(tmp, path, MAX_PATH);

	for (i = 0; tmp[i]; i++)
	{
		if ((tmp[i] == L'\\' || tmp[i] == L'/') && i > 0 && tmp[i - 1] != L':')
		{
			WCHAR c = tmp[i + 1];
			tmp[i + 1] = 0;
			CreateDirectoryW(tmp, NULL);
			tmp[i + 1] = c;
		}
	}
}

/*
 * The vomit function. Rips our carefully packed binary tail off and dumps it onto the disk.
 * Security teams love finding random EXEs dropping mystery payloads.
 */
static void FlyPackExtractToDisk(void)
{
	WCHAR exePath[MAX_PATH], exeDir[MAX_PATH], outPath[MAX_PATH];
	DWORD i, written, rd;
	BYTE* data;
	DWORD size;
	HANDLE hFile, hOld, hNew;

	if (!FlyPackLoadIndex() || g_flyPackCount == 0)
	{
		Con(L"[WARN] No FLYPAK1 tail found to extract.");
		return;
	}

	GetModuleFileNameW(NULL, exePath, MAX_PATH);
	lstrcpynW(exeDir, exePath, MAX_PATH);
	PathRemoveFileSpecW(exeDir);

	for (i = 0; i < g_flyPackCount; i++)
	{
		if (FlyPackReadEntry(g_flyPackEntries[i].name, &data, &size))
		{
			wsprintfW(outPath, L"%s\\assets\\%s", exeDir, g_flyPackEntries[i].name);
			for (int j = 0; outPath[j]; j++)
				if (outPath[j] == L'/')
					outPath[j] = L'\\';

			EnsureDirForFileW(outPath);
			hFile = CreateFileW(outPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
			if (hFile != INVALID_HANDLE_VALUE)
			{
				WriteFile(hFile, data, size, &written, NULL);
				CloseHandle(hFile);
			}
			HeapFree(GetProcessHeap(), 0, data);
		}
	}

	/* Creates a clean version of ourselves, shedding our binary skin */
	wsprintfW(outPath, L"%s\\Fly_Chess_unpacked.exe", exeDir);
	hOld = CreateFileW(exePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

	if (hOld != INVALID_HANDLE_VALUE)
	{
		hNew = CreateFileW(outPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
		if (hNew != INVALID_HANDLE_VALUE)
		{
			DWORD left = (DWORD)g_flyPackEntries[0].offset;
			BYTE buf[1024]; /* Shrink the buffer to dodge __chkstk limit */
			SetFilePointer(hOld, 0, NULL, FILE_BEGIN);

			while (left > 0)
			{
				DWORD chunk = left > sizeof(buf) ? sizeof(buf) : left;
				if (ReadFile(hOld, buf, chunk, &rd, NULL) && rd > 0)
					WriteFile(hNew, buf, rd, &written, NULL);
				else
					break;
				left -= rd;
			}
			CloseHandle(hNew);
		}
		CloseHandle(hOld);
	}

	Con(L"Assets successfully extracted and Fly_Chess_unpacked.exe created");
}

struct PackItem { char name[128]; WCHAR path[MAX_PATH]; DWORD size; ULONGLONG offset; };

static void ScanAssetsDir(LPCWSTR base, LPCWSTR sub, PackItem* items, DWORD* count)
{
	WCHAR search[MAX_PATH], newSub[MAX_PATH];
	WIN32_FIND_DATAW fd;
	HANDLE hFind;

	wsprintfW(search, L"%s\\%s*", base, sub);
	hFind = FindFirstFileW(search, &fd);
	if (hFind == INVALID_HANDLE_VALUE)
		return;

	do
	{
		if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
		{
			if (lstrcmpW(fd.cFileName, L".") != 0 && lstrcmpW(fd.cFileName, L"..") != 0)
			{
				wsprintfW(newSub, L"%s%s\\", sub, fd.cFileName);
				ScanAssetsDir(base, newSub, items, count);
			}
		}
		else if (*count < 1024)
		{
			WCHAR relPath[256];
			wsprintfW(relPath, L"%s%s", sub, fd.cFileName);
			WideCharToMultiByte(CP_UTF8, 0, relPath, -1, items[*count].name, 128, NULL, NULL);
			for (int i = 0; items[*count].name[i]; i++)
				if (items[*count].name[i] == '\\')
					items[*count].name[i] = '/';

			wsprintfW(items[*count].path, L"%s\\%s%s", base, sub, fd.cFileName);
			items[*count].size = fd.nFileSizeLow;
			(*count)++;
		}
	} while (FindNextFileW(hFind, &fd));
	FindClose(hFind);
}

/*
 * The ingestion function. Grabs every file in the assets folder and aggressively glues it
 * to the end of our own EXE so we can become a single portable, bloated monolith.
 */
static void FlyPackAppendFromDisk(LPCWSTR customDir)
{
	WCHAR exe[MAX_PATH], newExe[MAX_PATH], assetsDir[MAX_PATH], exeDir[MAX_PATH];
	PackItem* items = NULL;
	DWORD count = 0, baseSize = 0, rd, wr, i;
	HANDLE hOld, hNew, hSrc;
	BYTE buf[1024]; /* Small buffer to dodge __chkstk. Slow but sneaky. */

	GetModuleFileNameW(NULL, exe, MAX_PATH);
	lstrcpynW(exeDir, exe, MAX_PATH);
	PathRemoveFileSpecW(exeDir);
	wsprintfW(newExe, L"%s\\FlyChess_Packed.exe", exeDir);

	if (customDir && customDir[0])
		lstrcpynW(assetsDir, customDir, MAX_PATH);
	else
		wsprintfW(assetsDir, L"%s\\assets", exeDir);

	items = (PackItem*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 1024 * sizeof(PackItem));
	if (!items)
	{
		Con(L"[ERROR] Out of memory allocating pack items.");
		return;
	}

	ScanAssetsDir(assetsDir, L"", items, &count);
	if (count == 0)
	{
		Con(L"No files found in directory '%s' to pack.", assetsDir);
		HeapFree(GetProcessHeap(), 0, items);
		return;
	}

	hOld = CreateFileW(exe, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
	if (hOld == INVALID_HANDLE_VALUE)
	{
		HeapFree(GetProcessHeap(), 0, items);
		return;
	}
	baseSize = GetFileSize(hOld, NULL);

	if (FlyPackLoadIndex() && g_flyPackCount > 0)
		baseSize = (DWORD)g_flyPackEntries[0].offset;

	hNew = CreateFileW(newExe, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
	if (hNew != INVALID_HANDLE_VALUE)
	{
		DWORD left = baseSize;
		SetFilePointer(hOld, 0, NULL, FILE_BEGIN);
		while (left > 0)
		{
			DWORD chunk = left > sizeof(buf) ? sizeof(buf) : left;
			ReadFile(hOld, buf, chunk, &rd, NULL);
			WriteFile(hNew, buf, rd, &wr, NULL);
			left -= rd;
		}

		ULONGLONG currentOffset = baseSize;
		for (i = 0; i < count; i++)
		{
			items[i].offset = currentOffset;
			hSrc = CreateFileW(items[i].path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
			if (hSrc != INVALID_HANDLE_VALUE)
			{
				while (ReadFile(hSrc, buf, sizeof(buf), &rd, NULL) && rd > 0)
					WriteFile(hNew, buf, rd, &wr, NULL);
				CloseHandle(hSrc);
			}
			currentOffset += items[i].size;
		}

		DWORD indexOffset = SetFilePointer(hNew, 0, NULL, FILE_CURRENT);
		for (i = 0; i < count; i++)
		{
			WORD nameLen = (WORD)lstrlenA(items[i].name);
			WriteFile(hNew, &nameLen, 2, &wr, NULL);
			WriteFile(hNew, items[i].name, nameLen, &wr, NULL);
			WriteFile(hNew, &items[i].offset, 8, &wr, NULL);
			WriteFile(hNew, &items[i].size, 4, &wr, NULL);
		}

		BYTE footer[24] = { 'F','L','Y','P','A','K','1',0 };
		DWORD version = 1;
		ULONGLONG idxOff = indexOffset;
		CustomMemCpy(footer + 8, &version, 4);
		CustomMemCpy(footer + 12, &count, 4);
		CustomMemCpy(footer + 16, &idxOff, 8);
		WriteFile(hNew, footer, 24, &wr, NULL);
		CloseHandle(hNew);
	}
	CloseHandle(hOld);
	HeapFree(GetProcessHeap(), 0, items);

	Con(L"Successfully packed assets from '%s' into FlyChess_Packed.exe", assetsDir);
}

static HMODULE EnsureWithExeLoaded(void)
{
	HMODULE hDll = LoadLibraryW(L"With.dll");
	if (hDll) return hDll;

	WCHAR exeDir[MAX_PATH], tryPath[MAX_PATH];
	if (GetModuleFileNameW(NULL, exeDir, MAX_PATH))
	{
		PathRemoveFileSpecW(exeDir);

		/* 1. Search dynamically in local assets\dll\ first */
		wsprintfW(tryPath, L"%s\\assets\\dll\\With.dll", exeDir);
		hDll = LoadLibraryW(tryPath);
		if (hDll) return hDll;
	}

	/* 2. Check if it already exists in the TEMP folder from a previous run */
	WCHAR tempDir[MAX_PATH];
	if (GetTempPathW(MAX_PATH, tempDir))
	{
		/* GetTempPathW guarantees a trailing backslash */
		wsprintfW(tryPath, L"%sWith.dll", tempDir);

		hDll = LoadLibraryW(tryPath);
		if (hDll) return hDll; /* Found it! Skip extraction entirely. */

		/* 3. Not there? Time to rip it out of our payload and drop it in TEMP */
		BYTE* pData = NULL;
		DWORD size = 0;
		if (FlyPackReadEntry(L"dll/With.dll", &pData, &size) ||
			FlyPackReadEntry(L"With.dll", &pData, &size))
		{
			HANDLE hFile = CreateFileW(tryPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
			if (hFile != INVALID_HANDLE_VALUE)
			{
				DWORD written;
				WriteFile(hFile, pData, size, &written, NULL);
				CloseHandle(hFile);
			}
			HeapFree(GetProcessHeap(), 0, pData);
			hDll = LoadLibraryW(tryPath);
		}
	}

	if (!hDll)
	{
		MessageBoxW(NULL,
			L"[FATAL] Could not locate or extract With.dll.\n\n"
			L"Please ensure it is located at assets\\dll\\With.dll or packed into the EXE tail.",
			L"FlyChess Framework Error",
			MB_ICONERROR | MB_OK | MB_TOPMOST);
	}

	return hDll;
}

/*
 * The Grand Stage. We pretend to be a normal Windows GUI app here, but really we are just
 * looking for command line flags or hijacking the poor chess executable.
 */
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow)
{
	g_mainTid = GetCurrentThreadId();
	g_menuEvent = CreateEventW(NULL, FALSE, FALSE, NULL);

	int argc;
	LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
	BOOL doPack = FALSE;
	WCHAR packDir[MAX_PATH] = { 0 };

	if (argv)
	{
		for (int i = 1; i < argc; i++)
		{
			if (lstrcmpiW(argv[i], L"/unpack") == 0)
			{
				FlyPackExtractToDisk();
				LocalFree(argv);
				Chess3DExit(0);
			}
			else if (lstrcmpiW(argv[i], L"/pack") == 0)
			{
				doPack = TRUE;
				if (i + 1 < argc && argv[i + 1][0] != L'/')
				{
					lstrcpynW(packDir, argv[i + 1], MAX_PATH);
				}
			}
		}
		LocalFree(argv);
	}

	if (doPack)
	{
		FlyPackAppendFromDisk(packDir[0] ? packDir : NULL);
		Chess3DExit(0);
	}

	if (!FindChess())
	{
		MessageBoxW(NULL, L"Chess Titans not found anywhere under Microsoft Games or Program Files.", L"FlyChess Error", MB_ICONERROR);
		Chess3DExit(1);
	}

	/* Dynamically integrate the framework */
	HMODULE hWith = EnsureWithExeLoaded();
	if (hWith)
		g_pfnRun = (PFN_RUN)GetProcAddress(hWith, "Run");

	if (!g_pfnRun)
		Chess3DExit(1);

	/* And away we go into the abyss */
	RunHost();
	Chess3DExit(0);
	return 0;
}