Index: proj/libs/classes/include/list.h
===================================================================
--- proj/libs/classes/include/list.h	(revision 315)
+++ proj/libs/classes/include/list.h	(revision 316)
@@ -2,28 +2,133 @@
 #define LIST_H_INCLUDED
 
 struct list_node;
+/**
+ * @brief List node.
+ *
+ * Can be used like a C++ std::list iterator.
+ * A list node stores a void* to allow for more flexibility.
+ */
 typedef struct list_node list_node_t;
 
+/**
+ * @brief Construct list node.
+ * @param   p   Pointer to previous list node
+ * @param   n   Pointer to next list node
+ * @param   val Value to be stored in the list node
+ * @return      Pointer to created list node
+ */
 list_node_t* (list_node_ctor)(list_node_t *p, list_node_t *n, void *val);
+/**
+ * @brief Destruct list node.
+ * @param   p   Pointer to list node to be destroyed
+ */
 void         (list_node_dtor)(list_node_t *p);
+/**
+ * @brief Get next node.
+ * @param   p   Pointer to list node
+ * @return      Pointer to next list node
+ */
 list_node_t* (list_node_next)(const list_node_t *p);
+/**
+ * @brief Get previous node.
+ * @param   p   Pointer to list node
+ * @return      Pointer to previous list node
+ */
 list_node_t* (list_node_prev)(const list_node_t *p);
+/**
+ * @brief Get value stored in the node.
+ * @param   p   Pointer to list node
+ * @return      Pointer to the stored value (which is in turn a void*).
+ */
 void**       (list_node_val )(list_node_t *p);
 
 struct list;
+/**
+ * @brief List.
+ *
+ * Can be used like a C++ std::list.
+ * A list_t is a sequence of list_node_t nodes, that store void* to allow for more flexibility.
+ */
 typedef struct list list_t;
 
-list_t* (list_ctor)(void);
-int     (list_dtor)(list_t *l);
-list_node_t* (list_begin )(list_t *l);
-list_node_t* (list_end   )(list_t *l);
-size_t       (list_size  )(const list_t *l);
-int          (list_empty )(const list_t *l);
-list_node_t* (list_insert)(list_t *l, list_node_t *position, void *val);
-void*        (list_erase )(list_t *l, list_node_t *position);
+/**
+ * @brief Construct empty list.
+ * @return  Pointer to created list
+ */
+list_t*      (list_ctor)     (void);
+/**
+ * @brief Destruct list.
+ *
+ * A list can only be destroyed once it is empty.
+ * This is because a list stores void*, whose memory most likely need to be free'd.
+ * @param   l   Pointer to list to be destroyed
+ * @return      SUCCESS if the destruction was successful, other value otherwise.
+ */
+int          (list_dtor)     (list_t *l);
+/**
+ * @brief Get pointer to the first node of the list.
+ * @param   l   Pointer to list
+ * @return      Pointer to first node of the list.
+ */
+list_node_t* (list_begin)    (list_t *l);
+/**
+ * @brief Get pointer to the past-the-end node of the list.
+ * @param   l   Pointer to list
+ * @return      Pointer to past-the-end node of the list
+ */
+list_node_t* (list_end)      (list_t *l);
+/**
+ * @brief Get size of the list.
+ * @param   l   Pointer to list
+ * @return      Size of the list
+ */
+size_t       (list_size)     (const list_t *l);
+/**
+ * @brief Know if list is empty or not.
+ * @param   l   Pointer to list
+ * @return      true if the list is empty (size is zero), false otherwise
+ */
+int          (list_empty)    (const list_t *l);
+/**
+ * @brief Insert value in list.
+ * @param   l           Pointer to list
+ * @param   position    Pointer to node, before which the new value will be inserted
+ * @param   val         Value to be inserted before position
+ * @return              Pointer to newly-created node
+ */
+list_node_t* (list_insert)   (list_t *l, list_node_t *position, void *val);
+/**
+ * @brief Erase value in list.
+ * @param   l           Pointer to list
+ * @param   position    Node to be deleted
+ * @return  Value contained in the deleted node, which must be free'd if appropriate
+ */
+void*        (list_erase)    (list_t *l, list_node_t *position);
+/**
+ * @brief Insert new value at the end of the list.
+ * @param   l   Pointer to list
+ * @param   val Value to be inserted
+ */
 void         (list_push_back)(list_t *l, void *val);
