Index: proj/include/ent.h
===================================================================
--- proj/include/ent.h	(revision 319)
+++ proj/include/ent.h	(revision 320)
@@ -49,6 +49,8 @@
 void      (bullet_dtor)(bullet_t *p);
 double  (bullet_get_x)       (const bullet_t *p);
 double  (bullet_get_y)       (const bullet_t *p);
+double  (bullet_get_vx)      (const bullet_t *p);
+double  (bullet_get_vy)      (const bullet_t *p);
 int16_t (bullet_get_x_screen)(const bullet_t *p);
 int16_t (bullet_get_y_screen)(const bullet_t *p);
 double  (bullet_get_damage)  (const bullet_t *p);
Index: proj/include/proj_func.h
===================================================================
--- proj/include/proj_func.h	(revision 319)
+++ proj/include/proj_func.h	(revision 320)
@@ -37,6 +37,10 @@
 
 int32_t* get_mouse_Y(void);
 
+void build_host_structure(host_info_t *p, gunner_t *host, gunner_t *remote, list_t *bullet_list);
+
+void build_remote_structure(remote_info_t *p, keys_t *keys, double angle);
+
 /**
  * @brief
  * @param
Index: proj/include/proj_structures.h
===================================================================
--- proj/include/proj_structures.h	(revision 319)
+++ proj/include/proj_structures.h	(revision 320)
@@ -2,6 +2,7 @@
 #define PROJ_STRUCTURES_H_INCLUDED
 
 #include <stdint.h>
+#include "ent.h"
 
 typedef struct keys {
     uint8_t w_pressed       : 1;
@@ -18,6 +19,7 @@
     // host
     double  host_x;
     double  host_y;
+    double  host_angle;
     double  host_health;
     double  host_current_health;
 
@@ -24,6 +26,7 @@
     // remote
     double  remote_x;
     double  remote_y;
+    double  remote_angle;
     double  remote_health;
     double  remote_current_health;
 
@@ -38,16 +41,23 @@
 
 typedef struct __attribute__((packed)) {
     keys_t  remote_keys_pressed;
-    int32_t remote_mouse_x;
-    int32_t remote_mouse_y;
-    size_t  bullets_shot;
-    double *bullets_x;
-    double *bullets_y;
-    double *bullets_angle;
+    double  remote_angle;
 } remote_info_t;
 
+typedef struct __attribute__((packed)) {
+    bool   new_bullet;
+} bullet_info_t;
+
+host_info_t* host_info_ctor(gunner_t *host, gunner_t *remote);
+
 void host_info_dtor(host_info_t *p);
 
+remote_info_t* remote_info_ctor();
+
 void remote_info_dtor(remote_info_t *p);
 
+bullet_info_t* bullet_info_ctor();
+
+void bullet_info_dtor(bullet_info_t *p);
+
 #endif /* end of include guard: PROJ_STRUCTURES_H_INCLUDED */
Index: proj/libs/uart/include/hltp.h
===================================================================
--- proj/libs/uart/include/hltp.h	(revision 319)
+++ proj/libs/uart/include/hltp.h	(revision 320)
@@ -7,12 +7,14 @@
 typedef enum{
     hltp_type_invalid = 0x00,
     hltp_type_string  = 0x53,
-    hltp_type_host    = 0x54,
-    hltp_type_remote  = 0x55
+    hltp_type_host    = 0x48,
+    hltp_type_remote  = 0x52,
+    hltp_type_bullet  = 0x42
 } hltp_type;
 
 int hltp_send_string(const char *p);
 int hltp_send_host_info(const host_info_t *p);
 int hltp_send_remote_info(const remote_info_t *p);
+int hltp_send_bullet_info(const bullet_info_t *p);
 hltp_type hltp_interpret(const uint8_t *p, const size_t sz, void **dest);
 #endif //HLTP_H_INCLUDED
Index: proj/libs/uart/src/hltp.c
===================================================================
--- proj/libs/uart/src/hltp.c	(revision 319)
+++ proj/libs/uart/src/hltp.c	(revision 320)
@@ -21,8 +21,8 @@
     host_info_t *ret = (host_info_t*)malloc(sizeof(host_info_t));
     size_t pos = 0;
     // players information
