// Simulation of my submission for the final project for the 2021
// HackadayU course 'Raspberry Pi Pico and RP2040 - The Deep Dive
// This simulation runs Pong on the Raspberry Pi Pico, using a 
// custom PIO-based composite video peripheral
// Alan Reed, 2021

#include <stdio.h>
#include "pico/stdlib.h"
#include <stdlib.h>

#include "hardware/timer.h"
#include "hardware/gpio.h"
#include "connections.h"
#include "pong.h"

// Use alarm 0
#define ALARM_NUM 0
#define ALARM_IRQ TIMER_IRQ_0


// Manual timer initialisation as the timer SDK functions don't seem to work on sim
// Code borrowed from Pico Examples repo
static void alarm_in_us(uint32_t delay_us) {
    // Enable the interrupt for our alarm (the timer outputs 4 alarm irqs)
    hw_set_bits(&timer_hw->inte, 1u << ALARM_NUM);
    // Set irq handler for alarm irq
    irq_set_exclusive_handler(ALARM_IRQ, alarm_irq);
    // Enable the alarm irq
    irq_set_enabled(ALARM_IRQ, true);
    // Enable interrupt in block and at processor

    // Alarm is only 32 bits so if trying to delay more
    // than that need to be careful and keep track of the upper
    // bits
    uint64_t target = timer_hw->timerawl + delay_us;

    // Write the lower 32 bits of the target time to the alarm which
    // will arm it
    timer_hw->alarm[ALARM_NUM] = (uint32_t) target;
}

static void alarm_irq(void) {
    // Clear the alarm irq
    hw_clear_bits(&timer_hw->intr, 1u << ALARM_NUM);

    // Assume alarm 0 has fired
    alarm_in_us(PONG_FRAME_INTERVAL_ms * 1000);
    pong_tick();
}

void button_cb(unsigned int gpio, uint32_t events) {
  if (events & GPIO_IRQ_EDGE_RISE) { 
    if (gpio == PLAYER1_BUTTON_UP || gpio == PLAYER1_BUTTON_DOWN) {
      pong_move_player(1, PONG_DIRECTION_STOP);
    }
    else if (gpio == PLAYER2_BUTTON_UP || gpio == PLAYER2_BUTTON_DOWN) {
      pong_move_player(2, PONG_DIRECTION_STOP);
    }
  } else if (events & GPIO_IRQ_EDGE_FALL) { 
    switch(gpio) {
      case PLAYER1_BUTTON_UP:
        pong_move_player(1, PONG_DIRECTION_UP);
        break;
      case PLAYER1_BUTTON_DOWN:
        pong_move_player(1, PONG_DIRECTION_DOWN);
        break;
      case PLAYER2_BUTTON_UP:
        pong_move_player(2, PONG_DIRECTION_UP);
        break;
      case PLAYER2_BUTTON_DOWN:
        pong_move_player(2, PONG_DIRECTION_DOWN);
        break;
    }
  }
}

void setup() {
  Serial1.begin(115200);

  // stdio_init_all();
  gpio_set_function(SERIAL_RX_PIN, GPIO_FUNC_UART);
  gpio_set_function(SERIAL_TX_PIN, GPIO_FUNC_UART);

  Serial1.print("Pi Pico Pong\r\n");
  Serial1.print("Created by Alan Reed\r\n");
  pong_init();

  irq_set_enabled(TIMER_IRQ_3, false);
  // struct repeating_timer timer;
  // add_repeating_timer_ms(PONG_FRAME_INTERVAL_ms, pong_gametick_callback, NULL, &timer);

  gpio_pull_up(PLAYER1_BUTTON_DOWN);
  gpio_pull_up(PLAYER1_BUTTON_UP);
  gpio_pull_up(PLAYER2_BUTTON_DOWN);
  gpio_pull_up(PLAYER2_BUTTON_UP);
  gpio_set_irq_enabled_with_callback(PLAYER1_BUTTON_DOWN, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL, true, &button_cb);
  gpio_set_irq_enabled_with_callback(PLAYER1_BUTTON_UP, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL, true, &button_cb);
  gpio_set_irq_enabled_with_callback(PLAYER2_BUTTON_DOWN, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL, true, &button_cb);
  gpio_set_irq_enabled_with_callback(PLAYER2_BUTTON_UP, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL, true, &button_cb);

  // Set the tick timer going
  alarm_in_us(PONG_FRAME_INTERVAL_ms * 1000);
}

void loop() {
  pong_update();
}


tv-pong.ino

diagram.json

#ifndef __CVIDEO_H__
#define __CVIDEO_H__

#include "hardware/pio.h"

#define CVIDEO_LINES 576
// Pixels per line should be a multiple of 32
// For very high or very low pixel counts, DATA_DELAY within cvideo.pio may need adjustment
#define CVIDEO_PIX_PER_LINE 768

