LCOM1920-T5G03

#ifndef CAMPAIGN_H_INCLUDED

#define CAMPAIGN_H_INCLUDED

int (campaign)(void);

#endif //CAMPAIGN_H_INCLUDED

#ifndef CHAT_H_INCLUDED

#define CHAT_H_INCLUDED

int (chat)(void);

#endif //CHAT_H_INCLUDED

#ifndef PROJ_FUNC_H_INCLUDED

#define PROJ_FUNC_H_INCLUDED

/**

 * @defgroup proj_func proj_func

 * @brief Project helper functions.

 *

 * @{

 */

#include "libs.h"

#include "proj_structures.h"

//#include <stdint.h>

/**

 * @brief Cleans up all memory, unsubscribes interrupts.

 * @return ERROR_CODE code representing the result of the operation, SUCCESS code is returned if everything is OK

 * @see {_ERRORS_H_::errors}

 */

int cleanup(void);

/**

 * @brief Update key presses.

 */

void update_key_presses(void);

/**

 * @brief Get key presses.

 * @return  keys_t containing key presses

 */

keys_t* (get_key_presses)(void);

/**

 * @brief Update mouse.

 */

void update_mouse(struct packet *p);

/**

 * @brief Get pointer to mouse X-position.

 * @return  Pointer to mouse X-position.

 */

int16_t* get_mouse_X(void);

/**

 * @brief Get pointer to mouse Y-position.

 * @return  Pointer to mouse Y-position.

 */

int16_t* get_mouse_Y(void);

/**

 * @brief Get cursor angle relative to a gunner in the screen.

 * @param   p   Pointer to gunner

 * @return      Angle of the mouse relative to the gunner

 */

double get_mouse_angle(gunner_t *p);

/**

 * @brief Updates movement variables.

 */

void update_movement(map_t *map, gunner_t *p, keys_t *keys, list_t *shooter_list);

/**

 * @brief Get random spawn (actually, position) for new gunner.

 *

 * The new position cannot collide with the map, nor with any of the gunners

 * already in the list.

 * @param   map     Pointer to map

 * @param   p       Pointer to new gunner

 * @param   l       List of gunners that already exist

 */

void (get_random_spawn)(const map_t *map, gunner_t *p, list_t *l);

/**

 * @brief Update scale if the keys were pressed to change scale.

 */

void update_scale(void);

/**

 * @brief Shoot a bullet.

 * @param   shooter     Pointer to gunner that shot the bullet

 * @param   bullet_list List of the bullets in the map

 * @param   bsp_bullet  Basic sprite that will be used to render the bullet

 */

void (shoot_bullet)(const gunner_t *shooter, list_t *bullet_list, const basic_sprite_t *bsp_bullet);

/**

 * @brief Update game state.

 *

 * This includes moving bullets accordingly, processing damages, collisions of

 * bullets with walls, melee damage for the gunners that have autonomous melee.

 * @param   map             Pointer to map

 * @param   shooter_list    List of shooters

 * @param   bullet_list     List of bullets in the map

 */

void (update_game_state)(const map_t *map, list_t *shooter_list, list_t *bullet_list);

/**

 * @brief Wrapper to easen filling of the host_info_t.

 * @param   p       Host info to fill

 * @param   host    Host gunner

 * @param   remote  Remote gunner

 */

void build_host_structure(host_info_t *p, gunner_t *host, gunner_t *remote);

/**

 * @brief Wrapper to easen filling of the remote_info_t.

 * @param   p       Remote info to fill

 * @param   keys    Key presses of remote

 * @param   angle   Mouse angle of remote

 */

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

/**

 * @}

 */

/**

 * @defgroup text_timer_t text_timer_t

 * @ingroup proj_func

 * @brief Text timer.

 *

 * @{

 */

/**

 * @brief Text timer.

 */

typedef struct {

    /// @brief Time since construction.

    int time;

    /// @brief Text.

    text_t *text;

} text_timer_t;

/**

 * @brief Construct timer

 * @param   fnt Font used to render timer text

 * @return      Pointer to constructed timer, or NULL if failed

 */

text_timer_t* (text_timer_ctor)(const font_t *fnt);

/**

 * @brief Destruct timer.

 * @param   p   Pointer to timer to be destructed

 */

void (text_timer_dtor)(text_timer_t *p);

/**

 * @brief   Update timer, by incrementing the number of seconds.

 * @param   p   Pointer to timer

 */

void (text_timer_update)(text_timer_t *p);

/**

 * @brief   Reset timer to 0.

 * @param   p   Pointer to timer

 */

void (text_timer_reset)(text_timer_t *p);

/**

 * @}

 */

#endif /* end of include guard: PROJ_FUNC_H_INCLUDED */

#ifndef MAKE_CODE_MAP_H_

#define MAKE_CODE_MAP_H_

/**

 * @defgroup makecode_map makecode_map

 * @brief Makecode map.

 *

 * @{

 */

#include <stdint.h>

/// @brief Error code

#define ERROR_CODE      0

/**

 * @brief Maps make code into char

 * @param code      Make code to map.

 * @return ERROR_CODE if code char isn't valid, otherwise the character.

 */

