//########################################################################### // btl4fe -- the miniconsole front end (BT_GLASS only; compiled only when // the gate is on -- see CMakeLists.txt). Design: btl4fe.hpp. //########################################################################### #include "btl4fe.hpp" #ifdef BT_STEAM #include "btl4lobby.hpp" #endif #include #include #include #include //########################################################################### // Catalogs -- the verified content values (context/content-archives.md map // sweep; vehicle/color values from the shipped eggs). The egg writer // accepts anything; these are the menu's cycle sets. //########################################################################### //########################################################################### // The 4 static rank-place ordinal bitmaps -- byte-identical to the console // eggs (content/MP.EGG [ordinals] block: "1st" "2nd" "3rd" "4th" as 128x32 // plasma pages). //########################################################################### static const char *kOrdinalBlock = "[ordinals]\n" "bitmap=Ordinal::BitMap::1\n" "bitmap=Ordinal::BitMap::2\n" "bitmap=Ordinal::BitMap::3\n" "bitmap=Ordinal::BitMap::4\n" "[Ordinal::BitMap::1]\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=000038000003C000001FF00000000F00\n" "bitmap=0000F8000003C000003FF80000000F00\n" "bitmap=0001F8000003C00000707C0000000F00\n" "bitmap=0001F8000003C00000603C0000000F00\n" "bitmap=00007801FC0FF00000003C3DF807FF00\n" "bitmap=00007803FE0FF00000003C3FFC0FFF00\n" "bitmap=00007803C703C00000003C3E3C1F0F00\n" "bitmap=000078078303C0000000783C1E1E0F00\n" "bitmap=000078078003C0000000783C1E1E0F00\n" "bitmap=00007807C003C0000000F03C1E1E0F00\n" "bitmap=00007807F003C0000001E03C1E1E0F00\n" "bitmap=00007803FC03C0000003C03C1E1E0F00\n" "bitmap=00007801FE03C0000007803C1E1E0F00\n" "bitmap=000078007F03C000000F003C1E1E0F00\n" "bitmap=000078001F03C000001E003C1E1E0F00\n" "bitmap=000078000F03C000003C003C1E1E0F00\n" "bitmap=000078060F03C0000078003C1E1E0F00\n" "bitmap=000078071E03E0000078003C1E1F1F00\n" "bitmap=00007803FE01F000007FFC3C1E0FFF00\n" "bitmap=00007801FC00F000007FFC3C1E07EF00\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "x=128\n" "y=32\n" "width=8\n" "[Ordinal::BitMap::2]\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=001FFF0000003C0000003C03C0780000\n" "bitmap=001FFF0000003C0000007C03C0780000\n" "bitmap=00000E0000003C000000FC03C0780000\n" "bitmap=00003C0000003C000001BC03C0780000\n" "bitmap=0000700F3E1FFC000003BC0FF07BF000\n" "bitmap=0001E00F7E3FFC0000073C0FF07FF800\n" "bitmap=0003800FFE7C3C0000063C03C07C7800\n" "bitmap=0007F80FFE783C00000C3C03C0783C00\n" "bitmap=0007FE0F80783C0000183C03C0783C00\n" "bitmap=00001E0F00783C0000383C03C0783C00\n" "bitmap=00000F0F00783C0000703C03C0783C00\n" "bitmap=00000F0F00783C00007FFF03C0783C00\n" "bitmap=00000F0F00783C00007FFF03C0783C00\n" "bitmap=00000F0F00783C0000003C03C0783C00\n" "bitmap=00000F0F00783C0000003C03C0783C00\n" "bitmap=00000F0F00783C0000003C03C0783C00\n" "bitmap=00180F0F00783C0000003C03C0783C00\n" "bitmap=001C1F0F007C7C0000003C03E0783C00\n" "bitmap=000FFE0F003FFC0000003C01F0783C00\n" "bitmap=0007FC0F001FBC0000003C00F0783C00\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "x=128\n" "y=32\n" "width=8\n" "[Ordinal::BitMap::3]\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=001FFF03C07800000000FC03C0780000\n" "bitmap=001FFF03C07800000003FC03C0780000\n" "bitmap=001E0003C07800000007C003C0780000\n" "bitmap=001E0003C0780000000F0003C0780000\n" "bitmap=001E000FF07BF000000F000FF07BF000\n" "bitmap=001E000FF07FF800001E000FF07FF800\n" "bitmap=001E0003C07C7800001E0003C07C7800\n" "bitmap=001FFC03C0783C00001EFC03C0783C00\n" "bitmap=001FFE03C0783C00001FFE03C0783C00\n" "bitmap=00001F03C0783C00001F1F03C0783C00\n" "bitmap=00000F03C0783C00001E0F03C0783C00\n" "bitmap=00000F03C0783C00001E0F03C0783C00\n" "bitmap=00000F03C0783C00001E0F03C0783C00\n" "bitmap=00000F03C0783C00001E0F03C0783C00\n" "bitmap=00000F03C0783C00001E0F03C0783C00\n" "bitmap=00000F03C0783C00001E0F03C0783C00\n" "bitmap=00180F03C0783C00001E0F03C0783C00\n" "bitmap=001C1F03E0783C00001F1F03E0783C00\n" "bitmap=000FFE01F0783C00000FFE01F0783C00\n" "bitmap=0007FC00F0783C000007FC00F0783C00\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "x=128\n" "y=32\n" "width=8\n" "[Ordinal::BitMap::4]\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=001FFF03C07800000007FC03C0780000\n" "bitmap=001FFF03C0780000000FFE03C0780000\n" "bitmap=00000F03C0780000001F1F03C0780000\n" "bitmap=00000F03C0780000001E0F03C0780000\n" "bitmap=00000F0FF07BF000001E0F0FF07BF000\n" "bitmap=00001F0FF07FF800001E0F0FF07FF800\n" "bitmap=00001E03C07C7800001E0F03C07C7800\n" "bitmap=00003E03C0783C00001E0F03C0783C00\n" "bitmap=00003C03C0783C00000F1E03C0783C00\n" "bitmap=00003C03C0783C000007FC03C0783C00\n" "bitmap=00007803C0783C000007FC03C0783C00\n" "bitmap=00007803C0783C00000F1E03C0783C00\n" "bitmap=00007803C0783C00001E0F03C0783C00\n" "bitmap=0000F003C0783C00001E0F03C0783C00\n" "bitmap=0000F003C0783C00001E0F03C0783C00\n" "bitmap=0000F003C0783C00001E0F03C0783C00\n" "bitmap=0000F003C0783C00001E0F03C0783C00\n" "bitmap=0000F003E0783C00000F1E03E0783C00\n" "bitmap=0000F001F0783C00000FFE01F0783C00\n" "bitmap=0000F000F0783C000007FC00F0783C00\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "bitmap=00000000000000000000000000000000\n" "x=128\n" "y=32\n" "width=8\n"; //########################################################################### // GDI-rendered pilot-name plasma bitmaps. // // The console rendered each pilot's name into 128x32 (large) and 64x16 // (small) 1bpp plasma pages. We render with GDI into a mono bitmap and // hex-encode: `bitmap=` lines carry 16 BYTES each (32 hex chars) -- one // line per row for the large page (16-byte rows), TWO 8-byte rows per // line for the small page -- byte-identical framing to MP.EGG. //########################################################################### static int RenderNameBits(const char *name, int width, int height, int font_height, unsigned char *bits /* width/8*height bytes */) { int stride = width / 8; // mono GDI stride for 64/128 px HDC screen = GetDC(NULL); HDC dc = CreateCompatibleDC(screen); ReleaseDC(NULL, screen); if (dc == NULL) { return -1; } HBITMAP bitmap = CreateBitmap(width, height, 1, 1, NULL); HBITMAP old_bitmap = (HBITMAP)SelectObject(dc, bitmap); HFONT font = CreateFontW(-font_height, 0, 0, 0, FW_BOLD, 0, 0, 0, DEFAULT_CHARSET, 0, 0, NONANTIALIASED_QUALITY, 0, L"Arial"); HFONT old_font = (HFONT)SelectObject(dc, font); RECT r = { 0, 0, width, height }; SetBkColor(dc, RGB(0, 0, 0)); SetTextColor(dc, RGB(255, 255, 255)); HBRUSH black = (HBRUSH)GetStockObject(BLACK_BRUSH); FillRect(dc, &r, black); WCHAR wide[64]; int n = 0; for (const char *s = name; *s && n < 63; ++s) { wide[n++] = (WCHAR)*s; } wide[n] = 0; DrawTextW(dc, wide, -1, &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE); GdiFlush(); int got = GetBitmapBits(bitmap, stride * height, bits); SelectObject(dc, old_font); DeleteObject(font); SelectObject(dc, old_bitmap); DeleteObject(bitmap); DeleteDC(dc); return (got == stride * height) ? 0 : -1; } static void WriteBitmapPage(FILE *f, const char *page_name, const char *pilot_name, int width, int height, int font_height) { unsigned char bits[16 * 32]; // worst case 128x32 memset(bits, 0, sizeof(bits)); RenderNameBits(pilot_name, width, height, font_height, bits); fprintf(f, "[%s]\n", page_name); int total = (width / 8) * height; for (int off = 0; off < total; off += 16) { fprintf(f, "bitmap="); for (int b = 0; b < 16; ++b) { fprintf(f, "%02X", bits[off + b]); } fprintf(f, "\n"); } fprintf(f, "x=%d\ny=%d\nwidth=%d\n", width, height, width / 16); } //########################################################################### // The egg writer //########################################################################### int BTFeMission_WriteEgg(const BTFeMission *mission, const char *path) { FILE *f = fopen(path, "wt"); if (f == NULL) { return -1; } fprintf(f, "[mission]\n" "adventure=BattleTech\n" "map=%s\n" "scenario=freeforall\n" "time=%s\n" "weather=%s\n" "temperature=%d\n" "length=%d\n", mission->map, mission->time, mission->weather, mission->temperature, mission->lengthSeconds); fputs(kOrdinalBlock, f); fprintf(f, "[pilots]\n"); for (int p = 0; p < mission->pilotCount; ++p) { fprintf(f, "pilot=%s\n", mission->pilots[p].address); } for (int p = 0; p < mission->pilotCount; ++p) { const BTFePilot &pilot = mission->pilots[p]; fprintf(f, "[%s]\n" "hostType=0\n" "advancedDamage=1\n" "loadzones=1\n" "name=%s\n" "bitmapindex=%d\n" "experience=expert\n" "badge=VGL\n" "patch=Yellow\n" "role=Role::Default\n" "dropzone=one\n" "vehicle=%s\n" "vehicleValue=1000\n" "color=%s\n", pilot.address, pilot.name, p + 1, pilot.vehicle, pilot.color); } // // Name plasma pages. The shipped eggs carry ONE large/small pair (the // console personalized per pod); list every pilot's pair -- the engine // resolves by name. // fprintf(f, "[largebitmap]\n"); for (int p = 0; p < mission->pilotCount; ++p) { fprintf(f, "bitmap=BitMap::Large::%s\n", mission->pilots[p].name); } for (int p = 0; p < mission->pilotCount; ++p) { char page[64]; sprintf(page, "BitMap::Large::%s", mission->pilots[p].name); WriteBitmapPage(f, page, mission->pilots[p].name, 128, 32, 24); } fprintf(f, "[smallbitmap]\n"); for (int p = 0; p < mission->pilotCount; ++p) { fprintf(f, "bitmap=BitMap::Small::%s\n", mission->pilots[p].name); } for (int p = 0; p < mission->pilotCount; ++p) { char page[64]; sprintf(page, "BitMap::Small::%s", mission->pilots[p].name); WriteBitmapPage(f, page, mission->pilots[p].name, 64, 16, 12); } fprintf(f, "[Role::Default]\n" "model=dfltrole\n" "[Role::NoReturn]\n" "model=noretun\n"); fclose(f); return 0; } //########################################################################### // The menu -- the RP412 front-end pattern (RP_L4/RPL4FE.cpp, per Cyd): // full catalogs as always-visible clickable LISTS in three columns with // friendly display names -- bright green = selected, dim green = the rest -- // a real EDIT control for the pilot name (and one for LAN peers), framed // LAUNCH / HOST STEAM / JOIN STEAM buttons, double-buffered paint, and the // player's loadout persisted across runs (fe_last.ini beside the eggs; our // per-mission process relaunch would otherwise forget it). // ENTER = launch, ESC = quit. //########################################################################### struct CatalogEntry { const char *key; const char *name; }; static const CatalogEntry kMaps[] = { { "grass", "Grasslands" }, { "cavern", "The Cavern" }, { "rav", "The Ravine" }, { "polar3", "Polar Station 3" }, { "polar4", "Polar Station 4" }, { "arena1", "Arena One" }, { "arena2", "Arena Two" }, { "dbase", "Desert Base" }, }; // The canonical 8 (ALL 18 ModelList names certified 2026-07-18; the menu // offers the full mechs -- variants remain reachable via hand-built eggs). static const CatalogEntry kVehicles[] = { { "avatar", "Avatar" }, { "blkhawk", "Black Hawk" }, { "loki", "Loki" }, { "madcat", "Mad Cat" }, { "owens", "Owens" }, { "sunder", "Sunder" }, { "thor", "Thor" }, { "vulture", "Vulture" }, }; static const CatalogEntry kColors[] = { { "White", "White" }, { "Black", "Black" }, { "Crimson", "Crimson" }, }; static const CatalogEntry kTimes[] = { { "day", "Day" }, { "night", "Night" }, { "morning", "Morning" }, { "dusk", "Dusk" }, }; static const CatalogEntry kWeathers[] = { { "clear", "Clear" }, { "fog", "Light Fog" }, { "soup", "Heavy Fog" }, }; struct LengthEntry { int seconds; const char *name; }; static const LengthEntry kLengths[] = { { 60, "1:00" }, { 300, "5:00" }, { 600, "10:00" }, { 1200, "20:00" }, }; static const CatalogEntry kModes[] = { { "solo", "SOLO MISSION" }, { "raw", "RAW SOLO (endless)" }, { "hostlan", "HOST LAN" }, { "joinlan", "JOIN LAN" }, }; static const int kPorts[] = { 1501, 1601, 1701, 1801 }; #define COUNT(a) ((int)(sizeof(a)/sizeof((a)[0]))) enum MenuGroup { GroupMap = 0, GroupTime, GroupWeather, GroupVehicle, GroupLength, GroupMode, GroupColor, GroupPort, GroupLaunch, GroupSteamHost, GroupSteamJoin, GroupCount }; struct MenuItem { int group; int index; RECT rect; }; struct MenuState { int selection[GroupCount]; MenuItem items[96]; int itemCount; HWND window; HWND nameEdit; HWND peersEdit; HFONT textFont; HFONT titleFont; HBRUSH editBrush; int result; // 0 pending, 1 launch, -1 quit int steamAction; // 0 none, 1 host lobby, 2 join lobby }; static MenuState menu; static const COLORREF kGreenBright = RGB(64, 255, 64); static const COLORREF kGreenDim = RGB(24, 140, 24); static int GroupSize(int group) { switch (group) { case GroupMap: return COUNT(kMaps); case GroupTime: return COUNT(kTimes); case GroupWeather: return COUNT(kWeathers); case GroupVehicle: return COUNT(kVehicles); case GroupLength: return COUNT(kLengths); case GroupMode: return COUNT(kModes); case GroupColor: return COUNT(kColors); case GroupPort: return COUNT(kPorts); default: return 1; } } static void GroupRowText(int group, int index, char *out /*64*/) { switch (group) { case GroupMap: strcpy(out, kMaps[index].name); break; case GroupTime: strcpy(out, kTimes[index].name); break; case GroupWeather: strcpy(out, kWeathers[index].name); break; case GroupVehicle: strcpy(out, kVehicles[index].name); break; case GroupLength: strcpy(out, kLengths[index].name); break; case GroupMode: strcpy(out, kModes[index].name); break; case GroupColor: strcpy(out, kColors[index].name); break; case GroupPort: sprintf(out, "%d", kPorts[index]); break; default: out[0] = 0; break; } } static const char * GroupHeader(int group) { switch (group) { case GroupMap: return "MAP"; case GroupTime: return "TIME"; case GroupWeather: return "WEATHER"; case GroupVehicle: return "MECH"; case GroupLength: return "LENGTH"; case GroupMode: return "MODE"; case GroupColor: return "COLOR"; case GroupPort: return "NET PORT"; default: return ""; } } // // Layout: three catalog columns + the button column. // col1: MAP, TIME, WEATHER col2: MECH, LENGTH // col3: MODE, COLOR, NET PORT col4: name/peers edits + buttons // enum { MenuClientW = 960, MenuClientH = 560, MenuRowH = 22, MenuColW = 190, MenuCol1X = 28, MenuCol2X = 254, MenuCol3X = 480, MenuCol4X = 706, MenuTopY = 64 }; static void AddGroup(int group, int x, int *y) { *y += MenuRowH; // the header row int count = GroupSize(group); for (int i = 0; i < count; ++i) { MenuItem *item = &menu.items[menu.itemCount++]; item->group = group; item->index = i; item->rect.left = x; item->rect.top = *y; item->rect.right = x + MenuColW; item->rect.bottom = *y + MenuRowH; *y += MenuRowH; } *y += MenuRowH / 2; // gap below the group } static void AddButton(int group, int x, int y, int width, int height) { MenuItem *item = &menu.items[menu.itemCount++]; item->group = group; item->index = 0; item->rect.left = x; item->rect.top = y; item->rect.right = x + width; item->rect.bottom = y + height; } static void LayoutMenu() { menu.itemCount = 0; int y; y = MenuTopY; AddGroup(GroupMap, MenuCol1X, &y); AddGroup(GroupTime, MenuCol1X, &y); AddGroup(GroupWeather, MenuCol1X, &y); y = MenuTopY; AddGroup(GroupVehicle, MenuCol2X, &y); AddGroup(GroupLength, MenuCol2X, &y); y = MenuTopY; AddGroup(GroupMode, MenuCol3X, &y); AddGroup(GroupColor, MenuCol3X, &y); AddGroup(GroupPort, MenuCol3X, &y); AddButton(GroupLaunch, MenuCol4X, MenuClientH - 190, 220, 52); #ifdef BT_STEAM AddButton(GroupSteamHost, MenuCol4X, MenuClientH - 120, 220, 34); AddButton(GroupSteamJoin, MenuCol4X, MenuClientH - 76, 220, 34); #endif } // // fe_last.ini -- the persisted loadout (our process-relaunch model would // otherwise forget it between missions; RP412 persists in-process). // static void LoadPersisted(char *pilot_name, int name_capacity, char *peers, int peers_capacity) { FILE *f = fopen("fe_last.ini", "rt"); if (f == NULL) { return; } char line[160]; while (fgets(line, sizeof(line), f)) { char *newline = strchr(line, '\n'); if (newline) *newline = 0; char *equals = strchr(line, '='); if (equals == NULL) continue; *equals = 0; const char *value = equals + 1; for (int g = 0; g < GroupCount; ++g) { if (_stricmp(line, GroupHeader(g)) == 0) { int v = atoi(value); if (v >= 0 && v < GroupSize(g)) menu.selection[g] = v; } } if (_stricmp(line, "NAME") == 0 && value[0]) { strncpy(pilot_name, value, name_capacity - 1); pilot_name[name_capacity - 1] = 0; } if (_stricmp(line, "PEERS") == 0) { strncpy(peers, value, peers_capacity - 1); peers[peers_capacity - 1] = 0; } } fclose(f); } static void SavePersisted(const char *pilot_name, const char *peers) { FILE *f = fopen("fe_last.ini", "wt"); if (f == NULL) { return; } for (int g = 0; g <= GroupPort; ++g) { fprintf(f, "%s=%d\n", GroupHeader(g), menu.selection[g]); } fprintf(f, "NAME=%s\nPEERS=%s\n", pilot_name, peers); fclose(f); } static void DrawMenuText(HDC dc, const char *text, RECT *rect, COLORREF color, UINT format) { WCHAR wide[128]; int n = 0; for (const char *s = text; *s && n < 127; ++s) wide[n++] = (WCHAR)*s; wide[n] = 0; SetTextColor(dc, color); DrawTextW(dc, wide, -1, rect, format); } static void PaintMenu(HWND window) { PAINTSTRUCT paint; HDC screen = BeginPaint(window, &paint); RECT client; GetClientRect(window, &client); // double-buffered (the RP412 pattern) HDC dc = CreateCompatibleDC(screen); HBITMAP backing = CreateCompatibleBitmap(screen, client.right, client.bottom); HBITMAP old_backing = (HBITMAP)SelectObject(dc, backing); HBRUSH background = CreateSolidBrush(RGB(0, 0, 0)); FillRect(dc, &client, background); DeleteObject(background); SetBkMode(dc, TRANSPARENT); HFONT old_font = (HFONT)SelectObject(dc, menu.titleFont); RECT title_rect = { MenuCol1X, 14, client.right - 24, 54 }; DrawMenuText(dc, "BATTLETECH -- MISSION CONSOLE", &title_rect, kGreenBright, DT_LEFT | DT_TOP | DT_SINGLELINE); SelectObject(dc, menu.textFont); // // Group headers (above each group's first row). // for (int i = 0; i < menu.itemCount; ++i) { const MenuItem &item = menu.items[i]; if (item.index != 0 || item.group > GroupPort) { continue; } RECT header = item.rect; header.top -= MenuRowH; header.bottom = item.rect.top; DrawMenuText(dc, GroupHeader(item.group), &header, kGreenDim, DT_LEFT | DT_VCENTER | DT_SINGLELINE); } // // Catalog rows: bright = selected, dim = not. // for (int i = 0; i < menu.itemCount; ++i) { const MenuItem &item = menu.items[i]; if (item.group > GroupPort) { continue; } char text[64]; GroupRowText(item.group, item.index, text); int selected = (menu.selection[item.group] == item.index); RECT row = item.rect; row.left += 14; if (selected) { RECT marker = item.rect; marker.right = marker.left + 14; DrawMenuText(dc, ">", &marker, kGreenBright, DT_LEFT | DT_VCENTER | DT_SINGLELINE); } DrawMenuText(dc, text, &row, selected ? kGreenBright : kGreenDim, DT_LEFT | DT_VCENTER | DT_SINGLELINE); } // // Edit labels (the controls themselves are child windows). // RECT label = { MenuCol4X, MenuTopY, MenuCol4X + 220, MenuTopY + MenuRowH }; DrawMenuText(dc, "PILOT NAME", &label, kGreenDim, DT_LEFT | DT_VCENTER | DT_SINGLELINE); label.top = MenuTopY + 3 * MenuRowH; label.bottom = label.top + MenuRowH; DrawMenuText(dc, "LAN PEERS (host: ip:port,...)", &label, kGreenDim, DT_LEFT | DT_VCENTER | DT_SINGLELINE); // // Buttons (framed, RP412 style). // HBRUSH frame = CreateSolidBrush(kGreenBright); for (int i = 0; i < menu.itemCount; ++i) { const MenuItem &item = menu.items[i]; const char *text = (item.group == GroupLaunch) ? "L A U N C H" : (item.group == GroupSteamHost) ? "HOST STEAM LOBBY" : (item.group == GroupSteamJoin) ? "JOIN STEAM LOBBY" : NULL; if (text == NULL) { continue; } RECT box = item.rect; FrameRect(dc, &box, frame); DrawMenuText(dc, text, &box, kGreenBright, DT_CENTER | DT_VCENTER | DT_SINGLELINE); } DeleteObject(frame); RECT help = { MenuCol1X, client.bottom - 30, client.right - 24, client.bottom - 6 }; DrawMenuText(dc, "click to select ENTER = launch ESC = quit", &help, kGreenDim, DT_LEFT | DT_TOP | DT_SINGLELINE); SelectObject(dc, old_font); BitBlt(screen, 0, 0, client.right, client.bottom, dc, 0, 0, SRCCOPY); SelectObject(dc, old_backing); DeleteObject(backing); DeleteDC(dc); EndPaint(window, &paint); } static LRESULT CALLBACK MenuWndProc(HWND window, UINT message, WPARAM wparam, LPARAM lparam) { switch (message) { case WM_PAINT: PaintMenu(window); return 0; case WM_CTLCOLOREDIT: // // The edits render green-on-black like everything else. // SetTextColor((HDC)wparam, kGreenBright); SetBkColor((HDC)wparam, RGB(6, 20, 6)); return (LRESULT)menu.editBrush; case WM_LBUTTONDOWN: { int x = (int)(short)LOWORD(lparam); int y = (int)(short)HIWORD(lparam); for (int i = 0; i < menu.itemCount; ++i) { const MenuItem &item = menu.items[i]; if (x < item.rect.left || x >= item.rect.right || y < item.rect.top || y >= item.rect.bottom) { continue; } if (item.group == GroupLaunch) { menu.result = 1; } else if (item.group == GroupSteamHost) { menu.steamAction = 1; menu.result = 1; } else if (item.group == GroupSteamJoin) { menu.steamAction = 2; menu.result = 1; } else { menu.selection[item.group] = item.index; InvalidateRect(window, NULL, FALSE); } break; } SetFocus(window); // clicks outside the edits take focus back } return 0; case WM_KEYDOWN: if (wparam == VK_RETURN) { menu.result = 1; } else if (wparam == VK_ESCAPE) { menu.result = -1; } return 0; case WM_CLOSE: menu.result = -1; return 0; } return DefWindowProcW(window, message, wparam, lparam); } int BTFrontEnd_Run(BTFeLaunchSpec *spec) { memset(spec, 0, sizeof(*spec)); memset(&menu, 0, sizeof(menu)); menu.selection[GroupLength] = 2; // 10:00, the console default char pilot_name[32] = "Dev"; char peers[128] = ""; LoadPersisted(pilot_name, sizeof(pilot_name), peers, sizeof(peers)); LayoutMenu(); WNDCLASSW window_class; memset(&window_class, 0, sizeof(window_class)); window_class.lpfnWndProc = MenuWndProc; window_class.hInstance = GetModuleHandleW(NULL); window_class.hCursor = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW); window_class.lpszClassName = L"BTFrontEndWnd"; RegisterClassW(&window_class); RECT frame_rect = { 0, 0, MenuClientW, MenuClientH }; DWORD style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX; AdjustWindowRect(&frame_rect, style, FALSE); menu.window = CreateWindowW( L"BTFrontEndWnd", L"BattleTech - Mission Console", style, 100, 80, frame_rect.right - frame_rect.left, frame_rect.bottom - frame_rect.top, NULL, NULL, GetModuleHandleW(NULL), NULL); if (menu.window == NULL) { return -1; } menu.textFont = CreateFontW(-16, 0, 0, 0, FW_NORMAL, 0, 0, 0, DEFAULT_CHARSET, 0, 0, CLEARTYPE_QUALITY, FIXED_PITCH, L"Consolas"); menu.titleFont = CreateFontW(-24, 0, 0, 0, FW_BOLD, 0, 0, 0, DEFAULT_CHARSET, 0, 0, CLEARTYPE_QUALITY, FIXED_PITCH, L"Consolas"); menu.editBrush = CreateSolidBrush(RGB(6, 20, 6)); // // The two edit controls (name; LAN peers for host mode). // menu.nameEdit = CreateWindowW(L"EDIT", L"", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL, MenuCol4X, MenuTopY + MenuRowH, 220, MenuRowH + 4, menu.window, NULL, GetModuleHandleW(NULL), NULL); menu.peersEdit = CreateWindowW(L"EDIT", L"", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL, MenuCol4X, MenuTopY + 4 * MenuRowH, 220, MenuRowH + 4, menu.window, NULL, GetModuleHandleW(NULL), NULL); SendMessageW(menu.nameEdit, WM_SETFONT, (WPARAM)menu.textFont, TRUE); SendMessageW(menu.peersEdit, WM_SETFONT, (WPARAM)menu.textFont, TRUE); SetWindowTextA(menu.nameEdit, pilot_name); SetWindowTextA(menu.peersEdit, peers); ShowWindow(menu.window, SW_SHOW); SetForegroundWindow(menu.window); MSG message; while (menu.result == 0 && GetMessageW(&message, NULL, 0, 0)) { // // ENTER/ESC work with an edit focused too. // if (message.message == WM_KEYDOWN && (message.wParam == VK_RETURN || message.wParam == VK_ESCAPE)) { menu.result = (message.wParam == VK_RETURN) ? 1 : -1; continue; } TranslateMessage(&message); DispatchMessageW(&message); } GetWindowTextA(menu.nameEdit, pilot_name, sizeof(pilot_name)); GetWindowTextA(menu.peersEdit, peers, sizeof(peers)); DestroyWindow(menu.window); DeleteObject(menu.textFont); DeleteObject(menu.titleFont); DeleteObject(menu.editBrush); if (menu.result != 1) { return 1; // quit } SavePersisted(pilot_name[0] ? pilot_name : "Dev", peers); // // Resolve the launch spec + write the egg. // int console_port = kPorts[menu.selection[GroupPort]]; BTFeMission mission; memset(&mission, 0, sizeof(mission)); strcpy(mission.map, kMaps[menu.selection[GroupMap]].key); strcpy(mission.time, kTimes[menu.selection[GroupTime]].key); strcpy(mission.weather, kWeathers[menu.selection[GroupWeather]].key); mission.temperature = 27; mission.lengthSeconds = kLengths[menu.selection[GroupLength]].seconds; mission.pilotCount = 1; BTFePilot &self = mission.pilots[0]; strcpy(self.name, pilot_name[0] ? pilot_name : "Dev"); strcpy(self.vehicle, kVehicles[menu.selection[GroupVehicle]].key); strcpy(self.color, kColors[menu.selection[GroupColor]].key); spec->consolePort = console_port; spec->missionSeconds = mission.lengthSeconds; strcpy(spec->eggPath, "frontend.egg"); int mode = menu.selection[GroupMode]; #ifdef BT_STEAM if (menu.steamAction == 1) { BTLobbyRoster roster; if (BTLobby_HostAndRoom(self.name, self.vehicle, self.color, &roster, spec->steamMyToken, sizeof(spec->steamMyToken), spec->steamMap, sizeof(spec->steamMap)) != 0 || roster.memberCount == 0) { return 1; // cancelled / Steam unavailable } spec->mode = BTFeLaunchHostSteam; mission.pilotCount = 0; sprintf(spec->podList, "127.0.0.1:%d", console_port); for (int m = 0; m < roster.memberCount && m < 8; ++m) { const BTLobbyMember &member = roster.members[m]; BTFePilot &pilot = mission.pilots[mission.pilotCount++]; strncpy(pilot.name, member.name, sizeof(pilot.name) - 1); strncpy(pilot.vehicle, member.vehicle[0] ? member.vehicle : kVehicles[0].key, sizeof(pilot.vehicle) - 1); strncpy(pilot.color, member.color[0] ? member.color : kColors[0].key, sizeof(pilot.color) - 1); sprintf(pilot.address, "%s:%d", member.fakeAddress, member.gamePort); if (!member.isSelf) { char entry[64]; sprintf(entry, ",%s:%d", member.fakeAddress, member.consolePort); strcat(spec->podList, entry); } } if (BTFeMission_WriteEgg(&mission, spec->eggPath) != 0) { return -1; } return 0; } if (menu.steamAction == 2) { if (BTLobby_JoinAndWait(self.name, self.vehicle, self.color, spec->steamMyToken, sizeof(spec->steamMyToken), spec->steamMap, sizeof(spec->steamMap)) != 0) { return 1; } spec->mode = BTFeLaunchJoinSteam; spec->eggPath[0] = 0; return 0; } #endif switch (mode) { case 0: // SOLO MISSION: networked 1-pod, marshal feeds self spec->mode = BTFeLaunchSolo; sprintf(self.address, "127.0.0.1:%d", console_port + 1); sprintf(spec->podList, "127.0.0.1:%d", console_port); break; case 1: // RAW SOLO: the plain -egg endless path spec->mode = BTFeLaunchRawSolo; strcpy(self.address, "127.0.0.1"); break; case 2: // HOST LAN: marshal feeds self + the peers list { spec->mode = BTFeLaunchHostLan; sprintf(self.address, "127.0.0.1:%d", console_port + 1); sprintf(spec->podList, "127.0.0.1:%d", console_port); char peers_copy[128]; strcpy(peers_copy, peers); char *cursor = strtok(peers_copy, ", "); while (cursor != NULL && mission.pilotCount < 8) { char host[48]; int port = 0; const char *colon = strrchr(cursor, ':'); if (colon != NULL && (port = atoi(colon + 1)) > 0 && (int)(colon - cursor) < (int)sizeof(host)) { memcpy(host, cursor, colon - cursor); host[colon - cursor] = 0; BTFePilot &peer = mission.pilots[mission.pilotCount]; sprintf(peer.name, "Pilot%d", mission.pilotCount + 1); strcpy(peer.vehicle, kVehicles[ (menu.selection[GroupVehicle] + mission.pilotCount) % COUNT(kVehicles)].key); strcpy(peer.color, kColors[ (menu.selection[GroupColor] + mission.pilotCount) % COUNT(kColors)].key); sprintf(peer.address, "%s:%d", host, port + 1); ++mission.pilotCount; char entry[64]; sprintf(entry, ",%s:%d", host, port); strcat(spec->podList, entry); } cursor = strtok(NULL, ", "); } } break; default: // JOIN LAN: plain -net pod; the host's marshal feeds us spec->mode = BTFeLaunchJoinLan; spec->eggPath[0] = 0; return 0; } if (BTFeMission_WriteEgg(&mission, spec->eggPath) != 0) { return -1; } return 0; }