mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-15 21:29:58 -04:00
Up to four players, each in their own game and save, meet in a room. Rooms are Steam lobbies and the games talk through Steam's networking, so nobody forwards a port and nobody runs a server. The game signs in to Steam as its test app (480), so Steam shows the player as playing Spacewar. Off by default; the menu has a Co-op tab with Create a room, Join a room by its ID, Invite a friend, the players, chat and Leave, in English, Russian, Brazilian Portuguese and Simplified Chinese. runtime/steam.c loads steam_api64.dll from beside the exe at run time and declares the C functions it calls itself; nothing of the Steamworks SDK is in the repository, and a player copies the file from a Steam game they have. runtime/coop.c is the room: the lobby's owner is the host, lets games of the same protocol and game build in and lists them, and every game takes positions, chat and progress only from the players on that list. runtime/coop_game.c reads Link from the Player actor and shares progress, items, songs and quest items through the game's own flag routines, each value only ever raised; small keys, rupees, ammunition and hearts stay each player's own, and the save is copied to coop-backup before anything of a room reaches it. The other players show as a name with a distance where their Link stands, projected with the upscaler's camera. One Steam account cannot be in a lobby twice, and this PC has not the memory for two games, so the room and the game side were run with one game and tests/coop_peer.py as the second player over runtime/coop_local.c, a stand-in for Steam on 127.0.0.1 that only the environment turns on: the peer was let in, saw the game's Link in Hyrule Field, chat went both ways, the save was copied, one flag the save lacked was set and a flag the game does not share was refused. On Steam itself one game signed in as app 480, made a room, showed its ID and the player's Steam name on the Co-op tab and left. Not run: two Steam accounts in one room, an invite, a join by room ID over Steam, a host that leaves, a removal, and the menu's text probe on this build. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
528 lines
25 KiB
C++
528 lines
25 KiB
C++
// The menu's Co-op tab and co-op's drawing over the game (ui/coop_page.h).
|
|
//
|
|
// The page reads the co-op thread's view once a frame (coop_view) and hands it commands (coop_create, coop_join, ...);
|
|
// nothing here waits for Steam. What the page shows follows the view's state: off, Steam missing, in no room, on the
|
|
// way into one, in one. A press that turns co-op on and wants a room at once (Create a room while co-op is off) is
|
|
// kept for a few seconds until the thread has reached Steam.
|
|
//
|
|
// Names over the game: a player's position is projected with the frame's camera as the upscaler's pass knows it
|
|
// (vk_dlaa_fg_camera: position, right, up and forward in the world's metres, the vertical field of view and the
|
|
// aspect). Without a temporal upscaler there is no camera and no names; the player list still says where each is.
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "imgui.h"
|
|
#include "imgui_internal.h"
|
|
#include "menu_sound.h"
|
|
#include "ui/coop_page.h"
|
|
#include "ui/menu_skin.h"
|
|
#include "ui/option_rows.h"
|
|
|
|
extern "C" {
|
|
#include "cfg.h"
|
|
#include "coop.h"
|
|
#include "platform/platform.h"
|
|
#include "ui/menu.h"
|
|
#include "ui_text.h"
|
|
#include "vk_dlaa.h"
|
|
}
|
|
|
|
enum Page { P_NONE, P_JOIN, P_CHAT, P_INVITE, P_REMOVE, P_LEAVE };
|
|
enum { FIELD_CAP = COOP_CHAT_CAP + 1, PASTE_FRAMES = 120, PENDING_MS = 8000, CHAT_SHOWN_MS = 8000, CHAT_FADE_MS = 1000 };
|
|
|
|
static bool g_open, g_window_shown, g_page_new, g_by_pad;
|
|
static int g_page;
|
|
static char g_field[FIELD_CAP];
|
|
static bool g_field_bad, g_paste_empty;
|
|
static int g_paste_wait; // frames left to wait for the clipboard's text (gfx_window_paste)
|
|
static char g_return[48]; // the row the cursor goes back to when the window closes
|
|
static CoopView g_view; // this frame's copy of the layer's state
|
|
static int g_layout = -1; // the page's last kind, to move the cursor when its rows change
|
|
static uint64_t g_copied_at; // when the room ID was last copied
|
|
static uint64_t g_remove_id;
|
|
static char g_remove_name[COOP_NAME_CAP];
|
|
static char g_invited_name[COOP_NAME_CAP]; // the friend the last invite went to
|
|
static uint64_t g_invited_at;
|
|
static SteamFriend g_friends[COOP_FRIENDS];
|
|
static int g_nfriends;
|
|
// a command that waits for co-op to come up: 1 create, 2 join g_pending_code
|
|
static int g_pending;
|
|
static char g_pending_code[STEAM_CODE_CAP];
|
|
static uint64_t g_pending_until;
|
|
|
|
static bool in_room(void) { return g_view.state == COOP_IN_ROOM; }
|
|
|
|
static UiTextId note_text(CoopNote n) {
|
|
switch (n) {
|
|
case COOP_NOTE_NO_LIBRARY: return UI_MENU_COOP_NO_LIBRARY;
|
|
case COOP_NOTE_OLD_LIBRARY: return UI_MENU_COOP_OLD_LIBRARY;
|
|
case COOP_NOTE_NO_CLIENT:
|
|
case COOP_NOTE_OTHER_OS: return UI_MENU_COOP_NO_CLIENT;
|
|
case COOP_NOTE_CREATE_FAILED: return UI_MENU_COOP_N_CREATE_FAILED;
|
|
case COOP_NOTE_NO_ROOM:
|
|
case COOP_NOTE_BAD_CODE: return UI_MENU_COOP_N_NO_ROOM;
|
|
case COOP_NOTE_FULL: return UI_MENU_COOP_N_FULL;
|
|
case COOP_NOTE_REFUSED: return UI_MENU_COOP_N_REFUSED;
|
|
case COOP_NOTE_NOT_OURS: return UI_MENU_COOP_N_NOT_OURS;
|
|
case COOP_NOTE_OTHER_VERSION: return UI_MENU_COOP_N_OTHER_VERSION;
|
|
case COOP_NOTE_REMOVED: return UI_MENU_COOP_N_REMOVED;
|
|
case COOP_NOTE_HOST_SILENT: return UI_MENU_COOP_N_HOST_SILENT;
|
|
case COOP_NOTE_LOST: return UI_MENU_COOP_N_LOST;
|
|
case COOP_NOTE_LEFT: return UI_MENU_COOP_N_LEFT;
|
|
default: return UI_TEXT_COUNT;
|
|
}
|
|
}
|
|
|
|
// Create or join, turning co-op on first when it is off: the command then waits for the thread to reach Steam.
|
|
static void want_room(int what, const char *code) {
|
|
if (g_view.state == COOP_READY) {
|
|
if (what == 1) coop_create();
|
|
else coop_join(code);
|
|
return;
|
|
}
|
|
if (g_view.state == COOP_OFF) opt_apply("NX2NAVI_COOP", "1");
|
|
g_pending = what;
|
|
snprintf(g_pending_code, sizeof g_pending_code, "%s", code ? code : "");
|
|
g_pending_until = plat_now_ms() + PENDING_MS;
|
|
}
|
|
|
|
static void pending_tick(void) {
|
|
if (!g_pending) return;
|
|
if (g_view.state == COOP_READY) {
|
|
if (g_pending == 1) coop_create();
|
|
else coop_join(g_pending_code);
|
|
g_pending = 0;
|
|
} else if (g_view.state == COOP_NO_STEAM || plat_now_ms() > g_pending_until) {
|
|
g_pending = 0; // the page says why Steam is not there
|
|
}
|
|
}
|
|
|
|
static void open_window(int page, const char *ret) {
|
|
g_open = true, g_page = page, g_page_new = true;
|
|
g_by_pad = ImGui::IsKeyDown(ImGuiKey_GamepadFaceDown); // a pad's A opened it: no keyboard to type with
|
|
g_field_bad = g_paste_empty = false, g_paste_wait = 0;
|
|
g_field[0] = 0;
|
|
snprintf(g_return, sizeof g_return, "%s", ret);
|
|
}
|
|
|
|
static void settings_rows(void) {
|
|
opt_group(UI_MENU_COOP_SETTINGS);
|
|
opt_toggle("NX2NAVI_COOP_SHARE", UI_MENU_COOP_SHARE, UI_MENU_COOP_SHARE_DESC);
|
|
opt_toggle("NX2NAVI_COOP_NAMES", UI_MENU_COOP_NAMES, UI_MENU_COOP_NAMES_DESC);
|
|
opt_toggle("NX2NAVI_COOP_CHAT", UI_MENU_COOP_CHAT_SHOW, UI_MENU_COOP_CHAT_SHOW_DESC);
|
|
opt_toggle("NX2NAVI_COOP", UI_MENU_COOP_ON, UI_MENU_COOP_ON_DESC);
|
|
}
|
|
|
|
static void chat_text(const CoopChatLine &l, char *out, size_t cap) {
|
|
if (l.notice) snprintf(out, cap, menu_text(l.joined ? UI_MENU_COOP_CHAT_JOINED : UI_MENU_COOP_CHAT_LEFT), l.name);
|
|
else snprintf(out, cap, "%s: %s", l.name, l.text);
|
|
}
|
|
|
|
static void rows_out(void) {
|
|
if (g_view.state == COOP_OFF && !g_pending) {
|
|
opt_toggle("NX2NAVI_COOP", UI_MENU_COOP_ON, UI_MENU_COOP_ON_DESC);
|
|
return;
|
|
}
|
|
if (g_view.local) opt_text(UI_MENU_COOP_LOCAL);
|
|
if (g_view.state == COOP_NO_STEAM) {
|
|
const UiTextId why = note_text(g_view.note);
|
|
if (why != UI_TEXT_COUNT) opt_text(why, true);
|
|
if (opt_button("##coop_retry", UI_MENU_COOP_RETRY, UI_MENU_COOP_RETRY_DESC)) coop_retry();
|
|
settings_rows();
|
|
return;
|
|
}
|
|
if (g_view.state == COOP_ENTERING || g_pending) {
|
|
if (opt_button("##coop_stop", UI_MENU_COOP_STOP, UI_MENU_COOP_STOP_DESC)) {
|
|
g_pending = 0;
|
|
coop_leave();
|
|
}
|
|
opt_text(UI_MENU_COOP_JOINING);
|
|
return;
|
|
}
|
|
if (g_view.invite_room) {
|
|
char line[COOP_NAME_CAP + 96];
|
|
snprintf(line, sizeof line, menu_text(UI_MENU_COOP_INVITED), g_view.invite_from);
|
|
opt_text_str(line);
|
|
if (opt_button("##coop_invited_join", UI_MENU_COOP_INVITED_JOIN, UI_MENU_COOP_INVITED_JOIN_DESC)) coop_join_invite();
|
|
if (opt_button("##coop_invited_no", UI_MENU_COOP_INVITED_NO, UI_MENU_COOP_INVITED_NO_DESC)) coop_decline_invite();
|
|
}
|
|
if (opt_button("##coop_create", UI_MENU_COOP_CREATE, UI_MENU_COOP_CREATE_DESC)) want_room(1, nullptr);
|
|
if (opt_button("##coop_join", UI_MENU_COOP_JOIN, UI_MENU_COOP_JOIN_DESC)) open_window(P_JOIN, "##coop_join");
|
|
const UiTextId why = note_text(g_view.note);
|
|
if (why != UI_TEXT_COUNT) opt_text(why, g_view.note != COOP_NOTE_LEFT);
|
|
settings_rows();
|
|
}
|
|
|
|
static void rows_room(void) {
|
|
const uint64_t now = plat_now_ms();
|
|
if (g_view.local) opt_text(UI_MENU_COOP_LOCAL);
|
|
if (g_view.code[0]) {
|
|
const bool copied = g_copied_at && now - g_copied_at < 3000;
|
|
if (opt_text_row("##coop_code", menu_text(UI_MENU_COOP_ROOM_ID), g_view.code, copied ? menu_text(UI_MENU_COOP_COPIED) : nullptr,
|
|
menu_text(UI_MENU_COOP_ROOM_ID_DESC), false) == 2 &&
|
|
plat_clipboard_set(g_view.code))
|
|
g_copied_at = now;
|
|
}
|
|
if (!g_view.local && opt_button("##coop_invite", UI_MENU_COOP_INVITE, UI_MENU_COOP_INVITE_DESC)) {
|
|
coop_friends_refresh();
|
|
open_window(P_INVITE, "##coop_invite");
|
|
}
|
|
if (g_invited_at && now - g_invited_at < 5000) {
|
|
char line[COOP_NAME_CAP + 64];
|
|
snprintf(line, sizeof line, menu_text(UI_MENU_COOP_INVITE_SENT), g_invited_name);
|
|
opt_text_str(line);
|
|
}
|
|
opt_group(UI_MENU_COOP_PLAYERS);
|
|
for (int i = 0; i < g_view.n; i++) {
|
|
const CoopPlayer &p = g_view.players[i];
|
|
char id[40], note[96], where[COOP_SCENE_CAP + 16];
|
|
snprintf(id, sizeof id, "##coop_player%d", i);
|
|
snprintf(note, sizeof note, "%s%s%s", p.self ? menu_text(UI_MENU_COOP_YOU) : "", p.self && p.host ? ", " : "",
|
|
p.host ? menu_text(UI_MENU_COOP_HOST) : "");
|
|
const bool here = p.self ? false : p.has_pose && p.pose.scene[0];
|
|
snprintf(where, sizeof where, "%s", p.self ? "" : here ? p.pose.scene : menu_text(UI_MENU_COOP_PLAYER_AWAY));
|
|
const bool removable = g_view.host && !p.self;
|
|
if (opt_text_row(id, p.name[0] ? p.name : "…", where, note[0] ? note : nullptr,
|
|
menu_text(removable ? UI_MENU_COOP_PLAYER_REMOVE_DESC : UI_MENU_COOP_PLAYER_DESC), false) == 2 &&
|
|
removable) {
|
|
g_remove_id = p.id;
|
|
snprintf(g_remove_name, sizeof g_remove_name, "%s", p.name);
|
|
open_window(P_REMOVE, id);
|
|
}
|
|
}
|
|
opt_group(UI_MENU_COOP_CHAT);
|
|
for (int i = 0; i < g_view.nchat; i++) {
|
|
char line[COOP_NAME_CAP + COOP_CHAT_CAP + 8];
|
|
chat_text(g_view.chat[i], line, sizeof line);
|
|
opt_text_str(line);
|
|
}
|
|
if (opt_button("##coop_chat", UI_MENU_COOP_CHAT_WRITE, UI_MENU_COOP_CHAT_WRITE_DESC)) open_window(P_CHAT, "##coop_chat");
|
|
if (opt_button("##coop_leave", UI_MENU_COOP_LEAVE, UI_MENU_COOP_LEAVE_DESC)) open_window(P_LEAVE, "##coop_leave");
|
|
settings_rows();
|
|
}
|
|
|
|
void coop_rows(float scale) {
|
|
(void)scale;
|
|
coop_view(&g_view);
|
|
pending_tick();
|
|
// the page changes its rows when the player gets into a room, reaches for one or leaves it: the cursor goes to a row
|
|
// of the new page whose press changes nothing at once
|
|
const int layout = in_room() ? 2 : g_view.state == COOP_ENTERING || g_pending ? 1 : 0;
|
|
if (layout != g_layout) {
|
|
if (g_layout >= 0) opt_focus_key(layout == 2 ? "##coop_code" : layout == 1 ? "##coop_stop" : "##coop_join");
|
|
g_layout = layout;
|
|
}
|
|
if (layout == 2) rows_room();
|
|
else rows_out();
|
|
}
|
|
|
|
// ---- the window
|
|
|
|
// The cursor on the item just drawn, shown (as option_rows.cpp puts it on a row). SetItemDefaultFocus as well: on the
|
|
// window's first frame ImGui's own pick of a first item would replace the cursor set here.
|
|
static void take_cursor(void) {
|
|
ImGui::SetItemDefaultFocus();
|
|
ImGui::SetFocusID(ImGui::GetItemID(), ImGui::GetCurrentWindow());
|
|
ImGui::SetNavCursorVisible(true);
|
|
}
|
|
|
|
static bool field_page(void) { return g_page == P_JOIN || g_page == P_CHAT; }
|
|
|
|
// Two buttons side by side, the safe one first: 1 the first, 2 the second. The cursor goes to the safe one when the
|
|
// window opens (fresh); in a field's window typed by keyboard the field has the cursor instead. ImGui activates a
|
|
// button on a press, not on a held key's repeats.
|
|
static int two_buttons(const char *no, const char *yes, bool yes_enabled, bool fresh, float scale) {
|
|
const ImGuiStyle &st = ImGui::GetStyle();
|
|
float bw = (ImGui::CalcTextSize(no).x > ImGui::CalcTextSize(yes).x ? ImGui::CalcTextSize(no).x : ImGui::CalcTextSize(yes).x) +
|
|
st.FramePadding.x * 4;
|
|
char id[160];
|
|
snprintf(id, sizeof id, "%s##no", no);
|
|
int r = skin_widget_button(id, ImVec2(bw, 0), scale) ? 1 : 0;
|
|
if (fresh && !(field_page() && !g_by_pad)) take_cursor();
|
|
ImGui::SameLine(0, st.ItemSpacing.x + skin_cursor_reach(scale));
|
|
ImGui::BeginDisabled(!yes_enabled);
|
|
snprintf(id, sizeof id, "%s##yes", yes);
|
|
if (skin_widget_button(id, ImVec2(bw, 0), scale)) r = 2;
|
|
ImGui::EndDisabled();
|
|
return r;
|
|
}
|
|
|
|
static void gold(const char *text) {
|
|
ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertU32ToFloat4(SKIN_GOLD));
|
|
ImGui::TextUnformatted(text);
|
|
ImGui::PopStyleColor();
|
|
}
|
|
|
|
static void warn(const char *text) { ImGui::TextColored(ImVec4(0.95f, 0.45f, 0.35f, 1), "%s", text); }
|
|
|
|
// A pasted room ID: the characters one is typed with, no line ends or tabs.
|
|
static void take_paste(const char *text) {
|
|
char out[32];
|
|
size_t k = 0;
|
|
for (const char *p = text; *p && k + 1 < sizeof out; p++)
|
|
if ((*p >= '0' && *p <= '9') || (*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z') || *p == '-')
|
|
out[k++] = *p >= 'a' && *p <= 'z' ? (char)(*p - 'a' + 'A') : *p;
|
|
out[k] = 0;
|
|
g_paste_empty = !k;
|
|
if (k) snprintf(g_field, sizeof g_field, "%s", out), g_field_bad = false;
|
|
}
|
|
|
|
static void trimmed(char *out, size_t cap) {
|
|
const char *s = g_field;
|
|
while (*s == ' ') s++;
|
|
size_t n = strlen(s);
|
|
while (n && s[n - 1] == ' ') n--;
|
|
snprintf(out, cap, "%.*s", (int)n, s);
|
|
}
|
|
|
|
// The field's window: a room ID (Cancel, Join; Paste) or a chat line (Cancel, Send).
|
|
static void field_window(bool fresh, float scale, float wrap, bool *close, bool *back) {
|
|
const bool join = g_page == P_JOIN;
|
|
gold(menu_text(join ? UI_MENU_COOP_ROOM_ID : UI_MENU_COOP_CHAT_WRITE));
|
|
if (join) ImGui::TextDisabled("%s", menu_text(UI_MENU_COOP_ROOM_ID_HINT));
|
|
if (fresh && !g_by_pad) ImGui::SetKeyboardFocusHere();
|
|
ImGui::SetNextItemWidth(wrap);
|
|
const bool enter = ImGui::InputText("##coop_field", g_field, join ? 24 : sizeof g_field,
|
|
ImGuiInputTextFlags_EnterReturnsTrue | (join ? ImGuiInputTextFlags_CharsUppercase : 0));
|
|
if (ImGui::IsItemEdited()) g_field_bad = g_paste_empty = false;
|
|
if (join) {
|
|
char text[256];
|
|
if (g_paste_wait > 0 && menu_paste_take(text, sizeof text)) take_paste(text), g_paste_wait = 0;
|
|
else if (g_paste_wait > 0) g_paste_wait--;
|
|
const float bw = ImGui::CalcTextSize(menu_text(UI_MENU_COOP_PASTE)).x + ImGui::GetStyle().FramePadding.x * 4;
|
|
if (skin_widget_button(menu_text(UI_MENU_COOP_PASTE), ImVec2(bw, 0), scale)) {
|
|
menu_paste_take(text, sizeof text); // an answer of an earlier Paste is not this one's
|
|
gfx_window_paste();
|
|
g_paste_wait = PASTE_FRAMES;
|
|
}
|
|
if (g_field_bad) warn(menu_text(UI_MENU_COOP_ROOM_ID_BAD));
|
|
if (g_paste_empty) warn(menu_text(UI_MENU_COOP_PASTE_EMPTY));
|
|
}
|
|
ImGui::Spacing();
|
|
char text[FIELD_CAP];
|
|
trimmed(text, sizeof text);
|
|
const int r = two_buttons(menu_text(UI_MENU_RESET_NO), menu_text(join ? UI_MENU_COOP_JOIN : UI_MENU_COOP_SEND), text[0] != 0, fresh, scale);
|
|
if (r == 1) *back = true;
|
|
if ((r != 2 && !enter) || !text[0]) return;
|
|
if (join) {
|
|
if (!steam_code_parse(text)) {
|
|
g_field_bad = true;
|
|
return;
|
|
}
|
|
want_room(2, text);
|
|
} else {
|
|
coop_chat(text);
|
|
}
|
|
*close = true;
|
|
}
|
|
|
|
// The player's friends, each a button that sends the invite; Steam's own window when the game was started from Steam.
|
|
static void invite_window(bool fresh, float scale, bool *close, bool *back) {
|
|
static uint32_t serial;
|
|
if (fresh || serial != g_view.friends_serial) serial = g_view.friends_serial, g_nfriends = coop_friends(g_friends, COOP_FRIENDS);
|
|
gold(menu_text(UI_MENU_COOP_INVITE_TITLE));
|
|
const float bw = ImGui::GetFontSize() * 22;
|
|
if (skin_widget_button(menu_text(UI_MENU_COOP_INVITE_CLOSE), ImVec2(bw, 0), scale)) *back = true;
|
|
if (fresh) take_cursor();
|
|
if (g_view.overlay && skin_widget_button(menu_text(UI_MENU_COOP_INVITE_STEAM), ImVec2(bw, 0), scale)) {
|
|
coop_invite_window();
|
|
*close = true;
|
|
}
|
|
if (!g_nfriends) ImGui::TextDisabled("%s", menu_text(UI_MENU_COOP_INVITE_NONE));
|
|
ImGui::BeginChild("##coop_friends", ImVec2(bw + ImGui::GetStyle().ScrollbarSize + skin_cursor_reach(scale) * 2, ImGui::GetFontSize() * 14),
|
|
ImGuiChildFlags_NavFlattened);
|
|
for (int i = 0; i < g_nfriends; i++) {
|
|
const SteamFriend &f = g_friends[i];
|
|
char label[STEAM_NAME_CAP + 64];
|
|
snprintf(label, sizeof label, "%s (%s)##f%d", f.name, menu_text(f.in_app ? UI_MENU_COOP_INVITE_IN_GAME : f.online ? UI_MENU_COOP_INVITE_ONLINE
|
|
: UI_MENU_COOP_INVITE_OFFLINE), i);
|
|
if (skin_widget_button(label, ImVec2(bw, 0), scale)) {
|
|
coop_invite(f.id);
|
|
snprintf(g_invited_name, sizeof g_invited_name, "%s", f.name);
|
|
g_invited_at = plat_now_ms();
|
|
*close = true;
|
|
}
|
|
}
|
|
ImGui::EndChild();
|
|
}
|
|
|
|
static void confirm_window(bool fresh, float scale, bool *close, bool *back) {
|
|
const bool remove = g_page == P_REMOVE;
|
|
char line[COOP_NAME_CAP + 160];
|
|
if (remove) snprintf(line, sizeof line, menu_text(UI_MENU_COOP_REMOVE_CONFIRM), g_remove_name);
|
|
else snprintf(line, sizeof line, "%s", menu_text(UI_MENU_COOP_LEAVE_CONFIRM));
|
|
gold(line);
|
|
if (!remove && g_view.host && g_view.n > 1) ImGui::TextUnformatted(menu_text(UI_MENU_COOP_LEAVE_HOST));
|
|
ImGui::Spacing();
|
|
const int r = two_buttons(menu_text(remove ? UI_MENU_RESET_NO : UI_MENU_COOP_STAY), menu_text(remove ? UI_MENU_COOP_REMOVE : UI_MENU_COOP_LEAVE),
|
|
true, fresh, scale);
|
|
if (r == 1) *back = true;
|
|
if (r == 2) {
|
|
if (remove) coop_remove(g_remove_id);
|
|
else coop_leave(), g_return[0] = 0; // the page's rows change; coop_rows puts the cursor on the new page
|
|
*close = true;
|
|
}
|
|
}
|
|
|
|
void coop_after_page(float scale) {
|
|
g_window_shown = false;
|
|
if (g_open && !ImGui::IsPopupOpen("##coopwin")) ImGui::OpenPopup("##coopwin");
|
|
ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_Always, ImVec2(0.5f, 0.5f));
|
|
ImGui::PushStyleVar(ImGuiStyleVar_PopupBorderSize, 0);
|
|
const bool shown = ImGui::BeginPopupModal("##coopwin", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_AlwaysAutoResize);
|
|
ImGui::PopStyleVar();
|
|
if (!shown) {
|
|
g_open = false;
|
|
return;
|
|
}
|
|
g_window_shown = true;
|
|
// a window opened since the last frame: latched and cleared before it is drawn (as the Saves tab's file window)
|
|
const bool fresh = g_page_new;
|
|
g_page_new = false;
|
|
const ImVec2 box = ImGui::GetWindowPos(), box_size = ImGui::GetWindowSize();
|
|
skin_panel(ImGui::GetWindowDrawList(), box, ImVec2(box.x + box_size.x, box.y + box_size.y), scale);
|
|
const float wrap = ImGui::GetFontSize() * 30;
|
|
bool close = false, back = false;
|
|
ImGui::PushTextWrapPos(ImGui::GetCursorPosX() + wrap);
|
|
const bool needs_room = g_page == P_CHAT || g_page == P_INVITE || g_page == P_REMOVE || g_page == P_LEAVE;
|
|
if (needs_room && !in_room()) close = true; // the room ended under the window
|
|
else if (field_page()) field_window(fresh, scale, wrap, &close, &back);
|
|
else if (g_page == P_INVITE) invite_window(fresh, scale, &close, &back);
|
|
else if (g_page == P_REMOVE || g_page == P_LEAVE) confirm_window(fresh, scale, &close, &back);
|
|
else close = true;
|
|
ImGui::PopTextWrapPos();
|
|
if (!fresh && !ImGui::IsAnyItemActive() &&
|
|
(ImGui::IsKeyPressed(ImGuiKey_Escape, false) || ImGui::IsKeyPressed(ImGuiKey_GamepadFaceRight, false))) {
|
|
back = true;
|
|
menu_sound_play(MENU_SOUND_CANCEL);
|
|
}
|
|
if (back || close) {
|
|
g_open = false;
|
|
g_page = P_NONE;
|
|
g_field[0] = 0;
|
|
ImGui::CloseCurrentPopup();
|
|
if (g_return[0]) opt_focus_key(g_return); // back on the row that opened it
|
|
}
|
|
ImGui::EndPopup();
|
|
}
|
|
|
|
bool coop_modal(void) { return g_open || g_window_shown; }
|
|
|
|
void coop_cancel(void) {
|
|
g_open = false;
|
|
g_page = P_NONE;
|
|
g_field[0] = 0;
|
|
}
|
|
|
|
int coop_test_set(const char *key, const char *value) {
|
|
if (strcmp(key, "NX2NAVI_COOP_DO")) return 0;
|
|
coop_view(&g_view);
|
|
if (!strcmp(value, "create")) want_room(1, nullptr);
|
|
else if (!strcmp(value, "leave")) coop_leave();
|
|
else if (!strncmp(value, "join:", 5)) want_room(2, value + 5);
|
|
else if (!strncmp(value, "chat:", 5)) coop_chat(value + 5);
|
|
else if (!strcmp(value, "page:join")) open_window(P_JOIN, "##coop_join");
|
|
else if (!strcmp(value, "page:invite")) coop_friends_refresh(), open_window(P_INVITE, "##coop_invite");
|
|
else if (!strcmp(value, "page:chat")) open_window(P_CHAT, "##coop_chat");
|
|
else if (!strcmp(value, "page:leave")) open_window(P_LEAVE, "##coop_leave");
|
|
g_by_pad = true; // the cursor as a pad's A would leave it: on the safe button
|
|
return 1;
|
|
}
|
|
|
|
// ---- over the game
|
|
|
|
static CoopView g_over;
|
|
static bool g_over_on;
|
|
|
|
bool coop_overlay_tick(void) {
|
|
static unsigned cfg_seen = ~0u;
|
|
static uint32_t serial;
|
|
if (unsigned v = cfg_version(); v != cfg_seen) cfg_seen = v, g_over_on = cfg_bool("NX2NAVI_COOP") != 0;
|
|
if (!g_over_on) return false;
|
|
if (uint32_t s = coop_serial(); s != serial) serial = s, coop_view(&g_over);
|
|
if (g_over.invite_room) return true;
|
|
if (g_over.state != COOP_IN_ROOM) return false;
|
|
if (g_over.n > 1) return true;
|
|
const uint64_t now = plat_now_ms();
|
|
return g_over.nchat && now - g_over.chat[g_over.nchat - 1].at_ms < CHAT_SHOWN_MS;
|
|
}
|
|
|
|
// The label of a small panel centred on x, its top at y.
|
|
static float label(ImDrawList *dl, float x, float y, const char *text, float scale, float alpha) {
|
|
const float padx = 10 * scale, pady = 5 * scale;
|
|
const ImVec2 sz = ImGui::CalcTextSize(text);
|
|
const ImVec2 p(x - sz.x * 0.5f - padx, y);
|
|
skin_panel(dl, p, ImVec2(p.x + sz.x + padx * 2, p.y + sz.y + pady * 2), scale * 0.5f, 0.85f * alpha);
|
|
dl->AddText(ImVec2(p.x + padx, p.y + pady), IM_COL32(244, 236, 214, (int)(255 * alpha)), text);
|
|
return sz.y + pady * 2;
|
|
}
|
|
|
|
void coop_overlay_draw(float w, float h, float scale, bool menu_open) {
|
|
if (!g_over_on) return;
|
|
const uint64_t now = plat_now_ms();
|
|
ImDrawList *dl = menu_open ? ImGui::GetBackgroundDrawList() : ImGui::GetForegroundDrawList();
|
|
// the other players' names where their Link stands, in the area this game's Link is in
|
|
VkDlaaCamera cam;
|
|
const CoopPlayer *me = nullptr;
|
|
for (int i = 0; i < g_over.n; i++)
|
|
if (g_over.players[i].self) me = &g_over.players[i];
|
|
if (!menu_open && g_over.state == COOP_IN_ROOM && cfg_bool("NX2NAVI_COOP_NAMES") && vk_dlaa_fg_camera(&cam)) {
|
|
const float ty = tanf(cam.fov_y * 0.5f), tx = ty * cam.aspect;
|
|
// the game's picture in the frame: centred, with bars above and below or at the sides when its shape differs
|
|
const float pw = cam.aspect > w / h ? w : h * cam.aspect, ph = cam.aspect > w / h ? w / cam.aspect : h;
|
|
for (int i = 0; i < g_over.n; i++) {
|
|
const CoopPlayer &p = g_over.players[i];
|
|
if (p.self || !p.has_pose || !p.pose.scene[0]) continue;
|
|
// only a player in the area this game's Link is in
|
|
if (me && me->has_pose && me->pose.scene[0] && strcmp(me->pose.scene, p.pose.scene)) continue;
|
|
// a moment ahead along the velocity: the pose is up to a twentieth of a second old
|
|
float age = (float)p.pose_ms / 1000.0f;
|
|
if (age > 0.25f) age = 0.25f;
|
|
float d[3];
|
|
for (int k = 0; k < 3; k++) d[k] = p.pose.pos[k] + p.pose.vel[k] * age - cam.pos[k];
|
|
d[1] += 1.9f; // above the head of an adult Link; a child's name floats a little higher
|
|
const float z = d[0] * cam.fwd[0] + d[1] * cam.fwd[1] + d[2] * cam.fwd[2];
|
|
float x = d[0] * cam.right[0] + d[1] * cam.right[1] + d[2] * cam.right[2];
|
|
float y = d[0] * cam.up[0] + d[1] * cam.up[1] + d[2] * cam.up[2];
|
|
const float dist = sqrtf(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
|
|
char text[COOP_NAME_CAP + 24];
|
|
snprintf(text, sizeof text, "%s %.0f m", p.name[0] ? p.name : "?", dist);
|
|
float nx, ny;
|
|
bool on_screen = z > 0.1f;
|
|
if (on_screen) {
|
|
nx = x / (z * tx), ny = y / (z * ty);
|
|
on_screen = fabsf(nx) < 0.96f && fabsf(ny) < 0.92f;
|
|
}
|
|
if (!on_screen) {
|
|
// beside or behind the picture: at its edge, in the direction to turn to
|
|
float len = sqrtf(x * x + y * y);
|
|
if (len < 1e-4f) x = 1, y = 0, len = 1;
|
|
nx = x / len, ny = y / len;
|
|
const float m = fabsf(nx) / 0.96f > fabsf(ny) / 0.88f ? fabsf(nx) / 0.96f : fabsf(ny) / 0.88f;
|
|
nx /= m, ny /= m;
|
|
}
|
|
label(dl, w * 0.5f + nx * 0.5f * pw, h * 0.5f - ny * 0.5f * ph, text, scale, on_screen ? 1.0f : 0.75f);
|
|
}
|
|
}
|
|
if (menu_open) return;
|
|
float y = 12 * scale;
|
|
if (g_over.invite_room) {
|
|
char text[COOP_NAME_CAP + 160];
|
|
snprintf(text, sizeof text, menu_text(UI_MENU_COOP_TOAST_INVITE), g_over.invite_from);
|
|
y += label(dl, w * 0.5f, y, text, scale * 1.2f, 1) + 6 * scale;
|
|
}
|
|
if (g_over.state == COOP_IN_ROOM && cfg_bool("NX2NAVI_COOP_CHAT")) {
|
|
// the top middle: the game's hearts and rupees are at the left, the performance overlay at the right
|
|
for (int i = 0; i < g_over.nchat; i++) {
|
|
const uint64_t age = now - g_over.chat[i].at_ms;
|
|
if (age >= CHAT_SHOWN_MS) continue;
|
|
const float alpha = age > CHAT_SHOWN_MS - CHAT_FADE_MS ? (float)(CHAT_SHOWN_MS - age) / CHAT_FADE_MS : 1.0f;
|
|
char text[COOP_NAME_CAP + COOP_CHAT_CAP + 8];
|
|
chat_text(g_over.chat[i], text, sizeof text);
|
|
y += label(dl, w * 0.5f, y, text, scale * 1.2f, alpha) + 6 * scale;
|
|
}
|
|
}
|
|
}
|