-    memcpy(ret, p + pos, sizeof(double)*8);
-    pos += sizeof(double)*8;
+    memcpy(ret, p + pos, sizeof(double)*10);
+    pos += sizeof(double)*10;
     // size of arrays
     memcpy(&(ret->no_bullets), p + pos, sizeof(size_t));
     pos += sizeof(size_t);
@@ -52,23 +52,25 @@
 int hltp_send_host_info(const host_info_t *p) {
 
     uint8_t type = hltp_type_host;
-    uint8_t* ptr[15]; size_t sz[15];
-    ptr[0]  = (uint8_t*)&   type                  ;     sz[0] = 1;
-    ptr[1]  = (uint8_t*)&p->host_x                ;     sz[0] = sizeof(double);
-    ptr[2]  = (uint8_t*)&p->host_y                ;     sz[0] = sizeof(double);
-    ptr[3]  = (uint8_t*)&p->host_health           ;     sz[0] = sizeof(double);
-    ptr[4]  = (uint8_t*)&p->host_current_health   ;     sz[0] = sizeof(double);
-    ptr[5]  = (uint8_t*)&p->remote_x              ;     sz[0] = sizeof(double);
-    ptr[6]  = (uint8_t*)&p->remote_y              ;     sz[0] = sizeof(double);
-    ptr[7]  = (uint8_t*)&p->remote_health         ;     sz[0] = sizeof(double);
-    ptr[8]  = (uint8_t*)&p->remote_current_health ;     sz[0] = sizeof(double);
-    ptr[9]  = (uint8_t*)&p->no_bullets            ;     sz[0] = sizeof(size_t);
-    ptr[10] = (uint8_t*) p->bullets_x             ;     sz[0] = sizeof(double) * p->no_bullets;
-    ptr[11] = (uint8_t*) p->bullets_y             ;     sz[0] = sizeof(double) * p->no_bullets;
-    ptr[12] = (uint8_t*) p->bullets_vx            ;     sz[0] = sizeof(double) * p->no_bullets;
-    ptr[13] = (uint8_t*) p->bullets_vy            ;     sz[0] = sizeof(double) * p->no_bullets;
-    ptr[14] = (uint8_t*) p->bullets_shooter       ;     sz[0] = sizeof(double) * p->no_bullets;
-    return nctp_send(2, ptr, sz);
+    uint8_t* ptr[17]; size_t sz[17];
+    ptr[0]  = (uint8_t*)&   type                  ;     sz[0]   = 1;
+    ptr[1]  = (uint8_t*)&p->host_x                ;     sz[1]   = sizeof(double);
+    ptr[2]  = (uint8_t*)&p->host_y                ;     sz[2]   = sizeof(double);
+    ptr[3]  = (uint8_t*)&p->host_angle            ;     sz[3]   = sizeof(double);
+    ptr[4]  = (uint8_t*)&p->host_health           ;     sz[4]   = sizeof(double);
+    ptr[5]  = (uint8_t*)&p->host_current_health   ;     sz[5]   = sizeof(double);
+    ptr[6]  = (uint8_t*)&p->remote_x              ;     sz[6]   = sizeof(double);
+    ptr[7]  = (uint8_t*)&p->remote_y              ;     sz[7]   = sizeof(double);
+    ptr[8]  = (uint8_t*)&p->remote_angle          ;     sz[8]   = sizeof(double);
+    ptr[9]  = (uint8_t*)&p->remote_health         ;     sz[9]   = sizeof(double);
+    ptr[10] = (uint8_t*)&p->remote_current_health ;     sz[10]  = sizeof(double);
+    ptr[11] = (uint8_t*)&p->no_bullets            ;     sz[11]  = sizeof(size_t);
+    ptr[12] = (uint8_t*) p->bullets_x             ;     sz[12]  = sizeof(double) * p->no_bullets;
+    ptr[13] = (uint8_t*) p->bullets_y             ;     sz[13]  = sizeof(double) * p->no_bullets;
+    ptr[14] = (uint8_t*) p->bullets_vx            ;     sz[14]  = sizeof(double) * p->no_bullets;
+    ptr[15] = (uint8_t*) p->bullets_vy            ;     sz[15]  = sizeof(double) * p->no_bullets;
+    ptr[16] = (uint8_t*) p->bullets_shooter       ;     sz[16]  = sizeof(double) * p->no_bullets;
+    return nctp_send(17, ptr, sz);
 }
 
 static remote_info_t* hltp_interpret_remote_info(const uint8_t *p) {
@@ -78,26 +80,7 @@
     memcpy(&(ret->remote_keys_pressed), p + pos, sizeof(keys_t));
     pos += sizeof(keys_t);
     // mouse positions
-    memcpy(&(ret->remote_mouse_x), p + pos, sizeof(int32_t));
-    pos += sizeof(int32_t);
-    memcpy(&(ret->remote_mouse_y), p + pos, sizeof(int32_t));
-    pos += sizeof(int32_t);
-    // bullets shot
-    memcpy(&(ret->bullets_shot), p + pos, sizeof(size_t));
-    pos += sizeof(size_t);
-    size_t sz = ret->bullets_shot;
-    // array containing the X positions of the bullets
-    (ret->bullets_x) = (double*)malloc(sizeof(double)*sz);
-    memcpy((ret->bullets_x), p + pos, sizeof(double)*sz);
-    pos += sizeof(double)*sz;
-    // array containing the Y positions of the bullets
-    (ret->bullets_y) = (double*)malloc(sizeof(double)*sz);
-    memcpy((ret->bullets_y), p + pos, sizeof(double)*sz);
-    pos += sizeof(double)*sz;
-    // array containing the angle of the bullets
-    (ret->bullets_angle) = (double*)malloc(sizeof(double)*sz);
-    memcpy((ret->bullets_angle), p + pos, sizeof(double)*sz);
-    pos += sizeof(double)*sz;
+    memcpy(&(ret->remote_angle), p + pos, sizeof(double));
 
     return ret;
 }