char (map_makecode)(uint8_t code);

/**

 * @}

 */

#endif /* end of include guard: MAKE_CODE_MAP_H_ */

#ifndef ENT_H_INCLUDED

#define ENT_H_INCLUDED

/**

 * @defgroup ent ent

 * @brief Entities module

 *

 * @{

 */

#include "libs.h"

/**

 * @brief Set scale.

 * @param   n   Scale

 */

void (ent_set_scale) (double n);

/**

 * @brief Set origin of screen (upper-left corner) in game referential coordinates.

 * @param   x   X-position of the upper-left corner of the screen

 * @param   y   Y-position of the upper-left corner of the screen

 */

void (ent_set_origin)(double x, double y);

/**

 * @brief Get scale.

 * @return  Scale

 */

double (ent_get_scale)  (void);

/**

 * @brief Get X-length of the screen in game referencial coordinates.

 * @return X-length

 */

double (ent_get_XLength)(void);

/**

 * @brief Get Y-length of the screen in game referencial coordinates.

 * @return Y-length

 */

double (ent_get_YLength)(void);

/**

 * @}

 */

/**

 * @defgroup gunner_t gunner_t

 * @ingroup ent

 * @brief Gunner module.

 *

 * @{

 */

/// @brief Identifier of a melee gunner

#define GUNNER_MELEE    BIT(0)

/// @brief Identifier of a ranged gunner

#define GUNNER_RANGED   BIT(1)

/// @brief Identifier of a player-controlled gunner

#define GUNNER_PLAYER   BIT(2)

/// @brief Identifier of an automatic follower gunner

#define GUNNER_FOLLOW   BIT(3)

/**

 * @brief Gunner.

 */

typedef struct gunner gunner_t;

/**

 * @brief Construct gunner.

 * @param   dude    Basic sprite representing the gunner

 * @param   weapon  Basic sprite representing the weapon of the gunner

 * @param   type    Type of gunner. Can be one of the identifier macros and also the OR-merge of any combination of them

 * @param   team    Team of the gunner. 1 for player 1, 2 for player 2, 3 for opponents and 0 for no team (temporary gunner)

 */

gunner_t* (gunner_ctor)(basic_sprite_t *dude, basic_sprite_t *weapon, uint16_t type, int team);

/**

 * @brief Destruct gunner.

 * @param   p   Pointer to gunner to be destructed

 */

void      (gunner_dtor)(gunner_t *p);

/**

 * @brief   Set gunner position.

 * @param   p   Pointer to gunner

 * @param   x   X-position of the gunner in game coordinates

 * @param   y   Y-position of the gunner in game coordinates

 */

void (gunner_set_pos)               (gunner_t *p, double x, double y);

/**

 * @brief   Set gunner spawn position.

 * @param   p   Pointer to gunner

 * @param   x   Spawn X-position of the gunner in game coordinates

 * @param   y   Spawn Y-position of the gunner in game coordinates

 */

void (gunner_set_spawn)             (gunner_t *p, double x, double y);

/**

 * @brief   Set gunner angle.

 * @param   p       Pointer to gunner

 * @param   angle   Angle in radians

 */

void (gunner_set_angle)             (gunner_t *p, double angle);

/**

 * @brief   Set gunner health (total, max health).

 * @param   p       Pointer to gunner

 * @param   health  Health

 */

void (gunner_set_health)            (gunner_t *p, double health);

/**

 * @brief   Set gunner current health.

 * @param   p       Pointer to gunner

 * @param   health  Current health

 */

void (gunner_set_curr_health)       (gunner_t *p, double health);

/**

 * @brief   Get gunner X-position.

 * @param   p   Pointer to gunner

 * @return  X-position of the gunner

 */

double  (gunner_get_x)              (const gunner_t *p);

/**

 * @brief   Get gunner Y-position.

 * @param   p   Pointer to gunner

 * @return  Y-position of the gunner

 */

double  (gunner_get_y)              (const gunner_t *p);

/**

 * @brief   Get gunner spawn X-position.

 * @param   p   Pointer to gunner

 * @return  Spawn X-position of the gunner

 */

double  (gunner_get_spawn_x)        (const gunner_t *p);

/**

 * @brief   Get gunner spawn Y-position.

 * @param   p   Pointer to gunner

 * @return  Spawn Y-position of the gunner

 */

double  (gunner_get_spawn_y)        (const gunner_t *p);

/**

 * @brief   Get gunner angle.

 * @param   p   Pointer to gunner

 * @return  Angle of the gunner

 */

double  (gunner_get_angle)          (const gunner_t *p);

/**

 * @brief   Get gunner max health.

 * @param   p   Pointer to gunner

 * @return  Max health of the gunner

 */

double  (gunner_get_health)         (const gunner_t *p);

/**

 * @brief   Get gunner current health.

 * @param   p   Pointer to gunner

 * @return  Current health of the gunner

 */

double  (gunner_get_curr_health)    (const gunner_t *p);