-void**       (list_front)(list_t *l);
+/**
+ * @brief Get first element of the list.
+ * @param   l   Pointer to list
+ * @return      Pointer to value at the beginning of the list
+ */
+void**       (list_front)    (list_t *l);
+/**
+ * @brief Erase first element of the list.
+ * @param   l   Pointer to list
+ */
 void         (list_pop_front)(list_t *l);
-list_node_t* (list_find)(list_t *l, void *val);
+/**
+ * @brief Find value in list.
+ *
+ * Values are found by direct comparison of void*
+ * @param   l   Pointer to list
+ * @param   val Pointer to value to be found in the list
+ * @return  Node whose value compares equal to val, or past-the-end node if not found
+ */
+list_node_t* (list_find)     (list_t *l, void *val);
 
 #endif //LIST_H_INCLUDED
Index: proj/libs/classes/include/queue.h
===================================================================
--- proj/libs/classes/include/queue.h	(revision 315)
+++ proj/libs/classes/include/queue.h	(revision 316)
@@ -2,16 +2,56 @@
 #define QUEUE_H_INCLUDED
 
 struct queue;
+/**
+ * @brief Queue.
+ *
+ * Can be used like a C++ std::queue.
+ * A queue_t is an interface for a list_t that simulates a FIFO.
+ */
 typedef struct queue queue_t;
 
-const size_t queue_max_size;
-
+/**
+ * @brief Construct empty queue.
+ * @return  Pointer to created queue
+ */
 queue_t* (queue_ctor )(void);
+/**
+ * @brief Destruct queue.
+ *
+ * A queue can only be destroyed once it is empty.
+ * This is because a queue stores void*, whose memory most likely need to be free'd.
+ * @param   q   Pointer to queue to be destroyed
+ * @return      SUCCESS if the destruction was successful, other value otherwise.
+ */
 int      (queue_dtor )(queue_t *q);
+/**
+ * @brief Get size of the queue.
+ * @param   q   Pointer to queue
+ * @return      Size of the queue
+ */
 size_t   (queue_size )(const queue_t *q);
+/**
+ * @brief Know if queue is empty or not.
+ * @param   q   Pointer to queue
+ * @return      true if the queue is empty (size is zero), false otherwise
+ */
 int      (queue_empty)(const queue_t *q);
+/**
+ * @brief Insert new value in the queue.
+ * @param   q   Pointer to queue
+ * @param   val Value to be inserted
+ */
 void     (queue_push )(queue_t *q, void *val);
+/**
+ * @brief Get next element in the queue.
+ * @param   q   Pointer to queue
+ * @return      Value at the beginning of the queue
+ */
 void*    (queue_top  )(const queue_t *q);
+/**
+ * @brief Erase next element of the queue.
+ * @param   q   Pointer to queue
+ */
 void     (queue_pop  )(queue_t *q);
 
 #endif //QUEUE_H_INCLUDED
Index: proj/libs/classes/src/list.c
===================================================================
--- proj/libs/classes/src/list.c	(revision 315)
+++ proj/libs/classes/src/list.c	(revision 316)
@@ -6,6 +6,7 @@
     list_node_t *p, *n;
     void *val;
 };
+
 list_node_t* (list_node_ctor)(list_node_t *p, list_node_t *n, void *val){
     list_node_t *ret = malloc(sizeof(list_node_t));
     if(ret == NULL) return NULL;
@@ -14,7 +15,7 @@
     ret->val = val;
     return ret;
 }
-void (list_node_dtor)(list_node_t *p){
+void         (list_node_dtor)(list_node_t *p){
     free(p);
 }
 list_node_t* (list_node_next)(const list_node_t *p){ return p->n; }
@@ -26,7 +27,8 @@
     list_node_t *end_;
     size_t sz;
 };