@@ -104,15 +87,25 @@
 int hltp_send_remote_info(const remote_info_t *p) {
 
     uint8_t type = hltp_type_remote;
-    uint8_t* ptr[8]; size_t sz[8];
+    uint8_t* ptr[3]; size_t sz[3];
     ptr[0]  = (uint8_t*)&   type                  ;     sz[0] = 1;
-    ptr[1]  = (uint8_t*)&p->remote_keys_pressed   ;     sz[0] = sizeof(keys_t);
-    ptr[2]  = (uint8_t*)&p->remote_mouse_x        ;     sz[0] = sizeof(int32_t);
-    ptr[3]  = (uint8_t*)&p->remote_mouse_y        ;     sz[0] = sizeof(int32_t);
-    ptr[4]  = (uint8_t*)&p->bullets_shot          ;     sz[0] = sizeof(size_t);
-    ptr[5]  = (uint8_t*) p->bullets_x             ;     sz[0] = sizeof(double) * p->bullets_shot;
-    ptr[6]  = (uint8_t*) p->bullets_y             ;     sz[0] = sizeof(double) * p->bullets_shot;
-    ptr[7]  = (uint8_t*) p->bullets_angle         ;     sz[0] = sizeof(double) * p->bullets_shot;
+    ptr[1]  = (uint8_t*)&p->remote_keys_pressed   ;     sz[1] = sizeof(keys_t);
+    ptr[2]  = (uint8_t*)&p->remote_angle          ;     sz[2] = sizeof(double);
+    return nctp_send(3, ptr, sz);
+}
+
+static bullet_info_t* hltp_interpret_bullet_info(const uint8_t *p) {
+    bullet_info_t *ret = (bullet_info_t*)malloc(sizeof(bullet_info_t));
+    memcpy(&(ret->new_bullet), p, sizeof(bool));
+
+    return ret;
+}
+
+int hltp_send_bullet_info(const bullet_info_t *p) {
+    uint8_t type = hltp_type_bullet;
+    uint8_t* ptr[2]; size_t sz[2];
+    ptr[0]  = (uint8_t*)&   type            ;     sz[0] = 1;
+    ptr[1]  = (uint8_t*)&p->new_bullet      ;     sz[1] = sizeof(bool);
     return nctp_send(2, ptr, sz);
 }
 
