keraforge / src / actor.c

#include "keraforge/fs.h"
#include <keraforge.h>
#include <stdlib.h>
#include <raymath.h>
#include <string.h>


struct kf_actorregistry kf_actorregistry = {0};
struct kf_actor *kf_actors = NULL, *kf_actors_last = NULL;
u32 kf_actor_count = 0;


struct kf_actor *kf_actor_new(char *id, struct kf_spritesheet sprites, f32 width, f32 height, bool collides)
{
	struct kf_actor *actor = calloc(1, sizeof(struct kf_actor));
	kf_actor_count++;

	if (!kf_actors)
	{
		kf_actors = kf_actors_last = actor;
	}
	else
	{
		actor->prev = kf_actors_last;
		kf_actors_last->next = actor;
		kf_actors_last = actor;
	}

	actor->id = id;
	actor->sprites = sprites;
	actor->size.x = width;
	actor->size.y = height;
	actor->collide = collides;

	actor->speed = 25;
	actor->speedmod = 1;
	actor->friction = 1.5f;
	actor->pointing = kf_north;

	return actor;
}

struct kf_spritesheet kf_actor_loadspritesheet(char *filename)
{
	return kf_loadspritesheet(filename, 20, 20);
}

int kf_actor_canmovetowards(struct kf_world *world, struct kf_actor *actor, struct kf_vec2(f32) dir)
{
	Rectangle r = {
		actor->pos.x + (actor->size.x / 2) + actor->sizeoffset.x,
		actor->pos.y + (actor->size.y / 2) + actor->sizeoffset.y,
		actor->size.x,
		actor->size.y
	};
	r.x += dir.x;
	r.y += dir.y;

	/* get a range of tiles to check */
	const u32 sx = fmax(0, floorf(r.x / KF_TILE_SIZE_PX) - 1);
	const u32 sy = fmax(0, floorf(r.y / KF_TILE_SIZE_PX) - 1);
	const u32 ex = fmin(world->width, ceilf(r.width / KF_TILE_SIZE_PX) + sx + 2);
	const u32 ey = fmin(world->height, ceilf(r.height / KF_TILE_SIZE_PX) + sy + 2);
	const size_t down = world->width - ex + sx - 1; /* number of indexes to add to reach the next tile down */

	/* check if any tiles will collide with the actor's rect */
	const f32 trx = sx * KF_TILE_SIZE_PX;
	Rectangle tr = {
		trx,
		sy * KF_TILE_SIZE_PX,
		/* TODO:
		   Subtracting 1 as a bandaid fix to high velocities causing the player to be stopped early in collisions.
		   This is a very notorious problem in 3D collision and fwik there are plenty of 2D solutions.
		   I'll research and implement one eventually:tm: */
		KF_TILE_SIZE_PX - 1,
		KF_TILE_SIZE_PX - 1,
	}; /* tile rect */
	u32 x;
	struct kf_tile *tile = kf_world_gettile(world, sx, sy);

	for (u32 y = sy ; y <= ey ; y++)
	{
		for (x = sx ; x <= ex ; x++)
		{
			if (kf_tiles.collide[tile->id] && CheckCollisionRecs(r, tr))
				return 0;
			tile++; /* shift tile pointer to the right */
			tr.x += KF_TILE_SIZE_PX;
		}
		tile += down; /* shift tile pointer down */
		tr.x = trx;
		tr.y += KF_TILE_SIZE_PX;
	}

	return 1;
}

void kf_actor_addforce(struct kf_actor *self, struct kf_vec2(f32) force)
{
	self->vel.x += force.x;
	self->vel.y += force.y;
}

