LCOM1920-T5G03

#define ENT_H_INCLUDED

#include "sprite.h"

void (ent_set_scale) (double n);

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

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

double  (gunner_get_x)              (const gunner_t *p);

double  (gunner_get_y)              (const gunner_t *p);

int     (gunner_get_health)         (const gunner_t *p);

int     (gunner_get_curr_health)    (const gunner_t *p);

int16_t (gunner_get_x_screen)       (const gunner_t *p);

int     (bullet_get_damage)  (const bullet_t *p);

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

void (bullet_update_movement)(bullet_t *p);

void (bullet_draw)(bullet_t *p);

void (gunner_draw_health)(const gunner_t *p);

struct map;

    uint8_t ctrl_pressed    : 1;

    uint8_t plus_pressed    : 1;

    uint8_t minus_pressed   : 1;

} keys_t;

void update_scale(void);

int32_t get_mouse_X(void);

#define RIGHT   1   /** @brief Moving to the right side of screen */

#define REST    0   /** @brief Not moving */

// Extra Keys

#define ESC_MAKE_CODE   0x01    /** @brief ESC Make Code */

#define ESC_BREAK_CODE  0x81    /** @brief ESC Break Code */

int16_t  (sprite_get_x)(const sprite_t *p);

int16_t  (sprite_get_y)(const sprite_t *p);

uint16_t (sprite_get_w)(const sprite_t *p);

uint16_t (sprite_get_h)(const sprite_t *p);

}

double  (gunner_get_x)              (const gunner_t *p){ return p->x; }

double  (gunner_get_y)              (const gunner_t *p){ return p->y; }

int     (gunner_get_health)         (const gunner_t *p){ return p->health; }

int     (gunner_get_curr_health)    (const gunner_t *p){ return p->current_health; }

int16_t (gunner_get_x_screen)       (const gunner_t *p){ return (p->x-x_origin)*scale; }

    p->x += p->vx;

    p->y += p->vy;

}

void (bullet_draw)(bullet_t *p){

    const int16_t x_screen = bullet_get_x_screen(p);

    const int16_t y_screen = bullet_get_y_screen(p);

    sprite_draw     (p->b);

}

struct map{

    basic_sprite_t *bsp_background;

    sprite_t *background;

void (sprite_set_scale) (sprite_t *p, double scale          ){ p->scale = scale; }

int16_t  (sprite_get_x)(const sprite_t *p){ return p->x; }

int16_t  (sprite_get_y)(const sprite_t *p){ return p->y; }

uint16_t (sprite_get_w)(const sprite_t *p){ return basic_sprite_get_w(p->bsp); }

uint16_t (sprite_get_h)(const sprite_t *p){ return basic_sprite_get_h(p->bsp); }

void (sprite_src2pic)(const sprite_t *p, int16_t x, int16_t y, int16_t *u, int16_t *v){

#include "shooter.h"

#include "pistol.h"

#include "nothing.h"

#include "map1.h"

#include "list.h"

        gunner_set_pos(shooter1, 75, 75);

        gunner_t *shooter2 = gunner_ctor(bsp_shooter, bsp_nothing);

        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;

    #endif

    /// loop stuff

                                if (no_interrupts % refresh_count_value == 0) {

                                    update_movement(map1, shooter1);

                                    //bullet_update_movement(bullet);

                                    if(map_collides_gunner(map1, shooter1)){

                                        printf("COLLIDING\n");

                                    }

                                        printf("Bullet Collide with Shooter\n");

                                        gunner_set_curr_health(shooter1, gunner_get_curr_health(shooter1) - bullet_get_damage(bullet));

                                    update_scale();

                                    map_draw   (map1);

                                    gunner_draw(shooter2);

                                    gunner_draw(shooter1);

                                    t = clock()-t; //printf("%d\n", (t*1000)/CLOCKS_PER_SEC);

                            if (i == 12) {

                                if (counter_mouse_ih >= 3) {

                                    struct packet pp = mouse_parse_packet(packet_mouse_ih);

                                    //printf("X: %d Y: %d\n", get_mouse_X(), get_mouse_Y());

                                    counter_mouse_ih = 0;

                                }

                            }

                            #endif

    #ifdef TELMO

        gunner_dtor(shooter1); shooter1 = NULL;

        gunner_dtor(shooter2); shooter2 = NULL;

    #endif

    basic_sprite_dtor      (bsp_crosshair); bsp_crosshair = NULL;

#include "proj_macros.h"

#include "utils.h"

#include "ent.h"

#include "kbc_macros.h"

}

void update_movement(const map_t *map, gunner_t *p) {

    double x = gunner_get_x(p);

    double y = gunner_get_y(p);

    if (map_collides_gunner(map, p)) {

        gunner_set_pos(p, x, y);

    }

    x = gunner_get_x(p);

    if (map_collides_gunner(map, p)) {

        gunner_set_pos(p, x, y);

    }

}

void update_scale(void) {

    static uint8_t last_plus = 0, last_minus = 0;

    if (key_presses.ctrl_pressed) {

static int32_t mouse_x = 0, mouse_y = 0;

    mouse_x = max(0, mouse_x + p->delta_x);

    mouse_x = min(mouse_x, graph_get_XRes() - 1);

    mouse_y = max(0, mouse_y - p->delta_y);

    mouse_y = min(mouse_y, graph_get_YRes() - 1);

}

int32_t get_mouse_X(void) { return mouse_x; }

int32_t get_mouse_Y(void) { return mouse_y; }