// The menu's Co-op tab (runtime/ui/coop_page.cpp) without the game: the page's own code, the menu's rows and shapes, the // real room-secret parser and rules (coop_proto.c, coop_state.c) and Dear ImGui, driven frame by frame with the key // events the menu hands ImGui (menu.cpp drain_events and pad_events: a key's down and up, a held key's repeats as more // downs, a typed letter as its key and its character), the co-op layer and the settings answered here. Checks typing a // name, a relay and a secret with the letters that switch tabs elsewhere, Make, Join with a wrong secret and a pasted // one, the offer accepted and declined, a held or repeated confirm never accepting, removing, resetting or leaving, the // maker's rules and the others' read-only ones, the maker's key to compare, a player not identified (Accept greyed, // Remove by member id only while the same session holds it), Remove by key, the pools' contributors and their reset, // the three warnings before the first Accept, the relay's states; with the keyboard and with the pad. // tests/coop_page_check.py builds and runs it; the exit status is the number of failed checks. COOP_PAGE_FAULT=1 puts // the cursor on each window's acting button as the window opens (Right, as a player would), a fault the checks must // catch. #include #include #include #include #include #include #include "../runtime/ui/coop_page.cpp" // its statics (the window's step, the field) are checked below #include "imgui_internal.h" #include "ui/menu_art.h" // ---- the settings: the co-op rows of cfg.c's table, in memory static CfgMeta kMetas[] = { {"COOP", "0", "0|1", 1}, {"COOP_NAME", "", NULL, 1}, {"COOP_SERVER", "", NULL, 1}, {"COOP_PROGRESS", "shared", "shared|own", 1}, {"COOP_ITEMS", "shared", "shared|own", 1}, {"COOP_SONGS", "shared", "shared|own", 1}, {"COOP_QUEST", "shared", "shared|own", 1}, {"COOP_KEYS", "pool", "pool|own", 1}, {"COOP_RUPEES", "own", "own|pool", 1}, {"COOP_AMMO", "own", "own|pool", 1}, }; enum { N_METAS = sizeof kMetas / sizeof kMetas[0] }; static char g_set[N_METAS][160]; static bool g_is_set[N_METAS]; static unsigned g_cfg_version = 1; static int meta_index(const char *key) { if (!strncmp(key, "NX2NAVI_", 8)) key += 8; for (int i = 0; i < N_METAS; i++) if (!strcmp(kMetas[i].key, key)) return i; return -1; } static void settings_clear(void) { memset(g_is_set, 0, sizeof g_is_set); g_cfg_version++; } // ---- the co-op layer, as the test sets it static CoopView g_fake; static CoopOffer g_fake_offer; static CoopContributor g_fake_contrib[8]; static int g_fake_ncontrib; static bool g_fake_maker, g_fault; static int n_create, n_join, n_leave, n_remove, last_remove, n_accept, n_remove_key, n_reset; static uint32_t last_accept; static char last_join[64], g_clipboard[256], g_copied_text[64], last_remove_key[24]; static bool g_paste_asked; extern "C" { const CfgMeta *cfg_meta(const char *key) { int i = meta_index(key); return i >= 0 ? &kMetas[i] : NULL; } const CfgMeta *cfg_meta_at(int i) { return i >= 0 && i < N_METAS ? &kMetas[i] : NULL; } const char *cfg_get(const char *key) { int i = meta_index(key); return i >= 0 && g_is_set[i] ? g_set[i] : NULL; } const char *cfg_value(const char *key) { int i = meta_index(key); if (i < 0) return ""; return g_is_set[i] && g_set[i][0] ? g_set[i] : kMetas[i].def; } const char *cfg_default(const char *key) { int i = meta_index(key); return i >= 0 ? kMetas[i].def : NULL; } int cfg_int(const char *key) { return atoi(cfg_value(key)); } double cfg_double(const char *key) { return atof(cfg_value(key)); } int cfg_bool(const char *key) { return strcmp(cfg_value(key), "0") != 0 && cfg_value(key)[0]; } int cfg_from_env(const char *) { return 0; } int cfg_pending(const char *) { return 0; } // the rows' "after restart" note: no setting here waits for a restart void cfg_set(const char *key, const char *value) { int i = meta_index(key); if (i < 0) return; snprintf(g_set[i], sizeof g_set[i], "%s", value); g_is_set[i] = true; g_cfg_version++; } int cfg_save(void) { return 1; } int cfg_reset(const char *const *keys, int n) { for (int k = 0; k < n; k++) if (int i = meta_index(keys[k]); i >= 0) g_is_set[i] = false; g_cfg_version++; return n; } unsigned cfg_version(void) { return g_cfg_version; } void menu_sound_play(MenuSound) {} const char *ov_language(void) { return "en-US"; } const char *plat_ui_language(void) { return "en"; } uint64_t plat_now_ns(void) { struct timespec t; clock_gettime(CLOCK_MONOTONIC, &t); return (uint64_t)t.tv_sec * 1000000000ull + (uint64_t)t.tv_nsec; } void rt_log(const char *, ...) {} int menu_art(MenuArt, ImTextureID *, float *, float *) { return 0; } void plat_mutex_lock(PlatMutex *) {} void plat_mutex_unlock(PlatMutex *) {} int menu_is_open(void) { return 1; } void coop_view_get(CoopView *out) { *out = g_fake; } int coop_command(CoopCmd cmd, const char *secret) { if (g_fake.state == COOP_OFF) return 0; // as the layer: nothing while co-op is off if (cmd == COOP_CMD_CREATE) n_create++; if (cmd == COOP_CMD_JOIN) n_join++, snprintf(last_join, sizeof last_join, "%s", secret ? secret : ""); if (cmd == COOP_CMD_LEAVE) n_leave++; return 1; } int coop_remove_member(int member) { return n_remove++, last_remove = member, 1; } int coop_game_offer(CoopOffer *out) { *out = g_fake_offer; return out->token != 0; } // As the layer: refused while a member in the room has not said who they are. int coop_game_accept(uint32_t token) { if (!token || token != g_fake_offer.token || g_fake_offer.unidentified) return 0; return n_accept++, last_accept = token, 1; } int coop_game_remove_key(const char *fingerprint) { if (!g_fake_maker) return 0; return n_remove_key++, snprintf(last_remove_key, sizeof last_remove_key, "%s", fingerprint), 1; } int coop_game_reset_pools(void) { return g_fake_maker ? (n_reset++, 1) : 0; } int coop_game_contributors(CoopContributor *out, int max) { int n = g_fake_ncontrib < max ? g_fake_ncontrib : max; memcpy(out, g_fake_contrib, sizeof *out * (size_t)n); return n; } int coop_game_is_maker(void) { return g_fake_maker; } int plat_clipboard_set(const char *utf8) { return snprintf(g_copied_text, sizeof g_copied_text, "%s", utf8), 1; } void gfx_window_paste(void) { g_paste_asked = true; } int menu_paste_take(char *out, size_t cap) { if (!g_paste_asked) return 0; g_paste_asked = false; snprintf(out, cap, "%s", g_clipboard); return 1; } } // ---- frames and keys static int failures, n_tab_keys; #define CHECK(c, ...) \ do { \ if (!(c)) { \ failures++; \ printf("FAIL %s:%d: ", __FILE__, __LINE__); \ printf(__VA_ARGS__); \ printf("\n"); \ } \ } while (0) static ImGuiTextBuffer g_text; // the text the last frame drew with ImGui's text calls (lines, windows) static int g_fault_release; // frames until the fault's Right comes up again; 0 none down static bool g_fault_due; // a window opened: Right goes down once no item is held active (ImGui moves no cursor then) static void frame(void) { ImGuiIO &io = ImGui::GetIO(); io.DisplaySize = ImVec2(1280, 720); io.DeltaTime = 1 / 60.0f; ImGui::NewFrame(); ImGui::SetNextWindowPos(ImVec2(40, 40), ImGuiCond_Always); ImGui::SetNextWindowSize(ImVec2(1200, 640), ImGuiCond_Always); ImGui::Begin("##menu", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings); ImGui::LogToBuffer(); opt_begin("##coop", 1); // as menu.cpp tab_coop coop_rows(1); opt_end(); const bool fresh = g_page_new; coop_after_page(1); g_text.clear(); g_text.append(GImGui->LogBuffer.c_str()); ImGui::LogFinish(); // menu.cpp layout_menu's tab keys, which the page's window and a text field keep for themselves const bool keeps_keys = coop_modal() || io.WantTextInput; if (!keeps_keys && (ImGui::IsKeyPressed(ImGuiKey_E, false) || ImGui::IsKeyPressed(ImGuiKey_Q, false))) n_tab_keys++; ImGui::End(); ImGui::Render(); // the deliberate fault: a window that acts on the room opens with the cursor moved onto its acting button if (g_fault_release && !--g_fault_release) io.AddKeyEvent(ImGuiKey_RightArrow, false); if (g_fault && fresh && g_open && !field_page()) g_fault_due = true; if (g_fault_due && !g_open) g_fault_due = false; // ImGui moves no cursor while the key that opened the window is held or in the window's first frames const bool held = ImGui::IsKeyDown(ImGuiKey_Enter) || ImGui::IsKeyDown(ImGuiKey_GamepadFaceDown) || GImGui->ActiveId; if (g_fault_due && !fresh && !held && !g_fault_release) io.AddKeyEvent(ImGuiKey_RightArrow, true), g_fault_release = 2, g_fault_due = false; } static void frames(int n) { for (int i = 0; i < n; i++) frame(); } static void key(ImGuiKey k, bool down) { ImGui::GetIO().AddKeyEvent(k, down); } // A press and its release, a few frames apart as a player's are. static void tap(ImGuiKey k) { key(k, true); frames(3); key(k, false); frames(3); } // Held for n frames with the system's repeats (another down every frame), then released. static void hold(ImGuiKey k, int n) { for (int i = 0; i < n; i++) { key(k, true); frame(); } key(k, false); frames(3); } // Typed on a keyboard: a letter's key goes down, its character arrives, the key comes up (SDL's order). static void type(const char *s) { for (; *s; s++) { char c = *s; ImGuiKey k = c >= 'a' && c <= 'z' ? (ImGuiKey)(ImGuiKey_A + (c - 'a')) : c >= 'A' && c <= 'Z' ? (ImGuiKey)(ImGuiKey_A + (c - 'A')) : ImGuiKey_None; if (k != ImGuiKey_None) key(k, true); ImGui::GetIO().AddInputCharacter((unsigned)c); frame(); if (k != ImGuiKey_None) key(k, false); frame(); } } struct Input { const char *name; ImGuiKey act, back, up, down, right, left; }; static const Input kKeyboard = {"keyboard", ImGuiKey_Enter, ImGuiKey_Escape, ImGuiKey_UpArrow, ImGuiKey_DownArrow, ImGuiKey_RightArrow, ImGuiKey_LeftArrow}; static const Input kPad = {"gamepad", ImGuiKey_GamepadFaceDown, ImGuiKey_GamepadFaceRight, ImGuiKey_GamepadDpadUp, ImGuiKey_GamepadDpadDown, ImGuiKey_GamepadDpadRight, ImGuiKey_GamepadDpadLeft}; static ImGuiID window_id(const char *label) { ImGuiWindow *w = ImGui::FindWindowByName("##coopwin"); return w ? w->GetID(label) : 0; } static const char *nav_name(void) { static char out[64]; static const char *const labels[] = {"Not now##no", "Accept##yes", "Cancel##no", "Remove##yes", "Reset the pools##yes", "Stay##no", "Leave the room##yes", "OK##yes", "Join a room##yes", "Paste", "##coop_field"}; for (const char *l : labels) if (GImGui->NavId && GImGui->NavId == window_id(l)) return l; snprintf(out, sizeof out, "%08x", GImGui->NavId); return out; } static bool shows(UiTextId id) { return strstr(g_text.c_str(), menu_text(id)) != nullptr; } // The cursor on a row of the page, as a move of the D-pad would put it there; then act on it. static void row(const char *key_of_row) { opt_focus_key(key_of_row); frames(3); } static void press_row(const Input &in, const char *key_of_row) { row(key_of_row); tap(in.act); } static void close_window(void) { coop_cancel(); frames(4); } static void counters_clear(void) { n_create = n_join = n_leave = n_remove = n_accept = n_remove_key = n_reset = 0; last_remove = 0, last_accept = 0, last_join[0] = last_remove_key[0] = 0, n_tab_keys = 0; } // ---- the views the layer hands out static void member(CoopView &v, int id, const char *name, bool maker, uint32_t heard_ms) { CoopPeer &m = v.member[v.n++]; memset(&m, 0, sizeof m); m.id = (uint8_t)id, m.maker = maker, m.heard_ms = heard_ms, m.session = 0x5e550000u + (uint64_t)id; snprintf(m.name, sizeof m.name, "%s", name); } static void out_of_room(CoopState st, const char *status) { memset(&g_fake, 0, sizeof g_fake); memset(&g_fake_offer, 0, sizeof g_fake_offer); g_fake_ncontrib = 0, g_fake_maker = false; g_fake.state = st; g_fake.version++; snprintf(g_fake.status, sizeof g_fake.status, "%s", status); } static const char kAliceKey[] = "a11c-e000-0000-0001", kBobKey[] = "b0b0-0000-0000-0002", kDaveKey[] = "da7e-0000-0000-0004"; // An entry of the offer: the other member id, by the name and key its game signed (heard), or not identified. static void offer_member_add(int id, const char *name, const char *key, bool maker, bool heard) { CoopOfferMember &m = g_fake_offer.member[g_fake_offer.n++]; memset(&m, 0, sizeof m); m.id = id, m.maker = maker, m.heard = heard; snprintf(m.name, sizeof m.name, "%s", name); // the relay's name until heard (coop_game.c offer_of) snprintf(m.key, sizeof m.key, "%s", heard ? key : ""); } // Bob in Alice's room (Alice made it), or Alice in her own room with Bob; the offer waiting or not. static void in_room_as(bool maker, uint32_t token, bool accepted) { memset(&g_fake, 0, sizeof g_fake); g_fake.state = COOP_JOINED; snprintf(g_fake.code, sizeof g_fake.code, "K7M3PR-BCDFGH-234567"); member(g_fake, 1, "Alice", true, maker ? 0 : 1200); member(g_fake, 2, "Bob", false, maker ? 2300 : 0); g_fake.self = maker ? 1 : 2, g_fake.maker = 1, g_fake.made = maker; snprintf(g_fake.name, sizeof g_fake.name, "%s", maker ? "Alice" : "Bob"); g_fake.version++; g_fake_maker = maker, g_fake_ncontrib = 0; memset(&g_fake_offer, 0, sizeof g_fake_offer); g_fake_offer.token = token, g_fake_offer.accepted = accepted, g_fake_offer.copy = accepted; if (maker) offer_member_add(2, "Bob", kBobKey, false, true); else offer_member_add(1, "Alice", kAliceKey, true, true); snprintf(g_fake_offer.maker_key, sizeof g_fake_offer.maker_key, "%s", kAliceKey); coop_rules_default(&g_fake_offer.rules); g_fake_offer.rules.epoch = 1, g_fake_offer.rules.maker = 1; } // Carol in the room, who has not said who she is: her game never identified itself. static void carol_unidentified(void) { member(g_fake, 3, "Carol", false, UINT32_MAX); g_fake.version++; offer_member_add(3, "Carol", "", false, false); g_fake_offer.unidentified = 1; } static bool shows_text(const char *s) { return strstr(g_text.c_str(), s) != nullptr; } // ---- the checks static void check_fields_by_keyboard(void) { printf("keyboard text:\n"); settings_clear(); out_of_room(COOP_OFF, ""); counters_clear(); frames(4); // with no relay, Make and Join are greyed: a press makes nothing press_row(kKeyboard, "##coop_make"); press_row(kKeyboard, "##coop_join"); CHECK(n_create == 0 && !g_open, "Make and Join with no relay: %d rooms, window %d", n_create, g_open); // the name: the field takes the cursor, Q and E are letters (no tab switch), Enter keeps it press_row(kKeyboard, "NX2NAVI_COOP_NAME"); CHECK(g_open && g_page == P_NAME && GImGui->ActiveId == window_id("##coop_field"), "Name: window %d step %d, field %s", g_open, g_page, GImGui->ActiveId == window_id("##coop_field") ? "active" : "not active"); type("Zelda Qe"); CHECK(n_tab_keys == 0 && coop_modal(), "typing Q and E in the name switched tabs %d times", n_tab_keys); tap(ImGuiKey_Enter); CHECK(!g_open && !strcmp(cfg_value("NX2NAVI_COOP_NAME"), "Zelda Qe"), "Name: '%s' kept, window %d", cfg_value("NX2NAVI_COOP_NAME"), g_open); printf(" name typed with Q and E: '%s', %d tab switches\n", cfg_value("NX2NAVI_COOP_NAME"), n_tab_keys); // the same letters with no field: the tab keys work (the gate above is not always shut) tap(ImGuiKey_E); CHECK(n_tab_keys == 1, "E on the page itself: %d tab switches", n_tab_keys); n_tab_keys = 0; // Esc in a field drops the edit and closes the window press_row(kKeyboard, "NX2NAVI_COOP_NAME"); type("x"); tap(ImGuiKey_Escape); CHECK(!g_open && !strcmp(cfg_value("NX2NAVI_COOP_NAME"), "Zelda Qe"), "Esc in the name: '%s', window %d", cfg_value("NX2NAVI_COOP_NAME"), g_open); // the relay press_row(kKeyboard, "NX2NAVI_COOP_SERVER"); type("127.0.0.1:24680"); tap(ImGuiKey_Enter); CHECK(!strcmp(cfg_value("NX2NAVI_COOP_SERVER"), "127.0.0.1:24680"), "Relay: '%s'", cfg_value("NX2NAVI_COOP_SERVER")); printf(" relay typed: '%s'\n", cfg_value("NX2NAVI_COOP_SERVER")); // Make while co-op is off: the switch goes on and the room is made once the coop thread is up press_row(kKeyboard, "##coop_make"); CHECK(cfg_bool("NX2NAVI_COOP") && n_create == 0, "Make with co-op off: switch %d, %d rooms before it is up", cfg_bool("NX2NAVI_COOP"), n_create); out_of_room(COOP_LEFT, ""); frames(2); CHECK(n_create == 1, "Make once co-op is up: %d rooms", n_create); printf(" Make with co-op off: switch on, then %d room made\n", n_create); // Join with a wrong secret: refused in the window, nothing sent; then one in lower case with dashes press_row(kKeyboard, "##coop_join"); CHECK(g_open && g_page == P_JOIN && GImGui->ActiveId == window_id("##coop_field"), "Join: the field is not active"); type("k7m3pq-bcdfgh-23456e"); // E and Q are not in the alphabet of secrets tap(ImGuiKey_Enter); frames(2); CHECK(n_join == 0 && g_open && g_field_bad && shows(UI_MENU_COOP_SECRET_BAD) && n_tab_keys == 0, "a wrong secret: %d joins, window %d, said %d, %d tab switches", n_join, g_open, shows(UI_MENU_COOP_SECRET_BAD), n_tab_keys); printf(" wrong secret: %d joins, the window says it is not one\n", n_join); ImGui::ClearActiveID(); frames(2); tap(ImGuiKey_Escape); press_row(kKeyboard, "##coop_join"); type("k7m3pr-bcdfgh-234567"); tap(ImGuiKey_Enter); CHECK(n_join == 1 && !strcmp(last_join, "K7M3PRBCDFGH234567") && !g_open, "the secret in lower case: %d joins of '%s'", n_join, last_join); printf(" secret in lower case with dashes: %d join of %s\n", n_join, last_join); // the relay knows no such room: the page says the secret is wrong out_of_room(COOP_LEFT, "no such room"); frames(3); CHECK(shows(UI_MENU_COOP_NO_ROOM), "no such room: the page does not say the secret may be wrong"); printf(" the relay has no such room: the page says so\n"); } static void check_join_by_pad(void) { printf("gamepad join:\n"); out_of_room(COOP_LEFT, ""); counters_clear(); frames(3); // the window opens with the cursor on Cancel: A, A goes back press_row(kPad, "##coop_join"); CHECK(g_open && g_page == P_JOIN && !strcmp(nav_name(), "Cancel##no"), "Join by pad: cursor on %s", nav_name()); tap(kPad.act); CHECK(!g_open && n_join == 0, "Join, A, A: window %d, %d joins", g_open, n_join); // Paste: the clipboard's secret with a line end and spaces, then Join snprintf(g_clipboard, sizeof g_clipboard, " k7m3pr-bcdfgh-234567\n"); press_row(kPad, "##coop_join"); tap(kPad.up); CHECK(!strcmp(nav_name(), "Paste"), "up from Cancel: %s", nav_name()); tap(kPad.act); frames(2); CHECK(!strcmp(g_field, "K7M3PR-BCDFGH-234567"), "pasted: '%s'", g_field); tap(kPad.down); tap(kPad.right); CHECK(!strcmp(nav_name(), "Join a room##yes"), "down, right: %s", nav_name()); tap(kPad.act); CHECK(n_join == 1 && !strcmp(last_join, "K7M3PRBCDFGH234567"), "pasted secret: %d joins of '%s'", n_join, last_join); // an empty clipboard says so snprintf(g_clipboard, sizeof g_clipboard, "\n"); press_row(kPad, "##coop_join"); tap(kPad.up); tap(kPad.act); frames(2); CHECK(g_paste_empty && shows(UI_MENU_COOP_PASTE_EMPTY), "an empty clipboard is not said"); close_window(); printf(" pasted secret joined by pad: %d join; an empty clipboard is said\n", n_join); } static void check_offer(const Input &in) { printf("%s offer:\n", in.name); in_room_as(false, 0x1234567u, false); counters_clear(); g_accepted_once = false; // as at a start of the game: the warnings come before the first Accept frames(4); CHECK(shows(UI_MENU_COOP_OFFER_TRUST) == false && strstr(g_text.c_str(), "Alice (made the room)"), "the page does not name the room's members"); CHECK(shows_text(kAliceKey) && shows(UI_MENU_COOP_OFFER_COMPARE), "the page does not show the maker's key to compare"); CHECK(!shows(UI_MENU_COOP_POOLS) && !shows(UI_MENU_COOP_RESET), "a player who is not the maker sees the pools' remedies"); // the row's press opens the window with the cursor on Not now; the same button again goes back press_row(in, "##coop_answer"); CHECK(g_open && g_page == P_ACCEPT && !strcmp(nav_name(), "Not now##no"), "Accept window: cursor on %s", nav_name()); CHECK(shows(UI_MENU_COOP_OFFER_COPY) && shows(UI_MENU_COOP_OFFER_TRUST), "the window does not say what accepting does"); CHECK(shows(UI_MENU_COOP_WARN_SAVE) && shows(UI_MENU_COOP_WARN_ROOM) && shows(UI_MENU_COOP_WARN_KEY) && shows_text(kAliceKey), "the first Accept window lacks the three warnings or the maker's key"); tap(in.act); CHECK(n_accept == 0 && !g_open, "Accept or not, act, act: %d accepts, window %d", n_accept, g_open); // held on the row through the window's opening, then held again in it row("##coop_answer"); hold(in.act, 120); CHECK(n_accept == 0, "act held 2 s on the row: %d accepts", n_accept); if (!g_open) press_row(in, "##coop_answer"); hold(in.act, 120); CHECK(n_accept == 0, "act held again in the window: %d accepts", n_accept); // declined: Not now, and B close_window(); press_row(in, "##coop_answer"); tap(in.back); CHECK(n_accept == 0 && !g_open, "back: %d accepts", n_accept); // a new player while the cursor is on Accept: the window shows the new offer and the cursor goes back to Not now press_row(in, "##coop_answer"); tap(in.right); CHECK(!strcmp(nav_name(), "Accept##yes"), "right from Not now: %s", nav_name()); g_fake_offer.token = 0x7654321u, g_fake_offer.n = 2; snprintf(g_fake_offer.member[1].name, sizeof g_fake_offer.member[1].name, "Carol"); frames(3); CHECK(!strcmp(nav_name(), "Not now##no") && strstr(g_text.c_str(), "Carol"), "a new offer under the cursor: %s", nav_name()); tap(in.act); CHECK(n_accept == 0, "a new offer, act: %d accepts", n_accept); printf(" act, act / held / back / a new offer: %d accepts\n", n_accept); // accepted on purpose: right, act press_row(in, "##coop_answer"); tap(in.right); tap(in.act); CHECK(n_accept == 1 && last_accept == 0x7654321u && !g_open, "Accept chosen: %d accepts of %08x", n_accept, last_accept); printf(" right, act: %d accept of the offer shown\n", n_accept); g_fake_offer.accepted = 1, g_fake_offer.copy = 1; frames(3); CHECK(shows(UI_MENU_COOP_ACCEPTED), "accepted: the page does not say so"); // a later offer (another player): the warnings were read before the first Accept, the key is still there g_fake_offer.token = 0x7654322u, g_fake_offer.accepted = 0, g_fake_offer.copy = 0; press_row(in, "##coop_answer"); CHECK(g_open && !shows(UI_MENU_COOP_WARN_SAVE) && shows_text(kAliceKey), "a later Accept window: warnings %d, key %d", shows(UI_MENU_COOP_WARN_SAVE), shows_text(kAliceKey)); close_window(); printf(" the maker's key shown to compare; the three warnings before the first Accept only\n"); g_fake_offer.accepted = 1, g_fake_offer.copy = 1; frames(3); // the rules of someone else's room: read only const char *before = cfg_value("NX2NAVI_COOP_RUPEES"); press_row(in, "##coop_room_rule5"); row("##coop_room_rule5"); tap(in.right); CHECK(!strcmp(cfg_value("NX2NAVI_COOP_RUPEES"), before), "a member changed the room's rule: rupees %s", cfg_value("NX2NAVI_COOP_RUPEES")); printf(" a member's press and right on a rule: rupees still %s\n", cfg_value("NX2NAVI_COOP_RUPEES")); } static void check_maker(const Input &in) { printf("%s maker:\n", in.name); settings_clear(); in_room_as(true, 0x2222223u, true); counters_clear(); frames(4); // a rule the maker changes: rupees into a pool; items cannot leave a shared world (greyed) row("NX2NAVI_COOP_RUPEES"); tap(in.right); CHECK(!strcmp(cfg_value("NX2NAVI_COOP_RUPEES"), "pool"), "the maker's rupees: %s", cfg_value("NX2NAVI_COOP_RUPEES")); row("NX2NAVI_COOP_ITEMS"); tap(in.right); tap(in.act); CHECK(!strcmp(cfg_value("NX2NAVI_COOP_ITEMS"), "shared"), "items with progress shared: %s", cfg_value("NX2NAVI_COOP_ITEMS")); printf(" rupees -> %s; items stay %s while progress is shared\n", cfg_value("NX2NAVI_COOP_RUPEES"), cfg_value("NX2NAVI_COOP_ITEMS")); // Remove: the cursor on Cancel; act again, held, back: nothing; right, act: removed by its key CHECK(shows_text(kAliceKey), "the maker's page does not show its own key to read out"); press_row(in, "##coop_member2"); CHECK(g_open && g_page == P_REMOVE && !strcmp(nav_name(), "Cancel##no") && shows_text(kBobKey), "Remove window: cursor on %s, key shown %d", nav_name(), shows_text(kBobKey)); tap(in.act); CHECK(n_remove + n_remove_key == 0 && !g_open, "Remove, act, act: %d removals", n_remove + n_remove_key); row("##coop_member2"); hold(in.act, 120); if (!g_open) press_row(in, "##coop_member2"); hold(in.act, 120); CHECK(n_remove + n_remove_key == 0, "act held on a player and in the window: %d removals", n_remove + n_remove_key); close_window(); press_row(in, "##coop_member1"); // the maker's own row opens nothing CHECK(!g_open, "the maker's own row opened a window"); press_row(in, "##coop_member2"); tap(in.right); tap(in.act); CHECK(n_remove == 0 && n_remove_key == 1 && !strcmp(last_remove_key, kBobKey), "Remove chosen: %d by id, %d by key (%s)", n_remove, n_remove_key, last_remove_key); printf(" Remove: act, act / held: none; right, act: %d removal of key %s\n", n_remove_key, last_remove_key); // a player who never said who they are: by member id, and only while the same session holds it carol_unidentified(); frames(3); CHECK(shows_text("Players in the room who are not identified"), "the maker's page does not say Carol is not identified"); press_row(in, "##coop_member3"); CHECK(g_open && g_page == P_REMOVE && !strcmp(nav_name(), "Cancel##no") && shows(UI_MENU_COOP_NOT_IDENTIFIED), "Remove Carol: cursor on %s, not identified said %d", nav_name(), shows(UI_MENU_COOP_NOT_IDENTIFIED)); tap(in.right); g_fake.member[2].session++, g_fake.version++; // Carol left and someone else got her id meanwhile frames(3); CHECK(n_remove == 0 && !g_open, "another session under the window: %d removals by id, window %d", n_remove, g_open); press_row(in, "##coop_member3"); tap(in.right); tap(in.act); CHECK(n_remove == 1 && last_remove == 3 && n_remove_key == 1, "Remove of a player not identified: %d by id (%d)", n_remove, last_remove); printf(" a player not identified: removed by id only while the same session holds it (%d removal)\n", n_remove); // the pools: Dave, who left, took 3 keys beyond what he brought; Bob none; the maker's own row is left out g_fake_ncontrib = 3; memset(g_fake_contrib, 0, sizeof g_fake_contrib); snprintf(g_fake_contrib[0].key, sizeof g_fake_contrib[0].key, "%s", kAliceKey), g_fake_contrib[0].self = 1; g_fake_contrib[0].spent[0] = 9; snprintf(g_fake_contrib[1].key, sizeof g_fake_contrib[1].key, "%s", kBobKey), g_fake_contrib[1].member = 2; snprintf(g_fake_contrib[1].name, sizeof g_fake_contrib[1].name, "Bob"); snprintf(g_fake_contrib[2].key, sizeof g_fake_contrib[2].key, "%s", kDaveKey), g_fake_contrib[2].spent[0] = 3; counters_clear(); frames(3); char spent_row[48]; snprintf(spent_row, sizeof spent_row, "##coop_spent%s", kDaveKey); CHECK(shows(UI_MENU_COOP_POOLS) && !shows(UI_MENU_COOP_SPENT_NONE), "the maker's pools list nobody who took more"); press_row(in, spent_row); CHECK(g_open && g_page == P_REMOVE && !strcmp(nav_name(), "Cancel##no") && shows_text(kDaveKey) && shows(UI_MENU_COOP_NOT_IN_ROOM), "Remove Dave's key: cursor on %s, key %d", nav_name(), shows_text(kDaveKey)); tap(in.act); row(spent_row); hold(in.act, 120); if (!g_open) press_row(in, spent_row); hold(in.act, 120); CHECK(n_remove_key == 0, "act, act / held on Dave's key: %d removals", n_remove_key); close_window(); press_row(in, spent_row); tap(in.right); tap(in.act); CHECK(n_remove_key == 1 && !strcmp(last_remove_key, kDaveKey), "Dave's key chosen: %d removals of %s", n_remove_key, last_remove_key); // Reset the pools: the cursor on Cancel; act again, held: nothing; right, act: reset press_row(in, "##coop_reset"); CHECK(g_open && g_page == P_RESET && !strcmp(nav_name(), "Cancel##no"), "Reset window: cursor on %s", nav_name()); tap(in.act); row("##coop_reset"); hold(in.act, 120); if (!g_open) press_row(in, "##coop_reset"); hold(in.act, 120); CHECK(n_reset == 0, "act, act / held on Reset the pools: %d resets", n_reset); close_window(); press_row(in, "##coop_reset"); tap(in.right); tap(in.act); CHECK(n_reset == 1 && !g_open, "Reset chosen: %d resets", n_reset); printf(" pools: Dave's key removed (%d), act, act / held: nothing; Reset: %d\n", n_remove_key, n_reset); g_fake_ncontrib = 0; // the secret: hidden until asked (its row's press shows it, a second hides it), copied on its row CHECK(!g_show_secret, "the secret shows unasked"); press_row(in, "##coop_secret"); CHECK(g_show_secret, "the secret's row did not show it"); press_row(in, "##coop_secret"); CHECK(!g_show_secret, "the secret's row did not hide it again"); press_row(in, "##coop_copy"); CHECK(!strcmp(g_copied_text, "K7M3PR-BCDFGH-234567"), "copied: '%s'", g_copied_text); // Leave: the cursor on Stay, the maker told what leaving costs; act again, held: stays; right, act: leaves press_row(in, "##coop_leave"); CHECK(g_open && g_page == P_LEAVE && !strcmp(nav_name(), "Stay##no") && shows(UI_MENU_COOP_LEAVE_MAKER), "Leave window: cursor on %s", nav_name()); tap(in.act); CHECK(n_leave == 0 && !g_open, "Leave, act, act: %d leaves", n_leave); row("##coop_leave"); hold(in.act, 120); if (!g_open) press_row(in, "##coop_leave"); hold(in.act, 120); CHECK(n_leave == 0, "act held on Leave and in the window: %d leaves", n_leave); close_window(); press_row(in, "##coop_leave"); tap(in.right); tap(in.act); CHECK(n_leave == 1, "Leave chosen: %d leaves", n_leave); printf(" Leave: act, act / held: stays; right, act: %d leave\n", n_leave); } // A player in the room who is not identified: their game never said who they are, or two keys present themselves for // their session (the engine disputes it: heard 0, counted in unidentified, the same to the page). The page names them // and says why, the Accept window says it too with Accept greyed (right does not reach it, act does nothing); once they // are identified Accept works. static void check_unidentified(const Input &in) { printf("%s not identified:\n", in.name); in_room_as(false, 0x3333333u, false); carol_unidentified(); counters_clear(); frames(4); CHECK(shows(UI_MENU_COOP_NOT_IDENTIFIED) && shows_text("Carol (") && shows_text("Players in the room who are not identified"), "the page does not say Carol is not identified and why the room cannot be accepted"); press_row(in, "##coop_answer"); CHECK(g_open && !strcmp(nav_name(), "Not now##no") && shows_text("Players in the room who are not identified"), "Accept window with Carol not identified: cursor on %s", nav_name()); tap(in.right); tap(in.act); CHECK(n_accept == 0, "right, act with a player not identified: %d accepts", n_accept); close_window(); g_fake_offer.unidentified = 0, g_fake_offer.member[1].heard = 1; snprintf(g_fake_offer.member[1].name, sizeof g_fake_offer.member[1].name, "Carol"); snprintf(g_fake_offer.member[1].key, sizeof g_fake_offer.member[1].key, "c4r0-0000-0000-0003"); g_fake_offer.token = 0x3333334u; press_row(in, "##coop_answer"); tap(in.right); tap(in.act); CHECK(n_accept == 1 && last_accept == 0x3333334u, "Carol identified, right, act: %d accepts", n_accept); printf(" Accept greyed while Carol is not identified; 1 accept once she is\n"); } // What of a row's note the Co-op tab shows. option_rows.cpp draws a row's note at 0.72 of the font size, at most 60 % of // (row width - 2 pad) wide, and clips the rest. At the harness's 1903x1030 window Review T measured, from a picture of // the tab, a row 689 px wide with a 23 px pad (a note shows at most 386 px) and the note "press to show" 113 px wide; // the menu's font is Roboto Medium (runtime/ui/fonts, the menu's text below the CJK glyphs it takes from the game), here // scaled to that size. The first part of the note up to its first " · " must show whole. zh-Hans is not measured: its // glyphs come from the game's own files. static ImFont *g_roboto; static void note_fits(const char *what, const char *note) { CHECK(g_roboto, "the menu's font (COOP_PAGE_FONT) did not load: the note's width is not measured"); if (!g_roboto) return; const float row = 689, pad = 23, ref_px = 113, cap = (row - 2 * pad) * 0.6f; const float size = 26.0f * 0.72f * ref_px / g_roboto->CalcTextSizeA(26.0f * 0.72f, 1e9f, 0, "press to show").x; const char *end = strstr(note, " · "); const float width = g_roboto->CalcTextSizeA(size, 1e9f, 0, note, end ? end : note + strlen(note)).x; CHECK(width <= cap, "%s: the note's first part is %.0f px, of which the row shows %.0f: '%s'", what, width, cap, note); printf(" %s: the note's first part %.0f px of the %.0f px a row shows\n", what, width, cap); } // A key the player accepted that now signs another name (the seventh review: it took another member's place in the // room): Dave holds member 3 with the key the player accepted as Carol. The engine makes it a new offer // (CoopOfferMember.accepted_as); the page says the name it was accepted as in the offer, in Dave's row and in the Accept // window, and Accept takes the new offer only. static void check_moved_key(const Input &in) { printf("%s a key accepted under another name:\n", in.name); static const char kCarolKey[] = "c4r0-0000-0000-0003"; in_room_as(false, 0x4444444u, false); member(g_fake, 3, "Dave", false, 800); g_fake.version++; offer_member_add(3, "Dave", kCarolKey, false, true); snprintf(g_fake_offer.member[1].accepted_as, sizeof g_fake_offer.member[1].accepted_as, "Carol"); counters_clear(); frames(4); char moved[96], in_offer[128], note[400]; snprintf(moved, sizeof moved, menu_text(UI_MENU_COOP_ACCEPTED_AS), "Carol"); snprintf(in_offer, sizeof in_offer, "Dave (%s)", moved); // the row's note is drawn into the draw list, not logged as text: it is checked as the page builds it, and a row // shows only the start of a long note, so the name the key was accepted as comes first member_note(g_fake.member[2], offer_member(g_fake_offer, 3), false, note, sizeof note); CHECK(shows_text(in_offer), "the offer does not say Dave's key was accepted as Carol"); CHECK(!strncmp(note, moved, strlen(moved)), "Dave's row does not begin with his key's accepted name: '%s'", note); note_fits("Dave's row", note); static const char *const others[] = {"ru", "pt-BR"}; // the same part in the other languages; zh-Hans: see note_fits for (const char *l : others) { char other[160]; snprintf(other, sizeof other, ui_text_in(l, UI_MENU_COOP_ACCEPTED_AS), "Carol"); note_fits(l, other); } press_row(in, "##coop_answer"); CHECK(g_open && g_page == P_ACCEPT && !strcmp(nav_name(), "Not now##no") && shows_text(in_offer), "Accept window with Carol's key under Dave: cursor on %s", nav_name()); tap(in.right); tap(in.act); CHECK(n_accept == 1 && last_accept == 0x4444444u, "Carol's key under Dave, right, act: %d accepts of %08x", n_accept, last_accept); printf(" the offer, Dave's row and the Accept window say 'a key you accepted as Carol'; %d accept of the new offer\n", n_accept); } // The relay's states the page says in words: its limit on joins from one network, and a room it lost. static void check_states(void) { printf("relay states:\n"); out_of_room(COOP_CONNECTING, "too many joins from this network; trying again in a minute"); frames(3); CHECK(shows(UI_MENU_COOP_JOIN_LIMIT), "the relay's join limit is not said"); out_of_room(COOP_CONNECTING, "the room was lost; waiting for it"); frames(3); CHECK(shows(UI_MENU_COOP_LOST), "a room the relay lost is not said"); printf(" the join limit and a lost room are said\n"); } // The conversions of a printf format in order ("%s%u" for "heard %u s ago, %s"), "%%" left out. static void conversions(const char *f, char *out, size_t cap) { size_t k = 0; for (; *f && k + 3 < cap; f++) { if (*f != '%') continue; if (f[1] == '%') { f++; continue; } while (f[1] && !strchr("sdiuxXcfgp", f[1])) f++; out[k++] = '%', out[k++] = f[1]; } out[k] = 0; } // The checks --probe-services makes of the catalog (ov_probe.c probe_menu_text), for the Co-op tab's texts: English, // Russian, Brazilian Portuguese and Simplified Chinese, none empty, each short enough for the description pane, and // the same printf conversions in every language as in English. The other menu texts that lack a language are counted // and named, not failed: they are not this page's. static void check_catalog(void) { static const char *const langs[] = {"en", "ru", "pt-BR", "zh-Hans"}; for (int id = UI_MENU_TAB_COOP; id <= UI_MENU_COOP_ACCEPTED_AS; id++) { char en[32], other[32]; conversions(ui_text_in("en", (UiTextId)id), en, sizeof en); for (const char *l : langs) { CHECK(ui_text_defined(l, (UiTextId)id), "co-op text %d ('%s') lacks %s", id, ui_text_in("en", (UiTextId)id), l); CHECK(strlen(ui_text_in(l, (UiTextId)id)) + 256 < UI_DESC_BYTES, "co-op text %d in %s is too long", id, l); conversions(ui_text_in(l, (UiTextId)id), other, sizeof other); CHECK(!strcmp(en, other), "co-op text %d: %s has '%s', English '%s'", id, l, other, en); } } printf("catalog: the %d co-op texts in en, ru, pt-BR and zh-Hans, with English's conversions\n", UI_MENU_COOP_ACCEPTED_AS - UI_MENU_TAB_COOP + 1); int gaps = 0; for (int id = UI_MENU_FIRST; id < UI_MENU_TAB_COOP; id++) for (const char *l : langs) if (!ui_text_defined(l, (UiTextId)id)) { if (!gaps++) printf(" not this page's, lacking a language:"); printf(" %d (%s, '%s')", id, l, ui_text_in("en", (UiTextId)id)); } if (gaps) printf("\n"); } int main(void) { IMGUI_CHECKVERSION(); ImGui::CreateContext(); ImGuiIO &io = ImGui::GetIO(); io.IniFilename = nullptr; io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard | ImGuiConfigFlags_NavEnableGamepad; // as menu.cpp io.BackendFlags |= ImGuiBackendFlags_HasGamepad; io.Fonts->AddFontDefault(); // the font the page is drawn with here; Roboto only measures notes (note_fits) static const ImWchar ranges[] = {0x20, 0x24f, 0x400, 0x4ff, 0x2000, 0x206f, 0}; if (const char *f = getenv("COOP_PAGE_FONT")) g_roboto = io.Fonts->AddFontFromFileTTF(f, 26.0f, nullptr, ranges); unsigned char *px; int w, h; io.Fonts->GetTexDataAsRGBA32(&px, &w, &h); frames(2); g_fault = getenv("COOP_PAGE_FAULT") && atoi(getenv("COOP_PAGE_FAULT")); if (g_fault) printf("deliberate fault: each window that acts on the room opens with Right pressed\n"); check_fields_by_keyboard(); check_join_by_pad(); check_offer(kKeyboard); check_offer(kPad); check_maker(kKeyboard); check_maker(kPad); check_unidentified(kKeyboard); check_unidentified(kPad); check_moved_key(kKeyboard); check_moved_key(kPad); check_states(); check_catalog(); ImGui::DestroyContext(); printf("coop page: %s\n", failures ? "see FAIL lines" : "ok"); return failures; }