void kf_actor_move(struct kf_world *world, struct kf_actor *self, f32 dt)
{
	struct kf_vec2(f32) delta = kf_mulval_vec2(f32)(self->vel, (self->speed * self->speedmod) * dt);

	if (self->collide)
	{
		if (delta.x && !kf_actor_canmovetowards(world, self, kf_vec2_x(f32)(delta)))
			delta.x = 0;
		if (delta.y && !kf_actor_canmovetowards(world, self, kf_vec2_y(f32)(delta)))
			delta.y = 0;
	}

	if (!self->controlled)
	{
		if (delta.y > 0)
			self->pointing = kf_south;
		else if (delta.y < 0)
			self->pointing = kf_north;
		else if (delta.x < 0)
			self->pointing = kf_west;
		else if (delta.x > 0)
			self->pointing = kf_east;
	}

	self->pos = kf_add_vec2(f32)(self->pos, delta);

	static const f32 speed_deadzone = 0.1f;

	if (self->vel.x > -speed_deadzone && self->vel.x < speed_deadzone)
		self->vel.x = 0;
	else if (self->vel.x)
		self->vel.x /= self->friction;

	if (self->vel.y > -speed_deadzone && self->vel.y < speed_deadzone)
		self->vel.y = 0;
	else if (self->vel.y)
		self->vel.y /= self->friction;

	// if (self->speedmod > -(1+speed_deadzone) && self->speedmod < 1+speed_deadzone)
	// 	self->speedmod = 1;
	// else if (self->speedmod)
	// 	self->speedmod -= self->friction * self->friction * dt;
}

void kf_actor_draw(struct kf_actor *actor)
{
	int frames = 4;
	int x = 0, y = 0;

	switch (actor->pointing)
	{
	case kf_south: y = 0; break;
	case kf_east:  y = 1; break;
	case kf_west:  y = 2; break;
	case kf_north: y = 3; break;
	}

	bool moving = actor->vel.x != 0 || actor->vel.y != 0;

	if (actor->running && moving)
	{
		y += 5; /* run sprites */
		frames = 6;
	}
	else if (moving)
	{
		x += 7; /* walk sprites */
	}

	/* todo: jump */

	x += (int)(kf_s * (frames+1)) % frames;

	kf_drawsprite(&actor->sprites, actor->pos.x, actor->pos.y, x, y);
}

int kf_actor_getregistryid(char *id)
{
	size_t l = strlen(id);
	for (int i = 0 ; i < kf_actorregistry.count ; i++)
	{
		char *c = kf_actorregistry.id[i];
		size_t cl = strlen(c);
		if (strncmp(c, id, l>cl?l:cl) == 0)
		{
			return i;
		}
	}
	return -1;
}

#define _KF_ACTORFILE_TMP "data/tmp/actors.bin"
#define _KF_ACTORFILE_XZ "data/actors.bin.xz"
#define _KF_ACTORFILE "data/actors.bin"

int kf_saveactors(void)
{
	// char *outfile = compress ? _KF_ACTORFILE_TMP : _KF_ACTORFILE;
	char *outfile = _KF_ACTORFILE;

	FILE *fp = fopen(outfile, "wb");
	if (!fp)
		KF_THROW("failed to open %s", outfile);

	size_t nactors = 0;
	size_t total_bytes = 0;

	for (struct kf_actor *actor = kf_actors ; actor != NULL ; actor = actor->next)
	{
		if (!actor->id)
			continue;
		int id = kf_actor_getregistryid(actor->id);
		if (id == -1)
			continue;
		size_t n = strlen(actor->id);
		if (fwrite(actor->id, 1, n, fp) != n)
		{
			KF_THROWSOFTER("failed to write actor ID: %s", actor->id);
			fclose(fp);
			return 0;
		}
		n = 0;
		u8 *data = kf_actorregistry.serialize[id](actor, &n);
		if (!data)
		{
			KF_THROWSOFTER("failed to serialize actor of type %s", actor->id);
			fclose(fp);
			return 0;
		}
		if (fwrite(data, 1, n, fp) != n)
		{
			KF_THROWSOFTER("failed to write serialized actor of type %s", actor->id);
			fclose(fp);
			return 0;
		}
		nactors++;
		total_bytes += n;
	}

	kf_logdbg("serialized %d actors (%lu bytes)", nactors, total_bytes);
	fclose(fp);

	return 1;
}