taisei/src/player.c

/*
 * This software is licensed under the terms of the MIT License.
 * See COPYING for further information.
 * ---
 * Copyright (c) 2011-2024, Lukas Weber <laochailan@web.de>.
 * Copyright (c) 2012-2024, Andrei Alexeyev <akari@taisei-project.org>.
 */

#include "player.h"

#include "audio/audio.h"
#include "entity.h"
#include "gamepad.h"
#include "global.h"
#include "plrmodes.h"
#include "projectile.h"
#include "replay/stage.h"
#include "replay/struct.h"
#include "stage.h"
#include "stagedraw.h"
#include "stagetext.h"
#include "stats.h"
#include "util/glm.h"
#include "util/graphics.h"

DEFINE_ENTITY_TYPE(PlayerIndicators, {
	Player *plr;

	struct {
		Sprite *focus;
	} sprites;

	float focus_alpha;
	int focus_time;
});

void player_init(Player *plr) {
	memset(plr, 0, sizeof(Player));
	plr->pos = PLR_SPAWN_POS;
	plr->lives = PLR_START_LIVES;
	plr->bombs = PLR_START_BOMBS;
	plr->point_item_value = PLR_START_PIV;
	plr->power_stored = 100;
	plr->deathtime = -1;
	plr->continuetime = -1;
	plr->bomb_triggertime = -1;
	plr->bomb_endtime = 0;
	plr->mode = plrmode_find(0, 0);
}

void player_stage_pre_init(Player *plr) {
	plr->recoverytime = 0;
	plr->respawntime = 0;
	plr->bomb_triggertime = -1;
	plr->bomb_endtime = 0;
	plr->deathtime = -1;
	plr->axis_lr = 0;
	plr->axis_ud = 0;
}

double player_property(Player *plr, PlrProperty prop) {
	return plr->mode->procs.property(plr, prop);
}

static void ent_draw_player(EntityInterface *ent);
static DamageResult ent_damage_player(EntityInterface *ent, const DamageInfo *dmg);

DECLARE_TASK(player_logic, { BoxedPlayer plr; });
DECLARE_TASK(player_indicators, { BoxedPlayer plr; });

void player_stage_post_init(Player *plr) {
	assert(plr->mode != NULL);

	// ensure the essential callbacks are there. other code tests only for the optional ones
	assert(plr->mode->procs.property != NULL);
	assert(plr->mode->character != NULL);
	assert(plr->mode->dialog != NULL);

	plrchar_render_bomb_portrait(plr->mode->character, &plr->bomb_portrait);
	aniplayer_create(&plr->ani, plrchar_player_anim(plr->mode->character), "main");

	plr->ent.draw_layer = LAYER_PLAYER;
	plr->ent.draw_func = ent_draw_player;
	plr->ent.damage_func = ent_damage_player;
	ent_register(&plr->ent, ENT_TYPE_ID(Player));

	COEVENT_INIT_ARRAY(plr->events);

	INVOKE_TASK_DELAYED(1, player_logic, ENT_BOX(plr));
	INVOKE_TASK_DELAYED(1, player_indicators, ENT_BOX(plr));

	if(plr->mode->procs.init != NULL) {
		plr->mode->procs.init(plr);
	}

	plr->extralife_threshold = player_next_extralife_threshold(plr->extralives_given);

	while(plr->points >= plr->extralife_threshold) {
		plr->extralife_threshold = player_next_extralife_threshold(++plr->extralives_given);
	}
}

void player_free(Player *plr) {
	COEVENT_CANCEL_ARRAY(plr->events);
	r_texture_destroy(plr->bomb_portrait.tex);
	aniplayer_free(&plr->ani);
	ent_unregister(&plr->ent);
}

static void player_full_power(Player *plr) {
	stage_clear_hazards(CLEAR_HAZARDS_ALL);
	stagetext_add("Full Power!", VIEWPORT_W * 0.5 + VIEWPORT_H * 0.33 * I, ALIGN_CENTER, res_font("big"), RGB(1, 1, 1), 0, 60, 20, 20);
}

static int player_track_effective_power_change(Player *plr) {
	int old_effective = plr->_prev_effective_power;
	int new_effective = player_get_effective_power(plr);

	if(old_effective != new_effective) {
		plr->_prev_effective_power = new_effective;
		coevent_signal(&plr->events.effective_power_changed);
	}

	return new_effective;
}

