GitHub Vita Lite - Wolff's Store
Code / README | Releases | Issues
Federicoilgrandebardo/vampire-survivors-vita / src

net.c

12784 bytes ยท Original / download

// 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 <errno.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>
#include "net.h"
#include "vs.h"
#ifdef __vita__
#include <psp2/net/net.h>
#include <psp2/net/netctl.h>
#include <psp2/sysmodule.h>
#include <psp2/kernel/threadmgr.h>
#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);
}