/**

 * @brief   Get gunner X-position in screen coordinates.

 * @param   p   Pointer to gunner

 * @return  X-position of the gunner in screen coordinates

 */

int16_t (gunner_get_x_screen)       (const gunner_t *p);

/**

 * @brief   Get gunner Y-position in screen coordinates.

 * @param   p   Pointer to gunner

 * @return  Y-position of the gunner in screen coordinates

 */

int16_t (gunner_get_y_screen)       (const gunner_t *p);

/**

 * @brief   Get gunner type.

 * @param   p   Pointer to gunner

 * @return  Type of gunner

 */

uint16_t (gunner_get_type)          (const gunner_t *p);

/**

 * @brief   Get gunner team.

 * @param   p   Pointer to gunner

 * @return  Team of gunner

 */

int     (gunner_get_team)           (const gunner_t *p);

/**

 * @brief   Draw gunner on screen buffer.

 * @param   p   Pointer to gunner

 */

void (gunner_draw)(gunner_t *p);

/**

 * @brief   Draw gunner health bar on screen buffer.

 * @param   p   Pointer to gunner

 */

void (gunner_draw_health)(const gunner_t *p);

/**

 * @brief   Draw list of gunners on screen buffer.

 * @param   shooter_list    List of gunners

 */

void (gunner_draw_list)(list_t *shooter_list);

/**

 * @brief Get distance between two gunners.

 * @param   p1  Gunner 1

 * @param   p2  Gunner 2

 * @return  Euclidian distance between the two gunners

 */

double (gunner_distance)(const gunner_t *p1, const gunner_t *p2);

/**

 * @brief Check if two gunners are colliding.

 * @param   p1  Gunner 1

 * @param   p2  Gunner 2

 * @return  true if the two gunners are colliding, false otherwise

 */

int (gunner_collides_gunner)(const gunner_t *p1, const gunner_t *p2);

/**

 * @}

 */

/**

 * @defgroup bullet_t bullet_t

 * @ingroup ent

 * @brief Bullet module.

 *

 * @{

 */

/**

 * @brief Bullet.

 */

typedef struct bullet bullet_t;

/**

 * @brief Construct bullet.

 * @param   shooter Pointer to gunner that shot that bullet

 * @param   b       Basic sprite of the bullet

 * @param   x       X-position

 * @param   y       Y-position

 * @param   vx      X-speed

 * @param   vy      Y-speed

 * @return Pointer to constructed bullet, or NULL if failed

 */

bullet_t* (bullet_ctor)(const gunner_t *shooter, const basic_sprite_t *b, double x, double y, double vx, double vy);

/**

 * @brief Destruct bullet.

 * @param   p   Pointer to bullet to be destructed

 */

void      (bullet_dtor)(bullet_t *p);

/**

 * @brief   Get bullet X-position.

 * @param   p   Pointer to bullet

 * @return  X-position of the bullet

 */

double  (bullet_get_x)       (const bullet_t *p);

/**

 * @brief   Get bullet Y-position.

 * @param   p   Pointer to bullet

 * @return  Y-position of the bullet

 */

double  (bullet_get_y)       (const bullet_t *p);

/**

 * @brief   Get bullet X-speed.

 * @param   p   Pointer to bullet

 * @return  X-speed of the bullet

 */

double  (bullet_get_vx)      (const bullet_t *p);

/**

 * @brief   Get bullet Y-speed.

 * @param   p   Pointer to bullet

 * @return  Y-speed of the bullet

 */

double  (bullet_get_vy)      (const bullet_t *p);

/**

 * @brief   Get bullet X-position in screen coordinates.

 * @param   p   Pointer to bullet

 * @return  X-position of the bullet in screen coordinates

 */

int16_t (bullet_get_x_screen)(const bullet_t *p);

/**

 * @brief   Get bullet Y-position in screen coordinates.

 * @param   p   Pointer to bullet

 * @return  Y-position of the bullet in screen coordinates

 */

int16_t (bullet_get_y_screen)(const bullet_t *p);

/**

 * @brief   Get bullet damage.

 * @param   p   Pointer to bullet

 * @return  Damage

 */

double  (bullet_get_damage)  (const bullet_t *p);

/**

 * @brief   Set bullet damage.

 * @param   p   Pointer to bullet

 * @param   damage  Damage

 */

void    (bullet_set_damage)  (bullet_t *p, double damage);

/**

 * @brief Get gunner that shot the bullet.

 * @param   p   Pointer to bullet

 * @return  Pointer to gunner that shot the bullet

 */

const gunner_t* (bullet_get_shooter)(const bullet_t *p);

/**

 * @brief Update bullet position (i.e., advance it according to its speed).

 * @param   p   Pointer to bullet

 */

void (bullet_update_movement)(bullet_t *p);

/**

 * @brief Update movement of bullets in a list.

 * @param   bullet_list     Pointer to bullet list

 */

void (bullet_update_movement_list)(list_t *bullet_list);

/**

 * @brief Draw bullet on screen buffer.

 * @param   p   Pointer to bullet

 */

void (bullet_draw)(bullet_t *p);

