taisei/src/projectile.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 "projectile.h"

#include "global.h"
#include "list.h"
#include "stageobjects.h"
#include "util/glm.h"
#include "stage.h"

static ht_ptr2int_t shader_sublayer_map;

static ProjArgs defaults_proj = {
	.sprite = "proj/",
	.dest = &global.projs,
	.type = PROJ_ENEMY,
	.damage_type = DMG_ENEMY_SHOT,
	.color = RGB(1, 1, 1),
	.blend = BLEND_PREMUL_ALPHA,
	.shader = "sprite_bullet",
	.layer = LAYER_BULLET,
};

static ProjArgs defaults_part = {
	.sprite = "part/",
	.dest = &global.particles,
	.type = PROJ_PARTICLE,
	.damage_type = DMG_UNDEFINED,
	.color = RGB(1, 1, 1),
	.blend = BLEND_PREMUL_ALPHA,
	.shader = "sprite_particle",
	.layer = LAYER_PARTICLE_MID,
};

static void process_projectile_args(ProjArgs *args, ProjArgs *defaults) {
	if(args->proto && args->proto->process_args) {
		args->proto->process_args(args->proto, args);
		return;
	}

	// TODO: move this stuff into prototypes along with the defaults?

	if(args->sprite) {
		args->sprite_ptr = prefix_get_sprite(args->sprite, defaults->sprite);
	}

	if(!args->shader_ptr) {
		if(args->shader) {
			args->shader_ptr = res_shader(args->shader);
		} else {
			args->shader_ptr = defaults->shader_ptr;
		}
	}

	if(!args->draw_rule.func) {
		args->draw_rule = pdraw_basic();
	}

	if(!args->blend) {
		args->blend = defaults->blend;
	}

	if(!args->dest) {
		args->dest = defaults->dest;
	}

	if(!args->type) {
		args->type = defaults->type;
	}

	if(!args->color) {
		args->color = defaults->color;
	}

	if(!args->max_viewport_dist && args->type == PROJ_PARTICLE) {
		// TODO consider a saner value?
		args->max_viewport_dist = 300;
	}

	if(!args->layer) {
		if(args->type == PROJ_PLAYER) {
			args->layer = LAYER_PLAYER_SHOT;
		} else {
			args->layer = defaults->layer;
		}
	}

	if(args->damage_type == DMG_UNDEFINED) {
		args->damage_type = defaults->damage_type;

		if(args->type == PROJ_PLAYER && args->damage_type == DMG_ENEMY_SHOT) {
			args->damage_type = DMG_PLAYER_SHOT;
		}
	}

	if(args->scale == 0) {
		args->scale = 1+I;
	} else if(im(args->scale) == 0) {
		args->scale = CMPLXF(re(args->scale), re(args->scale));
	}

	if(args->opacity == 0) {
		args->opacity = 1;
	}

	assert(args->type <= PROJ_PLAYER);
}

static cmplx projectile_size(Projectile *p) {
	cmplx r;

	if(p->type == PROJ_PARTICLE && LIKELY(p->sprite != NULL)) {
		r = p->sprite->extent.as_cmplx;
	} else {
		r = p->size;
	}

	assert(re(r) > 0);
	assert(im(r) > 0);

	return r;
}

static Projectile *spawn_bullet_spawning_effect(Projectile *p);

// Returns true if projectile should be destroyed
static inline bool proj_update(Projectile *p, int t) {
	bool destroy = false;

	if(p->timeout > 0 && t >= p->timeout) {
		destroy = true;
	} else if(t >= 0) {
		if(!(p->flags & PFLAG_NOMOVE)) {
			move_update(&p->pos, &p->move);
		}

		if(p->flags & PFLAG_MANUALANGLE) {
			p->angle += p->angle_delta;
		} else {
			cmplx delta_pos = p->pos - p->prevpos;

			if(delta_pos) {
				real angle;

				if(p->_cached_delta_pos == delta_pos) {
					angle = p->_cached_angle;
				} else {
					angle = carg(delta_pos);
					p->_cached_delta_pos = delta_pos;
					p->_cached_angle = angle;
				}

				p->angle = angle + p->angle_delta;
			}
		}
	}

	if(t == 1) {
		// FIXME: not sure if this should happen before or after move_update,
		// or maybe even directly at spawn.
		spawn_bullet_spawning_effect(p);
	}

	return destroy;
}

