ASCIIlosaurus_server.c

/**
 * @file ASCIIlosaurus_server.c
 * @brief Server portion of the UDP game - process commands and sends state to client
 * @author Alejandro Alvarado
 * @course Intro to Operating Systems - CS333-006
 * @date March 11, 2026
 *
 * @details 
 * Note that large portions of this code are from the skeleton file provided by
 * the instructor: R Jesse chaney (rchaney@pdx.edu)
 *
 * This file creates the server side of the UDP terminal game. The server is
 * responsible for creating a UDP socket and binding it to a specified port,
 * maintaining the world state, connecting players, and providing those updates
 * to clients.
 */

#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdbool.h>
#include <poll.h>
#include <stdio.h>
#include <string.h>
#include <ncurses.h>
#include <signal.h>
#include <libgen.h>
#include <time.h>

#include "ASCIIlosaurus_world.h"

#define BUF_SIZE 100
#define SOCKET_FD 1
// #define POLL_TIMEOUT 500
#define POLL_TIMEOUT 300

#define DEFAULT_X 20
#define DEFAULT_Y 10

#define OPTIONS "P:vh"

volatile sig_atomic_t keep_running = 1;  // this is how we terminate the server (end the inf loop)

static bool is_verbose = false;
static socklen_t addrlen = sizeof(struct sockaddr_in);

static world_state_t world;  // this is what we will send to the client - it contains state like player pos
static struct sockaddr_in clients[MAX_PLAYERS];  // this is going to store the address of each connected client
static const char symbols[MAX_PLAYERS] = {
    '@', '=', '$', '%', '^', '&', '*', 'X', '?', '+'};  // symbols represent playable characters or players

static void process_server_command(void);
static void handle_sigint(int);
static void update_clients(int);