@@ -119,9 +112,10 @@
 hltp_type hltp_interpret(const uint8_t *p, const size_t sz, void **dest){
     uint8_t ret = p[0];
     switch(ret){
-        case hltp_type_string: *dest = hltp_interpret_string(p+1, sz-1); break;
-        case hltp_type_host  : *dest = hltp_interpret_host_info(p+1); break;
-        case hltp_type_remote: *dest = hltp_interpret_remote_info(p+1); break;
+        case hltp_type_string: *dest = hltp_interpret_string     (p+1, sz-1);   break;
+        case hltp_type_host  : *dest = hltp_interpret_host_info  (p+1);         break;
+        case hltp_type_remote: *dest = hltp_interpret_remote_info(p+1);         break;
+        case hltp_type_bullet: *dest = hltp_interpret_bullet_info(p+1);         break;
         default: *dest = NULL; break;
     }
     return ret;
Index: proj/src/ent.c
===================================================================
--- proj/src/ent.c	(revision 319)
+++ proj/src/ent.c	(revision 320)
@@ -155,6 +155,7 @@
     sprite_set_angle(ret->b, angle-M_PI_2);
     return ret;
 }
+
 void (bullet_dtor)(bullet_t *p){
     if(p == NULL) return;
     sprite_dtor(p->b);
@@ -162,6 +163,8 @@
 }
 double  (bullet_get_x)       (const bullet_t *p){ return p->x; }
 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; }
 int16_t (bullet_get_x_screen)(const bullet_t *p){ return (p->x-x_origin)*scale; }
 int16_t (bullet_get_y_screen)(const bullet_t *p){ return (p->y-y_origin)*scale; }
 double  (bullet_get_damage)  (const bullet_t *p){ return p->damage; }
@@ -384,6 +387,7 @@
 }
 
 int (gunner_collides_gunner)(const gunner_t *shooter1, const gunner_t *shooter2) {
+    if (shooter1 == shooter2) return false;
     double shooter1_radius = max(sprite_get_w(shooter1->dude), sprite_get_h(shooter1->dude))/2.0;
     double shooter2_radius = max(sprite_get_w(shooter2->dude), sprite_get_h(shooter2->dude))/2.0;
     double distance = distance_gunners(shooter1, shooter2);
Index: proj/src/proj.c
===================================================================
--- proj/src/proj.c	(revision 319)
+++ proj/src/proj.c	(revision 320)
@@ -182,8 +182,9 @@
     return 0;
 }
 
-host_info_t     *host   = NULL;
-remote_info_t   *remote = NULL;
+host_info_t     *host_info   = NULL;
+remote_info_t   *remote_info = NULL;
+bullet_info_t   *bullet_info = NULL;
 
 static void multiplayer_process(const uint8_t *p, const size_t sz) {
     void *dest = NULL;
@@ -190,13 +191,17 @@
     hltp_type tp = hltp_interpret(p, sz, &dest);
     switch(tp){
         case hltp_type_host:
-            host_info_dtor(host);
-            host = (host_info_t*)dest;
+            host_info_dtor(host_info);
+            host_info = (host_info_t*)dest;
             break;
         case hltp_type_remote:
-            remote_info_dtor(remote);
-            remote = (remote_info_t*)dest;
+            remote_info_dtor(remote_info);
+            remote_info = (remote_info_t*)dest;
             break;
+        case hltp_type_bullet:
+            bullet_info_dtor(bullet_info);
+            bullet_info = (bullet_info_t*)dest;
+            break;
         default: break;
     }
 }