typedef uint32_t (*cvideo_data_callback_t)(void); 

void cvideo_init(PIO pio, uint data_pin, uint sync_pin, cvideo_data_callback_t callback); 

#endif

cvideo.h

#include "cvideo.h"
#include "cvideo.pio.h"
#include "hardware/clocks.h"
#include "hardware/irq.h"
#include <stdio.h>

// Sync PIO needs 2us per instruction
#define SYNC_INTERVAL 0.000002
// Data transmits for 52us
#define DATA_INTERVAL 0.000052

#define DATA_SM_ID 0
#define SYNC_SM_ID 1

static PIO cvideo_pio;
static uint pio_irq_id = PIO0_IRQ_1;
static cvideo_data_callback_t data_callback;

static inline void cvsync_program_init(PIO pio, uint sm, uint offset, float clockdiv, uint sync_pin);
static inline void cvdata_program_init(PIO pio, uint sm, uint offset, float clockdiv, uint data_pin); 

static void cvdata_isr(void) {
    pio_sm_put(cvideo_pio, DATA_SM_ID, data_callback());
    irq_clear(pio_irq_id);
}

void cvideo_init(PIO pio, uint data_pin, uint sync_pin, cvideo_data_callback_t callback) {
    if (CVIDEO_PIX_PER_LINE % 32 != 0) {
        printf("ERROR: Horizontal pixel count must be a multiple of 32\r\n");
    }
    else {
        cvideo_pio = pio;
        data_callback = callback;
        if (pio_get_index(pio) == 1){
            pio_irq_id = PIO1_IRQ_1;
        }

        // Run the data clock 32x faster than needed to reduce horizontal jitter due to synchronisation between SMs
        float data_clockdiv = (clock_get_hz(clk_sys) / (CVIDEO_PIX_PER_LINE / DATA_INTERVAL)) / CLOCKS_PER_BIT;
        float sync_clockdiv = clock_get_hz(clk_sys) * SYNC_INTERVAL;
        
        if (data_clockdiv < 1) {
            printf("WARNING: PIO data SM clock divider (value %f) less than 1\r\n", data_clockdiv);
        }

        printf("Data clockdiv %f\r\n", data_clockdiv);
        printf("Sync clockdiv %f\r\n", sync_clockdiv);
        
        uint offset_sync = pio_add_program(pio, &cvsync_program);
        uint offset_data = pio_add_program(pio, &cvdata_program);

        cvdata_program_init(pio, DATA_SM_ID, offset_data, data_clockdiv, data_pin);
        cvsync_program_init(pio, SYNC_SM_ID, offset_sync, sync_clockdiv, sync_pin);

        // Enable FIFO refill interrupt for data state machine
        irq_set_enabled(pio_irq_id, true);
        irq_set_exclusive_handler(pio_irq_id, cvdata_isr);
        irq_set_priority(pio_irq_id, 0);
        cvideo_pio->inte1 = 1 << 4 + DATA_SM_ID;
    }
}

static inline void cvdata_program_init(PIO pio, uint sm, uint offset, float clockdiv, uint data_pin) {
    pio_sm_config c = cvdata_program_get_default_config(offset);

    // Map the state machine's OUT and SIDE pin group to one pin, namely the `pin`
    // parameter to this function.
    sm_config_set_set_pins(&c, data_pin, 1);
    sm_config_set_out_pins(&c, data_pin, 1);

    sm_config_set_clkdiv(&c, clockdiv);

    // Set this pin's GPIO function (connect PIO to the pad)
    pio_gpio_init(pio, data_pin);

    // Set the pin direction to output at the PIO
    pio_sm_set_consecutive_pindirs(pio, sm, data_pin, 1, true);

    // Enable autopull and set threshold to 32 bits
    // Note that register positions are the same for all state machines
    c.shiftctrl |= (1u<<PIO_SM0_SHIFTCTRL_AUTOPULL_LSB) |
                  (0u<<PIO_SM0_SHIFTCTRL_PULL_THRESH_LSB);

    
    // Load our configuration, and jump to the start of the program
    pio_sm_init(pio, sm, offset, &c);

    // Tell the state machine the number of pixels per line (minus 1)
    pio_sm_put(pio, sm, CVIDEO_PIX_PER_LINE - 1);
    pio_sm_exec(pio, sm, 0x80a0);  // pull
    pio_sm_exec(pio, sm, 0xa027);  // mov    x, osr 
    pio_sm_exec(pio, sm, 0x6060);  // out null 32 ; Discard OSR contents after copying to x

    // Set the state machine running
    pio_sm_set_enabled(pio, sm, true);
}