bool player_set_power(Player *plr, short npow) {
	int old_stored = plr->power_stored;
	int new_stored = clamp(npow, 0, PLR_MAX_POWER_STORED);
	plr->power_stored = new_stored;

	if(old_stored / 100 < new_stored / 100) {
		play_sfx("powerup");
	}

	bool change = old_stored != new_stored;

	if(change) {
		if(new_stored >= PLR_MAX_POWER_EFFECTIVE && old_stored < PLR_MAX_POWER_EFFECTIVE) {
			player_full_power(plr);
		}

		coevent_signal(&plr->events.stored_power_changed);
	}

	player_track_effective_power_change(plr);

	return change;
}

bool player_add_power(Player *plr, short pdelta) {
	return player_set_power(plr, plr->power_stored + pdelta);
}

int player_get_effective_power(Player *plr) {
	int p;

	if(player_is_powersurge_active(plr)) {
		p = plr->powersurge.player_power;
	} else {
		p = plr->power_stored;
	}

	return clamp(p, 0, PLR_MAX_POWER_EFFECTIVE);
}

void player_move(Player *plr, cmplx delta) {
	delta *= player_property(plr, PLR_PROP_SPEED);
	plr->uncapped_velocity = delta;
	cmplx lastpos = plr->pos;
	cmplx ofs = CMPLX(PLR_MIN_BORDER_DIST, PLR_MIN_BORDER_DIST);
	cmplx vp = CMPLX(VIEWPORT_W, VIEWPORT_H);
	plr->pos = cwclamp(lastpos + delta, ofs, vp - ofs);
	plr->velocity = plr->pos - lastpos;
}

void player_draw_overlay(Player *plr) {
	float a = 1 - plr->bomb_cutin_alpha;

	if(a <= 0 || a >= 1) {
		return;
	}

	r_state_push();
	r_shader("sprite_default");

	float char_in = clamp(a * 1.5f, 0, 1);
	float char_out = min(1, 2 - (2 * a));
	float char_opacity_in = 0.75 * min(1, a * 5);
	float char_opacity = char_opacity_in * char_out * char_out;
	float char_xofs = -20 * a;

	Sprite *char_spr = &plr->bomb_portrait;

	for(int i = 1; i <= 3; ++i) {
		float t = a * 200;
		float dur = 20;
		float start = 200 - dur * 5;
		float end = start + dur;
		float ofs = 0.2 * dur * (i - 1);
		float o = 1 - smoothstep(start + ofs, end + ofs, t);

		r_draw_sprite(&(SpriteParams) {
			.sprite_ptr = char_spr,
			.pos = { char_spr->w * 0.5 + VIEWPORT_W * powf(1 - char_in, 4 - i * 0.3f) - i + char_xofs, VIEWPORT_H - char_spr->h * 0.5f },
			.color = color_mul_scalar(color_add(RGBA(0.2, 0.2, 0.2, 0), RGBA(i==1, i==2, i==3, 0)), char_opacity_in * (1 - char_in * o) * o),
			.flip.x = true,
			.scale.both = 1.0f + 0.02f * (min(1, a * 1.2f)) + i * 0.5 * powf(1 - o, 2),
		});
	}

	r_draw_sprite(&(SpriteParams) {
		.sprite_ptr = char_spr,
		.pos = { char_spr->w * 0.5f + VIEWPORT_W * powf(1 - char_in, 4) + char_xofs, VIEWPORT_H - char_spr->h * 0.5f },
		.color = RGBA_MUL_ALPHA(1, 1, 1, char_opacity * min(1, char_in * 2) * (1 - min(1, (1 - char_out) * 5))),
		.flip.x = true,
		.scale.both = 1.0 + 0.1 * (1 - char_out),
	});

	float spell_in = min(1, a * 3.0);
	float spell_out = min(1, 3 - (3 * a));
	float spell_opacity = min(1, a * 5) * spell_out * spell_out;

	float spell_x = 128 * (1 - powf(1 - spell_in, 5)) + (VIEWPORT_W + 256) * powf(1 - spell_in, 3);
	float spell_y = VIEWPORT_H - 128 * sqrtf(a);

	Sprite *spell_spr = res_sprite("spell");

	r_draw_sprite(&(SpriteParams) {
		.sprite_ptr = spell_spr,
		.pos = { spell_x, spell_y },
		.color = color_mul_scalar(RGBA(1, 1, 1, spell_in * 0.5), spell_opacity),
		.scale.both = 3 - 2 * (1 - pow(1 - spell_in, 3)) + 2 * (1 - spell_out),
	});

	Font *font = res_font("standard");

	r_mat_mv_push();
	r_mat_mv_translate(spell_x - spell_spr->w * 0.5 + 10, spell_y + 5 - font_get_metrics(font)->descent, 0);

	TextParams tp = {
		// .pos = { spell_x - spell_spr->w * 0.5 + 10, spell_y + 5 - font_get_metrics(font)->descent },
		.shader = "text_hud",
		.font_ptr = font,
		.color = color_mul_scalar(RGBA(1, 1, 1, spell_in), spell_opacity),
	};

	r_mat_mv_push();
	r_mat_mv_scale(2 - 1 * spell_opacity, 2 - 1 * spell_opacity, 1);
	text_draw(plr->mode->spellcard_name, &tp);
	r_mat_mv_pop();

	r_mat_mv_pop();
	r_state_pop();
}