@@ -264,10 +269,10 @@
 }
 
 static int (multiplayer_host)(void) {
-    //int r;
+    int r;
 
     nctp_dump();
-    nctp_set_processor(multiplayer_process);/*
+    nctp_set_processor(multiplayer_process);
 
     ent_set_scale(DEFAULT_SCALE);
     text_timer_t *in_game_timer = timer_ctor(font_get_default());
@@ -277,7 +282,7 @@
     gunner_t *shooter1 = gunner_ctor(bsp_shooter, bsp_pistol, gunner_player, 1); if(shooter1 == NULL) printf("Failed to get shooter1\n");
     gunner_set_spawn(shooter1, 75, 75);
 
-    gunner_t *shooter2 = gunner_ctor(bsp_shooter, bsp_pistol, gunner_player, 1); if(shooter2 == NULL) printf("Failed to get shooter2\n");
+    gunner_t *shooter2 = gunner_ctor(bsp_shooter, bsp_pistol, gunner_player, 2); if(shooter2 == NULL) printf("Failed to get shooter2\n");
     gunner_set_spawn(shooter2, 975, 75);
 
     list_insert(shooter_list, list_end(shooter_list), shooter1);
@@ -286,8 +291,12 @@
     do {
         get_random_spawn(map1, shooter1, shooter_list);
         get_random_spawn(map1, shooter2, shooter_list);
-    } while (distance_gunners(shooter1, shooter2) < 700);
+    } while (distance_gunners(shooter1, shooter2) < 500);
 
+    host_info = host_info_ctor(shooter1, shooter2);
+    remote_info = remote_info_ctor();
+    bullet_info = bullet_info_ctor();
+
     list_t *bullet_list  = list_ctor();
 
     ent_set_origin(gunner_get_x(shooter1)-ent_get_XLength()/2.0,
@@ -297,37 +306,108 @@
     uint8_t last_lb = 0;
     struct packet pp;
     keys_t *keys = get_key_presses();
-
     /// loop stuff
     uint32_t int_vector = 0;
     int good = true;
     int state = 0; // -1 for remote win, 0 for draw, 1 for host win
+    list_node_t *p1, *p2; // player states
+    int state_1, state_2;
     while (good) {
         if ((r = get_interrupts_vector(&int_vector))) return r;
         for (uint32_t i = 0, n = 1; i < 32; i++, n <<= 1) {
-            interrupt_handler(i);
-            switch (i) {
-                case TIMER0_IRQ:
+            if (int_vector & n) {
+                interrupt_handler(i);
+                switch (i) {
+                    case TIMER0_IRQ:
+                    if (no_interrupts % 60 == 0) timer_update(in_game_timer);
 
-                break;
+                    update_movement(map1, shooter1, keys, shooter_list);
+                    update_movement(map1, shooter2, &(remote_info->remote_keys_pressed), shooter_list);
 
-                case KBC_IRQ:
+                    update_game_state(map1, shooter_list, bullet_list);
 
-                break;
+                    p1 = list_find(shooter_list, shooter1);
+                    p2 = list_find(shooter_list, shooter2);
 
-                case MOUSE_IRQ:
+                    if ((state_1 = (p1 == list_end(shooter_list))) || (state_2 = (p2 == list_end(shooter_list)))) {
+                        state = state_1 - state_2;
+                        good = false;
+                        break;
+                    }
 
+                    double angle = get_mouse_angle(shooter1);
+                    gunner_set_angle(shooter1, angle - M_PI_2);
 
-                break;
+                    ent_set_origin(gunner_get_x(shooter1)-ent_get_XLength()/2.0,
+                                   gunner_get_y(shooter1)-ent_get_YLength()/2.0);
 
-                case COM1_IRQ: nctp_ih(); break;
+                    gunner_set_angle(shooter2, remote_info->remote_angle);
+
+                    build_host_structure(host_info, shooter1, shooter2, bullet_list);
+
+                    hltp_send_host_info(host_info);
+
+                    graph_clear_screen();
+                    map_draw   (map1);
+                    bullet_draw_list(bullet_list);
+                    gunner_draw_list(shooter_list);
+
+                    text_draw(in_game_timer->text);
+
+                    sprite_set_pos(sp_crosshair, *get_mouse_X(), *get_mouse_Y());
+                    sprite_draw(sp_crosshair);
+                    graph_draw();
+
+                    break;
+                    case KBC_IRQ:
+                    if ((scancode[0]) == ESC_BREAK_CODE) {
+                        good = false;
+                    }
+                    break;
+                    case MOUSE_IRQ:
+                    if (counter_mouse_ih >= 3) {
+                        mouse_parse_packet(packet_mouse_ih, &pp);
+                        update_mouse(&pp);
+                        if (last_lb ^ keys->lb_pressed && keys->lb_pressed)
+                        shoot_bullet(shooter1, bullet_list, bsp_bullet);
+                        last_lb = keys->lb_pressed;
+                        counter_mouse_ih = 0;
+                    }
+                    break;
+
+                    case COM1_IRQ:
+                        nctp_ih();
+                        if (bullet_info->new_bullet) {
+                            shoot_bullet(shooter2, bullet_list, bsp_bullet);
+                            bullet_info->new_bullet = false;
+                        }
+                        break;
+                }
             }
         }
-    }*/
+    }
 