static inline void cvsync_program_init(PIO pio, uint sm, uint offset, float clockdiv, uint sync_pin) {
    pio_sm_config c = cvsync_program_get_default_config(offset);

    // Map the state machine's OUT and SIDE pin group to one pin, namely the `pin`
    // parameter to this function.
    sm_config_set_sideset_pins(&c, sync_pin);

    // Set the clock speed
    sm_config_set_clkdiv(&c, clockdiv);

    // Set this pin's GPIO function (connect PIO to the pad)
    pio_gpio_init(pio, sync_pin);

    // Set the pin direction to output at the PIO
    pio_sm_set_consecutive_pindirs(pio, sm, sync_pin, 1, true);

    // Load our configuration, and jump to the start of the program
    pio_sm_init(pio, sm, offset, &c);

    // Tell the state machine the number of video lines per frame (minus 1)
    pio_sm_put(pio, sm, (CVIDEO_LINES / 2) - 1);
    pio_sm_exec(pio, sm, 0x80a0);  // pull side 0

    // Set the state machine running
    pio_sm_set_enabled(pio, sm, true);
}


cvideo.cpp

// -------------------------------------------------- //
// This file is autogenerated by pioasm; do not edit! //
// -------------------------------------------------- //

#pragma once

#if !PICO_NO_HARDWARE
#include "hardware/pio.h"
#endif

#define CLOCKS_PER_BIT 6

// ------ //
// cvsync //
// ------ //

#define cvsync_wrap_target 0
#define cvsync_wrap 24

static const uint16_t cvsync_program_instructions[] = {
            //     .wrap_target
    0x0063, //  0: jmp    !y, 3           side 0     
    0xf023, //  1: set    x, 3            side 1     
    0x1d04, //  2: jmp    4               side 1 [13]
    0xfe24, //  3: set    x, 4            side 1 [14]
    0xa042, //  4: nop                    side 0     
    0x1e44, //  5: jmp    x--, 4          side 1 [14]
    0xed24, //  6: set    x, 4            side 0 [13]
    0x1129, //  7: jmp    !x, 9           side 1 [1] 
    0x0d47, //  8: jmp    x--, 7          side 0 [13]
    0x006c, //  9: jmp    !y, 12          side 0     
    0xf022, // 10: set    x, 2            side 1     
    0x1c0d, // 11: jmp    13              side 1 [12]
    0xfd23, // 12: set    x, 3            side 1 [13]
    0xb04a, // 13: mov    y, !y           side 1     
    0xa042, // 14: nop                    side 0     
    0x1e4e, // 15: jmp    x--, 14         side 1 [14]
    0xe130, // 16: set    x, 16           side 0 [1] 
    0xbe42, // 17: nop                    side 1 [14]
    0x1e34, // 18: jmp    !x, 20          side 1 [14]
    0x0151, // 19: jmp    x--, 17         side 0 [1] 
    0xa127, // 20: mov    x, osr          side 0 [1] 
    0xb242, // 21: nop                    side 1 [2] 
    0xdd00, // 22: irq    nowait 0        side 1 [13]
    0x1c20, // 23: jmp    !x, 0           side 1 [12]
    0x0155, // 24: jmp    x--, 21         side 0 [1] 
            //     .wrap
};

#if !PICO_NO_HARDWARE
static const struct pio_program cvsync_program = {
    .instructions = cvsync_program_instructions,
    .length = 25,
    .origin = -1,
};

static inline pio_sm_config cvsync_program_get_default_config(uint offset) {
    pio_sm_config c = pio_get_default_sm_config();
    sm_config_set_wrap(&c, offset + cvsync_wrap_target, offset + cvsync_wrap);
    sm_config_set_sideset(&c, 1, false, false);
    return c;
}
#endif

// ------ //
// cvdata //
// ------ //

#define cvdata_wrap_target 0
#define cvdata_wrap 4

static const uint16_t cvdata_program_instructions[] = {
            //     .wrap_target
    0xe000, //  0: set    pins, 0                    
    0xa041, //  1: mov    y, x                       
    0x20c0, //  2: wait   1 irq, 0                   
    0x6401, //  3: out    pins, 1                [4] 
    0x0083, //  4: jmp    y--, 3                     
            //     .wrap
};

#if !PICO_NO_HARDWARE
static const struct pio_program cvdata_program = {
    .instructions = cvdata_program_instructions,
    .length = 5,
    .origin = -1,
};

static inline pio_sm_config cvdata_program_get_default_config(uint offset) {
    pio_sm_config c = pio_get_default_sm_config();
    sm_config_set_wrap(&c, offset + cvdata_wrap_target, offset + cvdata_wrap);
    return c;
}
#endif



cvideo.pio.h

#ifndef __RENDERER_H__
#define __RENDERER_H__