static void ent_draw_player(EntityInterface *ent) {
	Player *plr = ENT_CAST(ent, Player);

	if(plr->deathtime >= global.frames) {
		return;
	}

	ShaderCustomParams shader_params = { 1.0f };
	ShaderProgram *shader = res_shader("sprite_particle");

	if(plr->focus_circle_alpha) {
		r_draw_sprite(&(SpriteParams) {
			.sprite_ptr = res_sprite("fairy_circle"),
			.shader_ptr = shader,
			.shader_params = &shader_params,
			.rotation.angle = DEG2RAD * global.frames * 10,
			.color = RGBA_MUL_ALPHA(1, 1, 1, 0.2 * plr->focus_circle_alpha),
			.pos = { re(plr->pos), im(plr->pos) },
		});
	}

	Color c;

	if(!player_is_vulnerable(plr)) {
		float f = 0.3*sin(0.1*global.frames);
		c = *RGBA_MUL_ALPHA(1.0+f, 1.0, 1.0-f, 0.7+f);
	} else {
		c = *RGBA_MUL_ALPHA(1.0, 1.0, 1.0, 1.0);
	}

	r_draw_sprite(&(SpriteParams) {
		.sprite_ptr = aniplayer_get_frame(&plr->ani),
		.shader_ptr = shader,
		.shader_params = &shader_params,
		.pos.as_cmplx = plr->pos,
		.color = &c,
	});
}

