LCOM1920-T5G03

int (map_make_dijkstra)(map_t *p, int16_t x, int16_t y);

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

#define ZOMBIE_SPEED    1.0

    uint8_t *collide_gunner;

    int32_t *prev;

    uint8_t *visited;

static int (map_collides_gunner_pos)(const map_t *p, double shooter_x, double shooter_y, double radius) {

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

        double y1 = sqrt(radius*radius - x*x);

        double y2 = -y1;

        if (map_collides_point(p, shooter_x + x, shooter_y + y1) || map_collides_point(p, shooter_x + x, shooter_y + y2)) return 1;

    }

    return 0;

}

    ret->prev           = NULL;

    ret->visited        = NULL;

    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){

        int16_t x = i%W, y = i/W;

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

    }

    ret->prev = malloc(W*H*sizeof(int32_t));

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

    if(ret->prev == NULL || ret->visited == NULL){

    free(p->prev);

    free(p->visited);

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;

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

}

int (map_make_dijkstra)(map_t *p, int16_t x, int16_t y){

    static uint8_t first_time = true;

    if(first_time){

        for(size_t i = 0; i < W*H; ++i) p->prev[i] = -1;

        first_time = false;

    }

    memset(p->visited, false, W*H*sizeof(uint8_t));

    int32_t c, pos;

    c = y*W+x; p->prev[c] = c; ptr = malloc(sizeof(int)); *ptr = c; queue_push(q, ptr);

        c = *(int*)queue_top(q); free(queue_top(q)); queue_pop(q);

        x = c%W, y = c/W;

        if(p->visited[c]) continue;

        p->visited[c] = true;

        if(p->collide_gunner[c]) continue;

        if(0   <= x-1){ pos = y*W+(x-1); if(!p->visited[pos] && p->prev[pos] != c){ p->prev[pos] = c; ptr = malloc(sizeof(int)); *ptr = pos; queue_push(q, ptr); }}

        if(x+1 <  W  ){ pos = y*W+(x+1); if(!p->visited[pos] && p->prev[pos] != c){ p->prev[pos] = c; ptr = malloc(sizeof(int)); *ptr = pos; queue_push(q, ptr); }}

        if(0   <= y-1){ pos = (y-1)*W+x; if(!p->visited[pos] && p->prev[pos] != c){ p->prev[pos] = c; ptr = malloc(sizeof(int)); *ptr = pos; queue_push(q, ptr); }}

        if(y+1 <  H  ){ pos = (y+1)*W+x; if(!p->visited[pos] && p->prev[pos] != c){ p->prev[pos] = c; ptr = malloc(sizeof(int)); *ptr = pos; queue_push(q, ptr); }}

    queue_dtor(q);

    return SUCCESS;

int (map_where_to_follow)(const map_t *p, float x, float y, float *theta){

    const uint16_t W = basic_sprite_get_w(p->bsp_background);

    int x_ = x, y_ = y;

    int pos = y_*W+x_;

    //printf("Is in %d,%d\n", x_, y_);

    int newx = p->prev[pos]%W, newy = p->prev[pos]/W;

    //printf("from %d,%d to %d,%d\n", x_, y_, newx, newy);

    *theta = atan2(-(newy-y_), newx-x_);

    return SUCCESS;

}

        text_set_pos(txt, graph_get_XRes()/2, graph_get_YRes()/2);

        text_set_valign(txt, text_valign_center);

        text_set_halign(txt, text_halign_center);

        text_set_color(txt, TEXT_COLOR);

            if(!good) break;

    /** #DEV */ /* {

        gunner_t *zombie = gunner_ctor(bsp_zombie, bsp_nothing, gunner_melee | gunner_follow, 3);

        gunner_set_health(zombie, health);

        gunner_set_curr_health(zombie, health);

        health *= ZOMBIE_HEALTH_FACTOR;

        gunner_set_pos(zombie, 1100, 75);

        list_push_back(shooter_list, zombie);

    }*/ //\#DEV

    map_make_dijkstra(map1, gunner_get_x(shooter1), gunner_get_y(shooter1));

            if(!good || dead) break;

                    if (no_interrupts %  6 == 0){

                        map_make_dijkstra(map1, gunner_get_x(shooter1), gunner_get_y(shooter1));

                    }

                    while(list_size(shooter_list) < ZOMBIES_NUM+1){

            float theta = 0.0;

            map_where_to_follow(map, gunner_get_x(g), gunner_get_y(g), &theta);

            float c = fm_cos(theta), s = fm_sin(theta);

            float dx = ZOMBIE_SPEED*c, dy = -ZOMBIE_SPEED*s;

            double x = gunner_get_x(g);

            double y = gunner_get_y(g);

            gunner_set_pos(g, x+dx, y+dy);

            if (map_collides_gunner(map, g)){

                //printf("Zombie colliding with map\n");

                gunner_set_pos(g, x, y);

            } else {

                list_node_t *it = list_begin(shooter_list);

                while (it != list_end(shooter_list)) {

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

                    if (g != p2 && gunner_collides_gunner(g, p2)) {

                        //printf("Zombie colliding with zombie\n");

                        gunner_set_pos(g, x, y);

                        break;

                    }

                    it = list_node_next(it);

                }

            }

            gunner_set_angle(g, theta-M_PI_2); /*printf("angle: %d.%d\n", (int)theta, abs((int)(theta*1000)%1000));*/