#include <stdint.h>
#include <stdbool.h>

extern uint32_t renderer_screen_width;
extern uint32_t renderer_screen_height;

typedef enum {
  JUSTIFY_LEFT,
  JUSTIFY_RIGHT,
  JUSTIFY_CENTRE,
} renderer_text_justify_t;

typedef void (*renderer_draw_callback_t)(void);

void renderer_init(renderer_draw_callback_t callback);

void renderer_run(void);

void renderer_draw_rect(unsigned int x, unsigned int y, unsigned int width, unsigned int height);

void renderer_draw_image(unsigned int x, unsigned int y, unsigned int width, unsigned int height, char *data);

void renderer_draw_character(unsigned int x, unsigned int y, unsigned int scale, char character);

void renderer_draw_string(unsigned int x, unsigned int y, unsigned int scale, char *text, unsigned int length, renderer_text_justify_t justification);

#endif

renderer.h

#include "renderer.h"
#include "cvideo.h"
#include "connections.h"
#include <stdio.h>
#include <stdbool.h>
#include "font.h"

// 32 bits per word
#define LINE_WORD_COUNT CVIDEO_PIX_PER_LINE / 32
// Font spritesheet is a grid of 16x16
#define CHAR_WIDTH font_width / 16
#define CHAR_HEIGHT font_height / 16

uint32_t renderer_screen_width = CVIDEO_PIX_PER_LINE;
uint32_t renderer_screen_height = CVIDEO_LINES;

// Screen data buffers
typedef uint32_t buffer_t[CVIDEO_LINES][LINE_WORD_COUNT];
static buffer_t buffer_0;
static buffer_t buffer_1;
static buffer_t *output_buffer = &buffer_0;
static buffer_t *drawing_buffer = &buffer_1;

// Counters and flags for cvideo data callback
static volatile int current_line;
static volatile int current_pix;
static bool data_underrun;

// Callback and flags for signalling frame redraw
static renderer_draw_callback_t drawing_callback;
static bool drawing_in_progress;
static bool redraw_frame_requested;
static bool drawing_overrun;

static void set_bit(uint x, uint y, bool value);
static void renderer_clear(buffer_t *buffer);
static void update_output_buffer(void);

// Callback for shipping out image words to cvideo peripheral
uint32_t data_callback(void) {
  uint32_t *line = (*output_buffer)[current_line];
  uint32_t data = line[current_pix];
  current_pix++;

  if (current_pix == LINE_WORD_COUNT) {
    current_pix = 0;
    current_line = current_line + 2;

    if (current_line == CVIDEO_LINES + 1){
      current_line = 0;
      update_output_buffer();
    }
    else if (current_line == CVIDEO_LINES){
      current_line = 1;
      update_output_buffer();
    }
  }
  if (pio_sm_is_tx_fifo_empty(pio0, 0)) {
      data_underrun = true;
  }
  return data;
}

void renderer_init(renderer_draw_callback_t callback){
  renderer_clear(output_buffer);
  renderer_clear(drawing_buffer);
  data_underrun = false;
  drawing_in_progress = false;
  redraw_frame_requested = false;
  drawing_overrun = false;
  drawing_callback = callback;

  // PIO starts with odd lines
  current_line = 1;
  current_pix = 0;

  cvideo_init(pio0, CVIDEO_DATA_PIN, CVIDEO_SYNC_PIN, data_callback);
}

void renderer_run(void) {
  if (data_underrun) {
    data_underrun = false;
    printf("Data underrun!\r\n");
  }
  if (drawing_overrun) {
    //printf("Drawing too slow! \r\n");
    drawing_overrun = false;
  }

  if (redraw_frame_requested) {
    drawing_in_progress = true;
    renderer_clear(drawing_buffer);
    drawing_callback();
    drawing_in_progress = false;
    redraw_frame_requested = false;
  }
}

void renderer_draw_rect(uint x, uint y, uint width, uint height) {
  if (drawing_in_progress) {
    uint32_t x_word_start_index = x / 32;
    uint32_t x_word_end_index = (x + width) / 32;

    uint32_t x_word_start_boundary_offset = x % 32;
    uint32_t x_word_end_boundary_offset = (x + width) % 32;

    // Set first and last words manually
    // Set other words quickly

    for (int j = y; j < y + height; j++) {
      // Small rectangles sometimes fit entirely within one word
      if (x_word_start_index == x_word_end_index) {
        uint32_t data = 0xFFFFFFFF;
        data ^= 0xFFFFFFFF << x_word_start_boundary_offset;
        data ^= 0xFFFFFFFF >> (32 - x_word_end_boundary_offset);
        (*drawing_buffer)[j][x_word_start_index] |= data;
      }
      else {
        // First word and last word only partially filled
        (*drawing_buffer)[j][x_word_start_index] |= 0xFFFFFFFF << x_word_start_boundary_offset;
        (*drawing_buffer)[j][x_word_end_index] |= 0xFFFFFFFF >> (32 - x_word_end_boundary_offset);

        for (int i = x_word_start_index + 1; i < x_word_end_index; i++) {
          (*drawing_buffer)[j][i] = 0xFFFFFFFF;
        }
      }
    }
  }
}