static void player_draw_indicators(EntityInterface *ent) {
	PlayerIndicators *indicators = ENT_CAST(ent, PlayerIndicators);
	Player *plr = indicators->plr;

	float focus_opacity = indicators->focus_alpha;
	int t = global.frames - indicators->focus_time;
	cmplxf pos = plr->pos;

	if(focus_opacity > 0) {
		float trans_frames = 12;
		float trans_factor = 1.0f - min(trans_frames, t) / trans_frames;
		float rot_speed = DEG2RAD * global.frames * (1.0f + 3.0f * trans_factor);
		float scale = 1.0f + trans_factor;

		SpriteParams sp = {
			.sprite_ptr = indicators->sprites.focus,
			.rotation.angle = rot_speed,
			.color = RGBA_MUL_ALPHA(1, 1, 1, focus_opacity),
			.pos.as_cmplx = pos,
			.scale.both = scale,
		};

		r_draw_sprite(&sp);
		sp.rotation.angle *= -1;
		r_draw_sprite(&sp);
	}

	float ps_opacity = 1.0;
	float ps_fill_factor = 1.0;

	if(player_is_powersurge_active(plr)) {
		ps_opacity *= clamp((global.frames - plr->powersurge.time.activated) / 30.0, 0, 1);
	} else if(plr->powersurge.time.expired == 0) {
		ps_opacity = 0;
	} else {
		ps_opacity *= (1 - clamp((global.frames - plr->powersurge.time.expired) / 40.0, 0, 1));
		ps_fill_factor = pow(ps_opacity, 2);
	}

	if(ps_opacity > 0) {
		r_state_push();
		r_mat_mv_push();
		r_mat_mv_translate(re(pos), im(pos), 0);
		r_mat_mv_scale(140, 140, 0);
		r_shader("healthbar_radial");
		r_uniform_vec4_rgba("borderColor",   RGBA(0.5, 0.5, 0.5, 0.5));
		r_uniform_vec4_rgba("glowColor",     RGBA(0.5, 0.5, 0.5, 0.75));
		r_uniform_vec4_rgba("fillColor",     RGBA(1.5, 0.5, 0.0, 0.75));
		r_uniform_vec4_rgba("altFillColor",  RGBA(0.0, 0.5, 1.5, 0.75));
		r_uniform_vec4_rgba("coreFillColor", RGBA(0.8, 0.8, 0.8, 0.25));
		r_uniform_vec2("fill", plr->powersurge.positive * ps_fill_factor, plr->powersurge.negative * ps_fill_factor);
		r_uniform_float("opacity", ps_opacity);
		r_draw_quad();
		r_mat_mv_pop();
		r_state_pop();

		char buf[64];
		format_huge_num(0, plr->powersurge.bonus.baseline, sizeof(buf), buf);
		Font *fnt = res_font("monotiny");

		float x = re(pos);
		float y = im(pos) + 80;

		float text_opacity = ps_opacity * 0.75;

		x += text_draw(buf, &(TextParams) {
			.shader = "text_hud",
			.font_ptr = fnt,
			.pos = { x, y },
			.color = RGBA_MUL_ALPHA(1.0, 1.0, 1.0, text_opacity),
			.align = ALIGN_CENTER,
		});

		snprintf(buf, sizeof(buf), " +%u", plr->powersurge.bonus.gain_rate);

		text_draw(buf, &(TextParams) {
			.shader = "text_hud",
			.font_ptr = fnt,
			.pos = { x, y },
			.color = RGBA_MUL_ALPHA(0.3, 0.6, 1.0, text_opacity),
			.align = ALIGN_LEFT,
		});

		r_shader("sprite_filled_circle");
		r_uniform_vec4("color_inner", 0, 0, 0, 0);
		r_uniform_vec4("color_outer", 0, 0, 0.1 * ps_opacity, 0.1 * ps_opacity);
	}
}

DEFINE_TASK(player_indicators) {
	PlayerIndicators *indicators = TASK_HOST_ENT(PlayerIndicators);
	indicators->plr = TASK_BIND(ARGS.plr);
	indicators->ent.draw_layer = LAYER_PLAYER_FOCUS;
	indicators->ent.draw_func = player_draw_indicators;
	indicators->sprites.focus = res_sprite("focus");

	Player *plr = indicators->plr;

	bool was_focused = false;
	bool is_focused = false;

	for(;;) {
		is_focused = (plr->inputflags & INFLAG_FOCUS) && player_is_alive(plr);

		if(is_focused && !was_focused) {
			indicators->focus_time = global.frames;
			indicators->focus_alpha = min(indicators->focus_alpha, 0.1f);
		}

		was_focused = is_focused;
		fapproach_p(&indicators->focus_alpha, is_focused, 1.0f/30.0f);

		YIELD;
	}
}

static void player_fail_spell(Player *plr) {
	Boss *boss = global.boss;

	if(!boss || global.stage->type == STAGE_SPELL) {
		return;
	}

	Attack *atk = boss->current;

	if(!atk || !attack_is_active(atk) || attack_was_failed(atk)) {
		return;
	}

	global.boss->current->failtime = global.frames;

	if(global.boss->current->type == AT_ExtraSpell) {
		boss_finish_current_attack(global.boss);
	}
}

bool player_should_shoot(Player *plr) {
	return
		(plr->inputflags & INFLAG_SHOT) &&
		!dialog_is_active(global.dialog) &&
		player_is_alive(&global.plr);
}

void player_placeholder_bomb_logic(Player *plr) {
	if(!player_is_bomb_active(plr)) {
		return;
	}

	DamageInfo dmg;
	dmg.amount = 100;
	dmg.type = DMG_PLAYER_BOMB;

	for(Enemy *en = global.enemies.first; en; en = en->next) {
		ent_damage(&en->ent, &dmg);
	}

	if(global.boss) {
		ent_damage(&global.boss->ent, &dmg);
	}

	stage_clear_hazards(CLEAR_HAZARDS_ALL);
}