/**

 * @brief Draw bullets in list on screen buffer.

 * @param   bullet_list     Pointer to bullet list

 */

void (bullet_draw_list)(list_t *bullet_list);

/**

 * @}

 */

/**

 * @defgroup map_t map_t

 * @ingroup ent

 * @brief Bullet module.

 *

 * @{

 */

/**

 * @brief Map.

 */

typedef struct map map_t;

/**

 * @brief Construct map.

 * @param   background  XPM describing map as it should be rendered

 * @param   collide     XPM with transparency describing what parts of the map will cause collision

 * @return  Pointer to constructed map, or NULL if failed

 */

map_t* (map_ctor)(const char *const *background, const char *const *collide);

/**

 * @brief Destruct map.

 * @param   p   Pointer to map to be destructed

 */

void   (map_dtor)(map_t *p);

/**

 * @brief Get map width.

 * @param   p   Pointer to map

 * @return      Width of map

 */

uint16_t (map_get_width)   (const map_t *p);

/**

 * @brief Get map height.

 * @param   p   Pointer to map

 * @return      Height of map

 */

uint16_t (map_get_height)  (const map_t *p);

/**

 * @brief Use Dijkstra's path-finding algorithm.

 *

 * Allows a follower to know where to move so it gets closer to a given target.

 *

 * This function is implemented in a clever way that reduces the time of execution.

 * On the other hand, it might not always give the shortest path, but it is

 * guaranteeed to provide a decent, valid path to the target.

 *

 * @param   p   Pointer to map

 * @param   x_  X-position of the target

 * @param   y_  Y-position of the target

 * @return  SUCCESS if operation is successful, false otherwise

 */

int (map_make_dijkstra)(map_t *p, double x_, double y_);

/**

 * @brief Get the direction a follower should move to get closer to the target.

 * @param   p       Pointer to map

 * @param   x       X-position of the follower

 * @param   y       Y-position of the follower

 * @param   theta   Pointer to angle that will be updated

 * @return SUCCESS if operation was successful, other value otherwise

 */

int (map_where_to_follow)(const map_t *p, double x, double y, double *theta);

/**

 * @brief Draw map on screen buffer.

 * @param   p   Pointer to map

 */

void   (map_draw)(map_t *p);

/**

 * @brief Evaluate if point collides with map.

 * @param   p   Pointer to map

 * @param   x   X-position of the point

 * @param   y   Y-position of the point

 * @return true if the point collides with the map, false otherwise

 */

int    (map_collides_point)(const map_t *p, double x, double y);

/**

 * @}

 */

/**

 * @brief Evaluate if gunner is colliding with map.

 * @param   p       Pointer to map

 * @param   gunner  Pointer to gunner

 * @return true if the gunner collides with the map, false otherwise

 */

int    (map_collides_gunner)(const map_t *p, const gunner_t *gunner);

/**

 * @brief Evaluate if bullet is colliding with map.

 * @param   p       Pointer to map

 * @param   bullet  Pointer to bullet

 * @return true if the bullet collides with the map, false otherwise

 */

int    (map_collides_bullet)(const map_t *p, const bullet_t *bullet);

/**

 * @brief Evaluate if bullet is colliding with gunner.

 * @param   shooter     Pointer to gunner

 * @param   bull        Pointer to bullet

 * @return true if the bullet collides with the gunner, false otherwise

 */

int (gunner_collides_bullet)(const gunner_t *shooter, const bullet_t *bull);

#endif //ENT_H_INCLUDED

#ifndef SCOREBOARD_H_INCLUDED

#define SCOREBOARD_H_INCLUDED

/**

 * @defgroup scoreboards scoreboards

 * @brief Scoreboards module.

 *

 * @{

 */

#include "libs.h"

#include <stdint.h>

/**

 * @brief Score.

 */

typedef struct  score_info score_info_t;

/**

 * @brief Table of highscores.

 */

typedef struct highscores highscores_t;

/**

 * @brief Construct score.

 * @param   score           Game score.

 * @param   time_played     Time elapsed on game.

 * @return      Pointer to constructed score, or NULL if failed.

 */

score_info_t* (score_ctor)(int score, int time_played);

/**

 * @brief Destruct score.

 * @param   p   Pointer to score to destruct

 */

void (score_dtor)(score_info_t *p);

/**

 * @brief Construct highscores.

 * @param   fnt     Font to use when rendering highscores text

 * @param   path    Path to file to be read with highscores values.

 * @return      Pointer to constructed highscores, or NULL if failed.

 */

highscores_t* (highscores_ctor)(const font_t *fnt, const char *path);

/**

 * @brief Save highscore into file.

 * @param f     Path to file to be written

 */

void (highscores_save)(const highscores_t *p, const char *path);

/**

 * @brief Destruct menu.

 * @param   p   Pointer to menu to destruct

 */

void (highscores_dtor)(highscores_t *p);

/**

 * @}

 */

#endif /* end of include guard: SCOREBOARD_H_INCLUDED */

#ifndef ZOMBIES_H_INCLUDED

#define ZOMBIES_H_INCLUDED

int (zombies)(void);