void renderer_draw_image(unsigned int x, unsigned int y, unsigned int width, unsigned int height, char *data) {
  if (drawing_in_progress) {
    for (int j = 0; j < height; j++) {
      for  (int i = 0; i < width; i++) {
        // XBM images pad rows with zeros
        uint32_t array_position = (j * (width + (8 - width % 8))) + i;
        uint32_t array_index = array_position / 8;
        // XBM image, low bits are first
        uint32_t byte_position = array_position % 8;

        uint8_t value = data[array_index] >> byte_position & 1 ;//(1 << (7 - byte_position));

        set_bit(x + i, y + j, !value);
      }
    }
  }
}

void renderer_draw_character(unsigned int x, unsigned int y, unsigned int scale, char character) {
  if (drawing_in_progress) {
    uint8_t row = character / 16;
    uint8_t column = character % 16;
    uint32_t font_x = column * 10;
    uint32_t font_y = row * 12;

    for (int j = font_y; j < font_y + CHAR_HEIGHT; j++) {
      for  (int i = font_x; i <  font_x + CHAR_WIDTH; i++) {
        // XBM images pad rows with zeros
        uint32_t array_position;
        if (font_width %8 != 0) {
          array_position = (j * (font_width + (8 - font_width % 8))) + i;
        }
        else {
          array_position = (j * font_width) + i;
        }
        uint32_t array_index = array_position / 8;
        // XBM image, low bits are first
        uint32_t byte_position = array_position % 8;

        uint8_t value = font_bits[array_index] >> byte_position & 1 ;

        for (int sx = 0; sx < scale; sx++) {
          for (int sy = 0; sy < scale; sy++) {
            set_bit(x + ((i - font_x) * scale) + sx, y + ((j- font_y) * scale) + sy, !value);
          }
        }
      }
    }
  }
}

void renderer_draw_string(unsigned int x, unsigned int y, unsigned int scale, char *text, unsigned int length, renderer_text_justify_t justification){
  if (drawing_in_progress) {
    switch (justification) {
      case JUSTIFY_LEFT:
        for(int i = 0; i < length; i++) {
          renderer_draw_character(x + (i * CHAR_WIDTH * scale), y, scale, text[i]);
        }
        break;

      case JUSTIFY_CENTRE:
        for(int i = 0; i < length; i++) {
          renderer_draw_character(x - (length * scale * CHAR_WIDTH / 2) + (i * CHAR_WIDTH * scale), y, scale, text[i]);
        }
        break;

      case JUSTIFY_RIGHT:
        for (int i = 0; i < length; i++) {
          renderer_draw_character(x - ((length - i) * CHAR_WIDTH * scale), y, scale, text[i]);
        }
        break;

      default:
        printf("Invalid justification\r\n");
    }
  }
}

static void update_output_buffer(void){
  if(!drawing_in_progress){
    // Swap drawing and output buffer
    buffer_t *temp = output_buffer;
    output_buffer = drawing_buffer;
    drawing_buffer = temp;
  }
  if (redraw_frame_requested) {
    drawing_overrun = true;
  }
  redraw_frame_requested = true;
}

static void renderer_clear(buffer_t *buffer) {
  for (int i =0; i < CVIDEO_LINES; i++) {
    for (int j = 0; j < CVIDEO_PIX_PER_LINE / 32; j++) {
      (*buffer)[i][j] = 0;
    }
  }
}

static void set_bit(uint x, uint y, bool value) {
  uint index_x = x / 32;
  uint pos_x = x % 32;

  uint flag = value << pos_x;
  (*drawing_buffer)[y][index_x] |= flag;
}


renderer.cpp

#ifndef __PONG_H__
#define __PONG_H__

#include <stdint.h>

#define PONG_FRAME_INTERVAL_ms 10

typedef enum {
  PONG_DIRECTION_UP = -1,
  PONG_DIRECTION_STOP = 0,
  PONG_DIRECTION_DOWN = 1,
} pong_player_direction_t;

void pong_init(void);

void pong_update(void);

void pong_tick(void);

void pong_move_player(uint32_t player_id, pong_player_direction_t direction);

#endif


pong.h

#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>
#include "pong.h"
#include "vec2.h"
#include "renderer.h"