+    while(list_size(shooter_list) > 0){
+        gunner_t *p = list_erase(shooter_list, list_begin(shooter_list));
+        gunner_dtor(p);
+    }
+    if(list_dtor(shooter_list)) printf("COULD NOT DESTRUCT SHOOTER LIST\n");
+
+    while(list_size(bullet_list) > 0){
+        bullet_t *p = (bullet_t*)list_erase(bullet_list, list_begin(bullet_list));
+        bullet_dtor(p);
+    }
+    if(list_dtor(bullet_list)) printf("COULD NOT DESTRUCT BULLET LIST\n");
+
+    host_info_dtor(host_info);
+    remote_info_dtor(remote_info);
+    bullet_info_dtor(bullet_info);
+
+    timer_dtor(in_game_timer); in_game_timer = NULL;
+
     return 0;
 }
-static int (multiplayer_remote)(void) {/*
+static int (multiplayer_remote)(void) {
     int r;
 
     nctp_dump();
@@ -338,7 +418,7 @@
 
     list_t *shooter_list = list_ctor();
 
-    gunner_t *shooter1 = gunner_ctor(bsp_shooter, bsp_pistol, gunner_player, 1); if(shooter1 == NULL) printf("Failed to get shooter1\n");
+    gunner_t *shooter1 = gunner_ctor(bsp_shooter, bsp_pistol, gunner_player, 2); if(shooter1 == NULL) printf("Failed to get shooter1\n");
     gunner_set_spawn(shooter1, 75, 75);
 
     gunner_t *shooter2 = gunner_ctor(bsp_shooter, bsp_pistol, gunner_player, 1); if(shooter2 == NULL) printf("Failed to get shooter2\n");
@@ -347,10 +427,9 @@
     list_insert(shooter_list, list_end(shooter_list), shooter1);
     list_insert(shooter_list, list_end(shooter_list), shooter2);
 
-    do {
-        get_random_spawn(map1, shooter1, shooter_list);
-        get_random_spawn(map1, shooter2, shooter_list);
-    } while (distance_gunners(shooter1, shooter2) < 700);
+    host_info = host_info_ctor(shooter2, shooter1);
+    remote_info = remote_info_ctor();
+    bullet_info = bullet_info_ctor();
 
     list_t *bullet_list  = list_ctor();
 
@@ -365,30 +444,103 @@
     /// loop stuff
     uint32_t int_vector = 0;
     int good = true;
-    int state = 0; // -1 for remote win, 0 for draw, 1 for host win
     while (good) {
         if ((r = get_interrupts_vector(&int_vector))) return r;
         for (uint32_t i = 0, n = 1; i < 32; i++, n <<= 1) {
-            interrupt_handler(i);
-            switch (i) {
-                case TIMER0_IRQ:
+            if (int_vector & n) {
+                interrupt_handler(i);
+                switch (i) {
+                    case TIMER0_IRQ:
+                    if (no_interrupts % 60 == 0) timer_update(in_game_timer);
 
-                break;
+                    double angle = get_mouse_angle(shooter1);
 
-                case KBC_IRQ:
+                    build_remote_structure(remote_info, keys, angle);
 
-                break;
+                    hltp_send_remote_info(remote_info);
 
-                case MOUSE_IRQ:
+                    gunner_set_pos(shooter1, host_info->remote_x, host_info->remote_y);
+                    gunner_set_angle(shooter1, host_info->remote_angle);
+                    gunner_set_health(shooter1, host_info->remote_health);
+                    gunner_set_curr_health(shooter1, host_info->remote_current_health);
 
+                    gunner_set_pos(shooter2, host_info->host_x, host_info->host_y);
+                    gunner_set_angle(shooter2, host_info->host_angle);
+                    gunner_set_health(shooter2, host_info->host_health);
+                    gunner_set_curr_health(shooter2, host_info->host_current_health);
 
-                break;
+                    ent_set_origin(gunner_get_x(shooter1)-ent_get_XLength()/2.0,
+                                   gunner_get_y(shooter1)-ent_get_YLength()/2.0);
 
-                case COM1_IRQ: nctp_ih(); break;
+                    for (size_t i = 0; i < host_info->no_bullets; i++) {
+                        if (host_info->bullets_shooter[i]) { // remote
+                            bullet_t *bullet = bullet_ctor(shooter1, bsp_bullet, host_info->bullets_x[i], host_info->bullets_y[i], host_info->bullets_vx[i], host_info->bullets_vy[i]);
+                            list_insert(bullet_list, list_end(bullet_list), bullet);
+                        } else { // host
+                            bullet_t *bullet = bullet_ctor(shooter2, bsp_bullet, host_info->bullets_x[i], host_info->bullets_y[i], host_info->bullets_vx[i], host_info->bullets_vy[i]);
+                            list_insert(bullet_list, list_end(bullet_list), bullet);
+                        }
+                    }
+
+                    graph_clear_screen();
+                    map_draw   (map1);
+                    bullet_draw_list(bullet_list);
+                    gunner_draw_list(shooter_list);
+
+                    text_draw(in_game_timer->text);
+
+                    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:
+                    if ((scancode[0]) == ESC_BREAK_CODE) {
+                        good = false;
+                    }
+                    break;
+                    case MOUSE_IRQ:
+                    if (counter_mouse_ih >= 3) {
+                        mouse_parse_packet(packet_mouse_ih, &pp);
+                        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;
+                        counter_mouse_ih = 0;
+                    }
+                    break;
+
+                    case COM1_IRQ: nctp_ih(); break;
+                }
             }
         }
-    }*/
+    }
 