#endif //ZOMBIES_H_INCLUDED

#ifndef INTERRUPTS_FUNC_H_INCLUDED

#define INTERRUPTS_FUNC_H_INCLUDED

/**

 * @defgroup interrupts_func interrupts_func

 * @brief Interrupts functions.

 *

 * @{

 */

#include "libs.h"

/**

 * @brief Subscribes all drivers used (timer->keyboard->mouse)

 * @return ERROR_CODE code representing the result of the operation, SUCCESS code is returned if everything is OK

 * @see {_ERRORS_H_::errors}

 */

int (subscribe_all)(void);

/**

 * @brief Unsubscribes all subscribed interrupts

 * @return ERROR_CODE code representing the result of the operation, SUCCESS code is returned if everything is OK

 * @see {_ERRORS_H_::errors}

 */

int (unsubscribe_all)(void);

/**

 * @brief Calls interrupt handler corresponding to the bit specified by the argument.

 * @param handler Interrupt handler to call

 */

void interrupt_handler(uint8_t handler);

/**

 * @brief Blocking function that waits for an interrupt to occur.

 *

 * Rewrites the provided argument with the interrupt vector it gets.

 *

 * This function decisively reduces the complexity of an interrupt cycle, allowing

 * for each menu to have its own, simplified interrupt cycle.

 * @param   p   Pointer where interrupt vector will be saved

 */

int get_interrupts_vector(uint64_t *p);

/**

 * @}

 */

#endif /* end of include guard: INTERRUPTS_FUNC_H_INCLUDED */

#ifndef PROJ_H_INCLUDED

#define PROJ_H_INCLUDED

#include "libs.h"

#include "ent.h"

basic_sprite_t       *bsp_crosshair;

basic_sprite_t       *bsp_shooter  ;

basic_sprite_t       *bsp_zombie   ;

basic_sprite_t       *bsp_pistol   ;

basic_sprite_t       *bsp_nothing  ;

basic_sprite_t       *bsp_bullet   ;

map_t                *map1         ;

sprite_t             *sp_crosshair ;

#endif //PROJ_H_INCLUDED

#ifndef PROJ_STRUCTURES_H_INCLUDED

#define PROJ_STRUCTURES_H_INCLUDED

/**

 * @defgroup proj_structures proj_structures

 * @brief Project structures.

 *

 * @{

 */

#include <stdint.h>

#include "ent.h"

/**

 * @}

 */

/**

 * @defgroup keys_t keys_t

 * @ingroup proj_structures

 * @brief Keys pressed module.

 *

 * @{

 */

/**

 * @brief Keys pressed.

 */

typedef struct {

    /// @brief W is pressed when 1

    uint8_t w_pressed       : 1;

    /// @brief A is pressed when 1

    uint8_t a_pressed       : 1;

    /// @brief S is pressed when 1

    uint8_t s_pressed       : 1;

    /// @brief D is pressed when 1

    uint8_t d_pressed       : 1;

    /// @brief Ctrl is pressed when 1

    uint8_t ctrl_pressed    : 1;

    /// @brief Plus (+) is pressed when 1

    uint8_t plus_pressed    : 1;

    /// @brief Minus (-) is pressed when 1

    uint8_t minus_pressed   : 1;

    /// @brief Mouse left button is pressed when 1

    uint8_t lb_pressed      : 1;

} keys_t;

/**

 * @}

 */

/**

* @defgroup host_info_t host_info_t

* @ingroup proj_structures

* @brief Host info module.

*

* @{

*/

/**

 * @brief Information to transmit from host to remote.

 */