int
main(int argc, char *argv[])
{
    struct sockaddr_in servaddr;  // this contains our connnection info
    struct pollfd fds[2];
    int port = DEFAULT_PORT;
    int socketfd = -1;  // this is our socket

    // Process the command line if anything was passed
    {
        int opt = 0;

        while ((opt = getopt(argc, argv, OPTIONS)) != -1) {
            switch (opt) {
            case 'P':
                port = atoi(optarg);
                break;
            case 'v':
                is_verbose = true;
                break;
            case 'h':
                printf("Usage: ASCIIlosaurus_server [-P port] [-v] [-h]\n");
                printf("  -P #   Set server port (default: %d)\n", DEFAULT_PORT);
                printf("  -v     Enable verbose logging to stderr\n");
                printf("  -h     Print this help and exit\n");
                exit(EXIT_SUCCESS);
                break;
            default:
                break;
            }
        }
    }

    // initialize world
    world.client_char = ' ';  // placeholder until we have a connection
    // setup the defualt positions of each player (spawn pos)
    for (int i = 0; i < MAX_PLAYERS; ++i) {
        world.players[i].x = 0;
        world.players[i].y = 0;
        world.players[i].symbol = symbols[i];
        world.players[i].active = false;
        world.players[i].cloaked = false;  // this is not used
        world.players[i].cloak_countdown = 0;  // this is not used
    }
    memset(clients, 0, sizeof(clients));  // prepare mem area with clean null values

    // register sig handler for ctrl-c
    {
        struct sigaction sa;

        sa.sa_handler = handle_sigint;
        sigemptyset(&sa.sa_mask);
        sa.sa_flags = 0;
        (void)sigaction(SIGINT, &sa, NULL);
        (void)sigaction(SIGTERM, &sa, NULL);
    }

    // Create an IPv4 datagram socket
    if ((socketfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
        perror("socket creation error");
        return EXIT_FAILURE;
    }

    fds[STDIN_FILENO].fd = STDIN_FILENO;  // STDIN_FILENO == 0
    fds[STDIN_FILENO].events = POLLIN;  // this is for processing data from stdin ie the keyboard (read events)

    fds[SOCKET_FD].fd = socketfd;
    fds[SOCKET_FD].events = POLLIN;  // read events from the client

    memset(&servaddr, 0, sizeof(struct sockaddr_in));  // again prepare mem area with clean values

    servaddr.sin_family = AF_INET;  // IPv4 connection
    servaddr.sin_port = htons((uint16_t)port);  // little-endian -> big-endian
    servaddr.sin_addr.s_addr = INADDR_ANY;  // allow any connection
    if (bind(socketfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {  // bind our datagram socket to the port
        perror("bind failure");
        fprintf(stderr, "  Port %d must already be in use.\n", port);
        fprintf(stderr, "  Try another with the -P # command line option.\n");
        fprintf(stderr, "  Remember to start your client with the same port.\n");
        close(socketfd);
        return EXIT_FAILURE;
    }

    if (is_verbose) {
        fprintf(stderr, "Server listening on port %d\n", port);
    }

    // the server console prompt
    printf("server > ");
    // =============== Main Server Loop ===============
    while (keep_running) {
        int ret = -1;  // this will signal the program that something arrived from a client and/or stdin
        int buf = -1;
        ssize_t br = -1;  // bytes read
        struct sockaddr_in cliaddr;  // connection info for clients - when they send something to us

        // this is necessary
        fflush(stdout);
        ret = poll(fds, 2, POLL_TIMEOUT);  // waits until fd is ready for I/O aka we can read from the socket now

        if (ret == 0) {
            // a timeout
            // update to the clients.
            update_clients(socketfd);
        } else if (ret > 0) {
            // got input from either or both of stdin or the socket
            if (fds[STDIN_FILENO].revents & POLLIN) {  // process stdin first in case we press q
                // user entered command from keyboard
                process_server_command();
            }
            if (fds[SOCKET_FD].revents & POLLIN) {
                // something arrived from a client
                buf = 0;
                addrlen = sizeof(struct sockaddr_in);
                br = recvfrom(socketfd, &buf, sizeof(int), 0,
                              (struct sockaddr *)&cliaddr, &addrlen);  // read bytes into buf

                if (br == (ssize_t)sizeof(int)) {  // an event is of size int
                    int found_it = -1;  // how we find the client that sent server a command
                    int first_empty = -1;
                    int ch = (int)ntohl((uint32_t)buf);  // get the character - convert from big-endian -> little-endian

                    // update or insert client
                    // first, locate which client just sent us a command
                    // or insert a new client into the client list
                    for (int i = 0; i < MAX_PLAYERS; ++i) {
                        if (world.players[i].active) {
                            // check to see if the port and ip match
                            if (clients[i].sin_port == cliaddr.sin_port &&
                                clients[i].sin_addr.s_addr == cliaddr.sin_addr.s_addr) {
                                found_it = i;
                                break;
                            }
                        } else if (first_empty == -1) {  // this means the first character is spawning in
                            // keep track of where to place a new client
                            first_empty = i;
                        }
                    }
                    if ((found_it == -1) && (first_empty != -1)) {
                        if (is_verbose) {
                            fprintf(stderr, "%d: new player found  %d\n", __LINE__, first_empty);
                        }
                        clients[first_empty] = cliaddr;

                        // put a new player in slightly different positions in the world.
                        world.players[first_empty].x = DEFAULT_X + first_empty;
                        world.players[first_empty].y = DEFAULT_Y + first_empty;

                        world.players[first_empty].symbol = symbols[first_empty];
                        world.players[first_empty].active = true;
                    } else if (found_it > -1) {
                        // Support gaming, vim, and arrow keys with collapsing cases
                        switch (ch) {
                        case 'w':
                        case 'k':
                        case KEY_UP:
                            world.players[found_it].y--;
                            if (world.players[found_it].y < 0) {
                                world.players[found_it].y = GRID_H - 1;
                            }
                            break;
                        case 's':
                        case 'j':
                        case KEY_DOWN:
                            world.players[found_it].y++;
                            if (world.players[found_it].y >= GRID_H) {
                                world.players[found_it].y = 0;
                            }
                            break;
                        case 'a':
                        case 'h':
                        case KEY_LEFT:
                            world.players[found_it].x--;
                            if (world.players[found_it].x < 0) {
                                world.players[found_it].x = GRID_W - 1;
                            }
                            break;
                        case 'd':
                        case 'l':
                        case KEY_RIGHT:
                            world.players[found_it].x++;
                            if (world.players[found_it].x >= GRID_W) {
                                world.players[found_it].x = 0;
                            }
                            break;
                        case 'q':
                            // client is leaving the game
                            world.players[found_it].active = false;
                            if (is_verbose) {
                                fprintf(stderr, "Player %d quit\n", found_it);
                            }
                            break;
                        default:
                            // unrecognized command - ignore
                            break;
                        }
                    }
                    // update all the clients
                    update_clients(socketfd);
                }
            }
        } else if (ret == -1) {
            if (errno == EINTR) {
                // let the signal handler change keep_running
            } else {
                perror("poll error");
            }
        }
    }

    printf("\n\nexiting...\n");

    if (socketfd != -1) {
        close(socketfd);
    }

    return EXIT_SUCCESS;
}

static void
process_server_command(void)
{
    static char buf[BUF_SIZE] = {'\0'};

    memset(buf, 0, BUF_SIZE);
    (void)read(STDIN_FILENO, buf, BUF_SIZE);
    switch (buf[0]) {
    case 'q':
        // change the keep_running variable
        keep_running = 0;
        break;
    case 'h':
        // extra credit
        printf("commands:\n");
        printf("        q: quit\n");
        printf("        h: help\n");
        printf("        k: client keyboard characters\n");
        printf("        l: list client ports\n");
        break;
    case 'k':
        // extra credit
        printf("client character movement keys:\n");
        printf("        w k <up arrow>   : move up\n");
        printf("        a h <left arrow>: move left\n");
        printf("        s j <down arrow>: move down\n");
        printf("        d l <right arrow>: move right\n");
        break;
    case 'l':
        // extra credit
        for (int i = 0; i < MAX_PLAYERS; i++) {
            if (world.players[i].active) {
                char ip_str[INET_ADDRSTRLEN];

                inet_ntop(AF_INET, &clients[i].sin_addr, ip_str, INET_ADDRSTRLEN);  // binary to text
                printf("        client host: %15s      port: %d\n",
                       ip_str, ntohs(clients[i].sin_port));
            }
        }
        break;
    case '\n':
        break;
    default:
        printf("unrecognized command %c\n", buf[0]);
        break;
    }
    // must print a new prompt
    printf("server > ");
}

static void
update_clients(int socketfd)
{
    // Copy the state.
    world_state_t tmp_world = world;

    // Serialization Loop: convert to network byte order
    for (int i = 0; i < MAX_PLAYERS; i++) {
        if (tmp_world.players[i].active) {
            tmp_world.players[i].x = (int)htonl((uint32_t)tmp_world.players[i].x);  // little-endian -> big-endian
            tmp_world.players[i].y = (int)htonl((uint32_t)tmp_world.players[i].y);
        }
    }

    // Now that we converted the values we can send it to the client
    for (int i = 0; i < MAX_PLAYERS; i++) {
        // send to each active client the entire world
        // set client_char so each client knows which character they are
        if (world.players[i].active) {
            tmp_world.client_char = world.players[i].symbol;
            (void)sendto(socketfd, &tmp_world, sizeof(world_state_t), 0,
                         (struct sockaddr *)&clients[i], sizeof(struct sockaddr_in));
        }
    }
}

static void
handle_sigint(int sig)
{
    (void)sig;
    keep_running = 0;
}