+    while(list_size(shooter_list) > 0){
+        gunner_t *p = list_erase(shooter_list, list_begin(shooter_list));
+        gunner_dtor(p);
+    }
+    if(list_dtor(shooter_list)) printf("COULD NOT DESTRUCT SHOOTER LIST\n");
+
+    while(list_size(bullet_list) > 0){
+        bullet_t *p = (bullet_t*)list_erase(bullet_list, list_begin(bullet_list));
+        bullet_dtor(p);
+    }
+    if(list_dtor(bullet_list)) printf("COULD NOT DESTRUCT BULLET LIST\n");
+
+    host_info_dtor(host_info);
+    remote_info_dtor(remote_info);
+    bullet_info_dtor(bullet_info);
+
+    timer_dtor(in_game_timer); in_game_timer = NULL;
+
     return 0;
 }
 
Index: proj/src/proj_func.c
===================================================================
--- proj/src/proj_func.c	(revision 319)
+++ proj/src/proj_func.c	(revision 320)
@@ -27,6 +27,28 @@
 
 static keys_t key_presses;
 
+host_info_t* host_info_ctor(gunner_t *host, gunner_t *remote) {
+    host_info_t *ret = (host_info_t*)malloc(sizeof(host_info_t));
+    if (ret == NULL) return ret;
+
+    ret->host_x               = gunner_get_x          (host);
+    ret->host_y               = gunner_get_y          (host);
+    ret->host_angle           = gunner_get_angle      (host);
+    ret->host_health          = gunner_get_health     (host);
+    ret->host_current_health  = gunner_get_curr_health(host);
+
+    // remote
+    ret->remote_x               = gunner_get_x          (remote);
+    ret->remote_y               = gunner_get_y          (remote);
+    ret->remote_angle           = gunner_get_angle      (remote);
+    ret->remote_health          = gunner_get_health     (remote);
+    ret->remote_current_health  = gunner_get_curr_health(remote);
+
+    ret->no_bullets = 0;
+
+    return ret;
+}
+
 void host_info_dtor(host_info_t *p) {
     if (p==NULL) return;
 
@@ -43,15 +65,33 @@
     free(p);
 }
 
