LCOM1920-T5G03

int    (map_collides_point)(const map_t *p, double x, double y);

int    (map_collides_gunner)(const map_t *p, const gunner_t *gunner);

int    (map_collides_bullet)(const map_t *p, const bullet_t *bullet);

int (map_make_dijkstra)(map_t *p, double x_, double y_);

int (map_where_to_follow)(const map_t *p, double x, double y, double *theta);

int (gunner_collides_bullet)(const gunner_t *shooter, const bullet_t *bull);

 */

void interrupt_handler(uint8_t handler);

#endif /* end of include guard: INTERRUPTS_FUNC_H_INCLUDED */

 */

void (text_set_pos)   (text_t *p, int16_t x, int16_t y);

/**

 * @param   p       Pointer to text

 * @param   size    Letter size of the text

 */

/**

 * @brief Set text color.

 * @param   p       Pointer to text

 * @param   xpm XPM describing the glyph

 * @return      Pointer to created glyph

 */

    if(xpm == NULL) return NULL;

    glyph_t *ret = malloc(sizeof(glyph_t));

    if(ret == NULL) return NULL;

        for(int16_t w = 0; w < p->w; ++w){

            uint8_t a = *(p->map + w + h*p->w);

            int16_t x_ = x+w, y_ = y-p->h+h;

        }

    }

    return SUCCESS;

    for(size_t i = 0; i < ret->nchars; ++i){

        sprintf(filepath, "%s/ascii%03d.xpm2", s, i);

        char **xpm = xpm_load_xpm2(filepath);

        if(ret->glyphs[i] != NULL) good = true;

    }

    if(good) return ret;

    const font_t *fnt;

    char *txt;

    int16_t x, y;

    text_valign valign;

    text_halign halign;

};

text_t* (text_ctor)(const font_t *fnt, const char *txt){

    if(fnt == NULL) return NULL;

}

const char* (text_get_string)(const text_t *p){return p->txt; }

void (text_set_pos)   (text_t *p, int16_t x, int16_t y){ p->x = x; p->y = y; }

void (text_set_color) (text_t *p, uint32_t color      ){ p->color = color  ; }

void (text_set_valign)(text_t *p, text_valign valign  ){ p->valign = valign; }

void (text_set_halign)(text_t *p, text_halign halign  ){ p->halign = halign; }

        uint16_t W = 0, H = 0; {

            for(size_t i = 0; i < len; ++i){

                const glyph_t *g = p->fnt->glyphs[(size_t)p->txt[i]];

            }

        }

        uint8_t *alp_buf = malloc(W*H);

        if(alp_buf == NULL) return ALLOC_ERROR;{

            int16_t x = 0;

            for(size_t i = 0; i < len; ++i){

                const glyph_t *g = p->fnt->glyphs[(size_t)p->txt[i]];

        double factor = (double)p->size/(double)H;

        alp_new_buf = malloc(newW*newH);

        if(alp_new_buf == NULL) return ALLOC_ERROR;

                *(alp_new_buf+newx+newy*newW) = *(alp_buf+x+y*W);

            }

        }

            case text_halign_left  : initx = p->x         ; break;

            case text_halign_center: initx = p->x - newW/2; break;

            case text_halign_right : initx = p->x - newW  ; break;

        }

    }

    // Get initial value of y

            case text_valign_top   : inity = p->y         ; break;

            case text_valign_center: inity = p->y - newH/2; break;

            case text_valign_bottom: inity = p->y - newH  ; break;

        }

    }

    // Draw text

            if(!(0 <= x && x < graph_get_XRes() &&

                 0 <= y && y < graph_get_YRes())) continue;

            uint8_t a = *(alp_new_buf+newx+newy*newW);

        }

    }

    free(alp_new_buf);

#define VC_BIOS_SERV  0x10 /** @brief Interrupt service of video card */

#define VBE_CALL      0x4F /** @brief VBE call function specifier */

// Graphics Functions

#define VBE_MD_INFO         0x01    /** @brief Get VBE Mode Information */

#define SET_VBE_MD          0x02    /** @brief Set VBE Mode */

// Error codes (AH)

#define AH_SUCCESS          0x00    /** @brief Success code on BIOS call */

