scufpong/src/server/server.c

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <errno.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdlib.h>

#include "scufeng/engine.h"
#include "scufeng/log.h"
#include "game.h"
#include "networking.h"

#define SERVER_HOST "127.0.0.1"
#define SERVER_PORT 8080

typedef enum {
    SS_LOBBY,
    SS_GAME
} ServerState;

static FILE *p1_conn = nullptr;
static FILE *p2_conn = nullptr;

static ServerState server_state = SS_LOBBY;

static void server_lobby(const int sock) {
    int player1 = accept(sock, nullptr, nullptr);
    if (player1 == -1) {
        LOG_FATALF("accept failed: %s", strerror(errno));
    }
    // if (fcntl(player1, F_SETFL, O_NONBLOCK) != 0) {
    //     LOG_FATALF("fcntl failed on player1: (%d) %s", errno, strerror(errno));
    // }
    printf("Player 1 connected\n");

    p1_conn = fdopen(player1, "r+");
    if (p1_conn == nullptr) {
        LOG_FATAL("fdoepn failed for p1");
    }

    // int player2 = accept(sock, nullptr, nullptr);
    // if (player2 == -1) {
    //     LOG_FATALF("accept failed: %s", strerror(errno));
    // }
    // if (fcntl(player2, F_SETFL, O_NONBLOCK) != 0) {
    //     LOG_FATALF("fcntl failed on player2: (%d) %s", errno, strerror(errno));
    // }
    // printf("Player 2 connected\n");

    // p2_conn = fdopen(player2, "r+");
    // if (p2_conn == nullptr) {
    //     LOG_FATAL("fdoepn failed for p2");
    // }
}

static void server_game() {
    GameState state = GameState_new(game_default_params);

    se_fps_lock_set_fps(60);

    double last_frame_time_s = 0.0;
    while (true) {
        const double current_time_s = se_get_time();
        const double delta = current_time_s - last_frame_time_s;
        se_fps_lock_frame_start_s(current_time_s);

        // Player input
        uint8_t buf[PADDLE_CHANGE_DIR_MSG_ENCODED_SIZE];
        if (!recv_msg(p1_conn, buf, PADDLE_CHANGE_DIR_MSG_ENCODED_SIZE)) {
            LOG_FATAL("Failed to receive message");
        }

        PaddleChangeDirMsg msg = PaddleChangeDir_decode(buf, PADDLE_CHANGE_DIR_MSG_ENCODED_SIZE);
        SEDirection dir = (SEDirection) msg.dir;
        bool player1 = (bool) msg.player1;
        if (player1) {
            const char *dir_str = dir == SE_UP ? "UP" : (dir == SE_DOWN ? "DOWN" : (dir == SE_NONE ? "NONE" : "INVALID"));
            printf("Player 1 moves paddle to direction: %s\n", dir_str);
        } else {
            printf("Message was not from player1\n");
        }

        // Tick
        GameState_update(&state, delta);

        // Player output

        // Wait
        se_fps_lock_wait();
    }
}

int main() {
    se_init(true);

    struct protoent *proto = getprotobyname("tcp");
    if (proto == nullptr) {
        LOG_FATAL("getprotobyname failed");
    }
    const int sock = socket(AF_INET, SOCK_STREAM, proto->p_proto);
    if (sock == -1) {
        LOG_FATALF("socket failed: %s", strerror(errno));
    }
    {
        int val = 1;
        val = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
        if (val != 0) {
            LOG_FATALF("setsockopt failed: (%d) %s", errno, strerror(errno));
        }
    }

    {
        struct in_addr addr;
        int res = inet_aton(SERVER_HOST, &addr);
        if (res == 0) {
            LOG_FATAL("inet_aton failed");
        }
        struct sockaddr_in own_addr = {
            .sin_family = AF_INET,
            .sin_addr = addr,
            .sin_port = htons(SERVER_PORT)
        };
        res = bind(sock, (struct sockaddr *) &own_addr, sizeof(own_addr));
        if (res == -1) {
            LOG_FATALF("bind failed: %s", strerror(errno));
        }
    }

    int res = listen(sock, 5);
    if (res == -1) {
        LOG_FATALF("listen failed: %s", strerror(errno));
    }

    while (true) {
        switch (server_state) {
        case SS_LOBBY:
            server_lobby(sock);
            server_state = SS_GAME;
            break;
        case SS_GAME:
            server_game();
            break;
        }
    }

    // printf("Player connected\n");
    //
    // FILE *conn_s = fdopen(conn, "r+");
    // if (conn_s == nullptr) {
    //     LOG_FATALF("fdopen failed: (%d) %s", errno, strerror(errno));
    // }
    //
    // while (true) {
    //     printf("Reading msg_len\n");
    //     size_t msg_len;
    //     size_t bytes_read = fread(&msg_len, sizeof(msg_len), 1, conn_s);
    //     if (bytes_read < 1) {
    //         LOG_FATALF("fread failed to read msg_len %zu", bytes_read);
    //     }
    //     printf("msg_len: %zu\n", msg_len);
    //
    //     printf("\nReading msg\n");
    //     char *msg = (char *) malloc(msg_len + 1);
    //     bytes_read = fread(msg, msg_len, 1, conn_s);
    //     if (bytes_read < 1) {
    //         LOG_FATALF("fread failed to read msg %zu", bytes_read);
    //     }
    //     msg[msg_len] = '\0';
    //
    //     printf("msg: %s\n\n", msg);
    //
    //     free(msg);
    // }
    //
    // fclose(conn_s);
    // close(conn);
    // close(sock);

    // char inter_buf[1024] = {0};
    // const size_t inter_buf_size = sizeof(inter_buf) / sizeof(inter_buf[0]);
    //
    // size_t buf_size = sizeof(char) * 1024;
    // size_t buf_len = 0;
    // char *buf = (char *) malloc(buf_size);
    // if (buf == nullptr) {
    //     LOG_FATAL("Failed to allocate buf");
    // }
    //
    // while (true) {
    //     int received = recv(conn, inter_buf, inter_buf_size, 0);
    //     for (int i = 0; i < received; i++) {
    //         printf("'%c' ", inter_buf[i]);
    //     }
    //     putc('\n', stdout);
    //     if (received == -1) {
    //         LOG_FATALF("recv failed: %d %s", errno, strerror(errno));
    //     } else if (received == 0) {
    //         printf("Player disconnected\n");
    //         break;
    //     } else {
    //         if (buf_len + received + 1 > buf_size) {
    //             buf_size *= 2;
    //             buf = realloc(buf, buf_size);
    //             if (buf == nullptr) {
    //                 LOG_FATAL("Failed to increase size of buf");
    //             }
    //         }
    //
    //         memcpy(buf + buf_len, inter_buf, received);
    //         buf_len += received;
    //         buf[buf_len] = '\0';
    //
    //         printf("buf: %s\n", buf);
    //     }
    //
    //     // if (received == 0) {
    //     //     printf("buf: %s\n", buf);
    //     //     buf[0] = '\0';
    //     //     break;
    //     // } else if (received == -1) {
    //     //     LOG_FATALF("recv failed: %d %s", errno, strerror(errno));
    //     // } else {
    //     //     buf[received] = '\0';
    //     // }
    //     // printf("loop buf: %s\n", buf);
    // }

    return 0;
}