-list_t* (list_ctor)(void){
+
+list_t*      (list_ctor)     (void){
     list_t *ret = malloc(sizeof(list_t));
     if(ret == NULL) return NULL;
     ret->sz = 0;
@@ -41,7 +43,7 @@
     ret->end_  ->p = ret->begin_;
     return ret;
 }
-int (list_dtor)(list_t *l){
+int          (list_dtor)     (list_t *l){
     if(l == NULL) return 0;
     if(list_size(l) > 0) return 1;
     list_node_dtor(l->begin_);
@@ -49,11 +51,11 @@
     free(l);
     return 0;
 }
-list_node_t* (list_begin )(      list_t *l){ return l->begin_->n; }
-list_node_t* (list_end   )(      list_t *l){ return l->end_; }
-size_t       (list_size  )(const list_t *l){ return l->sz; }
-int          (list_empty )(const list_t *l){ return !(l->sz); }
-list_node_t* (list_insert)(list_t *l, list_node_t *position, void *val){
+list_node_t* (list_begin)    (list_t *l){ return l->begin_->n; }
+list_node_t* (list_end)      (list_t *l){ return l->end_; }
+size_t       (list_size)     (const list_t *l){ return l->sz; }
+int          (list_empty)    (const list_t *l){ return (l->sz ? true : false); }
+list_node_t* (list_insert)   (list_t *l, list_node_t *position, void *val){
     list_node_t *node = list_node_ctor(position->p, position, val);
     position->p->n = node;
     position->p    = node;
@@ -60,7 +62,7 @@
     ++l->sz;
     return node;
 }
-void*        (list_erase )(list_t *l, list_node_t *position){
+void*        (list_erase)    (list_t *l, list_node_t *position){
     position->p->n = position->n;
     position->n->p = position->p;
     void *ret = position->val;
@@ -71,13 +73,13 @@
 void         (list_push_back)(list_t *l, void *val){
     list_insert(l, list_end(l), val);
 }
-void**       (list_front)(list_t *l){
+void**       (list_front)    (list_t *l){
     return list_node_val(list_begin(l));
 }
 void         (list_pop_front)(list_t *l){
     list_erase(l, list_begin(l));
 }
-list_node_t* (list_find)(list_t *l, void *val){
+list_node_t* (list_find)     (list_t *l, void *val){
     list_node_t *it = list_begin(l);
     while(it != list_end(l) && *list_node_val(it) != val){
         it = list_node_next(it);
Index: proj/libs/classes/src/queue.c
===================================================================
--- proj/libs/classes/src/queue.c	(revision 315)
+++ proj/libs/classes/src/queue.c	(revision 316)
@@ -5,8 +5,6 @@
 #include "list.h"
 #include "errors.h"
 
-const size_t queue_max_size = UINT_MAX;
-
 struct queue{
     list_t *l;
 };
Index: proj/libs/uart/src/uart.c
===================================================================
--- proj/libs/uart/src/uart.c	(revision 315)
+++ proj/libs/uart/src/uart.c	(revision 316)
@@ -313,13 +313,6 @@
 }
 
 int nctp_send(size_t num, uint8_t* ptr[], size_t sz[]){
-    {
-        size_t cnt = 0;
-        for(size_t i = 0; i < num; ++i){
-            cnt += sz[i];
-            if(cnt > queue_max_size) return TRANS_REFUSED;
-        }
-    }
     int ret;
     uint8_t *tmp;
     tmp = malloc(sizeof(uint8_t)); *tmp = NCTP_START; queue_push(out, tmp);
Index: proj/tasks.md
===================================================================
--- proj/tasks.md	(revision 315)
+++ proj/tasks.md	(revision 316)
@@ -3,12 +3,16 @@
 ### Most priority
 - [ ] Implement multiplayer 1v1 game and win condition to reach N kills.
 - [ ] Leaderboard of fastest win, or any achievement (to make use of RTC).
+- [ ] Documentation
+- [ ] Report
 
 ### Mid priority
-- [ ] Implement path finding for melee AI.
-- [ ] Implement zombie mode (single-player or co-op).
+- [x] Implement path finding for melee AI.
+- [x] Implement zombie mode (single-player)
+- [ ] Implement zombie mode (co-op)
 - [ ] Implement algorithm to decide when gunner AI needs to shoot.
-- [ ] Implement campaign mode (single-player or co-op).
+- [ ] Implement campaign mode (single-player)
+- [ ] Implement campaign mode (co-op).
 - [ ] Visibility algorithm
 
 ### Low Priority
