Index: proj/include/proj_structures.h
===================================================================
--- proj/include/proj_structures.h	(revision 328)
+++ proj/include/proj_structures.h	(revision 329)
@@ -17,26 +17,26 @@
 
 typedef struct {
     // host
-    float    host_x;
-    float    host_y;
-    float    host_angle;
-    float    host_health;
-    float    host_current_health;
+    int16_t    host_x;
+    int16_t    host_y;
+    int16_t    host_angle;
+    int16_t    host_health;
+    int16_t    host_current_health;
 
     // remote
-    float    remote_x;
-    float    remote_y;
-    float    remote_angle;
-    float    remote_health;
-    float    remote_current_health;
+    int16_t    remote_x;
+    int16_t    remote_y;
+    int16_t    remote_angle;
+    int16_t    remote_health;
+    int16_t    remote_current_health;
 
     // bullets
-    uint8_t  no_bullets;
-    float   *bullets_x;
-    float   *bullets_y;
-    float   *bullets_vx;
-    float   *bullets_vy;
-    bool    *bullets_shooter; // false for host, true for remote
+    uint8_t    no_bullets;
+    int16_t   *bullets_x;
+    int16_t   *bullets_y;
+    int16_t   *bullets_vx;
+    int16_t   *bullets_vy;
+    bool      *bullets_shooter; // false for host, true for remote
 } host_info_t;
 
 typedef struct {
Index: proj/libs/uart/src/hltp.c
===================================================================
--- proj/libs/uart/src/hltp.c	(revision 328)
+++ proj/libs/uart/src/hltp.c	(revision 329)
@@ -21,28 +21,28 @@
     host_info_t *ret = (host_info_t*)malloc(sizeof(host_info_t));
     size_t pos = 0;
     // players information
-    memcpy(ret, p + pos, sizeof(float)*10);
-    pos += sizeof(float)*10;
+    memcpy(ret, p + pos, sizeof(int16_t)*10);
+    pos += sizeof(int16_t)*10;
     // size of arrays
     memcpy(&(ret->no_bullets), p + pos, sizeof(uint8_t));
     pos += sizeof(uint8_t);
     size_t sz = ret->no_bullets;
     // array containing the X positions of the bullets
-    (ret->bullets_x) = (float*)malloc(sizeof(float)*sz);
-    memcpy((ret->bullets_x), p + pos, sizeof(float)*sz);
-    pos += sizeof(float)*sz;
+    (ret->bullets_x) = (int16_t*)malloc(sizeof(int16_t)*sz);
+    memcpy((ret->bullets_x), p + pos, sizeof(int16_t)*sz);
+    pos += sizeof(int16_t)*sz;
     // array containing the Y positions of the bullets
-    (ret->bullets_y) = (float*)malloc(sizeof(float)*(ret->no_bullets));
-    memcpy((ret->bullets_y), p + pos, sizeof(float)*sz);
-    pos += sizeof(float)*sz;
+    (ret->bullets_y) = (int16_t*)malloc(sizeof(int16_t)*(ret->no_bullets));
+    memcpy((ret->bullets_y), p + pos, sizeof(int16_t)*sz);
+    pos += sizeof(int16_t)*sz;
     // array containing the X velocity of the bullets
-    (ret->bullets_vx) = (float*)malloc(sizeof(float)*(ret->no_bullets));
-    memcpy((ret->bullets_vx), p + pos, sizeof(float)*sz);
-    pos += sizeof(float)*sz;
+    (ret->bullets_vx) = (int16_t*)malloc(sizeof(int16_t)*(ret->no_bullets));
+    memcpy((ret->bullets_vx), p + pos, sizeof(int16_t)*sz);
+    pos += sizeof(int16_t)*sz;
     // array containing the Y velocity of the bullets
-    (ret->bullets_vy) = (float*)malloc(sizeof(float)*(ret->no_bullets));
-    memcpy((ret->bullets_vy), p + pos, sizeof(float)*sz);
-    pos += sizeof(float)*sz;
+    (ret->bullets_vy) = (int16_t*)malloc(sizeof(int16_t)*(ret->no_bullets));
+    memcpy((ret->bullets_vy), p + pos, sizeof(int16_t)*sz);
+    pos += sizeof(int16_t)*sz;
     // 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);
@@ -54,22 +54,22 @@
     uint8_t type = hltp_type_host;
     const 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(float);
-    ptr[2]  = (uint8_t*)&p->host_y                ;     sz[2]   = sizeof(float);
-    ptr[3]  = (uint8_t*)&p->host_angle            ;     sz[3]   = sizeof(float);
-    ptr[4]  = (uint8_t*)&p->host_health           ;     sz[4]   = sizeof(float);
-    ptr[5]  = (uint8_t*)&p->host_current_health   ;     sz[5]   = sizeof(float);
-    ptr[6]  = (uint8_t*)&p->remote_x              ;     sz[6]   = sizeof(float);
-    ptr[7]  = (uint8_t*)&p->remote_y              ;     sz[7]   = sizeof(float);
-    ptr[8]  = (uint8_t*)&p->remote_angle          ;     sz[8]   = sizeof(float);
-    ptr[9]  = (uint8_t*)&p->remote_health         ;     sz[9]   = sizeof(float);
-    ptr[10] = (uint8_t*)&p->remote_current_health ;     sz[10]  = sizeof(float);
+    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[3]  = (uint8_t*)&p->host_angle            ;     sz[3]   = sizeof(int16_t);
+    ptr[4]  = (uint8_t*)&p->host_health           ;     sz[4]   = sizeof(int16_t);
+    ptr[5]  = (uint8_t*)&p->host_current_health   ;     sz[5]   = sizeof(int16_t);
+    ptr[6]  = (uint8_t*)&p->remote_x              ;     sz[6]   = sizeof(int16_t);
+    ptr[7]  = (uint8_t*)&p->remote_y              ;     sz[7]   = 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(float) * p->no_bullets;
-    ptr[13] = (uint8_t*) p->bullets_y             ;     sz[13]  = sizeof(float) * p->no_bullets;
-    ptr[14] = (uint8_t*) p->bullets_vx            ;     sz[14]  = sizeof(float) * p->no_bullets;
-    ptr[15] = (uint8_t*) p->bullets_vy            ;     sz[15]  = sizeof(float) * p->no_bullets;
-    ptr[16] = (uint8_t*) p->bullets_shooter       ;     sz[16]  = sizeof(float) * p->no_bullets;
+    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;
     return nctp_send(17, ptr, sz);
 }
 