static void player_powersurge_expired(Player *plr);

static void _powersurge_trail_draw(Projectile *p, float t, float cmul) {
	float nt = t / p->timeout;
	float s = 1 + (2 + 0.5 * psin((t+global.frames*1.23)/5.0)) * nt * nt;

	r_draw_sprite(&(SpriteParams) {
		.sprite_ptr = p->sprite,
		.scale.both = s,
		.pos = { re(p->pos), im(p->pos) },
		.color = color_mul_scalar(RGBA(0.8, 0.1 + 0.2 * psin((t+global.frames)/5.0), 0.1, 0.0), 0.5 * (1 - nt) * cmul),
		.shader_params = &(ShaderCustomParams){{ -2 * nt * nt }},
		.shader_ptr = p->shader,
	});
}

static void powersurge_trail_draw(Projectile *p, int t, ProjDrawRuleArgs args) {
	if(t > 0) {
		_powersurge_trail_draw(p, t - 0.5, 0.25);
		_powersurge_trail_draw(p, t, 0.25);
	} else {
		_powersurge_trail_draw(p, t, 0.5);
	}
}

TASK(powersurge_player_particles, { BoxedPlayer plr; }) {
	Player *plr = TASK_BIND(ARGS.plr);

	DECLARE_ENT_ARRAY(Projectile, trails, 32);
	DECLARE_ENT_ARRAY(Projectile, fields, 4);

	ShaderProgram *trail_shader = res_shader("sprite_silhouette");
	Sprite *field_sprite = res_sprite("part/powersurge_field");

	for(int t = 0; player_is_powersurge_active(plr); ++t, YIELD) {
		ENT_ARRAY_COMPACT(&trails);
		ENT_ARRAY_ADD(&trails, PARTICLE(
			.sprite_ptr = aniplayer_get_frame(&plr->ani),
			.shader_ptr = trail_shader,
			.pos = plr->pos,
			.color = RGBA(1, 1, 1, 0.5),
			.draw_rule = powersurge_trail_draw,
			.move = move_towards(0, plr->pos, 0),
			.timeout = 15,
			.layer = LAYER_PARTICLE_HIGH,
			.flags = PFLAG_NOREFLECT | PFLAG_MANUALANGLE,
		));

		if(t % 6 == 0 && plr->powersurge.bonus.discharge_range > 0) {
			real scale = 2 * plr->powersurge.bonus.discharge_range / field_sprite->w;
			real angle = rng_angle();
			Color *color = color_mul_scalar(rng_bool() ? RGBA(1.5, 0.5, 0.0, 0.1) : RGBA(0.0, 0.5, 1.5, 0.1), 0.25);

			ENT_ARRAY_COMPACT(&fields);

			ENT_ARRAY_ADD(&fields, PARTICLE(
				.sprite_ptr = field_sprite,
				.pos = plr->pos,
				.color = color,
				.draw_rule = pdraw_timeout_fade(1, 0),
				.timeout = 14,
				.angle = angle,
				.layer = LAYER_PLAYER - 1,
				.flags = PFLAG_NOREFLECT | PFLAG_NOMOVE | PFLAG_REQUIREDPARTICLE,
				.scale = scale,
			));

			ENT_ARRAY_ADD(&fields, PARTICLE(
				.sprite_ptr = field_sprite,
				.pos = plr->pos,
				.color = RGBA(0.5, 0.5, 0.5, 0),
				.draw_rule = pdraw_timeout_fade(1, 0),
				.timeout = 3,
				.angle = angle,
				.layer = LAYER_PLAYER - 1,
				.flags = PFLAG_NOREFLECT | PFLAG_NOMOVE,
				.scale = scale,
			));
		}

		ENT_ARRAY_FOREACH(&trails, Projectile *p, {
			p->move.attraction_point = plr->pos;
			p->move.attraction = 1 - (global.frames - p->birthtime) / p->timeout;
		});

		ENT_ARRAY_FOREACH(&fields, Projectile *p, {
			p->pos = plr->pos;
		});
	}
}

