371 lines
11 KiB
C
371 lines
11 KiB
C
#include "./warder.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
#include "util/math/algorithm.h"
|
|
#include "util/math/vector.h"
|
|
#include "util/statman/statman.h"
|
|
|
|
#include "core/lobullet/base.h"
|
|
#include "core/lobullet/linear.h"
|
|
#include "core/loeffect/effect.h"
|
|
#include "core/loeffect/recipient.h"
|
|
#include "core/loentity/ground.h"
|
|
#include "core/loresource/sound.h"
|
|
#include "core/loshader/character.h"
|
|
|
|
#include "./base.h"
|
|
#include "./combat.h"
|
|
|
|
#define WIDTH_ .02f
|
|
#define HEIGHT_ .055f
|
|
#define MARKER_ .022f
|
|
#define COLOR_ vec4(0, 0, 0, 1)
|
|
|
|
#define BULLET_DAMAGE_ .9f
|
|
#define BULLET_KNOCKBACK_ 6
|
|
#define BULLET_DURATION_ 2000
|
|
#define BULLET_SPEED_ .6f
|
|
#define BULLET_COLOR_ vec4(0, 0, 0, 1)
|
|
#define BULLET_SIZE_ vec2(.03f, .03f)
|
|
|
|
#define SHOOT_DURATION_ 2000
|
|
|
|
static const loeffect_recipient_status_t base_status_ = {
|
|
.attack = .2f,
|
|
.defence = .05f,
|
|
.speed = .05f,
|
|
.jump = 1.f,
|
|
};
|
|
|
|
static void lochara_warder_update_thrust_in_state_(
|
|
const statman_meta_t* meta, void* instance, statman_state_t* state) {
|
|
assert(meta != NULL);
|
|
assert(instance != NULL);
|
|
assert(state != NULL);
|
|
|
|
static const uint64_t dur = 100;
|
|
|
|
lochara_base_t* base = instance;
|
|
|
|
uint64_t t = base->ticker->time - base->param.last_state_changed;
|
|
if (t > dur) t = dur;
|
|
|
|
const float tf = t*1.f / dur;
|
|
base->cache.instance.motion.time = powf(tf, 2);
|
|
base->cache.instance.motion.from = LOSHADER_CHARACTER_MOTION_ID_ATTACK1;
|
|
base->cache.instance.motion.to = LOSHADER_CHARACTER_MOTION_ID_ATTACK2;
|
|
}
|
|
|
|
static void lochara_warder_update_thrust_out_state_(
|
|
const statman_meta_t* meta, void* instance, statman_state_t* state) {
|
|
assert(meta != NULL);
|
|
assert(instance != NULL);
|
|
assert(state != NULL);
|
|
|
|
static const uint64_t dur = 100;
|
|
|
|
lochara_base_t* base = instance;
|
|
|
|
uint64_t t = base->ticker->time - base->param.last_state_changed;
|
|
if (t > dur) t = dur;
|
|
|
|
const float tf = t*1.f / dur;
|
|
base->cache.instance.motion.time = powf(tf, 2);
|
|
base->cache.instance.motion.from = LOSHADER_CHARACTER_MOTION_ID_ATTACK2;
|
|
base->cache.instance.motion.to = LOSHADER_CHARACTER_MOTION_ID_ATTACK1;
|
|
}
|
|
|
|
static void lochara_warder_update_shoot_state_(
|
|
const statman_meta_t* meta, void* instance, statman_state_t* state) {
|
|
assert(meta != NULL);
|
|
assert(instance != NULL);
|
|
assert(state != NULL);
|
|
|
|
lochara_base_t* base = instance;
|
|
const uint64_t since = base->param.last_state_changed;
|
|
|
|
uint64_t t = base->ticker->time - since;
|
|
if (t > SHOOT_DURATION_) t = SHOOT_DURATION_;
|
|
|
|
const uint64_t pt = t == 0? 0: base->ticker->prev_time - since;
|
|
if (pt < SHOOT_DURATION_/2 && SHOOT_DURATION_/2 <= t) {
|
|
vec2_t v = base->param.direction;
|
|
vec2_muleq(&v, BULLET_SPEED_);
|
|
|
|
lobullet_base_t* b = lobullet_pool_create(base->bullet);
|
|
lobullet_linear_circle_build(b,
|
|
.owner = base->super.super.id,
|
|
.basepos = base->super.super.pos,
|
|
.size = BULLET_SIZE_,
|
|
.color = BULLET_COLOR_,
|
|
.velocity = v,
|
|
.knockback = BULLET_KNOCKBACK_,
|
|
.effect = loeffect_damage(
|
|
base->param.recipient.status.attack*BULLET_DAMAGE_),
|
|
.duration = BULLET_DURATION_,);
|
|
loentity_store_add(base->entities, &b->super.super);
|
|
loresource_sound_set_play(
|
|
&base->res->sound, LORESOURCE_SOUND_ID_ENEMY_SHOOT);
|
|
}
|
|
|
|
float tf = t*1.f/SHOOT_DURATION_*2;
|
|
if (tf < 1) {
|
|
tf *= 2;
|
|
if (tf < 1) {
|
|
base->cache.instance.motion.from = LOSHADER_CHARACTER_MOTION_ID_STAND1;
|
|
base->cache.instance.motion.to = LOSHADER_CHARACTER_MOTION_ID_ATTACK1;
|
|
} else {
|
|
tf -= 1;
|
|
base->cache.instance.motion.from = LOSHADER_CHARACTER_MOTION_ID_ATTACK1;
|
|
base->cache.instance.motion.to = LOSHADER_CHARACTER_MOTION_ID_ATTACK2;
|
|
}
|
|
base->cache.instance.motion.time = powf(tf, 4);
|
|
} else {
|
|
tf -= 1;
|
|
base->cache.instance.motion.from = LOSHADER_CHARACTER_MOTION_ID_ATTACK2;
|
|
base->cache.instance.motion.to = LOSHADER_CHARACTER_MOTION_ID_STAND1;
|
|
base->cache.instance.motion.time = tf;
|
|
}
|
|
}
|
|
|
|
static void lochara_warder_initialize_resuscitate_state_(
|
|
const statman_meta_t* meta, void* instance, statman_state_t* state) {
|
|
assert(meta != NULL);
|
|
assert(instance != NULL);
|
|
assert(state != NULL);
|
|
|
|
lochara_state_initialize_any_(meta, instance, state);
|
|
|
|
lochara_base_t* base = instance;
|
|
loeffect_recipient_apply_effect(
|
|
&base->param.recipient, &loeffect_resuscitate());
|
|
}
|
|
|
|
static void lochara_warder_update_dead_state_(
|
|
const statman_meta_t* meta, void* instance, statman_state_t* state) {
|
|
assert(meta != NULL);
|
|
assert(instance != NULL);
|
|
assert(state != NULL);
|
|
|
|
static uint64_t dur = 1000;
|
|
|
|
lochara_base_t* base = instance;
|
|
base->param.movement = vec2(0, 0);
|
|
|
|
uint64_t t = base->ticker->time - base->param.last_state_changed;
|
|
if (t > dur) t = dur;
|
|
|
|
if (base->param.state == LOCHARA_STATE_RESUSCITATE) t = dur - t;
|
|
|
|
base->cache.instance.motion.from = LOSHADER_CHARACTER_MOTION_ID_STAND1;
|
|
base->cache.instance.motion.to = LOSHADER_CHARACTER_MOTION_ID_DOWN;
|
|
base->cache.instance.motion.time = powf(t*1.f/dur, 6);
|
|
}
|
|
|
|
static const statman_meta_t state_table_[] = {
|
|
lochara_state_stand(
|
|
.period = 4000,
|
|
.acceleration = {{5, 5}},
|
|
.motion1 = LOSHADER_CHARACTER_MOTION_ID_STAND1,
|
|
.motion2 = LOSHADER_CHARACTER_MOTION_ID_STAND1,
|
|
),
|
|
lochara_state_walk(
|
|
.period = 1000,
|
|
.acceleration = {{5, 5}},
|
|
.motion1 = LOSHADER_CHARACTER_MOTION_ID_STAND1,
|
|
.motion2 = LOSHADER_CHARACTER_MOTION_ID_WALK,
|
|
),
|
|
{
|
|
.state = LOCHARA_STATE_THRUST_IN,
|
|
.name = "THRUST_IN",
|
|
.initialize = lochara_state_initialize_any_,
|
|
.update = lochara_warder_update_thrust_in_state_,
|
|
},
|
|
{
|
|
.state = LOCHARA_STATE_THRUST_OUT,
|
|
.name = "THRUST_OUT",
|
|
.initialize = lochara_state_initialize_any_,
|
|
.update = lochara_warder_update_thrust_out_state_,
|
|
},
|
|
{
|
|
.state = LOCHARA_STATE_SHOOT,
|
|
.name = "SHOOT",
|
|
.initialize = lochara_state_initialize_any_,
|
|
.update = lochara_warder_update_shoot_state_,
|
|
},
|
|
{
|
|
.state = LOCHARA_STATE_DEAD,
|
|
.name = "DEAD",
|
|
.initialize = lochara_state_initialize_any_,
|
|
.update = lochara_warder_update_dead_state_,
|
|
},
|
|
{
|
|
.state = LOCHARA_STATE_RESUSCITATE,
|
|
.name = "RESUSCITATE",
|
|
.initialize = lochara_warder_initialize_resuscitate_state_,
|
|
.update = lochara_warder_update_dead_state_,
|
|
},
|
|
{0},
|
|
};
|
|
|
|
static const lochara_combat_action_t combo1_[] = {
|
|
lochara_combat_action_rest(
|
|
.duration = 400,
|
|
.state = LOCHARA_STATE_STAND,
|
|
),
|
|
lochara_combat_action_attack(
|
|
.duration = 200,
|
|
.state = LOCHARA_STATE_THRUST_IN,
|
|
.damage = 1,
|
|
),
|
|
lochara_combat_action_rest(
|
|
.duration = 200,
|
|
.state = LOCHARA_STATE_THRUST_OUT,
|
|
),
|
|
lochara_combat_action_attack(
|
|
.duration = 300,
|
|
.state = LOCHARA_STATE_THRUST_IN,
|
|
.damage = 1,
|
|
),
|
|
lochara_combat_action_rest(
|
|
.duration = 200,
|
|
.state = LOCHARA_STATE_THRUST_OUT,
|
|
),
|
|
lochara_combat_action_attack(
|
|
.duration = 300,
|
|
.state = LOCHARA_STATE_THRUST_IN,
|
|
.damage = 1.2f,
|
|
),
|
|
lochara_combat_action_rest(
|
|
.duration = 200,
|
|
.state = LOCHARA_STATE_THRUST_OUT,
|
|
),
|
|
lochara_combat_action_attack(
|
|
.duration = 300,
|
|
.state = LOCHARA_STATE_THRUST_IN,
|
|
.damage = .8f,
|
|
),
|
|
lochara_combat_action_rest(
|
|
.duration = 400,
|
|
.state = LOCHARA_STATE_THRUST_OUT,
|
|
),
|
|
lochara_combat_action_rest(
|
|
.duration = 600,
|
|
.state = LOCHARA_STATE_STAND,
|
|
),
|
|
{0},
|
|
};
|
|
|
|
static const lochara_combat_action_t shoot1_[] = {
|
|
lochara_combat_action_rest(
|
|
.duration = 100,
|
|
.state = LOCHARA_STATE_STAND,
|
|
),
|
|
lochara_combat_action_rest(
|
|
.duration = SHOOT_DURATION_,
|
|
.state = LOCHARA_STATE_SHOOT,
|
|
),
|
|
lochara_combat_action_rest(
|
|
.duration = 500,
|
|
.state = LOCHARA_STATE_STAND,
|
|
),
|
|
{0},
|
|
};
|
|
|
|
static const lochara_combat_action_t dead_[] = {
|
|
lochara_combat_action_rest(
|
|
.duration = 30000,
|
|
.state = LOCHARA_STATE_DEAD,
|
|
),
|
|
lochara_combat_action_rest(
|
|
.duration = 2000,
|
|
.state = LOCHARA_STATE_RESUSCITATE,
|
|
),
|
|
{0},
|
|
};
|
|
|
|
static const statman_meta_t strategy_table_[] = {
|
|
lochara_strategy_scouting(
|
|
.state_table = state_table_,
|
|
.period = 2000,
|
|
.stagger = .8f,
|
|
.range_back = .5f,
|
|
.range_close = WIDTH_*4,
|
|
.found_close = LOCHARA_STRATEGY_COMBO1,
|
|
.range_mid = .4f,
|
|
.found_mid = LOCHARA_STRATEGY_SHOOT1,
|
|
),
|
|
lochara_strategy_combat(COMBO1,
|
|
.state_table = state_table_,
|
|
.actions = combo1_,
|
|
.next = LOCHARA_STRATEGY_SCOUTING,
|
|
),
|
|
lochara_strategy_combat(SHOOT1,
|
|
.state_table = state_table_,
|
|
.actions = shoot1_,
|
|
.next = LOCHARA_STRATEGY_SCOUTING,
|
|
),
|
|
lochara_strategy_combat(DEAD,
|
|
.state_table = state_table_,
|
|
.actions = dead_,
|
|
.next = LOCHARA_STRATEGY_SCOUTING,
|
|
),
|
|
{0},
|
|
};
|
|
|
|
bool lochara_warder_update(lochara_base_t* base) {
|
|
assert(base != NULL);
|
|
|
|
loeffect_recipient_update(&base->param.recipient, &base_status_);
|
|
|
|
statman_update(strategy_table_, base, &base->param.strategy);
|
|
|
|
const float dir = MATH_SIGN_NOZERO(base->param.direction.x);
|
|
base->cache.instance = (loshader_character_drawer_instance_t) {
|
|
.character_id = LOSHADER_CHARACTER_ID_WARDER,
|
|
.pos = vec2(0, -MARKER_),
|
|
.size = vec2(dir*HEIGHT_, HEIGHT_),
|
|
.color = COLOR_,
|
|
.marker_offset = vec2(0, MARKER_),
|
|
};
|
|
statman_update(state_table_, base, &base->param.state);
|
|
|
|
if (base->param.state != LOCHARA_STATE_DEAD) {
|
|
base->cache.instance.marker = lochara_base_affect_bullets(base);
|
|
}
|
|
|
|
lochara_base_calculate_physics(
|
|
base, &vec2(WIDTH_, HEIGHT_), &vec2(0, MARKER_));
|
|
lochara_base_bind_on_ground(base, &vec2(WIDTH_, HEIGHT_+MARKER_));
|
|
return true;
|
|
}
|
|
|
|
void lochara_warder_build(
|
|
lochara_base_t* base, const loentity_ground_t* gnd, float pos) {
|
|
assert(base != NULL);
|
|
assert(gnd != NULL);
|
|
assert(MATH_FLOAT_VALID(pos));
|
|
|
|
base->super.super.pos = gnd->super.pos;
|
|
vec2_addeq(
|
|
&base->super.super.pos.fract,
|
|
&vec2(gnd->size.x*pos, gnd->size.y));
|
|
locommon_position_reduce(&base->super.super.pos);
|
|
|
|
base->param = (typeof(base->param)) {
|
|
.type = LOCHARA_TYPE_WARDER,
|
|
.state = LOCHARA_STATE_STAND,
|
|
.last_state_changed = base->ticker->time,
|
|
.strategy = LOCHARA_STRATEGY_SCOUTING,
|
|
.last_strategy_changed = base->ticker->time,
|
|
|
|
.ground = gnd->super.id,
|
|
};
|
|
loeffect_recipient_initialize(
|
|
&base->param.recipient, base->ticker, &base_status_);
|
|
}
|