void projectile_set_prototype(Projectile *p, ProjPrototype *proto) {
	if(p->proto && p->proto->deinit_projectile) {
		p->proto->deinit_projectile(p->proto, p);
	}

	if(proto && proto->init_projectile) {
		proto->init_projectile(proto, p);
	}

	p->proto = proto;
}

cmplx projectile_graze_size(Projectile *p) {
	if(
		p->type == PROJ_ENEMY &&
		!(p->flags & (PFLAG_NOGRAZE | PFLAG_NOCOLLISION)) &&
		p->graze_counter < 3 &&
		global.frames >= p->graze_cooldown
	) {
		real scale = 420.0 /* graze it */ / (2 * p->graze_counter + 1);
		cmplx s = scale * p->size;
		return CMPLX(sqrt(re(s)), sqrt(im(s)));
	}

	return 0;
}

float projectile_timeout_factor(Projectile *p) {
	return p->timeout ? (global.frames - p->birthtime) / p->timeout : 0;
}

static double projectile_rect_area(Projectile *p) {
	cmplx s = projectile_size(p);
	return re(s) * im(s);
}

void projectile_set_layer(Projectile *p, drawlayer_t layer) {
	if(!(layer & LAYER_LOW_MASK)) {
		drawlayer_low_t sublayer;

		switch(p->type) {
			case PROJ_ENEMY:
				// 1. Large projectiles go below smaller ones.
				sublayer = LAYER_LOW_MASK - (drawlayer_low_t)projectile_rect_area(p);
				sublayer = (sublayer << 4) & LAYER_LOW_MASK;
				// 2. Group by shader (hardcoded precedence).
				sublayer |= ht_get(&shader_sublayer_map, p->shader, 0) & 0xf;
				// If specific blending order is required, then you should set up the sublayer manually.
				layer |= sublayer;
				break;

			case PROJ_PARTICLE:
				// 1. Group by shader (hardcoded precedence).
				sublayer = ht_get(&shader_sublayer_map, p->shader, 0) & 0xf;
				sublayer <<= 4;
				sublayer |= 0x100;
				// If specific blending order is required, then you should set up the sublayer manually.
				layer |= sublayer;
				break;

			default:
				break;
		}
	}

	p->ent.draw_layer = layer;
}

static void ent_draw_projectile(EntityInterface *ent);

static Projectile* _create_projectile(ProjArgs *args) {
	if(IN_DRAW_CODE) {
		log_fatal("Tried to spawn a projectile while in drawing code");
	}

	auto p = STAGE_ACQUIRE_OBJ(Projectile);

	p->birthtime = global.frames;
	p->pos = p->pos0 = p->prevpos = args->pos;
	p->angle = args->angle;
	p->angle_delta = args->angle_delta;
	p->draw_rule = args->draw_rule;
	p->shader = args->shader_ptr;
	p->blend = args->blend;
	p->sprite = args->sprite_ptr;
	p->type = args->type;
	p->color = *args->color;
	p->max_viewport_dist = args->max_viewport_dist;
	p->size = args->size;
	p->collision_size = args->collision_size;
	p->flags = args->flags;
	p->timeout = args->timeout;
	p->damage = args->damage;
	p->damage_type = args->damage_type;
	p->clear_flags = 0;
	p->move = args->move;
	p->scale = args->scale;
	p->opacity = args->opacity;

	p->_cached_angle = p->angle;

	p->ent.draw_func = ent_draw_projectile;

	projectile_set_prototype(p, args->proto);

	// p->collision_size *= 10;
	// p->size *= 5;

	if((p->type == PROJ_ENEMY || p->type == PROJ_PLAYER) && (re(p->size) <= 0 || im(p->size) <= 0)) {
		log_fatal("Tried to spawn a projectile with invalid size %f x %f", re(p->size), im(p->size));
	}

	projectile_set_layer(p, args->layer);

	if(!(p->flags & (PFLAG_MANUALANGLE | PFLAG_NOMOVE))) {
		p->angle = carg(p->move.velocity) + p->angle_delta;
	}

	COEVENT_INIT_ARRAY(p->events);
	ent_register(&p->ent, ENT_TYPE_ID(Projectile));
	alist_append(args->dest, p);

	return p;
}