typedef struct {

    // host

    /// @brief Host player X-position

    int16_t    host_x;

    /// @brief Host player Y-postition

    int16_t    host_y;

    /// @brief Host player angle

    float      host_angle;

    /// @brief Host player health

    int16_t    host_health;

    /// @brief Host player current health

    int16_t    host_current_health;

    // remote

    /// @brief Remote player X-position

    int16_t    remote_x;

    /// @brief Remote player Y-postition

    int16_t    remote_y;

    /// @brief Remote player angle

    float      remote_angle;

    /// @brief Remote player health

    int16_t    remote_health;

    /// @brief Remote player current health

    int16_t    remote_current_health;

    /*

    // bullets

    /// @brief Number of bullets

    uint8_t    no_bullets;

    /// @brief X-position of the bullets

    int16_t   *bullets_x;

    /// @brief Y-position of the bullets

    int16_t   *bullets_y;

    /// @brief X-speed of the bullets

    int16_t   *bullets_vx;

    /// @brief Y-speed of the 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.

 * @param   host    Pointer to host gunner

 * @param   remote  Pointer to remote gunner

 * @return  Pointer to constructed host information, or NULL if failed

 */

host_info_t* host_info_ctor(gunner_t *host, gunner_t *remote);

/**

 * @brief Destruct host information.

 * @param   p   Pointer to host information to be destructed

 */

void host_info_dtor(host_info_t *p);

/**

 * @}

 */

/**

* @defgroup remote_info_t remote_info_t

* @ingroup proj_structures

* @brief Remote info module.

*

* @{

*/

/**

 * @brief Information to transmit from remote to host.

 */

typedef struct {

    /// @brief Remote keys that are pressed

    keys_t  remote_keys_pressed;

    /// @brief Remote player angle

    double  remote_angle;

} remote_info_t;

/**

 * @brief Construct remote information.

 * @return  Pointer to constructed remote information, or NULL if failed

 */

remote_info_t* remote_info_ctor(void);

/**

 * @brief Destruct remote information.

 * @param   p   Pointer to remote information to be destructed

 */

void remote_info_dtor(remote_info_t *p);

/**

 * @}

 */

/**

* @defgroup bullet_info_t bullet_info_t

* @ingroup proj_structures

* @brief Bullet event module.

*

* @{

*/

/**

 * @brief Bullet event to transmit from remote to host.

 */

typedef struct {

    /// @brief New bullet signal from remote

    bool   new_bullet;

} bullet_info_t;

/**

 * @brief Construct bullet event.

 * @return  Pointer to constructed bullet event, or NULL if failed

 */

bullet_info_t* bullet_info_ctor(void);

/**

 * @brief Destruct bullet event.

 * @param   p   Pointer to bullet event to be destructed

 */

void bullet_info_dtor(bullet_info_t *p);

/**

 * @}

 */

#endif /* end of include guard: PROJ_STRUCTURES_H_INCLUDED */

#ifndef SINGLEPLAYER_H_INCLUDED

#define SINGLEPLAYER_H_INCLUDED

int (singleplayer)(void);

#endif //SINGLEPLAYER_H_INCLUDED

#ifndef PROJ_MACROS_H_INCLUDED

#define PROJ_MACROS_H_INCLUDED

/**

 * @defgroup proj_macros proj_macros

 * @brief Project macros.

 *

 * @{

 */

// Movement Directions

/** @brief Moving to the top side of screen */

#define UP      -1

/** @brief Moving to the bottom side of screen */

#define DOWN    1

/** @brief Moving to the left side of screen */

#define LEFT    -1

/** @brief Moving to the right side of screen */

#define RIGHT   1

/** @brief Not moving */

#define REST    0

// Movement Constants

/** @brief Shooter speed */

#define SHOOTER_SPEED   5

/** @brief Bullet speet */

#define BULLET_SPEED    8

// Refresh Rate

/** @brief Screen refresh rate */

#define REFRESH_RATE    60

//Graphics mode

/** @brief Graphic mode used */

#define GRAPH_MODE      DIRECT_1024_768_888

/** @brief Minimum zoom */

#define MIN_SCALE       0.2

/** @brief Default zoom */

#define DEFAULT_SCALE   0.5

/** @brief Maximum zoom */

#define MAX_SCALE       10.0

// Colors

/** @brief Text color */

#define TEXT_COLOR              0xFFFFFF

/** @brief Highlight color */

#define HIGHLIGHT_COLOR         0x404040

/** @brief Delimiter color */

#define DELIMITER_COLOR         0x404040

/** @brief Melee attacks range */

#define MELEE_RANGE    80

/** @brief Melee attack damage (for zombies). */

#define MELEE_DAMAGE   1

/** @brief Zombie speed */

#define ZOMBIE_SPEED    1.0

/**

 * @}

 */

#endif /* end of include guard: PROJ_MACROS_H_INCLUDED */

#include <lcom/lcf.h>

#include "singleplayer.h"

#include "proj.h"

#include "proj_macros.h"

#include "proj_func.h"

#include "ent.h"

#include "interrupts_func.h"

#include "libs.h"

#include "campaign.h"

#include "zombies.h"

int (singleplayer)(void) {

    int r;

    menu_t *main_menu = menu_ctor(font_get_default());

    menu_add_item(main_menu, "Campaign");

    menu_add_item(main_menu, "Zombies");

    menu_add_item(main_menu, "Back");

    //uint32_t refresh_count_value = sys_hz() / REFRESH_RATE;

    uint8_t last_lb = 0;

    struct packet pp;

    keys_t *keys = get_key_presses();

    /// loop stuff

    int click = 0;

    uint64_t int_vector = 0;

    int good = true;

    while (good) {

        /* Get a request message. */

        if((r = get_interrupts_vector(&int_vector))) return r;

        uint32_t n = 1;

        for (uint8_t i = 0; i < 32; i++, n <<= 1) {

            if (int_vector & n) {

                interrupt_handler(i);

                switch (i) {

                    case TIMER0_IRQ:

                    graph_clear_screen();

                    switch(menu_update_state(main_menu, click)){

                        case -1: break;

                        case  0: campaign(); break;

                        case  1: zombies(); break;

                        case  2: good = false; break;

                    }

                    menu_draw(main_menu);

                    click = 0;

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

                    sprite_draw(sp_crosshair);

                    graph_draw();

                    break;

                    case KBC_IRQ:

                    if (keyboard_get_scancode()[0] == ESC_BREAK_CODE) good = false;

                    case MOUSE_IRQ:

                    if (mouse_get_counter_mouse_ih() >= 3) {

                        mouse_parse_packet(mouse_get_packet_mouse_ih(), &pp);

                        update_mouse(&pp);

                        if (!click) click = last_lb ^ keys->lb_pressed && keys->lb_pressed;

                        last_lb = keys->lb_pressed;

                        mouse_set_counter_mouse_ih(0);

                    }

                    break;

                    case COM1_IRQ: nctp_ih(); break;

                }

            }

        }

    }

    return 0;

}

#include <lcom/lcf.h>

#include "chat.h"

#include "proj.h"

#include "proj_macros.h"

#include "proj_func.h"

#include "ent.h"

#include "interrupts_func.h"

#include "libs.h"

#include "makecode_map.h"

#include <math.h>

#include "hltp.h"

#define CHAT_MAX_SIZE   75

#define CHAT_MAX_NUM    19

static text_t      *t_text[CHAT_MAX_NUM] = {NULL};

static rectangle_t *r_text               =  NULL;

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

    char buffer2[CHAT_MAX_NUM+3];

    void *dest = NULL;

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

    switch(tp){

        case hltp_type_string:

        strcpy(buffer2, dest);

        strncat(buffer2, " <", 2);

        for(size_t i = CHAT_MAX_NUM-1; i; --i)

        text_set_string(t_text[i], text_get_string(t_text[i-1]));

        text_set_string(t_text[0], buffer2);

        for(size_t i = 0; i < CHAT_MAX_NUM; ++i){

            if(text_get_string(t_text[i])[0] == '>'){

                text_set_pos(t_text[i], rectangle_get_x(r_text)+50, text_get_y(t_text[i]));

                text_set_halign(t_text[i], text_halign_left);

            }else{

                text_set_pos(t_text[i], rectangle_get_x(r_text)+rectangle_get_w(r_text)-50, text_get_y(t_text[i]));

                text_set_halign(t_text[i], text_halign_right);

            }

        }

        break;

        case hltp_type_invalid: break;

        case hltp_type_bullet : break;

        case hltp_type_host   : break;

        case hltp_type_remote : break;

    }

}