Index: proj/src/proj_func.c
===================================================================
--- proj/src/proj_func.c	(revision 328)
+++ proj/src/proj_func.c	(revision 329)
@@ -31,18 +31,18 @@
     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);
+    ret->host_x               = (int16_t)gunner_get_x          (host);
+    ret->host_y               = (int16_t)gunner_get_y          (host);
+    ret->host_angle           = (int16_t)gunner_get_angle      (host);
+    ret->host_health          = (int16_t)gunner_get_health     (host);
+    ret->host_current_health  = (int16_t)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->remote_x               = (int16_t)gunner_get_x          (remote);
+    ret->remote_y               = (int16_t)gunner_get_y          (remote);
+    ret->remote_angle           = (int16_t)gunner_get_angle      (remote);
+    ret->remote_health          = (int16_t)gunner_get_health     (remote);
+    ret->remote_current_health  = (int16_t)gunner_get_curr_health(remote);
 
     ret->no_bullets = 0;
 
@@ -320,36 +320,36 @@
 
 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);
+    p->host_x               = (int16_t)gunner_get_x          (host);
+    p->host_y               = (int16_t)gunner_get_y          (host);
+    p->host_angle           = (int16_t)gunner_get_angle      (host);
+    p->host_health          = (int16_t)gunner_get_health     (host);
+    p->host_current_health  = (int16_t)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);
+    p->remote_x               = (int16_t)gunner_get_x          (remote);
+    p->remote_y               = (int16_t)gunner_get_y          (remote);
+    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;
-    p->bullets_x        = (float*)realloc(p->bullets_x         , sz * sizeof(float));
-    p->bullets_y        = (float*)realloc(p->bullets_y         , sz * sizeof(float));
-    p->bullets_vx       = (float*)realloc(p->bullets_vx        , sz * sizeof(float));
-    p->bullets_vy       = (float*)realloc(p->bullets_vy        , sz * sizeof(float));
-    p->bullets_shooter  = (bool*) realloc(p->bullets_shooter   , sz * sizeof(bool ));
+    p->bullets_x        = (int16_t*)realloc(p->bullets_x         , sz * sizeof(int16_t));
+    p->bullets_y        = (int16_t*)realloc(p->bullets_y         , sz * sizeof(int16_t));
+    p->bullets_vx       = (int16_t*)realloc(p->bullets_vx        , sz * sizeof(int16_t));
+    p->bullets_vy       = (int16_t*)realloc(p->bullets_vy        , sz * sizeof(int16_t));
+    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_x        [i] = (int16_t)bullet_get_x                      (bullet);
+        p->bullets_y        [i] = (int16_t)bullet_get_y                      (bullet);
+        p->bullets_vx       [i] = (int16_t)bullet_get_vx                     (bullet);
+        p->bullets_vy       [i] = (int16_t)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++;
