// Lockstep: le due console simulano la stessa partita e si scambiano solo gli input, con qualche frame di anticipo. // Un frame parte quando ci sono gli input di entrambe. Ogni pacchetto ripete gli ultimi input, cosi' UDP puo' perderne senza danni, // e porta l'hash dello stato: se le due simulazioni divergono si vede subito. #include #include #include #include #include #include #include #include #include #include #include "net.h" #include "vs.h" #ifdef __vita__ #include #include #include #include #endif #define NET_PORT 7711 #define NET_DELAY 4 // frame di anticipo degli input #define NET_RING 1024 #define NET_RESEND 24 // input ripetuti in ogni pacchetto #define NET_HASHES 8 #define NET_MAGIC 0x5653u int net_on, net_role; static double last_rx; static double now_s(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return ts.tv_sec + ts.tv_nsec / 1e9; } static int fd = -1; static struct sockaddr_in peer_addr; static int peer_known; static NetMove moves[2][NET_RING]; static unsigned have[2]; // frame fino a cui (esclusi) gli input sono noti static unsigned hashes[NET_RING], hash_done; static unsigned hash_checked, desync_at, desyncs, stalls, lost_percent; static int desynced; typedef struct { unsigned short magic; unsigned char kind, count; // kind: 0 saluto, 1 risposta col seme, 2 input unsigned first, seed, hash_first, hash_done, hash[NET_HASHES]; NetMove m[NET_RESEND]; } Packet; static void sleep_ms(int ms) { #ifdef __vita__ sceKernelDelayThread(ms * 1000); #else usleep(ms * 1000); #endif } static void net_system_init(void) { #ifdef __vita__ static char mem[256 * 1024]; sceSysmoduleLoadModule(SCE_SYSMODULE_NET); SceNetInitParam p = { mem, sizeof(mem), 0 }; sceNetInit(&p); // gia' inizializzata va bene sceNetCtlInit(); #endif } static void net_send(const Packet *p) { if (peer_known && (!lost_percent || (unsigned)(rand() % 100) >= lost_percent)) sendto(fd, p, sizeof(*p), 0, (struct sockaddr *)&peer_addr, sizeof(peer_addr)); } int net_open(const char *peer, unsigned *seed) { net_system_init(); if (getenv("VS_NETLOSS")) lost_percent = (unsigned)atoi(getenv("VS_NETLOSS")); fd = socket(AF_INET, SOCK_DGRAM, 0); if (fd < 0) return 0; fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK); struct sockaddr_in me; memset(&me, 0, sizeof(me)); me.sin_family = AF_INET, me.sin_addr.s_addr = htonl(INADDR_ANY), me.sin_port = htons(peer ? 0 : NET_PORT); if (bind(fd, (struct sockaddr *)&me, sizeof(me)) < 0) return 0; net_role = peer ? 1 : 0; if (peer) { memset(&peer_addr, 0, sizeof(peer_addr)); peer_addr.sin_family = AF_INET, peer_addr.sin_port = htons(NET_PORT), peer_addr.sin_addr.s_addr = inet_addr(peer); peer_known = 1; } for (int tries = 0; tries < 3000; tries++) { // 60 s Packet p = { NET_MAGIC }, r; if (peer) { p.kind = 0; sendto(fd, &p, sizeof(p), 0, (struct sockaddr *)&peer_addr, sizeof(peer_addr)); } struct sockaddr_in from; socklen_t fl = sizeof(from); while (recvfrom(fd, &r, sizeof(r), 0, (struct sockaddr *)&from, &fl) == (int)sizeof(r)) { if (r.magic != NET_MAGIC) continue; if (peer && r.kind == 1) { *seed = r.seed; net_begin(); return 1; } if (!peer && r.kind == 0) { peer_addr = from, peer_known = 1; p.kind = 1, p.seed = *seed; for (int i = 0; i < 20; i++) sendto(fd, &p, sizeof(p), 0, (struct sockaddr *)&peer_addr, sizeof(peer_addr)); net_begin(); return 1; } } sleep_ms(20); } return 0; } int net_in_sim, net_input_player; unsigned net_input_frame; static unsigned net_bits(int player, unsigned frame) { return moves[player][frame % NET_RING].buttons; } int net_pad_down(int b) { return (net_bits(net_input_player, net_input_frame) >> b) & 1; } static int net_was_down(int player, int b) { return net_input_frame ? (net_bits(player, net_input_frame - 1) >> b) & 1 : 0; } int net_pad_pressed(int b) { return net_pad_down(b) && !net_was_down(net_input_player, b); } int net_pad_released(int b) { return !net_pad_down(b) && net_was_down(net_input_player, b); } float net_pad_axis(int a) { NetMove m = moves[net_input_player][net_input_frame % NET_RING]; return a == 0 ? m.x / 127.0f : a == 1 ? m.y / 127.0f : 0; } int net_player_pressed(int player, int b) { return ((net_bits(player, net_input_frame) >> b) & 1) && !net_was_down(player, b); } // --- Lobby ------------------------------------------------------------------------------------------------------------ #define NET_BEACON_PORT 7712 enum { LK_BEACON = 10, LK_HELLO, LK_WELCOME, LK_CHUNK, LK_ACK }; typedef struct { unsigned short magic; unsigned char kind, pad; unsigned seed, index, total, length; char data[1200]; } LobbyPacket; static int lobby_host, lobby_polls, lobby_connected, go_received, go_total; static char *go_text; static void lobby_send(const LobbyPacket *p, const struct sockaddr_in *to) { sendto(fd, p, sizeof(*p), 0, (const struct sockaddr *)to, sizeof(*to)); } static int lobby_bind(int port) { fd = socket(AF_INET, SOCK_DGRAM, 0); if (fd < 0) return 0; fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK); int on = 1; setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)); setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); struct sockaddr_in me; memset(&me, 0, sizeof(me)); me.sin_family = AF_INET, me.sin_addr.s_addr = htonl(INADDR_ANY), me.sin_port = htons(port); return bind(fd, (struct sockaddr *)&me, sizeof(me)) == 0; } int net_lobby_start(int host) { net_system_init(); net_close(); lobby_host = host, lobby_polls = 0, lobby_connected = 0, peer_known = 0, go_received = 0, go_total = 0; free(go_text), go_text = NULL; net_role = host ? 0 : 1; if (!lobby_bind(host ? NET_PORT : NET_BEACON_PORT)) return 0; const char *direct = getenv("VS_NETPEER"); // sviluppo: senza annunci if (direct && !host) { memset(&peer_addr, 0, sizeof(peer_addr)); peer_addr.sin_family = AF_INET, peer_addr.sin_port = htons(NET_PORT), peer_addr.sin_addr.s_addr = inet_addr(direct); peer_known = 1; } return 1; } int net_lobby_poll(const char *hello, char *out, int out_size) { LobbyPacket r, p; memset(&p, 0, sizeof(p)); p.magic = NET_MAGIC; struct sockaddr_in from; socklen_t fl = sizeof(from); while (recvfrom(fd, &r, sizeof(r), 0, (struct sockaddr *)&from, &fl) == (int)sizeof(r)) { if (r.magic != NET_MAGIC) continue; if (!lobby_host && r.kind == LK_BEACON && !peer_known) { peer_addr = from, peer_known = 1; peer_addr.sin_port = htons(NET_PORT); } if (!lobby_host && r.kind == LK_WELCOME) lobby_connected = 1; if (lobby_host && r.kind == LK_HELLO) { peer_addr = from, peer_known = 1, lobby_connected = 1; snprintf(out, out_size, "%s", r.data); p.kind = LK_WELCOME; lobby_send(&p, &peer_addr); } } if (lobby_polls++ % 15 == 0) { if (lobby_host && !lobby_connected) { struct sockaddr_in all; memset(&all, 0, sizeof(all)); all.sin_family = AF_INET, all.sin_port = htons(NET_BEACON_PORT), all.sin_addr.s_addr = htonl(INADDR_BROADCAST); p.kind = LK_BEACON; lobby_send(&p, &all); } else if (!lobby_host && peer_known && !lobby_connected) { p.kind = LK_HELLO; snprintf(p.data, sizeof(p.data), "%s", hello); lobby_send(&p, &peer_addr); } } return lobby_connected; } void net_lobby_resend(const char *hello) { // chi si unisce, gia' collegato, ha cambiato personaggio: solo invio (i pezzi del via restano a wait_go) if (lobby_host || !peer_known) return; LobbyPacket p; memset(&p, 0, sizeof(p)); p.magic = NET_MAGIC, p.kind = LK_HELLO; snprintf(p.data, sizeof(p.data), "%s", hello); lobby_send(&p, &peer_addr); } int net_lobby_send_go(unsigned seed, const char *text) { unsigned length = (unsigned)strlen(text) + 1, chunk = sizeof(((LobbyPacket *)0)->data), total = (length + chunk - 1) / chunk; for (unsigned i = 0; i < total; i++) { LobbyPacket p, r; memset(&p, 0, sizeof(p)); p.magic = NET_MAGIC, p.kind = LK_CHUNK, p.seed = seed, p.index = i, p.total = total, p.length = length; memcpy(p.data, text + i * chunk, i == total - 1 ? length - i * chunk : chunk); int acked = 0; for (int tries = 0; tries < 500 && !acked; tries++) { // 10 s lobby_send(&p, &peer_addr); sleep_ms(20); struct sockaddr_in from; socklen_t fl = sizeof(from); while (recvfrom(fd, &r, sizeof(r), 0, (struct sockaddr *)&from, &fl) == (int)sizeof(r)) if (r.magic == NET_MAGIC && r.kind == LK_ACK && r.index == i) acked = 1; } if (!acked) return 0; } return 1; } int net_lobby_wait_go(unsigned *seed, char **text) { LobbyPacket r; struct sockaddr_in from; socklen_t fl = sizeof(from); unsigned chunk = sizeof(r.data); while (recvfrom(fd, &r, sizeof(r), 0, (struct sockaddr *)&from, &fl) == (int)sizeof(r)) { if (r.magic != NET_MAGIC || r.kind != LK_CHUNK) continue; if (!go_text) go_text = calloc(r.length + 1, 1); if ((int)r.index == go_received) { unsigned n = r.index == r.total - 1 ? r.length - r.index * chunk : chunk; memcpy(go_text + r.index * chunk, r.data, n); go_received++, go_total = (int)r.total, *seed = r.seed; } LobbyPacket a; memset(&a, 0, sizeof(a)); a.magic = NET_MAGIC, a.kind = LK_ACK, a.index = r.index; for (int k = 0; k < 2; k++) lobby_send(&a, &peer_addr); } if (go_total && go_received == go_total) { *text = go_text; go_text = NULL; return 1; } return 0; } void net_begin(void) { memset(moves, 0, sizeof(moves)), memset(hashes, 0, sizeof(hashes)); have[0] = have[1] = NET_DELAY; hash_done = hash_checked = desync_at = desyncs = stalls = 0, desynced = 0; net_input_player = 0, net_input_frame = 0, net_on = 1; last_rx = now_s(); } void net_close(void) { net_on = 0; if (fd >= 0) close(fd); fd = -1, peer_known = 0; } int net_lost(void) { return now_s() - last_rx > 10; } int net_wants_input(unsigned frame) { return have[net_role] < frame + NET_DELAY + 1; } void net_submit(NetMove local) { moves[net_role][have[net_role] % NET_RING] = local, have[net_role]++; } NetMove net_move(int player, unsigned frame) { return moves[player][frame % NET_RING]; } void net_frame_hash(unsigned frame, unsigned hash) { hashes[frame % NET_RING] = hash, hash_done = frame + 1; } int net_tick(unsigned frame) { Packet r; struct sockaddr_in from; socklen_t fl = sizeof(from); int other = !net_role; while (recvfrom(fd, &r, sizeof(r), 0, (struct sockaddr *)&from, &fl) == (int)sizeof(r)) { if (r.magic != NET_MAGIC || r.kind != 2) continue; for (unsigned i = 0; i < r.count; i++) { unsigned f = r.first + i; if (f == have[other]) moves[other][f % NET_RING] = r.m[i], have[other]++; last_rx = now_s(); } for (unsigned i = 0; i < NET_HASHES; i++) { unsigned f = r.hash_first + i; if (f == hash_checked && f < hash_done && f < r.hash_done) { if (r.hash[i] != hashes[f % NET_RING]) { if (!desynced) desynced = 1, desync_at = f; desyncs++; } hash_checked++; } } } Packet p = { NET_MAGIC }; p.kind = 2; unsigned mine = have[net_role]; p.first = mine > NET_RESEND ? mine - NET_RESEND : 0, p.count = (unsigned char)(mine - p.first); for (unsigned i = 0; i < p.count; i++) p.m[i] = moves[net_role][(p.first + i) % NET_RING]; p.hash_first = hash_done > NET_HASHES ? hash_done - NET_HASHES : 0; p.hash_done = hash_done; for (unsigned i = 0; i < NET_HASHES; i++) p.hash[i] = hashes[(p.hash_first + i) % NET_RING]; net_send(&p); int ready = have[0] > frame && have[1] > frame; if (!ready) stalls++; return ready; } void net_report(unsigned frame) { FILE *f = fopen(vs_path("net.log"), "a"); if (!f) return; fprintf(f, "frame %u controllati %u fermi %u divergenze %u prima %d\n", frame, hash_checked, stalls, desyncs, desynced ? (int)desync_at : -1); fclose(f); }