int (chat)(void){

    int r;

    nctp_dump();

    nctp_set_processor(chat_process);

    struct packet pp;

    char buffer[CHAT_MAX_SIZE] = "";

    rectangle_t *r_buffer = NULL; {

        r_buffer = rectangle_ctor(0,0,900,70);

        rectangle_set_pos(r_buffer, graph_get_XRes()/2  -rectangle_get_w(r_buffer)/2,

        (int16_t)(graph_get_YRes()*0.87-rectangle_get_h(r_buffer)/2));

        rectangle_set_fill_color   (r_buffer, GRAPH_BLACK);

        rectangle_set_outline_width(r_buffer, 2);

        rectangle_set_outline_color(r_buffer, GRAPH_WHITE);

        rectangle_set_fill_trans(r_buffer, GRAPH_TRANSPARENT);

    }

    text_t      *t_buffer = NULL; {

        t_buffer = text_ctor(font_get_default(), "");

        text_set_pos(t_buffer, rectangle_get_x(r_buffer)+50,

        rectangle_get_y(r_buffer)+rectangle_get_h(r_buffer)/2);

        text_set_halign(t_buffer, text_halign_left);

        text_set_valign(t_buffer, text_valign_center);

        text_set_color (t_buffer, TEXT_COLOR);

    }

    text_t      *t_size   = NULL; {

        t_size = text_ctor(font_get_default(), "");

        text_set_pos(t_size, rectangle_get_x(r_buffer)+rectangle_get_w(r_buffer)-5,

        rectangle_get_y(r_buffer)+rectangle_get_h(r_buffer)-5);

        text_set_halign(t_size, text_halign_right);

        text_set_valign(t_size, text_valign_bottom);

        text_set_color (t_size, TEXT_COLOR);

        text_set_size  (t_size, 18);

        char buffer2[20];

        sprintf(buffer2, "%d/%d", strlen(buffer), CHAT_MAX_SIZE);

        text_set_string(t_size, buffer2);

    }

    /** r_text */ {

    r_text = rectangle_ctor(0,0,900,550);

    rectangle_set_pos(r_text, graph_get_XRes()/2  -rectangle_get_w(r_buffer)/2,

    (int16_t)(graph_get_YRes()*0.09));

    rectangle_set_fill_color   (r_text, GRAPH_BLACK);

    rectangle_set_outline_width(r_text, 2);

    rectangle_set_outline_color(r_text, GRAPH_WHITE);

    rectangle_set_fill_trans(r_text, GRAPH_TRANSPARENT);

    }

    /** t_text */ {

    for(uint16_t i = 0; i < CHAT_MAX_NUM; ++i){

        t_text[i] = text_ctor(font_get_default(), " ");

        text_set_pos(t_text[i], rectangle_get_x(r_text)+50,

        rectangle_get_y(r_text)+rectangle_get_h(r_text)-30-25*i);

        text_set_halign(t_text[i], text_halign_left);

        text_set_valign(t_text[i], text_valign_bottom);

        text_set_color (t_text[i], TEXT_COLOR);

    }

}

/// loop stuff

uint64_t int_vector = 0;

int good = true;

while (good) {

    /* Get a request message. */

    if((r = get_interrupts_vector(&int_vector))) return r;

    uint32_t n = 1;

    for (uint8_t i = 0; i < 32; i++, n <<= 1) {

        if (int_vector & n) {

            interrupt_handler(i);

            switch (i) {

                case TIMER0_IRQ:

                graph_clear_screen();

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

                rectangle_draw(r_buffer);

                text_draw(t_buffer);

                text_draw(t_size);

                rectangle_draw(r_text);

                for(size_t j = 0; j < CHAT_MAX_NUM; ++j) text_draw(t_text[j]);

                sprite_draw(sp_crosshair);

                graph_draw();

                break;

                case KBC_IRQ:

                if      (keyboard_get_scancode()[0] == ESC_BREAK_CODE) good = false;

                else if (keyboard_get_scancode()[0] == ENTER_MAKE_CODE) {

                    hltp_send_string(buffer);

                    char buffer2[CHAT_MAX_SIZE+3] = "> ";

                    strncat(buffer2, buffer, strlen(buffer));

                    for(size_t j = CHAT_MAX_NUM-1; j; --j) text_set_string(t_text[i], text_get_string(t_text[i-1]));

                    text_set_string(t_text[0], buffer2);

                    for(size_t j = 0; j < CHAT_MAX_NUM; ++j){

                        if(text_get_string(t_text[j])[0] == '>'){

                            text_set_pos(t_text[j], rectangle_get_x(r_text)+50, text_get_y(t_text[j]));

                            text_set_halign(t_text[j], text_halign_left);

                        }else{

                            text_set_pos(t_text[j], rectangle_get_x(r_text)+rectangle_get_w(r_text)-50, text_get_y(t_text[j]));

                            text_set_halign(t_text[j], text_halign_right);

                        }

                    }

                    buffer[0] = '\0';

                } else if(keyboard_get_scancode()[0] == BACKSPACE_MAKE_CODE){

                    buffer[strlen(buffer)-1] = '\0';

                } else {

                    char c = map_makecode(keyboard_get_scancode()[0]);

                    if (c == ERROR_CODE) break;

                    if(strlen(buffer) < CHAT_MAX_SIZE) strncat(buffer, &c, 1);

                    else                               printf("Char limit exceeded\n");

                }

                text_set_string(t_buffer, buffer);

                char buffer2[20];

                sprintf(buffer2, "%d/%d", strlen(buffer), CHAT_MAX_SIZE);

                text_set_string(t_size, buffer2);

                case MOUSE_IRQ:

                if (mouse_get_counter_mouse_ih() >= 3) {

                    mouse_parse_packet(mouse_get_packet_mouse_ih(), &pp);

                    update_mouse(&pp);

                    mouse_set_counter_mouse_ih(0);

                }

                break;

                case COM1_IRQ: nctp_ih(); break;

            }

        }

    }

}

rectangle_dtor(r_buffer);

text_dtor     (t_buffer);

rectangle_dtor(r_text);

for(size_t i = 0; i < CHAT_MAX_NUM; ++i) text_dtor(t_text[i]);

nctp_set_processor(NULL);

return SUCCESS;

}