void player_powersurge_calc_bonus(Player *plr, PowerSurgeBonus *b) {
	b->gain_rate = round(1000 * plr->powersurge.negative * plr->powersurge.negative);
	b->baseline = plr->powersurge.total_charge + plr->powersurge.damage_done * 0.4;
	b->score = b->baseline;
	b->discharge_power = sqrtf(0.2 * b->baseline + 1024 * log1pf(b->baseline)) * smoothstep(0, 1, 0.0001 * b->baseline);
	b->discharge_range = 1.2 * b->discharge_power;
	b->discharge_damage = 10 * pow(b->discharge_power, 1.1);
}

static void player_powersurge_logic(Player *plr) {
	if(dialog_is_active(global.dialog)) {
		return;
	}

	plr->powersurge.positive = max(0, plr->powersurge.positive - lerp(PLR_POWERSURGE_POSITIVE_DRAIN_MIN, PLR_POWERSURGE_POSITIVE_DRAIN_MAX, plr->powersurge.positive));
	plr->powersurge.negative = max(0, plr->powersurge.negative - lerp(PLR_POWERSURGE_NEGATIVE_DRAIN_MIN, PLR_POWERSURGE_NEGATIVE_DRAIN_MAX, plr->powersurge.negative));

	if(stage_is_cleared()) {
		player_cancel_powersurge(plr);
		return;
	}

	if(plr->powersurge.positive <= plr->powersurge.negative) {
		player_powersurge_expired(plr);
		return;
	}

	player_powersurge_calc_bonus(plr, &plr->powersurge.bonus);

	plr->powersurge.total_charge += plr->powersurge.bonus.gain_rate;
}

DEFINE_TASK(player_logic) {
	Player *plr = TASK_BIND(ARGS.plr);
	uint prev_inputflags = 0;

	plr->_prev_effective_power = player_get_effective_power(plr);

	for(;;) {
		YIELD;

		if(prev_inputflags != plr->inputflags) {
			coevent_signal(&plr->events.inputflags_changed);
			prev_inputflags = plr->inputflags;
		}

		fapproach_p(&plr->bomb_cutin_alpha, 0, 1/200.0);

		if(
			plr->respawntime - PLR_RESPAWN_TIME/2 == global.frames &&
			plr->lives < 0 && global.replay.input.replay == NULL
		) {
			stage_gameover();
		}

		if(plr->continuetime == global.frames) {
			plr->lives = PLR_START_LIVES;
			plr->bombs = PLR_START_BOMBS;
			plr->point_item_value = PLR_START_PIV;
			plr->life_fragments = 0;
			plr->bomb_fragments = 0;
			stats_track_continue_used(&plr->stats);
			player_set_power(plr, 0);
			stage_clear_hazards(CLEAR_HAZARDS_ALL);
			spawn_items(plr->deathpos, ITEM_POWER, (int)ceil(PLR_MAX_POWER_EFFECTIVE/(real)POWER_VALUE));
		}

		aniplayer_update(&plr->ani);

		if(plr->lives < 0) {
			continue;
		}

		if(plr->respawntime > global.frames) {
			double x = PLR_SPAWN_POS_X;
			double y = lerp(PLR_SPAWN_POS_Y, VIEWPORT_H + 64, smoothstep(0.0, 1.0, (plr->respawntime - global.frames) / (double)PLR_RESPAWN_TIME));
			plr->pos = CMPLX(x, y);
			stage_clear_hazards(CLEAR_HAZARDS_ALL | CLEAR_HAZARDS_NOW);
			continue;
		}

		if(player_is_powersurge_active(plr)) {
			player_powersurge_logic(plr);
		}

		fapproach_p(&plr->focus_circle_alpha, !!(plr->inputflags & INFLAG_FOCUS), 1.0f/15.0f);

		if(player_should_shoot(plr)) {
			coevent_signal(&plr->events.shoot);
		}

		if(global.frames == plr->deathtime) {
			player_realdeath(plr);
		} else if(plr->deathtime > global.frames) {
			stage_clear_hazards(CLEAR_HAZARDS_ALL | CLEAR_HAZARDS_NOW);
		}

		player_track_effective_power_change(plr);
	}
}