2 more AI plugins for shits n giggles

2026-07-30 22:31:13 -05:00
parent 6c208da75f
commit 9288824fa6
12 changed files with 1755 additions and 0 deletions
@@ -0,0 +1,261 @@
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <windowsx.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define EXPORT __declspec(dllexport)
+
+typedef void (__stdcall *host_callback_t)(const char *, uintptr_t, const char *, uintptr_t);
+static host_callback_t g_callback;
+static HINSTANCE g_instance;
+static HWND g_window;
+static HANDLE g_thread;
+static SRWLOCK g_lock = SRWLOCK_INIT;
+static char g_game_id[80];
+static char g_operator[96] = "operator";
+static char g_board[9];
+static char g_turn;
+static char g_status[24];
+static int g_waiting;
+static char g_winner;
+static ULONGLONG g_confetti_until;
+
+static void send_event(const char *event, const char *payload) {
+    if (g_callback) g_callback(event, (uintptr_t)strlen(event), payload, payload ? (uintptr_t)strlen(payload) : 0);
+}
+
+static void json_string(const char *json, const char *key, char *out, size_t capacity) {
+    const char *start = strstr(json, key);
+    if (!start || capacity == 0) return;
+    start += strlen(key);
+    const char *end = strchr(start, '"');
+    if (!end) return;
+    size_t length = (size_t)(end - start);
+    if (length >= capacity) length = capacity - 1;
+    memcpy(out, start, length);
+    out[length] = 0;
+}
+
+static void parse_board(const char *json) {
+    const char *cursor = strstr(json, "\"board\":[");
+    memset(g_board, 0, sizeof(g_board));
+    if (!cursor) return;
+    cursor += 9;
+    for (int index = 0; index < 9; index++) {
+        cursor = strchr(cursor, '"');
+        if (!cursor) break;
+        cursor++;
+        if (*cursor == 'X' || *cursor == 'O') g_board[index] = *cursor;
+        cursor = strchr(cursor, '"');
+        if (!cursor) break;
+        cursor++;
+    }
+}
+
+static void parse_state(const char *json) {
+    AcquireSRWLockExclusive(&g_lock);
+    json_string(json, "\"id\":\"", g_game_id, sizeof(g_game_id));
+    json_string(json, "\"status\":\"", g_status, sizeof(g_status));
+    int was_client_win = strcmp(g_status, "won") == 0 && g_winner == 'O';
+    char winner[4] = {0};
+    json_string(json, "\"winner\":\"", winner, sizeof(winner));
+    g_winner = winner[0];
+    int client_won = strcmp(g_status, "won") == 0 && g_winner == 'O';
+    if (client_won && !was_client_win) g_confetti_until = GetTickCount64() + 3000;
+    else if (!client_won) g_confetti_until = 0;
+    char turn[4] = {0};
+    json_string(json, "\"turn\":\"", turn, sizeof(turn));
+    g_turn = turn[0];
+    const char *player = strstr(json, "\"playerX\":");
+    if (player) json_string(player, "\"username\":\"", g_operator, sizeof(g_operator));
+    parse_board(json);
+    g_waiting = 0;
+    ReleaseSRWLockExclusive(&g_lock);
+}
+
+static void draw_centered(HDC dc, const char *text, RECT rect, HFONT font, COLORREF color) {
+    SelectObject(dc, font);
+    SetTextColor(dc, color);
+    SetBkMode(dc, TRANSPARENT);
+    DrawTextA(dc, text, -1, &rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
+}
+
+static void draw_confetti(HDC dc, RECT client, ULONGLONG until) {
+    ULONGLONG now = GetTickCount64();
+    if (!until || now >= until) return;
+    ULONGLONG elapsed = 3000 - (until - now);
+    int width = client.right - client.left;
+    int height = client.bottom - client.top;
+    COLORREF colors[] = {RGB(251, 113, 133), RGB(254, 205, 211), RGB(255, 255, 255)};
+    for (int index = 0; index < 60; index++) {
+        int x = (index * 73) % width;
+        int speed = 110 + (index % 5) * 24;
+        int y = (int)((elapsed * speed / 1000 + index * 47) % (height + 36)) - 18;
+        HBRUSH brush = CreateSolidBrush(colors[index % 3]);
+        RECT piece = {x, y, x + 8, y + 14};
+        FillRect(dc, &piece, brush);
+        DeleteObject(brush);
+    }
+}
+
+static LRESULT CALLBACK window_proc(HWND window, UINT message, WPARAM wparam, LPARAM lparam) {
+    if (message == WM_PAINT) {
+        PAINTSTRUCT paint;
+        HDC dc = BeginPaint(window, &paint);
+        RECT client;
+        GetClientRect(window, &client);
+        HBRUSH background = CreateSolidBrush(RGB(8, 13, 22));
+        FillRect(dc, &client, background);
+        DeleteObject(background);
+
+        char board[9], status[24], opponent[96];
+        char turn, winner;
+        ULONGLONG confetti_until;
+        AcquireSRWLockShared(&g_lock);
+        memcpy(board, g_board, sizeof(board));
+        strcpy(status, g_status);
+        strcpy(opponent, g_operator);
+        turn = g_turn;
+        winner = g_winner;
+        confetti_until = g_confetti_until;
+        ReleaseSRWLockShared(&g_lock);
+
+        HFONT title_font = CreateFontA(24, 0, 0, 0, FW_BOLD, 0, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, "Segoe UI");
+        HFONT mark_font = CreateFontA(58, 0, 0, 0, FW_BOLD, 0, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, "Segoe UI");
+        HFONT text_font = CreateFontA(16, 0, 0, 0, FW_NORMAL, 0, 0, 0, DEFAULT_CHARSET, 0, 0, 0, 0, "Segoe UI");
+        RECT title = {20, 10, 340, 45};
+        char title_text[160];
+        snprintf(title_text, sizeof(title_text), "Tic Tac Toe vs %s", opponent);
+        draw_centered(dc, title_text, title, title_font, RGB(229, 231, 235));
+
+        HPEN grid_pen = CreatePen(PS_SOLID, 2, RGB(51, 65, 85));
+        SelectObject(dc, grid_pen);
+        for (int index = 1; index < 3; index++) {
+            MoveToEx(dc, 20 + index * 100, 60, NULL); LineTo(dc, 20 + index * 100, 360);
+            MoveToEx(dc, 20, 60 + index * 100, NULL); LineTo(dc, 320, 60 + index * 100);
+        }
+        DeleteObject(grid_pen);
+        for (int index = 0; index < 9; index++) {
+            if (!board[index]) continue;
+            int row = index / 3, column = index % 3;
+            RECT cell = {20 + column * 100, 60 + row * 100, 120 + column * 100, 160 + row * 100};
+            char mark[2] = {board[index], 0};
+            draw_centered(dc, mark, cell, mark_font, board[index] == 'X' ? RGB(56, 189, 248) : RGB(251, 113, 133));
+        }
+        RECT footer = {20, 370, 320, 405};
+        const char *footer_text = strcmp(status, "active") != 0
+            ? (strcmp(status, "won") == 0 ? (winner == 'O' ? "You won!" : "You lost.") : "Waiting for game")
+            : (turn == 'O' ? "Your turn" : "Operator's turn");
+        draw_centered(dc, footer_text, footer, text_font, RGB(148, 163, 184));
+        draw_confetti(dc, client, confetti_until);
+        DeleteObject(title_font);
+        DeleteObject(mark_font);
+        DeleteObject(text_font);
+        EndPaint(window, &paint);
+        return 0;
+    }
+    if (message == WM_TIMER) {
+        ULONGLONG until;
+        AcquireSRWLockShared(&g_lock);
+        until = g_confetti_until;
+        ReleaseSRWLockShared(&g_lock);
+        if (until > GetTickCount64()) InvalidateRect(window, NULL, FALSE);
+        else KillTimer(window, 1);
+        return 0;
+    }
+    if (message == WM_LBUTTONUP) {
+        int x = GET_X_LPARAM(lparam), y = GET_Y_LPARAM(lparam);
+        if (x < 20 || x >= 320 || y < 60 || y >= 360) return 0;
+        int cell = ((y - 60) / 100) * 3 + ((x - 20) / 100);
+        char game_id[80];
+        int allowed = 0;
+        AcquireSRWLockExclusive(&g_lock);
+        if (!g_waiting && strcmp(g_status, "active") == 0 && g_turn == 'O' && !g_board[cell]) {
+            g_waiting = 1;
+            strcpy(game_id, g_game_id);
+            allowed = 1;
+        }
+        ReleaseSRWLockExclusive(&g_lock);
+        if (allowed) {
+            char payload[160];
+            snprintf(payload, sizeof(payload), "{\"gameId\":\"%s\",\"cell\":%d}", game_id, cell);
+            send_event("move", payload);
+            InvalidateRect(window, NULL, FALSE);
+        }
+        return 0;
+    }
+    if (message == WM_CLOSE) { DestroyWindow(window); return 0; }
+    if (message == WM_DESTROY) { PostQuitMessage(0); return 0; }
+    return DefWindowProcW(window, message, wparam, lparam);
+}
+
+static DWORD WINAPI ui_thread(void *unused) {
+    (void)unused;
+    const wchar_t *class_name = L"OverlordTicTacToePlugin";
+    WNDCLASSW wc = {0};
+    wc.lpfnWndProc = window_proc;
+    wc.hInstance = g_instance;
+    wc.lpszClassName = class_name;
+    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+    RegisterClassW(&wc);
+    g_window = CreateWindowExW(WS_EX_TOPMOST, class_name, L"Tic Tac Toe", WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
+        CW_USEDEFAULT, CW_USEDEFAULT, 360, 455, NULL, NULL, g_instance, NULL);
+    if (!g_window) return 1;
+    ShowWindow(g_window, SW_SHOW);
+    UpdateWindow(g_window);
+    SetTimer(g_window, 1, 33, NULL);
+    MSG message;
+    while (GetMessageW(&message, NULL, 0, 0) > 0) { TranslateMessage(&message); DispatchMessageW(&message); }
+    g_window = NULL;
+    return 0;
+}
+
+static void ensure_window(void) {
+    if (g_window) {
+        ShowWindow(g_window, SW_RESTORE);
+        SetWindowPos(g_window, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
+        SetForegroundWindow(g_window);
+        return;
+    }
+    if (g_thread) { CloseHandle(g_thread); g_thread = NULL; }
+    g_thread = CreateThread(NULL, 0, ui_thread, NULL, 0, NULL);
+}
+
+BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved) {
+    (void)reserved;
+    if (reason == DLL_PROCESS_ATTACH) { g_instance = instance; DisableThreadLibraryCalls(instance); }
+    return TRUE;
+}
+
+EXPORT const char *PluginGetRuntime(void) { return "c"; }
+EXPORT void PluginSetCallback(uint64_t callback) { g_callback = (host_callback_t)(uintptr_t)callback; }
+EXPORT int PluginOnLoad(const char *host_info, int host_info_length, uint64_t callback) {
+    (void)host_info; (void)host_info_length;
+    g_callback = (host_callback_t)(uintptr_t)callback;
+    send_event("ready", "{\"ready\":true}");
+    return 0;
+}
+EXPORT int PluginOnEvent(const char *event, int event_length, const char *payload, int payload_length) {
+    if (event_length == 5 && memcmp(event, "state", 5) == 0 && payload && payload_length > 0) {
+        char *json = (char *)malloc((size_t)payload_length + 1);
+        if (!json) return 1;
+        memcpy(json, payload, (size_t)payload_length);
+        json[payload_length] = 0;
+        parse_state(json);
+        free(json);
+        ensure_window();
+        if (g_window) {
+            SetTimer(g_window, 1, 33, NULL);
+            InvalidateRect(g_window, NULL, FALSE);
+        }
+    }
+    return 0;
+}
+EXPORT void PluginOnUnload(void) {
+    if (g_window) PostMessageW(g_window, WM_CLOSE, 0, 0);
+    if (g_thread) { WaitForSingleObject(g_thread, 2000); CloseHandle(g_thread); g_thread = NULL; }
+    g_callback = NULL;
+}