#include <lcom/lcf.h>

#include "campaign.h"

#include "proj.h"

#include "proj_macros.h"

#include "proj_func.h"

#include "ent.h"

#include "interrupts_func.h"

#include "libs.h"

#include <math.h>

int (campaign)(void){

    int r;

    ent_set_scale(DEFAULT_SCALE);

    text_timer_t *in_game_timer = text_timer_ctor(font_get_default());

    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_set_spawn(shooter1, 75, 75);

    gunner_set_pos(shooter1, 75, 75);

    gunner_t *shooter2 = gunner_ctor(bsp_shooter, bsp_nothing, GUNNER_PLAYER, 2);

    gunner_set_spawn(shooter2, 975, 75);

    gunner_set_pos(shooter2, 775, 75);

    list_insert(shooter_list, list_end(shooter_list), shooter1);

    list_insert(shooter_list, list_end(shooter_list), shooter2);

    list_t *bullet_list  = list_ctor();

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

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

    //uint32_t refresh_count_value = sys_hz() / REFRESH_RATE;

    uint8_t last_lb = 0;

    struct packet pp;

    keys_t *keys = get_key_presses();

    /// loop stuff

    uint64_t int_vector = 0;

    int good = true;

    while (good) {

        /* Get a request message. */

        if((r = get_interrupts_vector(&int_vector))) return r;

        uint32_t n = 1;

        for (uint8_t i = 0; i < 32; i++, n <<= 1) {

            if(!good) break;

            if (int_vector & n) {

                interrupt_handler(i);

                switch (i) {

                    case TIMER0_IRQ:

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

                    update_movement(map1, shooter1, keys, shooter_list);

                    update_game_state(map1, shooter_list, bullet_list);

                    //update_scale();

                    double angle = get_mouse_angle(shooter1);

                    gunner_set_angle(shooter1, angle - M_PI_2);