#define COURT_WIDTH 600
#define COURT_HEIGHT 400
#define COURT_EDGE_THICKNESS 10
#define COURT_X (renderer_screen_width - COURT_WIDTH)/2
#define COURT_Y (renderer_screen_height - COURT_HEIGHT)/2

#define NET_THICKNESS 5
#define NET_SEGMENTS 21
#define NET_SEGMENT_LENGTH (COURT_HEIGHT + COURT_EDGE_THICKNESS) / NET_SEGMENTS

#define PLAYER_WIN_THRESHOLD 11
#define PLAYER_WIDTH 10
#define PLAYER_HEIGHT 100
#define PLAYER_SPEED 8
#define PLAYER_START_Y COURT_Y + (COURT_HEIGHT / 2) - (PLAYER_HEIGHT / 2)
#define PLAYER_Y_MIN COURT_Y
#define PLAYER_Y_MAX COURT_Y + COURT_HEIGHT - PLAYER_HEIGHT
#define PLAYER_1_START_X COURT_X
#define PLAYER_2_START_X COURT_X + COURT_WIDTH - PLAYER_WIDTH

#define BAT_ANGLE_STEP M_PI / 64
#define BAT_DIVSIONS 8

#define BALL_DIAMETER 10
#define BALL_START_SPEED 2
#define BALL_ACCELERATION 0.5
#define BALL_START_ANGLE_MAX (double)(M_PI / 10)
#define BALL_START_ANGLE_MIN (double)(M_PI / 30)
#define BALL_START_X COURT_X + (COURT_WIDTH / 2) - (BALL_DIAMETER / 2)
#define BALL_START_Y COURT_Y + (COURT_HEIGHT/ 2) - (BALL_DIAMETER / 2)

typedef struct {
  int id;
  vec2_t position;
  vec2_t velocity;
  uint32_t width;
  uint32_t height;
  uint32_t score;
} player_t;

typedef struct {
  vec2_t position;
  vec2_t velocity;
  uint32_t diameter;
} ball_t;

typedef enum {
  STATE_START,
  STATE_RUNNING,
  STATE_WIN,
} game_state_t;

// Bat is not actually flat, instead divided into 8 sections with different angles
// following info on Wikipedia (https://en.wikipedia.org/wiki/Pong#Development_and_history)
static const float bat_angles[8] = {-3 * BAT_ANGLE_STEP, -2 *BAT_ANGLE_STEP, -BAT_ANGLE_STEP, 0, 0, BAT_ANGLE_STEP, 2 * BAT_ANGLE_STEP, 3 * BAT_ANGLE_STEP};
static player_t player_1;
static player_t player_2;
static ball_t ball;
static char score_text[5];
static game_state_t state;
static bool update_game_flag;

static void draw(void);
static void reset_ball(int player_id);
static void bounce_ball(float surface_angle);
static void update_player_position(player_t *player);
static void reset_game(void); 
static void score_point(player_t *player);

void pong_tick(void) {
  update_game_flag = true;
}

void pong_init(void) {
  reset_game();
  renderer_init(draw);
}

void pong_update(void) {
  renderer_run();
  if(update_game_flag) {
    update_game_flag = false;
    if (state == STATE_RUNNING) {
      ball.position = vec2_add(ball.position, ball.velocity);
      update_player_position(&player_1);
      update_player_position(&player_2);

      // Bat collisions, with bats divided into angled segments
      if (ball.position.v0 <= player_1.position.v0 + player_1.width && player_1.position.v1 - ball.diameter <= ball.position.v1 && ball.position.v1 <= player_1.position.v1 + player_1.height) {
        ball.position.v0 = player_1.position.v0 + player_1.width;

        uint32_t bat_index_position = (ball.position.v1 - player_1.position.v1) / (PLAYER_HEIGHT / BAT_DIVSIONS);
        bounce_ball(bat_angles[bat_index_position]);
      }
      else if (ball.position.v0 >= player_2.position.v0 - ball.diameter && player_2.position.v1 - ball.diameter <= ball.position.v1 && ball.position.v1 <= player_2.position.v1 + player_2.height) {
        ball.position.v0 = player_2.position.v0 - ball.diameter;

        uint32_t bat_index_position = BAT_DIVSIONS - (ball.position.v1 - player_2.position.v1) / (PLAYER_HEIGHT / BAT_DIVSIONS);
        bounce_ball(bat_angles[bat_index_position]);
      }

      // Court borders - simple v_y reflection on top/bottom, scoring on left/right
      if (ball.position.v1 <= COURT_Y){
        ball.position.v1 = COURT_Y;
        ball.velocity.v1 = -ball.velocity.v1;
      }
      else if (ball.position.v1 >= COURT_Y + COURT_HEIGHT - BALL_DIAMETER){
        ball.position.v1 = COURT_Y + COURT_HEIGHT - BALL_DIAMETER;
        ball.velocity.v1 = -ball.velocity.v1;
      }
      else if (ball.position.v0 < COURT_X) {
        score_point(&player_2);
      }
      else if (ball.position.v0 > COURT_X + COURT_WIDTH - BALL_DIAMETER) {
        score_point(&player_1);
      }
    }
  }
}

