This repository has been archived on 2022-05-21. You can view files and clone it, but cannot push or open issues or pull requests.
LEFTONE/core/locharacter/theists_child.c

764 lines
22 KiB
C
Raw Normal View History

#include "./theists_child.h"
#include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <msgpack.h>
#include "util/chaos/xorshift.h"
#include "util/math/algorithm.h"
#include "util/math/constant.h"
#include "util/math/rational.h"
#include "util/math/vector.h"
#include "util/mpkutil/get.h"
#include "util/mpkutil/pack.h"
#include "core/lobullet/base.h"
#include "core/lobullet/bomb.h"
#include "core/lobullet/linear.h"
#include "core/lobullet/pool.h"
#include "core/locommon/msgpack.h"
#include "core/locommon/ticker.h"
#include "core/loeffect/recipient.h"
#include "core/loeffect/stance.h"
#include "core/loentity/bullet.h"
#include "core/loentity/store.h"
#include "core/loplayer/event.h"
#include "core/loplayer/player.h"
#include "core/loresource/music.h"
#include "core/loresource/set.h"
#include "core/loresource/text.h"
#include "core/loshader/character.h"
#include "./base.h"
#include "./misc.h"
#include "./util.h"
typedef struct {
locharacter_event_holder_t event;
uint64_t phase;
vec2_t from;
vec2_t to;
} locharacter_theists_child_param_t;
#define LOCHARACTER_THEISTS_CHILD_PARAM_TO_PACK_EACH_(PROC) do { \
PROC("event-start-time", event.start_time); \
PROC("phase", phase); \
PROC("from", from); \
PROC("to", to); \
} while (0)
#define LOCHARACTER_THEISTS_CHILD_PARAM_TO_PACK_COUNT 4
static const vec2_t locharacter_theists_child_size_ = vec2(.02f, .06f);
static const loeffect_recipient_status_t
locharacter_theists_child_base_status_ = {
.attack = .1f,
.defence = .9f,
.speed = .1f,
.jump = .2f,
};
#define LOCHARACTER_THEISTS_CHILD_BEAT (60000/140.f) /* 140 BPM */
#define LOCHARACTER_THEISTS_CHILD_MUSIC_DURATION \
((uint64_t) LOCHARACTER_THEISTS_CHILD_BEAT*236)
#define LOCHARACTER_THEISTS_CHILD_MELODY_B_START_BEAT 128
#define LOCHARACTER_THEISTS_CHILD_MELODY_B_END_BEAT 192
#include "./theists_child.private.h"
static void
locharacter_theists_child_start_wait_state_(
locharacter_base_t* c
);
static void
locharacter_theists_child_start_standup_state_(
locharacter_base_t* c
);
static void
locharacter_theists_child_start_rush_state_(
locharacter_base_t* c
);
static void
locharacter_theists_child_start_combo_state_(
locharacter_base_t* c
);
static void
locharacter_theists_child_start_cooldown_state_(
locharacter_base_t* c
);
static void
locharacter_theists_child_start_stunned_state_(
locharacter_base_t* c
);
static void
locharacter_theists_child_start_dead_state_(
locharacter_base_t* c
);
static void locharacter_theists_child_finalize_event_(locharacter_base_t* c) {
assert(c != NULL);
/* This function must start next state. */
locharacter_theists_child_param_t* p = (typeof(p)) c->data;
assert(p != NULL);
locharacter_event_holder_release_control(&p->event);
if (c->recipient.madness > 0) {
loentity_character_apply_effect(
&c->player->entity.super, &loeffect_curse_trigger());
locharacter_theists_child_start_wait_state_(c);
} else {
loplayer_gain_stance(c->player, LOEFFECT_STANCE_ID_REVOLUTIONER);
locharacter_theists_child_start_dead_state_(c);
}
}
static bool locharacter_theists_child_reset_if_player_left_(
locharacter_base_t* c) {
assert(c != NULL);
locharacter_theists_child_param_t* p = (typeof(p)) c->data;
if (MATH_ABS(c->cache.player_pos.x) < 1 &&
0 < c->cache.player_pos.y && c->cache.player_pos.y < 1) {
return false;
}
locharacter_event_holder_release_control(&p->event);
locharacter_theists_child_start_wait_state_(c);
return true;
}
static void locharacter_theists_child_fire_bullets_(locharacter_base_t* c) {
assert(c != NULL);
static const float len = .3f;
static const float accel = .6f;
static const uint64_t dur = 1000;
for (size_t i = 0; i < 30; ++i) {
const float t = MATH_PI/15*i;
const vec2_t v = vec2(cos(t), sin(t));
locommon_position_t pos = c->super.super.pos;
pos.fract.x += v.x*len;
pos.fract.y += v.y*len;
locommon_position_reduce(&pos);
lobullet_base_t* bullet = lobullet_pool_create(c->bullets);
lobullet_linear_light_build(bullet, (&(lobullet_linear_param_t) {
.owner = c->super.super.id,
.pos = pos,
.size = vec2(.015f, .015f),
.acceleration = vec2(-v.x*accel, -v.y*accel),
.color = vec4(1, 1, 1, .8f),
.duration = dur,
.knockback = .1f,
.effect = loeffect_immediate_damage(c->recipient.status.attack),
}));
loentity_store_add(c->entities, &bullet->super.super);
}
}
static void locharacter_theists_child_update_wait_state_(
locharacter_base_t* c) {
assert(c != NULL);
static const float standup_range = .5f;
static const int32_t sit_duration = 4000;
c->cache.gravity = true;
/* ---- motion ---- */
float t = (c->cache.time - c->since)*1.f/sit_duration;
if (t > 1) t = 1;
loshader_character_drawer_instance_t* instance = &c->cache.instance;
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_STAND1;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_DOWN;
instance->motion_time = t;
/* ---- state transition ---- */
if (c->since+sit_duration <= c->cache.time) {
if (MATH_ABS(c->cache.player_pos.x) < 1 &&
0 < c->cache.player_pos.y && c->cache.player_pos.y < 1) {
vec2_t diff;
vec2_sub(&diff, &c->cache.player_pos, &c->pos);
if (vec2_pow_length(&diff) < standup_range*standup_range) {
locharacter_theists_child_start_standup_state_(c);
return;
}
}
}
}
static void locharacter_theists_child_start_wait_state_(locharacter_base_t* c) {
assert(c != NULL);
c->since = c->cache.time;
c->state = LOCHARACTER_STATE_WAIT;
}
static void locharacter_theists_child_update_standup_state_(
locharacter_base_t* c) {
assert(c != NULL);
static const float beat = LOCHARACTER_THEISTS_CHILD_BEAT;
static const uint64_t line_duration = beat*10;
locharacter_theists_child_param_t* p = (typeof(p)) c->data;
const bool event = locharacter_event_holder_has_control(&p->event);
const uint64_t standup_duration = event? beat*64: 1000;
/* ---- motion ---- */
float t = (c->cache.time - c->since)*1.0f/standup_duration;
if (t > 1) t = 1;
loshader_character_drawer_instance_t* instance = &c->cache.instance;
if (t < .5f) {
t *= 2;
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_DOWN;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_SIT;
instance->motion_time = t*t*(3-2*t);
} else {
t = (t-.5f)*2;
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_SIT;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_STAND1;
instance->motion_time = t*t*(3-2*t);
}
/* ---- event ---- */
if (event) {
p->event.param->cinescope = true;
p->event.param->hide_hud = true;
if (c->since+(p->phase+2)*line_duration < c->cache.time) {
static const char* text[] = {
"boss_theists_child_line0",
"boss_theists_child_line1",
"boss_theists_child_line2",
};
if (p->phase < sizeof(text)/sizeof(text[0])) {
const char* v = loresource_text_get(
c->res->lang, text[(size_t) p->phase]);
loplayer_event_param_set_line(p->event.param, v, strlen(v));
} else {
loplayer_event_param_set_line(p->event.param, "", 0);
}
++p->phase;
}
}
/* ---- state transition ---- */
if (locharacter_theists_child_reset_if_player_left_(c)) return;
if (c->since+standup_duration < c->cache.time) {
if (event) {
p->event.param->hide_hud = false;
p->event.param->cinescope = false;
loplayer_event_param_set_line(p->event.param, "", 0);
}
locharacter_theists_child_start_rush_state_(c);
return;
}
}
static void locharacter_theists_child_start_standup_state_(
locharacter_base_t* c) {
assert(c != NULL);
locharacter_theists_child_param_t* p = (typeof(p)) c->data;
c->since = c->cache.time;
c->state = LOCHARACTER_STATE_STANDUP;
p->phase = 0;
loeffect_recipient_reset(&c->recipient);
if (!loeffect_stance_set_has(
&c->player->status.stances, LOEFFECT_STANCE_ID_REVOLUTIONER)) {
locharacter_event_holder_take_control(&p->event);
}
}
static void locharacter_theists_child_update_rush_state_(
locharacter_base_t* c) {
assert(c != NULL);
static const float beat = LOCHARACTER_THEISTS_CHILD_BEAT;
static const uint64_t premotion_duration = beat*2;
static const uint64_t whole_duration = beat*4;
const locharacter_theists_child_param_t* p = (typeof(p)) c->data;
const uint64_t elapsed = c->cache.time - c->since;
/* ---- motion ---- */
float t = elapsed*1.f/premotion_duration;
if (t > 1) t = 1;
loshader_character_drawer_instance_t* instance = &c->cache.instance;
if (t < .1f) {
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_STAND1;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_WALK;
instance->motion_time = 1-powf(1-t*10, 2);
} else if (t < .5f) {
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_WALK;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_ATTACK1;
instance->motion_time = 1-powf(1-(t-.1f)/4*10, 2);
} else {
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_ATTACK1;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_ATTACK2;
instance->motion_time = powf((t-.5f)*2, 4);
}
/* ---- position ---- */
vec2_sub(&c->pos, &p->to, &p->from);
c->direction = MATH_SIGN(c->pos.x);
vec2_muleq(&c->pos, powf(t, 2));
c->pos.y += (1-MATH_ABS(t*2-1))*c->recipient.status.jump*.1f;
vec2_addeq(&c->pos, &p->from);
/* ---- state transition ---- */
if (locharacter_theists_child_reset_if_player_left_(c)) return;
if (c->since+whole_duration < c->cache.time) {
locharacter_theists_child_start_cooldown_state_(c);
return;
}
}
static void locharacter_theists_child_start_rush_state_(
locharacter_base_t* c) {
assert(c != NULL);
static const float beat = LOCHARACTER_THEISTS_CHILD_BEAT;
static const uint64_t parry = 300;
locharacter_theists_child_param_t* p = (typeof(p)) c->data;
if (c->last_knockback_time + parry > c->cache.time) {
locharacter_theists_child_start_stunned_state_(c);
return;
}
c->since = c->cache.time;
c->state = LOCHARACTER_STATE_RUSH;
const vec2_t* player = &c->cache.player_pos;
const float diffx = player->x - c->pos.x;
p->from = c->pos;
p->to = vec2(
player->x - MATH_SIGN(diffx)*locharacter_theists_child_size_.x*2,
player->y - .02f);
const loplayer_combat_attack_t attack = {
.attacker = c->super.super.id,
.start = c->ticker->time + (uint64_t) beat,
.duration = beat*3,
.knockback = vec2(MATH_SIGN(player->x)*.2f, 0),
.effect = loeffect_immediate_damage(c->recipient.status.attack*2),
};
loplayer_attack(c->player, &attack);
}
static void locharacter_theists_child_update_combo_state_(
locharacter_base_t* c) {
assert(c != NULL);
static const float beat = LOCHARACTER_THEISTS_CHILD_BEAT;
static const uint64_t premotion_duration = beat;
static const uint64_t attack_duration = beat;
static const uint64_t whole_duration = beat*4;
const locharacter_theists_child_param_t* p = (typeof(p)) c->data;
const uint64_t elapsed = c->cache.time - c->since;
/* ---- motion ---- */
loshader_character_drawer_instance_t* instance = &c->cache.instance;
if (elapsed < premotion_duration) {
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_STAND1;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_ATTACK1;
instance->motion_time = elapsed*1.f / premotion_duration;
} else {
const uint64_t attack_elapsed = elapsed - premotion_duration;
float t = 1;
if (attack_elapsed < attack_duration*p->phase) {
t = attack_elapsed%attack_duration*1.f / attack_duration;
}
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_ATTACK1;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_ATTACK2;
instance->motion_time = 1-powf(1-t, 4);
}
/* ---- position ---- */
if (elapsed < premotion_duration) {
const float t = elapsed*1.f/premotion_duration;
vec2_sub(&c->pos, &p->to, &p->from);
vec2_muleq(&c->pos, t*t);
vec2_addeq(&c->pos, &p->from);
}
/* ---- state transition ---- */
if (locharacter_theists_child_reset_if_player_left_(c)) return;
if (elapsed >= whole_duration) {
locharacter_theists_child_start_cooldown_state_(c);
return;
}
}
static void locharacter_theists_child_start_combo_state_(
locharacter_base_t* c) {
assert(c != NULL);
static const float beat = LOCHARACTER_THEISTS_CHILD_BEAT;
static const uint64_t parry = 200;
locharacter_theists_child_param_t* p = (typeof(p)) c->data;
if (c->last_knockback_time + parry > c->cache.time) {
locharacter_theists_child_start_stunned_state_(c);
return;
}
c->since = c->cache.time;
c->state = LOCHARACTER_STATE_COMBO;
const float diffx = c->cache.player_pos.x - c->pos.x;
c->direction = MATH_SIGN(diffx);
p->phase = 2 + chaos_xorshift(c->since)%2;
p->from = c->pos;
p->to = c->cache.player_pos;
p->to.x -= c->direction*locharacter_theists_child_size_.x*2;
p->to.y -= .02f;
const loplayer_combat_attack_t attack1 = {
.attacker = c->super.super.id,
.start = c->ticker->time + (uint64_t) beat,
.duration = beat/2,
.knockback = vec2(c->direction*.1f, 0),
.effect = loeffect_immediate_damage(c->recipient.status.attack*.8f),
};
loplayer_attack(c->player, &attack1);
const loplayer_combat_attack_t attack2 = {
.attacker = c->super.super.id,
.start = c->ticker->time + (uint64_t) (beat*2),
.duration = p->phase == 2? beat*1.5: beat/2,
.knockback = vec2(c->direction*.1f, 0),
.effect = loeffect_immediate_damage(c->recipient.status.attack*1.1f),
};
loplayer_attack(c->player, &attack2);
if (p->phase >= 3) {
const loplayer_combat_attack_t attack3 = {
.attacker = c->super.super.id,
.start = c->ticker->time + (uint64_t) (beat*3),
.duration = beat/2,
.knockback = vec2(c->direction*.1f, 0),
.effect = loeffect_immediate_damage(c->recipient.status.attack*1.3f),
};
loplayer_attack(c->player, &attack3);
}
}
static void locharacter_theists_child_update_cooldown_state_(
locharacter_base_t* c) {
assert(c != NULL);
static const float beat = LOCHARACTER_THEISTS_CHILD_BEAT;
static const uint64_t duration = beat*4;
const locharacter_theists_child_param_t* p = (typeof(p)) c->data;
c->cache.bullet_hittest = true;
c->cache.gravity = true;
/* ---- motion ---- */
float t = (c->cache.time - c->since)*1.0f/duration;
if (t > 1) t = 1;
loshader_character_drawer_instance_t* instance = &c->cache.instance;
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_ATTACK2;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_STAND1;
instance->motion_time = t;
/* ---- state transition ---- */
if (locharacter_theists_child_reset_if_player_left_(c)) return;
if (c->since+duration < c->cache.time) {
if (locharacter_event_holder_has_control(&p->event)) {
static const uint64_t dur = LOCHARACTER_THEISTS_CHILD_MUSIC_DURATION;
if (p->event.start_time+dur < c->cache.time) {
locharacter_theists_child_finalize_event_(c);
return;
}
} else {
if (c->recipient.madness <= 0) {
locharacter_theists_child_start_dead_state_(c);
return;
}
}
vec2_t diff;
vec2_sub(&diff, &c->cache.player_pos, &c->pos);
if (vec2_pow_length(&diff) < .5f*.5f) {
locharacter_theists_child_start_combo_state_(c);
return;
}
locharacter_theists_child_start_rush_state_(c);
return;
}
}
static void locharacter_theists_child_start_cooldown_state_(
locharacter_base_t* c) {
assert(c != NULL);
const locharacter_theists_child_param_t* p = (typeof(p)) c->data;
c->since = c->cache.time;
c->state = LOCHARACTER_STATE_COOLDOWN;
bool skip_firing = false;
if (locharacter_event_holder_has_control(&p->event)) {
const float beat =
(c->cache.time - p->event.start_time)/LOCHARACTER_THEISTS_CHILD_BEAT;
skip_firing =
LOCHARACTER_THEISTS_CHILD_MELODY_B_START_BEAT <= beat &&
beat < LOCHARACTER_THEISTS_CHILD_MELODY_B_END_BEAT;
}
if (!skip_firing) locharacter_theists_child_fire_bullets_(c);
}
static void locharacter_theists_child_update_stunned_state_(
locharacter_base_t* c) {
assert(c != NULL);
static const float beat = LOCHARACTER_THEISTS_CHILD_BEAT;
static const uint64_t duration = beat*4;
/* ---- motion ---- */
float t = (c->cache.time - c->since)*1.f/duration;
t *= 6;
loshader_character_drawer_instance_t* instance = &c->cache.instance;
if (t < 1) {
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_STAND1;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_SIT;
instance->motion_time = 1-powf(1-t, 6);
} else {
t = (t-1)/5;
if (t > 1) t = 1;
t = t*t*(3-2*t);
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_SIT;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_ATTACK2;
instance->motion_time = t;
}
/* ---- state transition ---- */
if (c->since+duration < c->cache.time) {
locharacter_theists_child_start_cooldown_state_(c);
return;
}
}
static void locharacter_theists_child_start_stunned_state_(
locharacter_base_t* c) {
assert(c != NULL);
c->since = c->cache.time;
c->state = LOCHARACTER_STATE_STUNNED;
loeffect_recipient_apply_effect(
&c->recipient, &loeffect_immediate_damage(1.f));
}
static void locharacter_theists_child_update_dead_state_(
locharacter_base_t* c) {
assert(c != NULL);
static const uint64_t anime_duration = 4000;
static const uint64_t duration = 30000;
c->cache.gravity = true;
/* ---- motion ---- */
float t = (c->cache.time - c->since)*1.f/anime_duration;
if (t > 1) t = 1;
loshader_character_drawer_instance_t* instance = &c->cache.instance;
instance->from_motion_id = LOSHADER_CHARACTER_MOTION_ID_STAND1;
instance->to_motion_id = LOSHADER_CHARACTER_MOTION_ID_DOWN;
instance->motion_time = t*t;
instance->color.w = 1-t;
/* ---- state transition ---- */
if (c->since+duration < c->cache.time) {
c->pos = vec2(0, 0);
locharacter_theists_child_start_wait_state_(c);
return;
}
}
static void locharacter_theists_child_start_dead_state_(
locharacter_base_t* c) {
assert(c != NULL);
c->since = c->cache.time;
c->state = LOCHARACTER_STATE_DEAD;
loplayer_gain_faith(c->player, .5f);
}
bool locharacter_theists_child_update(locharacter_base_t* base) {
assert(base != NULL);
static const vec2_t size = locharacter_theists_child_size_;
static const vec4_t color = vec4(.05f, 0, 0, 1);
static const float height = size.y * 1.4f;
static const float drawsz = MATH_MAX(size.x, size.y);
locharacter_theists_child_param_t* p = (typeof(p)) base->data;
loeffect_recipient_update(
&base->recipient, &locharacter_theists_child_base_status_);
if (!locharacter_event_holder_update(&p->event)) {
locharacter_theists_child_start_wait_state_(base);
}
base->cache.instance = (loshader_character_drawer_instance_t) {
.character_id = LOSHADER_CHARACTER_ID_CAVIA,
.marker_offset = vec2(0, height - drawsz),
.pos = vec2(0, drawsz - height),
.size = vec2(drawsz, drawsz),
.color = color,
};
switch (base->state) {
case LOCHARACTER_STATE_WAIT:
locharacter_theists_child_update_wait_state_(base);
break;
case LOCHARACTER_STATE_STANDUP:
locharacter_theists_child_update_standup_state_(base);
break;
case LOCHARACTER_STATE_RUSH:
locharacter_theists_child_update_rush_state_(base);
break;
case LOCHARACTER_STATE_COMBO:
locharacter_theists_child_update_combo_state_(base);
break;
case LOCHARACTER_STATE_COOLDOWN:
locharacter_theists_child_update_cooldown_state_(base);
break;
case LOCHARACTER_STATE_STUNNED:
locharacter_theists_child_update_stunned_state_(base);
break;
case LOCHARACTER_STATE_DEAD:
locharacter_theists_child_update_dead_state_(base);
break;
default:
locharacter_theists_child_start_wait_state_(base);
}
locharacter_theists_child_update_passive_action_(base);
base->cache.height = height;
base->cache.instance.marker = !!base->cache.bullet_hittest;
base->cache.instance.size.x *= base->direction;
return true;
}
void locharacter_theists_child_build(locharacter_base_t* base, loentity_id_t ground) {
assert(base != NULL);
base->type = LOCHARACTER_TYPE_THEISTS_CHILD;
base->ground = ground;
base->pos = vec2(0, 0);
base->direction = 1;
base->state = LOCHARACTER_STATE_WAIT;
base->since = base->cache.time;
locharacter_theists_child_param_t* p = (typeof(p)) base->data;
*p = (typeof(*p)) {0};
locharacter_event_holder_initialize(
&p->event,
&base->res->music.boss_theists_child,
base,
LOCHARACTER_THEISTS_CHILD_MUSIC_DURATION,
0);
}
void locharacter_theists_child_tear_down(locharacter_base_t* base) {
assert(base != NULL);
locharacter_theists_child_param_t* p = (typeof(p)) base->data;
locharacter_event_holder_deinitialize(&p->event);
}
void locharacter_theists_child_pack_data(
const locharacter_base_t* base, msgpack_packer* packer) {
assert(base != NULL);
assert(packer != NULL);
const locharacter_theists_child_param_t* p = (typeof(p)) base->data;
msgpack_pack_map(packer, LOCHARACTER_THEISTS_CHILD_PARAM_TO_PACK_COUNT);
# define pack_(name, var) do { \
mpkutil_pack_str(packer, name); \
LOCOMMON_MSGPACK_PACK_ANY(packer, &p->var); \
} while (0)
LOCHARACTER_THEISTS_CHILD_PARAM_TO_PACK_EACH_(pack_);
# undef pack_
}
bool locharacter_theists_child_unpack_data(
locharacter_base_t* base, const msgpack_object* obj) {
assert(base != NULL);
locharacter_theists_child_param_t* p = (typeof(p)) base->data;
const msgpack_object_map* root = mpkutil_get_map(obj);
# define item_(v) mpkutil_get_map_item_by_str(root, v)
# define unpack_(name, var) do { \
if (!LOCOMMON_MSGPACK_UNPACK_ANY(item_(name), &p->var)) { \
return false; \
} \
} while (0)
LOCHARACTER_THEISTS_CHILD_PARAM_TO_PACK_EACH_(unpack_);
# undef unpack_
# undef item_
locharacter_event_holder_initialize(
&p->event,
&base->res->music.boss_theists_child,
base,
LOCHARACTER_THEISTS_CHILD_MUSIC_DURATION,
p->event.start_time);
return true;
}