LCOM1920-T5G03

int16_t* get_mouse_Y(void);

void build_remote_structure(remote_info_t *p, keys_t *keys, double angle);

    int16_t    remote_health;

    /// @brief Remote player current health

    int16_t    remote_current_health;

    // bullets

    /// @brief Number of bullets

    uint8_t    no_bullets;

    int16_t   *bullets_vy;

    /// @brief Who shot each bullet

    bool      *bullets_shooter; // false for host, true for remote

} host_info_t;

/**

 * @brief Construct host information.

    return nctp_send(2, ptr, sz);

}

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

    // players information

    pos += sizeof(int16_t)*10;

    // size of arrays

    memcpy(&(ret->no_bullets), p + pos, sizeof(uint8_t));

    // array containing the shooter id of the bullets

    (ret->bullets_shooter) = (bool*)malloc(sizeof(bool)*(ret->no_bullets));

    memcpy((ret->bullets_shooter), p + pos, sizeof(bool)*sz);

    return ret;

}

int hltp_send_host_info(const host_info_t *p) {

    uint8_t type = hltp_type_host;

    ptr[0]  = (uint8_t*)&   type                  ;     sz[0]   = 1;

    ptr[1]  = (uint8_t*)&p->host_x                ;     sz[1]   = sizeof(int16_t);

    ptr[2]  = (uint8_t*)&p->host_y                ;     sz[2]   = sizeof(int16_t);

    ptr[8]  = (uint8_t*)&p->remote_angle          ;     sz[8]   = sizeof(int16_t);

    ptr[9]  = (uint8_t*)&p->remote_health         ;     sz[9]   = sizeof(int16_t);

    ptr[10] = (uint8_t*)&p->remote_current_health ;     sz[10]  = sizeof(int16_t);

    ptr[11] = (uint8_t*)&p->no_bullets            ;     sz[11]  = sizeof(uint8_t);

    ptr[12] = (uint8_t*) p->bullets_x             ;     sz[12]  = sizeof(int16_t) * p->no_bullets;

    ptr[13] = (uint8_t*) p->bullets_y             ;     sz[13]  = sizeof(int16_t) * p->no_bullets;

    ptr[14] = (uint8_t*) p->bullets_vx            ;     sz[14]  = sizeof(int16_t) * p->no_bullets;

    ptr[15] = (uint8_t*) p->bullets_vy            ;     sz[15]  = sizeof(int16_t) * p->no_bullets;

    ptr[16] = (uint8_t*) p->bullets_shooter       ;     sz[16]  = sizeof(bool) * p->no_bullets;

}

static remote_info_t* hltp_interpret_remote_info(const uint8_t *p) {

    uint8_t ret = p[0];

    switch(ret){

        case hltp_type_string: *dest = hltp_interpret_string     (p+1, sz-1);   break;

        default: *dest = NULL; break;

    }

    return ret;

void (interrupt_handler)(uint8_t handler) {

    if (handler >= 32)              return;

    (*ih[handler])();

}

static void multiplayer_process(const uint8_t *p, const size_t sz) {

    void *dest = NULL;

    hltp_type tp = hltp_interpret(p, sz, &dest);

    switch(tp){

        case hltp_type_host:

            host_info = (host_info_t*)dest;

            break;

        case hltp_type_remote:

            remote_info = (remote_info_t*)dest;

            break;

        case hltp_type_bullet:

            bullet_info = (bullet_info_t*)dest;

            break;

        case hltp_type_invalid: break;

                switch (i) {

                    case TIMER0_IRQ:

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

                    update_movement(map1, shooter1, keys, shooter_list);

                    update_movement(map1, shooter2, &(remote_info->remote_keys_pressed), shooter_list);

                                   gunner_get_y(shooter1)-ent_get_YLength()/2.0);

                    gunner_set_angle(shooter2, remote_info->remote_angle);

                    graph_clear_screen();

                    map_draw   (map1);

                    bullet_draw_list(bullet_list);

                    build_remote_structure(remote_info, keys, angle);

                    //hltp_send_remote_info(remote_info);

                    gunner_set_pos(shooter1, (double)host_info->remote_x, (double)host_info->remote_y);

                    gunner_set_angle(shooter1, (double)host_info->remote_angle);

                    gunner_set_health(shooter1, (double)host_info->remote_health);

                    ent_set_origin(gunner_get_x(shooter1)-ent_get_XLength()/2.0,

                                   gunner_get_y(shooter1)-ent_get_YLength()/2.0);

                    for (size_t j = 0; j < host_info->no_bullets; j++) {

                        if (host_info->bullets_shooter[j]) { // remote

                            bullet_t *bullet = bullet_ctor(shooter1, bsp_bullet, (double)host_info->bullets_x[j], (double)host_info->bullets_y[j], (double)host_info->bullets_vx[j], (double)host_info->bullets_vy[j]);

                            bullet_t *bullet = bullet_ctor(shooter2, bsp_bullet, (double)host_info->bullets_x[j], (double)host_info->bullets_y[j], (double)host_info->bullets_vx[j], (double)host_info->bullets_vy[j]);

                            list_insert(bullet_list, list_end(bullet_list), bullet);

                        }

                    graph_clear_screen();

                    map_draw   (map1);

                    sprite_set_pos(sp_crosshair, *get_mouse_X(), *get_mouse_Y());

                    sprite_draw(sp_crosshair);

                    graph_draw();

                    while(list_size(bullet_list) > 0){

                        bullet_t *p = (bullet_t*)list_erase(bullet_list, list_begin(bullet_list));

                        bullet_dtor(p);

                    }

                    break;

                    case KBC_IRQ:

                    }

                    break;

                }

            }

        }

    ret->remote_health          = (int16_t)gunner_get_health     (remote);

    ret->remote_current_health  = (int16_t)gunner_get_curr_health(remote);

    return ret;

}

void host_info_dtor(host_info_t *p) {

    if (p==NULL) return;

    if ((p->bullets_x) != NULL){ free(p->bullets_x); p->bullets_x = NULL; }

    if ((p->bullets_y) != NULL){ free(p->bullets_y); p->bullets_y = NULL; }

    if ((p->bullets_vy) != NULL){ free(p->bullets_vy); p->bullets_vy = NULL; }

    if ((p->bullets_shooter) != NULL){ free(p->bullets_shooter); p->bullets_shooter = NULL; }

    free(p);

}

    return atan2(gunner_get_y_screen(p) - mouse_y, mouse_x - gunner_get_x_screen(p));

}

    // host

    p->host_x               = (int16_t)gunner_get_x          (host);

    p->host_y               = (int16_t)gunner_get_y          (host);

    p->remote_angle           = (int16_t)gunner_get_angle      (remote);

    p->remote_health          = (int16_t)gunner_get_health     (remote);

    p->remote_current_health  = (int16_t)gunner_get_curr_health(remote);

    // bullets

    size_t sz = list_size(bullet_list);

    p->no_bullets = sz;

        it = list_node_next(it);

        i++;

    }

}

void build_remote_structure(remote_info_t *p, keys_t *keys, double angle) {

SRCS= list.c queue.c graph.c kbc.c keyboard.c mouse.c utils.c timer.c interrupts_func.c fast_math.c xpm_utils.c rtc.c uart.c makecode_map.c menu.c proj_func.c rectangle.c font.c ent.c proj.c hltp.c

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}