void pong_move_player(uint32_t player_id, pong_player_direction_t direction){
  switch(state) {
    case STATE_RUNNING:
      if (player_id == 1) {
        player_1.velocity.v1 = PLAYER_SPEED * (direction % 2);
      }
      else if (player_id == 2) {
        player_2.velocity.v1  = PLAYER_SPEED * (direction % 2);
      }
      break;
    case STATE_START:
      // Only change state on keypress, ignore releases
      if (direction != PONG_DIRECTION_STOP){
        state = STATE_RUNNING;
      }
      break;
    case STATE_WIN:
      if (direction != PONG_DIRECTION_STOP){
        reset_game();
      }
      break;
  }
}

void draw(void) {
  // Court top edge
  renderer_draw_rect(COURT_X - COURT_EDGE_THICKNESS, COURT_Y - COURT_EDGE_THICKNESS, COURT_WIDTH + 2 * COURT_EDGE_THICKNESS, COURT_EDGE_THICKNESS);
  // Court bottom edge
  renderer_draw_rect(COURT_X - COURT_EDGE_THICKNESS, COURT_Y + COURT_HEIGHT, COURT_WIDTH + 2 * COURT_EDGE_THICKNESS, COURT_EDGE_THICKNESS);
  // Court left side
  renderer_draw_rect(COURT_X - COURT_EDGE_THICKNESS, COURT_Y - COURT_EDGE_THICKNESS, COURT_EDGE_THICKNESS, COURT_HEIGHT + 2 * COURT_EDGE_THICKNESS);
  // Court right side
  renderer_draw_rect(COURT_X + COURT_WIDTH, COURT_Y - COURT_EDGE_THICKNESS, COURT_EDGE_THICKNESS, COURT_HEIGHT + 2 * COURT_EDGE_THICKNESS);

  sprintf(score_text, "%d", player_1.score);
  renderer_draw_string(COURT_X + COURT_WIDTH / 4, COURT_Y / 2, 2, score_text, strlen(score_text), JUSTIFY_CENTRE);
  sprintf(score_text, "%d", player_2.score);
  renderer_draw_string(COURT_X + 3 * COURT_WIDTH / 4, COURT_Y / 2, 2, score_text, strlen(score_text), JUSTIFY_CENTRE);

  switch(state) {
    case STATE_RUNNING:
      // Net
      for (int i = 0; i < NET_SEGMENTS; i+=2) {
        renderer_draw_rect(COURT_X + ((COURT_WIDTH - NET_THICKNESS) / 2), (COURT_Y - COURT_EDGE_THICKNESS/2) + i * NET_SEGMENT_LENGTH, NET_THICKNESS, NET_SEGMENT_LENGTH);
      }

      renderer_draw_rect(player_1.position.v0, player_1.position.v1, player_1.width, player_1.height);
      renderer_draw_rect(player_2.position.v0, player_2.position.v1, player_2.width, player_2.height);
      renderer_draw_rect(ball.position.v0, ball.position.v1, ball.diameter, ball.diameter);
      break;
    
    case STATE_WIN:
      if(player_1.score > player_2.score) {
        renderer_draw_string(COURT_X + COURT_WIDTH / 2, COURT_Y + COURT_HEIGHT / 4, 3, "Player 1 wins!", 14, JUSTIFY_CENTRE);
      } else {
        renderer_draw_string(COURT_X + COURT_WIDTH / 2, COURT_Y + COURT_HEIGHT / 4, 3, "Player 2 wins!", 14, JUSTIFY_CENTRE);
      }
      renderer_draw_string(COURT_X + COURT_WIDTH / 2, COURT_Y + COURT_HEIGHT / 2, 2, "Press button to restart", 23, JUSTIFY_CENTRE);
      break;

    case STATE_START:
      renderer_draw_string(COURT_X + COURT_WIDTH / 2, COURT_Y + COURT_HEIGHT / 4, 3, "Pi Pico Pong", 12, JUSTIFY_CENTRE);
      renderer_draw_string(COURT_X + COURT_WIDTH / 2, COURT_Y + COURT_HEIGHT / 2, 2, "By Alan Reed", 12, JUSTIFY_CENTRE);
      renderer_draw_string(COURT_X + COURT_WIDTH / 2, COURT_Y + 3 * COURT_HEIGHT / 4, 2, "Press button to start", 21, JUSTIFY_CENTRE);
      break;
  }
}