Projectile* create_projectile(ProjArgs *args) {
	process_projectile_args(args, &defaults_proj);
	return _create_projectile(args);
}

Projectile* create_particle(ProjArgs *args) {
	process_projectile_args(args, &defaults_part);
	return _create_projectile(args);
}

#ifdef PROJ_DEBUG
Projectile* _proj_attach_dbginfo(Projectile *p, DebugInfo *dbg, const char *callsite_str) {
	// log_debug("Spawn: [%s]", callsite_str);
	memcpy(&p->debug, dbg, sizeof(DebugInfo));
	set_debug_info(dbg);
	return p;
}
#endif

static void signal_event_with_collision_result(Projectile *p, CoEvent *evt, ProjCollisionResult *col) {
	assert(p->collision == NULL);
	p->collision = col;
	coevent_signal(evt);
	assert(p->collision == col);
	p->collision = NULL;
}

static void delete_projectile(ProjectileList *projlist, Projectile *p, ProjCollisionResult *col) {
	signal_event_with_collision_result(p, &p->events.killed, col);
	COEVENT_CANCEL_ARRAY(p->events);
	ent_unregister(&p->ent);
	STAGE_RELEASE_OBJ(alist_unlink(projlist, p));
}

static void *foreach_delete_projectile(ListAnchor *projlist, List *proj, void *arg) {
	delete_projectile((ProjectileList*)projlist, (Projectile*)proj, arg);
	return NULL;
}

void delete_projectiles(ProjectileList *projlist) {
	alist_foreach(projlist, foreach_delete_projectile, NULL);
}

void calc_projectile_collision(Projectile *p, ProjCollisionResult *out_col) {
	out_col->type = PCOL_NONE;
	out_col->entity = NULL;
	out_col->fatal = false;
	out_col->location = p->pos;
	out_col->damage.amount = p->damage;
	out_col->damage.type = p->damage_type;

	if(p->flags & PFLAG_NOCOLLISION) {
		goto skip_collision;
	}

	if(p->type == PROJ_ENEMY) {
		Ellipse e_proj = {
			.axes = p->collision_size,
			.angle = p->angle + M_PI/2,
		};

		LineSegment seg = {
			.a = global.plr.pos - global.plr.velocity - p->prevpos,
			.b = global.plr.pos - p->pos
		};

#ifdef DEBUG
		attr_unused real seglen2 = cabs2(seg.a - seg.b);

		if(seglen2 > 30 * 30) {
			attr_unused real seglen = sqrt(seglen2);
			log_debug(
				seglen > VIEWPORT_W
					? "Lerp over HUGE distance %f; this is ABSOLUTELY a bug! Player speed was %f. Spawned at %s:%d (%s); proj time = %d"
					: "Lerp over large distance %f; this is either a bug or a very fast projectile, investigate. Player speed was %f. Spawned at %s:%d (%s); proj time = %d",
				seglen,
				cabs(global.plr.velocity),
				p->debug.file,
				p->debug.line,
				p->debug.func,
				global.frames - p->birthtime
			);
		}
#endif

		if(lineseg_ellipse_intersect(seg, e_proj)) {
			out_col->type = PCOL_ENTITY;
			out_col->entity = &global.plr.ent;
			out_col->fatal = !(p->flags & PFLAG_INDESTRUCTIBLE);
		} else {
			e_proj.axes = projectile_graze_size(p);

			if(re(e_proj.axes) > 1 && lineseg_ellipse_intersect(seg, e_proj)) {
				out_col->type = PCOL_PLAYER_GRAZE;
				out_col->entity = &global.plr.ent;
				out_col->location = p->pos;
			}
		}
	} else if(p->type == PROJ_PLAYER) {
		for(Enemy *e = global.enemies.first; e; e = e->next) {
			if(
				!(e->flags & EFLAG_NO_HIT) &&
				cabs2(e->pos - p->pos) < e->hit_radius * e->hit_radius
			) {
				out_col->type = PCOL_ENTITY;
				out_col->entity = &e->ent;
				out_col->fatal = !(p->flags & PFLAG_INDESTRUCTIBLE);

				return;
			}
		}

		if(
			global.boss &&
			boss_is_vulnerable(global.boss) &&
			cabs2(global.boss->pos - p->pos) < 42 * 42
		) {
			out_col->type = PCOL_ENTITY;
			out_col->entity = &global.boss->ent;
			out_col->fatal = !(p->flags & PFLAG_INDESTRUCTIBLE);
		}
	}

skip_collision:

	if(
		out_col->type == PCOL_NONE &&
		!(p->flags & PFLAG_NOAUTOREMOVE) &&
		!projectile_in_viewport(p)
	) {
		out_col->type = PCOL_VOID;
		out_col->fatal = true;
	}
}

