LCOM1920-T5G03

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

int16_t (map_get_width)   (const map_t *p);

int16_t (map_get_height)  (const map_t *p);

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

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

void   (map_draw)(map_t *p);

/**

 * @brief Updates movement variables.

 */

void update_mouse(struct packet *p);

void (update_game_state)(const map_t *map, list_t *shooter_list, list_t *bullet_list);

void update_scale(void);

#define HIGHLIGHT_COLOR         0x404040

#define DELIMITER_COLOR         0x404040

#define MELEE_DAMAGE   1

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

font_t* (font_ctor)(const char *s);

void    (font_dtor)(font_t *p);

struct text;

typedef struct text text_t;

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

#define LINEAR_FRAME_BUFFER_MD  BIT(14)

// Colors in RBG (8 bit)

// Alpha

#define ALPHA_THRESHOLD     0x7F

        }

    }

    // Draw text

        for(int16_t newx = 0; newx < newW; ++newx){

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

        }

    }

    free(alp_new_buf);

#include "graph.h"

#include "utils.h"

#include "rectangle.h"

#include <math.h>

static double scale = 1.0;

static int16_t x_origin = 0;

static int16_t y_origin = 0;

    sprite_t *dude;

    sprite_t *weapon;

    double health, current_health;

    gunner_type type;

    int team;

};

    ret->y = 0.0;

    ret->health = 100;

    ret->current_health = ret->health;

    ret->type = type;

    ret->team = team;

    ret->dude   = sprite_ctor(dude  );

    if(ret->dude == NULL || ret->weapon == NULL){

        gunner_dtor(ret);

        return NULL;

}

void (gunner_dtor)(gunner_t *p){

    if(p == NULL) return;

    sprite_dtor(p->dude);

    sprite_dtor(p->weapon);

    free(p);

}

void (gunner_set_pos)  (gunner_t *p, double x, double y){ p->x = x; p->y = y; }

    double health = gunner_get_health(p);

    double perc = curr_health/health;

    rectangle_t *green_bar = rectangle_ctor(x, y, (int16_t)(w*perc), 10);

    rectangle_t *red_bar = rectangle_ctor(x+(int16_t)(w*perc), y, (int16_t)(w*(1-perc)), 10);

    rectangle_draw(green_bar);

    rectangle_draw(red_bar);

    rectangle_dtor(green_bar);

    rectangle_dtor(red_bar);

}

double (gunner_distance)(const gunner_t *p1, const gunner_t *p2){

    basic_sprite_t *bsp_background;

    sprite_t *background;

    uint8_t *collide;

};

map_t* (map_ctor)(const char **background, const char **collide){

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

    ret->bsp_background = NULL;

    ret->background     = NULL;

    ret->collide        = NULL;

    ret->bsp_background = basic_sprite_ctor(background, 0, 0);

    ret->background     = sprite_ctor(ret->bsp_background);

    if(ret->bsp_background == NULL ||

    basic_sprite_t *bsp_collide = basic_sprite_ctor(collide, 0, 0);

    if(bsp_collide == NULL){ map_dtor(ret); return NULL; }

    }

    basic_sprite_dtor(bsp_collide);

    return ret;

}

void (map_dtor)(map_t *p){

    sprite_dtor(p->background);

    basic_sprite_dtor(p->bsp_background);

    free(p->collide);

    free(p);

}

int16_t (map_get_x_screen)(const map_t *p){ return (-x_origin)*scale; }

    uint32_t pos = x_ + y_*w;

    return p->collide[pos];

}

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

    double radius = max(sprite_get_w(shooter->dude), sprite_get_h(shooter->dude))/2.0;

    double shooter_x = gunner_get_x(shooter);

    keys_t *keys = get_key_presses();

    /// loop stuff

    int click = 0;

    int good = true;

    while (good) {

        /* Get a request message. */

                    }

                }

            }

        }

    }

    basic_sprite_dtor      (bsp_crosshair); bsp_crosshair = NULL;

    basic_sprite_dtor      (bsp_shooter  ); bsp_shooter   = NULL;

    sprite_dtor            (sp_crosshair ); sp_crosshair  = NULL;

    basic_sprite_dtor      (bsp_pistol   ); bsp_pistol    = NULL;

    basic_sprite_dtor      (bsp_nothing  ); bsp_nothing   = NULL;

                        list_node_t *it = list_begin(shooter_list);

                        while (it != list_end(shooter_list)) {

                            gunner_t *p = *(gunner_t**)list_node_val(it);

                            gunner_set_curr_health(p, gunner_get_health(p));

                            it = list_node_next(it);

                        }

                    case TIMER0_IRQ:

                    if (no_interrupts % 60 == 0) timer_update(in_game_timer);

                    update_movement(map1, shooter1, keys, shooter_list);

                    update_game_state(map1, shooter_list, bullet_list);

                        gunner_set_health(zombie, health);

                        gunner_set_curr_health(zombie, health);

                        health *= ZOMBIE_HEALTH_FACTOR;

                        list_push_back(shooter_list, zombie);

                    }

                    sprite_draw(sp_crosshair);

                    graph_draw();

                    break;

                    case KBC_IRQ:

                    if ((scancode[0]) == ESC_BREAK_CODE) {

                        good = false;

                    }

                    break;

                    case MOUSE_IRQ:

    }

}

    int ver_mov = keys->s_pressed - keys->w_pressed;

    int hor_mov = keys->d_pressed - keys->a_pressed;

    double x = gunner_get_x(p);

            it = list_node_next(it);

        }

    }

}

void (shoot_bullet)(const gunner_t *shooter, list_t *bullet_list, const basic_sprite_t *bsp_bullet) {

        list_node_t *it2 = list_begin(shooter_list);

        while(it2 != list_end(shooter_list)){

            gunner_t *s2 = *list_node_val(it2);

                gunner_set_curr_health(s2, gunner_get_curr_health(s2) - MELEE_DAMAGE);

            if(gunner_get_curr_health(s2) <= 0){

                list_node_t *aux = list_node_next(it2);

    }

}

    uint16_t w = map_get_width(map), h = map_get_height(map);

    double x, y;

        x = rand() % w;

        y = rand() % h;

        gunner_set_pos(p, x, y);

}

void update_scale(void) {