static void reset_game(void) {
  player_1 = (player_t){.id = 1,
                        .position = (vec2_t){.v0 = PLAYER_1_START_X, .v1 = PLAYER_START_Y},
                        .velocity = (vec2_t){.v0 = 0, .v1 = 0}, 
                        .width = PLAYER_WIDTH,
                        .height = PLAYER_HEIGHT,
                        .score = 0};
  player_2 = (player_t){.id = 2,
                        .position = (vec2_t){.v0 = PLAYER_2_START_X, .v1 = PLAYER_START_Y},
                        .velocity = (vec2_t){.v0 = 0, .v1 = 0},
                        .width = PLAYER_WIDTH,
                        .height = PLAYER_HEIGHT,
                        .score = 0};

  reset_ball(1 + (rand() < RAND_MAX / 2));
  update_game_flag = false;
  state = STATE_START;
}

static void reset_ball(int player_id) {
  ball = (ball_t){.position = (vec2_t){.v0 = BALL_START_X, .v1 = BALL_START_Y}, .diameter = BALL_DIAMETER};
  double angle = BALL_START_ANGLE_MIN + ((double)rand() / (double)RAND_MAX) * (BALL_START_ANGLE_MAX - BALL_START_ANGLE_MIN);
  if (rand() > RAND_MAX / 2) {
    angle *= -1;
  }
  // Start the ball towards the player that scored
  if (player_id == 1) {
    ball.velocity.v0 = -BALL_START_SPEED * cos(angle);
  }
  else {
    ball.velocity.v0  = BALL_START_SPEED * cos(angle);
  }
  ball.velocity.v1 = BALL_START_SPEED * sin(angle);
}

static void bounce_ball(float surface_angle) {
  vec2_t v = ball.velocity;
  vec2_t n = (vec2_t){cos(surface_angle), sin(surface_angle)};

  vec2_t u = vec2_scale(n, vec2_dot(v, n));
  vec2_t w = vec2_subtract(v, u);
  vec2_t v_after = vec2_subtract(w, u);

  vec2_t v_increase = vec2_scale(v_after, BALL_ACCELERATION / vec2_length(v_after));
  ball.velocity = vec2_add(v_after, v_increase);
}

static void update_player_position(player_t *player){
  player->position = vec2_add(player->position, player->velocity);
  if (player->position.v1 < PLAYER_Y_MIN) {
    player->position.v1 = PLAYER_Y_MIN;
  }
  else if (player->position.v1 > PLAYER_Y_MAX) {
    player->position.v1 = PLAYER_Y_MAX;
  }
}

static void score_point(player_t *player) {
  reset_ball(player->id);
  player->score++;
  if (player->score >= PLAYER_WIN_THRESHOLD) {
    state = STATE_WIN;
  }
}


pong.cpp

#ifndef __VEC2_H__
#define __VEC2_H__

#include <stdio.h>
#include <math.h>

typedef struct {
  float v0;
  float v1;
}
vec2_t;

inline vec2_t vec2_add(vec2_t p1, vec2_t p2) {
  return (vec2_t){.v0=p1.v0 + p2.v0, .v1 = p1.v1 + p2.v1};
}

inline vec2_t vec2_subtract(vec2_t p1, vec2_t p2) {
  return (vec2_t){.v0=p1.v0 - p2.v0, .v1 = p1.v1 - p2.v1};
}

inline float vec2_dot(vec2_t p1, vec2_t p2) {
  return (p1.v0 * p2.v0) + (p1.v1 * p2.v1);
}

inline vec2_t vec2_scale(vec2_t p, float scalar) {
  return (vec2_t){.v0 = p.v0 * scalar, .v1 = p.v1 * scalar};
}

inline float vec2_length(vec2_t vec) {
  return sqrt((vec.v0 * vec.v0) + (vec.v1 * vec.v1));
}

inline void vec2_print(vec2_t vec) {
  printf("v: (%f, %f)\r\n", vec.v0, vec.v1);
  printf("len %f\r\n", vec2_length(vec));
}

#endif

vec2.h

font.h

#ifndef __CONNECTIONS_H__
#define __CONNECTIONS_H__

#include "pico.h"

// Composite video output
#define CVIDEO_DATA_PIN 2
#define CVIDEO_SYNC_PIN 3

// Serial output
#define SERIAL_RX_PIN PICO_DEFAULT_UART_RX_PIN
#define SERIAL_TX_PIN PICO_DEFAULT_UART_TX_PIN

// Buttons
#define PLAYER1_BUTTON_UP 4
#define PLAYER1_BUTTON_DOWN 5
#define PLAYER2_BUTTON_UP 6
#define PLAYER2_BUTTON_DOWN 7

#endif