void apply_projectile_collision(ProjectileList *projlist, Projectile *p, ProjCollisionResult *col) {
	signal_event_with_collision_result(p, &p->events.collision, col);

	switch(col->type) {
		case PCOL_NONE:
		case PCOL_VOID:
			break;

		case PCOL_PLAYER_GRAZE: {
			player_graze(ENT_CAST(col->entity, Player), col->location, 10 + 10 * p->graze_counter, 3 + p->graze_counter, &p->color);

			p->graze_counter++;
			p->graze_cooldown = global.frames + 12;
			p->graze_counter_reset_timer = global.frames;

			break;
		}

		case PCOL_ENTITY: {
			ent_damage(col->entity, &col->damage);
			break;
		}

		default:
			UNREACHABLE;
	}

	if(col->fatal) {
		delete_projectile(projlist, p, col);
	}
}

static void ent_draw_projectile(EntityInterface *ent) {
	Projectile *proj = ENT_CAST(ent, Projectile);

	r_blend(proj->blend);
	r_shader_ptr(proj->shader);

#ifdef PROJ_DEBUG
	static Projectile prev_state;
	memcpy(&prev_state, proj, sizeof(Projectile));

	proj->draw_rule.func(proj, global.frames - proj->birthtime, proj->draw_rule.args);

	if(memcmp(&prev_state, proj, sizeof(Projectile))) {
		set_debug_info(&proj->debug);
		log_fatal("Projectile modified its state in draw rule");
	}
#else
	proj->draw_rule.func(proj, global.frames - proj->birthtime, proj->draw_rule.args);
#endif
}

bool projectile_in_viewport(Projectile *proj) {
	real e = proj->max_viewport_dist;
	cmplx size = projectile_size(proj);
	cmplx buffer = 0.5 * size + CMPLX(e, e);
	cmplx pos = proj->pos;
	cmplx br = pos + buffer;

	if(re(br) < 0 || im(br) < 0) {
		return false;
	}

	cmplx tl = pos - buffer;

	if(re(tl) > VIEWPORT_W || im(tl) > VIEWPORT_H) {
		return false;
	}

	return true;
}

Projectile *spawn_projectile_collision_effect(Projectile *proj) {
	if(proj->flags & PFLAG_NOCOLLISIONEFFECT) {
		return NULL;
	}

	if(proj->sprite == NULL) {
		return NULL;
	}

	return PARTICLE(
		.sprite_ptr = proj->sprite,
		.size = proj->size,
		.pos = proj->pos,
		.color = &proj->color,
		.flags = proj->flags | PFLAG_NOREFLECT | PFLAG_REQUIREDPARTICLE,
		.layer = LAYER_PARTICLE_HIGH,
		.shader_ptr = proj->shader,
		.draw_rule = pdraw_timeout_scale(2+I, 0.0001+I),
		.angle = proj->angle,
		.move = { .velocity = 5 * cdir(proj->angle), .retention = 0.95 },
		.timeout = 10,
	);
}

static void really_clear_projectile(ProjectileList *projlist, Projectile *proj) {
	spawn_projectile_clear_effect(proj);

	if(!(proj->flags & PFLAG_NOCLEARBONUS)) {
		create_clear_item(proj->pos, proj->clear_flags);
	}

	// TODO: synthetic collision type for clears?
	delete_projectile(projlist, proj, NULL);
}

bool clear_projectile(Projectile *proj, uint flags) {
	switch(proj->type) {
		case PROJ_PLAYER:
		case PROJ_PARTICLE:
			return false;