+remote_info_t* remote_info_ctor() {
+    remote_info_t *ret = (remote_info_t*)malloc(sizeof(remote_info_t));
+    if (ret == NULL) return ret;
+
+    memset(&(ret->remote_keys_pressed), 0, sizeof(keys_t));
+
+    ret->remote_angle = 0;
+
+    return ret;
+}
+
 void remote_info_dtor(remote_info_t *p) {
     if (p==NULL) return;
+    free(p);
+}
 
-    if ((p->bullets_x) != NULL){ free(p->bullets_x); p->bullets_x = NULL; }
+bullet_info_t* bullet_info_ctor() {
+    bullet_info_t *ret = (bullet_info_t*)malloc(sizeof(bullet_info_t));
+    if (ret == NULL) return ret;
 
-    if ((p->bullets_y) != NULL){ free(p->bullets_y); p->bullets_y = NULL; }
+    ret->new_bullet = false;
 
-    if ((p->bullets_angle) != NULL){ free(p->bullets_angle); p->bullets_angle = NULL; }
+    return ret;
+}
 
+void bullet_info_dtor(bullet_info_t *p) {
+    if (p == NULL) return;
     free(p);
 }
 
@@ -278,6 +318,49 @@
     return atan2(gunner_get_y_screen(p) - mouse_y, mouse_x - gunner_get_x_screen(p));
 }
 
+void build_host_structure(host_info_t *p, gunner_t *host, gunner_t *remote, list_t *bullet_list) {
+    // host
+    p->host_x               = gunner_get_x          (host);
+    p->host_y               = gunner_get_y          (host);
+    p->host_angle           = gunner_get_angle      (host);
+    p->host_health          = gunner_get_health     (host);
+    p->host_current_health  = gunner_get_curr_health(host);
+
+    // remote
+    p->remote_x               = gunner_get_x          (remote);
+    p->remote_y               = gunner_get_y          (remote);
+    p->remote_angle           = gunner_get_angle      (remote);
+    p->remote_health          = gunner_get_health     (remote);
+    p->remote_current_health  = gunner_get_curr_health(remote);
+
+    // bullets
+    size_t sz = list_size(bullet_list);
+    p->no_bullets = sz;
+    p->bullets_x        = (double*)realloc(p->bullets_x         , sz * sizeof(double));
+    p->bullets_y        = (double*)realloc(p->bullets_y         , sz * sizeof(double));
+    p->bullets_vx       = (double*)realloc(p->bullets_vx        , sz * sizeof(double));
+    p->bullets_vy       = (double*)realloc(p->bullets_vy        , sz * sizeof(double));
+    p->bullets_shooter  = (bool*)  realloc(p->bullets_shooter   , sz * sizeof(bool  ));
+
+    list_node_t *it = list_begin(bullet_list);
+    size_t i = 0;
+    while (it != list_end(bullet_list)) {
+        bullet_t *bullet = *list_node_val(it);
+        p->bullets_x        [i] = bullet_get_x                      (bullet);
+        p->bullets_y        [i] = bullet_get_y                      (bullet);
+        p->bullets_vx       [i] = bullet_get_vx                     (bullet);
+        p->bullets_vy       [i] = bullet_get_vy                     (bullet);
+        p->bullets_shooter  [i] = gunner_get_team(bullet_get_shooter(bullet)) != gunner_get_team(host);
+        it = list_node_next(it);
+        i++;
+    }
+}
+
+void build_remote_structure(remote_info_t *p, keys_t *keys, double angle) {
+    memcpy(&(p->remote_keys_pressed), keys, sizeof(keys_t));
+    p->remote_angle = angle;
+}
+
 text_timer_t* (timer_ctor)(const font_t *fnt){
     if(fnt == NULL) return NULL;
     text_timer_t *ret = malloc(sizeof(timer_t));