/// MACROS

/// STRUCT

typedef struct __attribute__((packed)) {

*/

/// INIT

static int (graph_set_mode)(uint16_t mode) {

    struct reg86 reg_86;

int16_t        (basic_sprite_get_u0) (const basic_sprite_t *p){ return p->u0 ; }

int16_t        (basic_sprite_get_v0) (const basic_sprite_t *p){ return p->v0 ; }

struct sprite{

    const basic_sprite_t *bsp;

    int16_t x, y; //position in screen

void (sprite_set_pos)   (sprite_t *p, int16_t x , int16_t y ){ p->x = x; p->y = y; }

void (sprite_set_angle) (sprite_t *p, double angle          ){ p->theta = angle; p->c = fm_cos(p->theta); p->s = fm_sin(p->theta); }

void (sprite_set_scale) (sprite_t *p, double scale          ){

    p->scale = scale;

    const uint16_t W = basic_sprite_get_w(p->bsp),

                   H = basic_sprite_get_h(p->bsp);

    p->sbuf = realloc(p->sbuf, sW*sH*4);

    const uint8_t *map = basic_sprite_get_map(p->bsp);

    for(uint16_t sx = 0; sx < sW; ++sx){

        for(uint16_t sy = 0; sy < sH; ++sy){

            if(x > W || y > H) continue;

            memcpy(p->sbuf+4*(sx+sy*sW), map+4*(x+y*W), 4);

        }

double   (sprite_get_angle)(const sprite_t *p){ return p->theta; }

uint16_t (sprite_get_w)(const sprite_t *p){ return basic_sprite_get_w(p->bsp); }

uint16_t (sprite_get_h)(const sprite_t *p){ return basic_sprite_get_h(p->bsp); }

    if(p->theta == 0.0){

        *u = x - p->x + p->su0;

        *v = y - p->y + p->sv0;

    }else{

        double dx = x - p->x;

        double dy = y - p->y;

        *u = du + p->su0;

        *v = dv + p->sv0;

    }

}

    int16_t du = u - p->su0;

    int16_t dv = v - p->sv0;

    double dx =  du*p->c + dv*p->s;

    double dy = -du*p->s + dv*p->c;

}

void (sprite_draw)(const sprite_t *p){

    int16_t xmin, xmax, ymin, ymax; {

        int16_t x, y;

        xmin = x; xmax = x; ymin = y; ymax = y;

    }

    const uint16_t bytes_pixel = 3/*graph_get_bytes_pixel()*/;

    for(int16_t u, v, y = ymin; y < ymax; ++y){

struct rectangle{

    int16_t  x, y;

    uint16_t w, h;

    uint32_t fill_color;

    uint8_t  fill_alpha;

};

rectangle_t* (rectangle_ctor)(int16_t x, int16_t y, uint16_t w, uint16_t h){

static void (rectangle_draw_hline)(int16_t x, int16_t y, int16_t l, uint32_t color){

    if(l < 0){ rectangle_draw_hline(x+l, y, -l, color); return; }

    }

}

static void (rectangle_draw_vline)(int16_t x, int16_t y, int16_t l, uint32_t color){

    if(l < 0){ rectangle_draw_vline(x, y+l, -l, color); return; }

    }

}

void (rectangle_draw)(const rectangle_t *p){

    /// fill

    if(p->fill_alpha > ALPHA_THRESHOLD)

    /// border

    int16_t step = (p->outline_width > 0 ? 1 : -1);

    int16_t l = p->x, r = p->x+p->w, t = p->y, b = p->y+p->h;

int (mouse_get_got_error_mouse_ih)(void);

const uint8_t* (mouse_get_packet_mouse_ih)(void);

int (mouse_get_counter_mouse_ih)(void);

/**

 * @brief   Parse 3 bytes and returns it as a parsed, struct packet.

 * @param   packet_bytes    array of bytes to parse

 * @return ERROR_CODE code representing the result of the operation, SUCCESS code is returned if everything is OK

 * @see {_ERRORS_H_::errors}

 */

/**

 * @brief Reads byte from mouse

    if((ret = kbc_issue_arg(cmd))) return ret;

    return SUCCESS;

}

    int ret = 0;

    uint8_t cmd = 0;

    if((ret = kbc_read_cmd(&cmd))) return ret;

    if((ret = kbc_change_cmd(cmd))) return ret;

    return SUCCESS;

}

int (kbc_issue_cmd)(uint8_t cmd){

    int ret = 0;

    uint8_t stat;

// Byte 2 - Y delta

/* Mouse Commands */

#define DIS_DATA_REP    0xF5 /* @brief Disable Data Reporting */

#define ENABLE_DATA_REP 0xF4 /* @brief Enable Data Reporting */

#define READ_DATA       0xEB /* @brief Sends data packet request */

/* Mouse Controller Responses */

#define ACK_OK      0xFA /* @brief Operation sucessful */

#define ACK_ERROR   0xFC /* @brief Invalid Byte on resend */

int (subscribe_mouse_interrupt)(uint8_t interrupt_bit, int *interrupt_id) {

    return SUCCESS;

}

int (mouse_get_got_error_mouse_ih)(void){return got_error_mouse_ih; }

const uint8_t* (mouse_get_packet_mouse_ih)(void){return packet_mouse_ih; }

int (mouse_get_counter_mouse_ih)(void){return counter_mouse_ih; }

void (mouse_ih)(void) {

    uint8_t status = 0;

    return SUCCESS;

}

    int ret;

    uint8_t ack = 0;

    for (unsigned int i = 0; i < KBC_NUM_TRIES; i++) {

int (subscribe_timer_interrupt)(uint8_t interrupt_bit, int *interrupt_id);

uint32_t (timer_get_no_interrupts)(void);

#endif //TIMER_H_INCLUDED

#include "timer.h"

/* I/O port addresses */

/* Timer control */

/* Timer selection: bits 7 and 6 */

/* Register selection: bits 5 and 4 */

/* Operating mode: bits 3, 2 and 1 */

/* Counting mode: bit 0 */

/* READ-BACK COMMAND FORMAT */

int (subscribe_timer_interrupt)(uint8_t interrupt_bit, int *interrupt_id) {

    if (interrupt_id == NULL) return 1;

}

static uint32_t no_interrupts = 0;

    no_interrupts++;

}

uint32_t (timer_get_no_interrupts)(void){ return no_interrupts; }

int nctp_send(size_t num, uint8_t* ptr[], size_t sz[]);

void nctp_ih(void);

#endif //UART_H_INCLUDED

    return SUCCESS;

}

void nctp_ih(void){

    uint8_t iir;

    if((nctp_ih_err = uart_get_iir(COM1_ADDR, &iir))) return;

/**

 * @brief Gets the most significant byte of a 16-bit variable

 * @param val 16-bit variable

 * @return ERROR_CODE code representing the result of the operation, SUCCESS code is returned if everything is OK

 */

int(util_get_MSB)(uint16_t val, uint8_t *msb);

 * @param b     Second value

 * @return  The minimum of the two values

 */

/**

 * @brief Gets the maximum value out of two values.

 * @param b     Second value

 * @return  The maximum of the two values

 */

#endif //UTILS_H_INCLUDED

#ifndef XMP_UTILS_H_INCLUDED

#define XMP_UTILS_H_INCLUDED

char** xpm_load_xpm2(const char *s);

int(util_get_LSB)(uint16_t val, uint8_t *lsb) {

    if (lsb == NULL) return NULL_PTR;

    return SUCCESS;

}

    if(value == NULL) return NULL_PTR;

    uint32_t n = 0;

    if(sys_inb(port, &n)) return READ_ERROR;

    return SUCCESS;

}

    return SUCCESS;

}

#include <stdlib.h>

#include <string.h>

    FILE *f = fopen(s, "w");

    int w, h, num_colors, chars_per_pixel;

    sscanf(p[0], "%d %d %d %d", &w, &h, &num_colors, &chars_per_pixel);

    FILE *f = fopen(fpath, "r");

    if(f == NULL) return NULL;

    size_t len = 1024; char *line_buf = malloc(len*sizeof(char));

    char **ret = NULL;

    sz = getline(&line_buf, &len, f);{

        sscanf(line_buf, "%d %d %d %d", &w, &h, &num_colors, &chars_per_pixel);

        ret = malloc((1+num_colors+h)*sizeof(char*));

    }

    strcpy(ret[0], line_buf);

        sz = getline(&line_buf, &len, f);

        if(ret[i] == NULL){

                free(ret[i]);

            free(ret);

            return NULL;

        ret[i][sz-1] = '\0';

    }

    fclose(f); f = NULL;

    return ret;

}

#define GREEN_HEALTH_COLOR      0x009900

static double scale = 1.0;

void (ent_set_scale) (double n){ scale = n; }

void (ent_set_origin)(double x, double y){ x_origin = x; y_origin = y; }

double  (gunner_get_angle)          (const gunner_t *p){ return sprite_get_angle(p->dude); }

double  (gunner_get_health)         (const gunner_t *p){ return p->health; }

double  (gunner_get_curr_health)    (const gunner_t *p){ return p->current_health; }

uint16_t (gunner_get_type)          (const gunner_t *p){ return p->type; }

int     (gunner_get_team)           (const gunner_t *p){ return p->team; }

void (gunner_draw)(gunner_t *p){

    gunner_draw_health(p);

}

void (gunner_draw_health)(const gunner_t *p) {

    double curr_health = gunner_get_curr_health(p);

    double health = gunner_get_health(p);

    double perc = curr_health/health;

    char buf[20]; sprintf(buf, "%d/%d", (int)p->current_health, (int)p->health);

    text_set_string(p->txt, buf);

    text_set_pos(p->txt, x+w/2, y+10/2);

double  (bullet_get_y)       (const bullet_t *p){ return p->y; }

double  (bullet_get_vx)      (const bullet_t *p){ return p->vx; }

double  (bullet_get_vy)      (const bullet_t *p){ return p->vy; }

double  (bullet_get_damage)  (const bullet_t *p){ return p->damage; }

void    (bullet_set_damage)  (bullet_t *p, double damage) {

    if (damage < 0) damage = 0;

    ret->collide_gunner = malloc(W*H*sizeof(uint8_t));

    if(ret->collide_gunner == NULL){ map_dtor(ret); return NULL; }

    for(size_t i = 0; i < W*H; ++i){

        ret->collide_gunner[i] = (map_collides_gunner_pos(ret, x, y, 36) ? 1 : 0);

    }

    free(p->visited);

    free(p);

}

int (map_collides_point)(const map_t *p, double x, double y){

    const uint16_t w = sprite_get_w(p->background), h = sprite_get_h(p->background);

    if(x_ < 0 || w <= x_ || y_ < 0 || h <= y_) return 0;

}

int (map_collides_gunner)(const map_t *p, const gunner_t *shooter) {

    return map_collides_gunner_pos(p, gunner_get_x(shooter), gunner_get_y(shooter), radius);

}

int (map_make_dijkstra)(map_t *p, double x_, double y_){

}

int (map_collides_bullet)(const map_t *p, const bullet_t *bull){

    double bullet_x = bullet_get_x(bull);

    double bullet_y = bullet_get_y(bull);

    for (double x = -radius; x < radius; x += 1){

int (gunner_collides_bullet)(const gunner_t *shooter, const bullet_t *bull){

    if(bull->shooter == shooter) return false;

    double shooter_x = gunner_get_x(shooter);

    double shooter_y = gunner_get_y(shooter);

    double bullet_x = bullet_get_x(bull);

    double bullet_y = bullet_get_y(bull);

int (gunner_collides_gunner)(const gunner_t *shooter1, const gunner_t *shooter2) {

    if (shooter1 == shooter2) return false;

    double distance = distance_gunners(shooter1, shooter2);

    return distance <= shooter1_radius+shooter2_radius;

}

    (*ih[handler])();

}

    int r;

    *p = 0;

    lcf_set_language("EN-US");

    if (lcf_start(argc, argv)) return 1;

    /// loop stuff

    int click = 0;

    int good = true;

    while (good) {

        /* Get a request message. */

                    case KBC_IRQ:

                    if (keyboard_get_scancode()[0] == ESC_BREAK_CODE) good = false;

                    case MOUSE_IRQ:

                        update_mouse(&pp);

                        if (!click) click = last_lb ^ keys->lb_pressed && keys->lb_pressed;

                        last_lb = keys->lb_pressed;

                    }

                    break;

                    case COM1_IRQ: nctp_ih(); break;

    /// loop stuff

    int click = 0;

    int good = true;

    while (good) {

        /* Get a request message. */

                    case KBC_IRQ:

                    if (keyboard_get_scancode()[0] == ESC_BREAK_CODE) good = false;

                    case MOUSE_IRQ:

                        update_mouse(&pp);

                        if (!click) click = last_lb ^ keys->lb_pressed && keys->lb_pressed;

                        last_lb = keys->lb_pressed;

                    }

                    break;

                    case COM1_IRQ: nctp_ih(); break;

    struct packet pp;

    keys_t *keys = get_key_presses();

    /// loop stuff

    int good = true;

    int state = 0; // -1 for remote win, 0 for draw, 1 for host win

    list_node_t *p1, *p2; // player states

                    }

                    break;

                    case MOUSE_IRQ:

                        update_mouse(&pp);

                        if (last_lb ^ keys->lb_pressed && keys->lb_pressed)

                        shoot_bullet(shooter1, bullet_list, bsp_bullet);

                        last_lb = keys->lb_pressed;

                    }

                    break;

    keys_t *keys = get_key_presses();

    /// loop stuff

    int good = true;

    while (good) {

        if ((r = get_interrupts_vector(&int_vector))) return r;

                    }

                    break;

                    case MOUSE_IRQ:

                        update_mouse(&pp);

                        if (last_lb ^ keys->lb_pressed && keys->lb_pressed) {

                            bullet_info->new_bullet = true;

                            hltp_send_bullet_info(bullet_info);

                        }

                        last_lb = keys->lb_pressed;

                    }

                    break;

    /// loop stuff

    int click = 0;

    int good = true;

    while (good) {

        /* Get a request message. */

                    case KBC_IRQ:

                    if (keyboard_get_scancode()[0] == ESC_BREAK_CODE) good = false;

                    case MOUSE_IRQ:

                        update_mouse(&pp);

                        if (!click) click = last_lb ^ keys->lb_pressed && keys->lb_pressed;

                        last_lb = keys->lb_pressed;

                    }

                    break;

                    case COM1_IRQ: nctp_ih(); break;

    keys_t *keys = get_key_presses();

    /// loop stuff

    int good = true;

    while (good) {

        /* Get a request message. */

                    }

                    break;

                    case MOUSE_IRQ:

                        update_mouse(&pp);

                        if (last_lb ^ keys->lb_pressed && keys->lb_pressed)

                        shoot_bullet(shooter1, bullet_list, bsp_bullet);

                        last_lb = keys->lb_pressed;

                    }

                    break;

    keys_t *keys = get_key_presses();

    /// loop stuff

    int good = true;

    int dead = false;

                    }

                    break;

                    case MOUSE_IRQ:

                        update_mouse(&pp);

                        if (last_lb ^ keys->lb_pressed && keys->lb_pressed)

                        shoot_bullet(shooter1, bullet_list, bsp_bullet);

                        last_lb = keys->lb_pressed;

                    }

                    break;

}

/// loop stuff

int good = true;

while (good) {

    /* Get a request message. */

                sprintf(buffer2, "%d/%d", strlen(buffer), CHAT_MAX_SIZE);

                text_set_string(t_size, buffer2);

                case MOUSE_IRQ:

                    update_mouse(&pp);

                }

                break;

                case COM1_IRQ: nctp_ih(); break;

static int16_t mouse_x = 0, mouse_y = 0;

void (update_mouse)(struct packet *p) {

    key_presses.lb_pressed = p->lb;

}

.PATH: ${.CURDIR}/libs/classes/src

.PATH: ${.CURDIR}/libs/utils/src

IPATHS=-I./include -I./libs/graph/include -I./libs/kbc/include -I./libs/rtc/include -I./libs/timer/include -I./libs/uart/include -I./libs/classes/include -I./libs/utils/include -I./maps -I./media/xpm

DPADD += ${LIBLCF}