diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/walker.c | 199 |
1 files changed, 157 insertions, 42 deletions
diff --git a/src/walker.c b/src/walker.c index 9a74816..0d32d57 100644 --- a/src/walker.c +++ b/src/walker.c @@ -1,23 +1,36 @@ #include "main.h" #include "entity.h" #include "loader.h" -#include "input.h" #include "tilemap.h" #include <stdbool.h> +#include <math.h> #define SIZE 4 -#define ACCELERATION 2 -#define FRICTION 3 +#define ACCELERATION 1 +#define FRICTION 2 #define MAX_SPEED 16 -#define GRAVITY 2 -#define JUMP 40 +#define GRAVITY 1 +#define WALKABLE_CHECK_DISTANCE 10 +#define IDLE_TIME 90 +#define ATTACK_DELAY 120 +#define ATTACK_DELAY2 60 +#define ATTACK_REPEAT 60 + +struct walker_ext { + unsigned idle_time, attack_delay, attack_delay2, attack_repeat; + signed facing; +}; enum { WALKER_NONE, + WALKER_FALL, WALKER_IDLE, WALKER_PATROL, - WALKER_ALERT, - WALKER_ATTACK, + WALKER_ALERT_IDLE, + WALKER_ALERT_CHASE, + WALKER_ALERT_RUN, + WALKER_ALERT_HALT, + WALKER_ALERT_ATTACK, }; enum { @@ -30,11 +43,12 @@ enum { WALKER_A_JUMP, WALKER_A_FALL, WALKER_A_FALL2, + WALKER_A_ATTACK, }; struct anim walker_anims[] = { {WALKER_A_IDLE2, {0, 0, 16, 16}, 300}, - {WALKER_A_IDLE, {0, 32, 16, 16}, 2}, + {WALKER_A_IDLE, {64, 0, 16, 16}, 2}, {WALKER_A_WALK2, {0, 0, 16, 16}, 6}, {WALKER_A_WALK3, {16, 0, 16, 16}, 6}, {WALKER_A_WALK4, {32, 0, 16, 16}, 6}, @@ -42,6 +56,7 @@ struct anim walker_anims[] = { {WALKER_A_JUMP, {16, 0, 16, 16}, 300}, {WALKER_A_FALL2, {32, 0, 16, 16}, 15}, {WALKER_A_FALL2, {48, 0, 16, 16}, 15}, + {WALKER_A_ATTACK, {80, 0, 16, 16}, 15}, }; static int bullet_update(struct projectile *self) { @@ -71,6 +86,10 @@ static int bullet_update(struct projectile *self) { part->hp = 5; entities.particles++; #endif + if (hitbox_overlap(self->hitbox, entities.player[0].hitbox)) { + entities.player[0].hurt(entities.player + 0, 1); + return 1; + } if (self->hp == 0) { return 1; self->state = 0; @@ -162,7 +181,7 @@ static void anim(struct entity *self, unsigned anim) { self->anim = walker_anims[anim]; } -static void attack(struct entity *self) { +static void attack(struct entity const *const self) { entities.projectile[entities.projectiles] = (struct projectile) { .update = bullet_update, .draw = bullet_draw, @@ -186,64 +205,145 @@ static void attack(struct entity *self) { entities.projectiles++; } +static inline int is_walkable(int const x, int const y) { + collision_T const front = tilemap_tile(tilemap, from_fixed(x), from_fixed(y) - 4); + collision_T const floor = tilemap_tile(tilemap, from_fixed(x), from_fixed(y) + 4); + return !collision_solid(front) && collision_solid(floor) && !collision_hazard(floor); +} + +static void walker_free(struct entity *self) { + self->state = 0; + free(self->ext), self->ext = NULL; +} + static int walker_update(struct entity *self) { + struct walker_ext *const ext = self->ext; if (self->hp <= 0) { - self->state = 0; + walker_free(self); entities.enemies--; return 1; } switch (self->state) { + case WALKER_FALL: + if (move(self, 0) != false) { + anim(self, WALKER_A_WALK); + self->state = WALKER_PATROL; + } + break; + case WALKER_IDLE: if (move(self, 0) == false) { - abort(); self->velocity.y = 0; anim(self, WALKER_A_FALL); - //self->state = WALKER_FALL; + self->state = WALKER_FALL; } self->timer--; if (self->timer == 0) { - self->facing = -self->facing; + ext->facing = -ext->facing; anim(self, WALKER_A_WALK); self->state = WALKER_PATROL; } + if (abs(entities.player[0].x - self->x) + abs(entities.player[0].y - self->y) < to_fixed(64)) { + self->state = WALKER_ALERT_IDLE; + self->timer = ext->attack_delay; + } break; case WALKER_PATROL: - if (move(self, self->facing) == false) { - abort(); + if (move(self, ext->facing) == false) { self->velocity.y = 0; anim(self, WALKER_A_FALL); - //self->state = WALKER_FALL; + self->state = WALKER_FALL; } - if (collision_solid(tilemap_tile(tilemap, from_fixed(self->x) + self->facing * 8, from_fixed(self->y) - 4)) || - !collision_solid(tilemap_tile(tilemap, from_fixed(self->x) + self->facing * 8, from_fixed(self->y) + 4))) { + if (!is_walkable(self->x + to_fixed(ext->facing * WALKABLE_CHECK_DISTANCE), self->y)) { anim(self, WALKER_A_IDLE); self->state = WALKER_IDLE; - self->timer = 30; + self->timer = ext->idle_time; + } + if (abs(entities.player[0].x - self->x) + abs(entities.player[0].y - self->y) < to_fixed(64)) { + anim(self, WALKER_A_IDLE); + self->state = WALKER_ALERT_IDLE; + self->timer = ext->attack_delay; } break; - case WALKER_ALERT: - attack(self); - if (!input_a(input_held)) { - self->velocity.y /= 2; - anim(self, WALKER_A_FALL); - //self->state = WALKER_FALL; + case WALKER_ALERT_IDLE: + move(self, 0); + ext->facing = self->x > entities.player[0].x? -1: 1; + self->facing = ext->facing; + if (abs(entities.player[0].x - self->x) > to_fixed(48)) { + if (is_walkable(self->x + to_fixed(ext->facing * WALKABLE_CHECK_DISTANCE), self->y)) { + anim(self, WALKER_A_WALK); + self->state = WALKER_ALERT_CHASE; + } + } else if (abs(entities.player[0].x - self->x) < to_fixed(32)) { + if (is_walkable(self->x + to_fixed(-ext->facing * WALKABLE_CHECK_DISTANCE), self->y)) { + ext->facing = -ext->facing; + anim(self, WALKER_A_WALK); + self->state = WALKER_ALERT_RUN; + } else if (is_walkable(self->x + to_fixed(ext->facing * WALKABLE_CHECK_DISTANCE), self->y)) { + anim(self, WALKER_A_WALK); + self->state = WALKER_ALERT_RUN; + } } - if (self->velocity.y > 0) { - anim(self, WALKER_A_FALL); - //self->state = WALKER_FALL; + if (abs(entities.player[0].x - self->x) + abs(entities.player[0].y - self->y) > to_fixed(96)) { + self->state = WALKER_IDLE; } - if (move(self, 0) == true) { + self->timer--; + if (self->timer == 0) { + anim(self, WALKER_A_ATTACK); + self->state = WALKER_ALERT_ATTACK; + self->timer = ext->attack_delay2; + } + break; + + case WALKER_ALERT_CHASE: + move(self, ext->facing); + if (abs(entities.player[0].x - self->x) < to_fixed(40) || !is_walkable(self->x + to_fixed(ext->facing * WALKABLE_CHECK_DISTANCE), self->y)) { anim(self, WALKER_A_IDLE); - self->state = WALKER_IDLE; + self->state = WALKER_ALERT_IDLE; + self->timer = ext->attack_delay; + } + break; + + case WALKER_ALERT_RUN: + move(self, ext->facing); + if (abs(entities.player[0].x - self->x) > to_fixed(40)) { + anim(self, WALKER_A_IDLE); + self->state = WALKER_ALERT_IDLE; + self->timer = ext->attack_delay; + } + if (!is_walkable(self->x + to_fixed(ext->facing * WALKABLE_CHECK_DISTANCE), self->y)) { + anim(self, WALKER_A_IDLE); + self->state = WALKER_ALERT_HALT; + } + break; + + case WALKER_ALERT_HALT: // hack workaround for a weird issue where enemies would rapidly switch between moving and idling + move(self, 0); + if (self->velocity.x == 0) { + ext->facing = -ext->facing; + anim(self, WALKER_A_WALK); + self->state = WALKER_ALERT_RUN; } break; - case WALKER_ATTACK: - if (move(self, 0) == true) { + case WALKER_ALERT_ATTACK: + ext->facing = self->x > entities.player[0].x? -1: 1; + self->facing = ext->facing; + if (self->timer > 0) { + self->timer--; + } + if (self->timer == 0 && self->y + to_fixed(4) > entities.player[0].y && self->y <= entities.player[0].y) { + attack(self); + anim(self, WALKER_A_IDLE); + self->state = WALKER_ALERT_IDLE; + self->timer = ext->attack_repeat; + } + if (abs(entities.player[0].x - self->x) + abs(entities.player[0].y - self->y) > to_fixed(96)) { anim(self, WALKER_A_IDLE); self->state = WALKER_IDLE; + self->timer = ext->idle_time; } break; } @@ -288,22 +388,19 @@ static int walker_draw(struct entity *self, int camX, int camY) { return 0; } -static void walker_free(struct entity *self) { - self->state = 0; -} - struct entity *walker_new(struct entities *entities) { - entities->enemy[entities->enemies] = (struct entity) { + struct entity *self = entities->enemy + entities->enemies; + *self = (struct entity) { .update = walker_update, .hurt = walker_hurt, .draw = walker_draw, .free = walker_free, .x = 0, .y = 0, - .velocity = {.x = 0, .y = to_fixed(1)}, + .velocity = {.x = 0, .y = 0}, .hitbox = { 0, 0, 0, 0, }, - .state = WALKER_PATROL, + .state = WALKER_FALL, .hp = 3, .timer = 0, .facing = 1, @@ -312,16 +409,34 @@ struct entity *walker_new(struct entities *entities) { .texture = NULL, .ext = NULL, }; - anim(entities->enemy + entities->enemies, WALKER_A_IDLE); - entities->enemy[entities->enemies].texture = res_get_texture("fywi").data; - return entities->enemy + entities->enemies++; + self->ext = malloc(sizeof (struct walker_ext)); + *(struct walker_ext *) self->ext = (struct walker_ext) { + .idle_time = IDLE_TIME, + .attack_delay = ATTACK_DELAY, + .attack_delay2 = ATTACK_DELAY2, + .attack_repeat = ATTACK_REPEAT, + .facing = 1, + }; + anim(self, WALKER_A_FALL); + self->texture = res_get_texture("enemy").data; + entities->enemies++; + return self; } int walker_property(struct entity *const restrict self, char const *const restrict property, char const *const restrict value) { + struct walker_ext *const ext = self->ext; if (strcmp(property, "x") == 0) { self->x = to_fixed(atoi(value)); } else if (strcmp(property, "y") == 0) { self->y = to_fixed(atoi(value)); + } else if (strcmp(property, "idle time") == 0) { + ext->idle_time = atoi(value); + } else if (strcmp(property, "attack delay") == 0) { + ext->attack_delay = atoi(value); + } else if (strcmp(property, "attack delay 2") == 0) { + ext->attack_delay2 = atoi(value); + } else if (strcmp(property, "attack repeat") == 0) { + ext->attack_repeat = atoi(value); } else { return 1; } |