/ - Diff - LCOM1920-T5G03 - FEUP Project Manager

     #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

     #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

         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;
-...
         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; }
-...
         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;
-...
         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_);
-...
         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;
         ++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;
-...
     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);

     #include "list.h"
     #include "errors.h"
     const size_t queue_max_size = UINT_MAX;
     struct queue{
         list_t *l;
     };

+    }
     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);

     ### 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

Project

General

Profile

LCOM1920-T5G03

Revision 316