phantasia

world.c (29931B)

---

 #include "engine/world.h"
 #include "config.h"
 
 #include <stdint.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 #include <string.h>
 
 #if PH_ACCURACY_LUCK_DIVISOR <= 0 || PH_DAMAGE_LUCK_DIVISOR <= 0 || \
 	PH_PHYSICAL_DEFENSE_DIVISOR <= 0 || PH_MAGIC_DEFENSE_DIVISOR <= 0
 #error "combat formula divisors must be positive"
 #endif
 
 #if PH_WORLD_STEP_MILLISECONDS <= 0 || PH_WORLD_ANIMATION_PIXELS_PER_FRAME <= 0 || \
 	PH_WORLD_ACTION_MILLISECONDS <= 0 || \
 	PH_MOB_MEMORY_TURNS < 0 || \
 	PH_MOB_WANDER_PERCENT < 0 || PH_MOB_WANDER_PERCENT > 100
 #error "invalid world movement configuration"
 #endif
 
 typedef struct {
 	uint32_t magic;
 	uint32_t version;
 	uint32_t width;
 	uint32_t height;
 	uint32_t marker_count;
 	char name[PH_AREA_NAME_MAX];
 } PhMapHeader;
 
 typedef struct {
 	uint32_t symbol;
 	uint32_t tile_x;
 	uint32_t tile_y;
 } PhMapMarker;
 
 static int
 ph_clampi(int value, int min, int max)
 {
 	if (value < min) return min;
 	if (value > max) return max;
 	return value;
 }
 
 static unsigned int
 ph_world_random(PhWorld *world)
 {
 	world->rng_state = world->rng_state * 1664525u + 1013904223u;
 	return world->rng_state;
 }
 
 static float
 ph_dist2(PhVec2 a, PhVec2 b)
 {
 	float dx = a.x - b.x;
 	float dy = a.y - b.y;
 	return dx * dx + dy * dy;
 }
 
 static int
 ph_entity_def_index(const PhWorld *world, int type_id)
 {
 	int i;
 
 	for (i = 0; i < world->content.entity_count; ++i)
 		if (world->content.entities[i].id == type_id) return i;
 	return -1;
 }
 
 static int
 ph_item_def_index(const PhWorld *world, int item_id)
 {
 	int i;
 
 	for (i = 0; i < world->content.item_count; ++i)
 		if (world->content.items[i].id == item_id) return i;
 	return -1;
 }
 
 static int
 ph_position_blocked(const PhWorld *world, PhVec2 pos)
 {
 	int tx = (int)floorf(pos.x / (float)PH_TILE_SIZE);
 	int ty = (int)floorf(pos.y / (float)PH_TILE_SIZE);
 
 	return ph_area_tile_blocked(&world->area, tx, ty);
 }
 
 static void
 ph_world_set_notice(PhWorld *world, const char *text)
 {
 	snprintf(world->notice.text, sizeof(world->notice.text), "%s", text);
 	world->notice.seconds = PH_NOTICE_SECONDS;
 }
 
 int
 ph_world_emit_event(PhWorld *world, PhWorldEventKind kind, PhVec2 pos,
 	int entity_index)
 {
 	int tail;
 
 	if (!world || kind <= PH_WORLD_EVENT_NONE) return -1;
 	if (world->event_count >= PH_MAX_WORLD_EVENTS) {
 		if (world->event_dropped < UINT_MAX) ++world->event_dropped;
 		return -1;
 	}
 	tail = (world->event_head + world->event_count) % PH_MAX_WORLD_EVENTS;
 	world->events[tail] = (PhWorldEvent){ kind, pos, entity_index };
 	++world->event_count;
 	return 0;
 }
 
 int
 ph_world_take_event(PhWorld *world, PhWorldEvent *event)
 {
 	if (!world || !event || world->event_count <= 0) return 0;
 	*event = world->events[world->event_head];
 	world->event_head = (world->event_head + 1) % PH_MAX_WORLD_EVENTS;
 	--world->event_count;
 	return 1;
 }
 
 static const PhEntity *
 ph_world_blocking_entity(const PhWorld *world, int self_index, PhVec2 pos)
 {
 	int i;
 
 	for (i = 0; i < world->entity_count; ++i) {
 		const PhEntity *entity = &world->entities[i];
 		const PhEntityDef *def;
 
 		if (i == self_index || !entity->active || entity->area_id != world->area_id) {
 			continue;
 		}
 
 		def = ph_world_entity_def(world, entity->type_id);
 		if (!def || (!def->blocks_movement && i != world->player_index)) {
 			continue;
 		}
 
 		if (ph_dist2(entity->pos, pos) <
 				(float)(PH_ENTITY_BLOCK_RADIUS * PH_ENTITY_BLOCK_RADIUS)) {
 			return entity;
 		}
 		if (entity->motion.moving && ph_dist2(entity->motion.target, pos) <
 				(float)(PH_ENTITY_BLOCK_RADIUS * PH_ENTITY_BLOCK_RADIUS)) {
 			return entity;
 		}
 	}
 
 	return NULL;
 }
 
 static int
 ph_entity_step_blocked(PhWorld *world, int entity_index, PhVec2 pos)
 {
 	const PhEntity *blocker;
 	const PhEntityDef *mover;
 	const PhEntityDef *def;
 
 	if (ph_position_blocked(world, pos)) {
 		int tx = (int)floorf(pos.x / (float)PH_TILE_SIZE);
 		int ty = (int)floorf(pos.y / (float)PH_TILE_SIZE);
 		const PhTileDef *tile = ph_area_tile_def(&world->area, tx, ty);
 
 		mover = ph_world_entity_def(world, world->entities[entity_index].type_id);
 		if (mover && mover->kind == PH_ENTITY_PLAYER && tile &&
 				tile->interaction_notice)
 			ph_world_set_notice(world, tile->interaction_notice);
 		return 1;
 	}
 
 	blocker = ph_world_blocking_entity(world, entity_index, pos);
 	if (!blocker) {
 		return 0;
 	}
 
 	mover = ph_world_entity_def(world, world->entities[entity_index].type_id);
 	def = ph_world_entity_def(world, blocker->type_id);
 	if (mover && def && mover->kind == PH_ENTITY_PLAYER &&
 			def->kind == PH_ENTITY_MONSTER) {
 		world->encounter_index = (int)(blocker - world->entities);
 		return 1;
 	}
 	if (mover && def && mover->kind == PH_ENTITY_MONSTER &&
 			def->kind == PH_ENTITY_PLAYER) {
 		world->encounter_index = entity_index;
 		return 1;
 	}
 	if (mover && mover->kind == PH_ENTITY_PLAYER && def && def->name) {
 		char text[PH_NOTICE_SIZE];
 
 		snprintf(text, sizeof(text), "%s blocks your path.", def->name);
 		ph_world_set_notice(world, text);
 	}
 	return 1;
 }
 
 static void
 ph_try_pickup(PhWorld *world, PhEntity *entity)
 {
 	int i;
 
 	if (!entity || !entity->active) {
 		return;
 	}
 
 	for (i = 0; i < world->ground_item_count; ++i) {
 		PhGroundItem *drop = &world->ground_items[i];
 		int item_index;
 
 		if (!drop->active || drop->area_id != world->area_id) {
 			continue;
 		}
 		if ((int)floorf(entity->pos.x / PH_TILE_SIZE) !=
 				(int)floorf(drop->pos.x / PH_TILE_SIZE) ||
 				(int)floorf(entity->pos.y / PH_TILE_SIZE) !=
 				(int)floorf(drop->pos.y / PH_TILE_SIZE)) {
 			continue;
 		}
 
 		item_index = ph_item_def_index(world, drop->item_id);
 		if (item_index >= 0) {
 			world->inventory[item_index] += drop->amount;
 			ph_world_emit_event(world, PH_WORLD_EVENT_ITEM_PICKUP,
 				drop->pos, world->player_index);
 		}
 		drop->active = 0;
 	}
 }
 
 static void
 ph_try_interact(PhWorld *world, const PhEntity *player)
 {
 	PhVec2 target = {
 		player->pos.x + (float)(player->motion.facing_x * PH_TILE_SIZE),
 		player->pos.y + (float)(player->motion.facing_y * PH_TILE_SIZE),
 	};
 	float closest = PH_INTERACT_RADIUS * PH_INTERACT_RADIUS;
 	PhVec2 interaction_pos = player->pos;
 	int i;
 
 	for (i = 0; i < world->entity_count; ++i) {
 		const PhEntity *entity = &world->entities[i];
 		const PhEntityDef *def;
 		float distance;
 
 		if (i == world->player_index || !entity->active ||
 				entity->area_id != world->area_id) continue;
 		def = ph_world_entity_def(world, entity->type_id);
 		if (!def || def->interaction_id <= 0) continue;
 		distance = ph_dist2(entity->pos, target);
 		if (distance > closest) continue;
 		closest = distance;
 		world->interaction_id = def->interaction_id;
 		interaction_pos = entity->pos;
 	}
 	if (world->interaction_id)
 		ph_world_emit_event(world, PH_WORLD_EVENT_INTERACT, interaction_pos,
 			world->player_index);
 	if (!world->interaction_id) {
 		int tx = (int)floorf(target.x / (float)PH_TILE_SIZE);
 		int ty = (int)floorf(target.y / (float)PH_TILE_SIZE);
 		const PhTileDef *tile = ph_area_tile_def(&world->area, tx, ty);
 
 		if (tile && tile->interaction_notice)
 			ph_world_set_notice(world, tile->interaction_notice);
 	}
 }
 
 static PhInput
 ph_orthogonal_input(PhInput input)
 {
 	if (input.move_y != 0) {
 		input.move_x = 0;
 	}
 	return input;
 }
 
 static int
 ph_area_line_clear(const PhArea *area, PhVec2 from, PhVec2 to)
 {
 	int x = (int)floorf(from.x / PH_TILE_SIZE);
 	int y = (int)floorf(from.y / PH_TILE_SIZE);
 	int end_x = (int)floorf(to.x / PH_TILE_SIZE);
 	int end_y = (int)floorf(to.y / PH_TILE_SIZE);
 	int dx = abs(end_x - x);
 	int dy = -abs(end_y - y);
 	int step_x = x < end_x ? 1 : -1;
 	int step_y = y < end_y ? 1 : -1;
 	int error = dx + dy;
 
 	for (;;) {
 		if (ph_area_tile_blocked(area, x, y)) return 0;
 		if (x == end_x && y == end_y) return 1;
 		if (error * 2 >= dy) {
 			error += dy;
 			x += step_x;
 		}
 		if (error * 2 <= dx) {
 			error += dx;
 			y += step_y;
 		}
 	}
 }
 
 static int
 ph_actor_sees_player(const PhWorld *world, const PhEntity *actor,
 	const PhEntityDef *def)
 {
 	const PhEntity *player = ph_world_player(world);
 	float range = (float)(def->vision * PH_TILE_SIZE);
 
 	return def->aggressive && def->vision > 0 && player && player->active &&
 		ph_dist2(actor->pos, player->pos) <= range * range &&
 		ph_area_line_clear(&world->area, actor->pos, player->pos);
 }
 
 static int
 ph_entity_begin_step(PhWorld *world, int entity_index, int dx, int dy,
 	int stay_in_territory)
 {
 	PhEntity *entity = &world->entities[entity_index];
 	PhVec2 target = {
 		entity->pos.x + (float)(dx * PH_TILE_SIZE),
 		entity->pos.y + (float)(dy * PH_TILE_SIZE),
 	};
 	float radius = (float)(entity->behavior.territory_radius * PH_TILE_SIZE);
 
 	if ((!dx && !dy) || entity->motion.moving) return 0;
 	entity->motion.facing_x = dx;
 	entity->motion.facing_y = dy;
 	if (stay_in_territory && entity->behavior.territory_radius > 0 &&
 			ph_dist2(target, entity->behavior.home) > radius * radius) return 0;
 	if (ph_entity_step_blocked(world, entity_index, target)) return 0;
 	entity->motion.target = target;
 	entity->motion.moving = 1;
 	ph_world_emit_event(world, PH_WORLD_EVENT_MOVE, entity->pos, entity_index);
 	return 1;
 }
 
 static int
 ph_entity_step_toward(PhWorld *world, int entity_index, PhVec2 target)
 {
 	PhEntity *entity = &world->entities[entity_index];
 	float dx = target.x - entity->pos.x;
 	float dy = target.y - entity->pos.y;
 	int sx = dx < 0.0f ? -1 : dx > 0.0f ? 1 : 0;
 	int sy = dy < 0.0f ? -1 : dy > 0.0f ? 1 : 0;
 
 	if (fabsf(dx) >= fabsf(dy)) {
 		if (ph_entity_begin_step(world, entity_index, sx, 0, 0)) return 1;
 		return ph_entity_begin_step(world, entity_index, 0, sy, 0);
 	}
 	if (ph_entity_begin_step(world, entity_index, 0, sy, 0)) return 1;
 	return ph_entity_begin_step(world, entity_index, sx, 0, 0);
 }
 
 static void
 ph_world_actor_action(PhWorld *world, int entity_index)
 {
 	PhEntity *actor = &world->entities[entity_index];
 	const PhEntityDef *def = ph_world_entity_def(world, actor->type_id);
 	int direction;
 
 	if (!def || def->kind == PH_ENTITY_PLAYER || !actor->active || actor->vitals.hp <= 0)
 		return;
 	if (ph_actor_sees_player(world, actor, def)) {
 		actor->behavior.last_seen = ph_world_player(world)->pos;
 		actor->behavior.chase_turns = PH_MOB_MEMORY_TURNS;
 		ph_entity_step_toward(world, entity_index, actor->behavior.last_seen);
 		return;
 	}
 	if (actor->behavior.chase_turns > 0) {
 		--actor->behavior.chase_turns;
 		ph_entity_step_toward(world, entity_index, actor->behavior.last_seen);
 		return;
 	}
 	if (actor->behavior.territory_radius > 0) {
 		float radius = (float)(actor->behavior.territory_radius * PH_TILE_SIZE);
 
 		if (ph_dist2(actor->pos, actor->behavior.home) > radius * radius) {
 			ph_entity_step_toward(world, entity_index, actor->behavior.home);
 			return;
 		}
 	}
 	if ((int)(ph_world_random(world) % 100u) >= PH_MOB_WANDER_PERCENT) return;
 	direction = (int)(ph_world_random(world) % 4u);
 	ph_entity_begin_step(world, entity_index,
 		direction == 0 ? -1 : direction == 1 ? 1 : 0,
 		direction == 2 ? -1 : direction == 3 ? 1 : 0, 1);
 }
 
 static void
 ph_world_advance_movers(PhWorld *world, float dt)
 {
 	float step_seconds = (float)PH_WORLD_STEP_MILLISECONDS / 1000.0f;
 	int i;
 
 	for (i = 0; i < world->entity_count; ++i) {
 		PhEntity *entity = &world->entities[i];
 		const PhEntityDef *def;
 		float dx;
 		float dy;
 		float distance;
 		float travel;
 		float moved;
 		float animation_cycle;
 		int animation_frames;
 
 		if (!entity->active || !entity->motion.moving ||
 				entity->area_id != world->area_id) continue;
 		def = ph_world_entity_def(world, entity->type_id);
 		if (!def || def->move_speed <= 0) continue;
 		dx = entity->motion.target.x - entity->pos.x;
 		dy = entity->motion.target.y - entity->pos.y;
 		distance = sqrtf(dx * dx + dy * dy);
 		travel = (float)(PH_TILE_SIZE * def->move_speed) * dt / step_seconds;
 		moved = distance < travel ? distance : travel;
 		entity->motion.animation_distance += moved;
 		animation_frames = def->animation_frames > 0 &&
 			def->animation_frames <= PH_ANIMATION_FRAMES ?
 			def->animation_frames : 1;
 		animation_cycle = (float)(animation_frames *
 			PH_WORLD_ANIMATION_PIXELS_PER_FRAME);
 		if (entity->motion.animation_distance >= animation_cycle)
 			entity->motion.animation_distance = fmodf(entity->motion.animation_distance,
 				animation_cycle);
 		if (distance <= travel || distance <= 0.001f) {
 			entity->pos = entity->motion.target;
 			entity->motion.moving = 0;
 		} else {
 			entity->pos.x += dx / distance * travel;
 			entity->pos.y += dy / distance * travel;
 		}
 	}
 }
 
 static void
 ph_world_update_actors(PhWorld *world, float dt)
 {
 	float action_seconds = (float)PH_WORLD_ACTION_MILLISECONDS / 1000.0f;
 	int i;
 
 	for (i = 0; i < world->entity_count && world->encounter_index < 0; ++i) {
 		PhEntity *entity = &world->entities[i];
 		const PhEntityDef *def = ph_world_entity_def(world, entity->type_id);
 
 		if (!def || def->kind == PH_ENTITY_PLAYER || def->move_speed <= 0 ||
 				!entity->active || entity->area_id != world->area_id) continue;
 		entity->motion.credit += (float)def->move_speed * dt;
 		if (entity->motion.credit > action_seconds) entity->motion.credit = action_seconds;
 		if (entity->motion.moving || entity->motion.credit < action_seconds) continue;
 		entity->motion.credit -= action_seconds;
 		ph_world_actor_action(world, i);
 	}
 }
 
 int
 ph_world_init(PhWorld *world, PhArea area, int area_id,
 	PhWorldCatalog content)
 {
 	if (content.entity_count < 0 || content.entity_count > PH_MAX_ENTITY_TYPES ||
 			content.item_count < 0 || content.item_count > PH_MAX_ITEM_TYPES ||
 			(content.entity_count && !content.entities) ||
 			(content.item_count && !content.items)) return -1;
 	memset(world, 0, sizeof(*world));
 	world->area = area;
 	world->area_id = area_id;
 	world->content = content;
 	world->player_index = -1;
 	world->encounter_index = -1;
 	world->rng_state = 0x5048414eu;
 	return 0;
 }
 
 void
 ph_world_enter_area(PhWorld *world, PhArea area, int area_id, PhVec2 player_pos)
 {
 	PhEntity *player;
 
 	ph_area_free(&world->area);
 	world->area = area;
 	world->area_id = area_id;
 	world->encounter_index = -1;
 	world->interaction_id = 0;
 	player = world->player_index >= 0 && world->player_index < world->entity_count ?
 		&world->entities[world->player_index] : NULL;
 	if (!player) return;
 	player->area_id = area_id;
 	player->pos = player->motion.target = player->behavior.home = player_pos;
 	player->motion.moving = 0;
 }
 
 int
 ph_area_load(PhArea *area, const char *path)
 {
 	FILE *fp;
 	PhMapHeader header;
 	size_t tile_count;
 	size_t name_len;
 	unsigned char *tiles;
 	PhAreaMarker *markers = NULL;
 	char *name;
 	uint32_t i;
 
 	memset(area, 0, sizeof(*area));
 
 	fp = fopen(path, "rb");
 	if (!fp) {
 		return -1;
 	}
 
 	if (fread(&header, sizeof(header), 1, fp) != 1 ||
 			header.magic != PH_MAP_MAGIC ||
 			header.version != PH_MAP_VERSION ||
 			header.width == 0 ||
 			header.height == 0 || header.width > INT_MAX ||
 			header.height > INT_MAX || header.marker_count > INT_MAX ||
 			(size_t)header.width > SIZE_MAX / header.height) {
 		fclose(fp);
 		return -1;
 	}
 
 	tile_count = (size_t)header.width * (size_t)header.height;
 	if (header.marker_count > tile_count) {
 		fclose(fp);
 		return -1;
 	}
 	tiles = malloc(tile_count);
 	if (!tiles) {
 		fclose(fp);
 		return -1;
 	}
 
 	if (fread(tiles, 1, tile_count, fp) != tile_count) {
 		free(tiles);
 		fclose(fp);
 		return -1;
 	}
 	if (header.marker_count > 0) {
 		markers = calloc(header.marker_count, sizeof(*markers));
 		if (!markers) {
 			free(tiles);
 			fclose(fp);
 			return -1;
 		}
 		for (i = 0; i < header.marker_count; ++i) {
 			PhMapMarker marker;
 
 			if (fread(&marker, sizeof(marker), 1, fp) != 1 ||
 					marker.symbol > 255 || marker.tile_x >= header.width ||
 					marker.tile_y >= header.height) {
 				free(markers);
 				free(tiles);
 				fclose(fp);
 				return -1;
 			}
 			markers[i] = (PhAreaMarker){ (unsigned char)marker.symbol,
 				(int)marker.tile_x, (int)marker.tile_y };
 		}
 	}
 	fclose(fp);
 
 	header.name[PH_AREA_NAME_MAX - 1] = '\0';
 	name_len = strlen(header.name) + 1;
 	name = malloc(name_len);
 	if (!name) {
 		free(markers);
 		free(tiles);
 		return -1;
 	}
 	memcpy(name, header.name, name_len);
 
 	area->name = name;
 	area->width = (int)header.width;
 	area->height = (int)header.height;
 	area->tiles = tiles;
 	area->markers = markers;
 	area->marker_count = (int)header.marker_count;
 	area->owns_tiles = 1;
 	return 0;
 }
 
 void
 ph_area_free(PhArea *area)
 {
 	if (area->owns_tiles) {
 		free(area->tiles);
 		free(area->markers);
 		free((char *)area->name);
 	}
 	memset(area, 0, sizeof(*area));
 }
 
 void
 ph_world_destroy(PhWorld *world)
 {
 	int i;
 
 	if (!world) return;
 	ph_area_free(&world->area);
 	for (i = 0; i < world->initialized_area_count; ++i) {
 		free(world->area_states[i].entities);
 		free(world->area_states[i].ground_items);
 	}
 	free(world->area_states);
 	memset(world, 0, sizeof(*world));
 }
 
 int
 ph_world_spawn_entity(PhWorld *world, int type_id, PhVec2 pos,
 	int territory_radius, int area_id)
 {
 	PhEntity *entity;
 	const PhEntityDef *def;
 
 	if (world->entity_count >= PH_MAX_ENTITIES) {
 		return -1;
 	}
 
 	def = ph_world_entity_def(world, type_id);
 	if (!def) {
 		return -1;
 	}
 
 	entity = &world->entities[world->entity_count];
 	memset(entity, 0, sizeof(*entity));
 	entity->type_id = type_id;
 	entity->area_id = area_id;
 	entity->pos = pos;
 	entity->motion.target = pos;
 	entity->behavior.home = pos;
 	entity->behavior.last_seen = pos;
 	entity->vitals.hp = def->stats.max_hp;
 	entity->vitals.mp = def->stats.max_mp;
 	entity->gold = def->starting_gold;
 	entity->motion.facing_x = 0;
 	entity->motion.facing_y = 1;
 	entity->behavior.territory_radius = territory_radius > 0 ? territory_radius : 0;
 	entity->active = 1;
 
 	return world->entity_count++;
 }
 
 int
 ph_world_drop_item(PhWorld *world, int item_id, PhVec2 pos, int amount,
 	int area_id)
 {
 	PhGroundItem *drop = NULL;
 	int i;
 
 	if (amount <= 0 || !ph_world_item_def(world, item_id)) {
 		return -1;
 	}
 	for (i = 0; i < world->ground_item_count; ++i)
 		if (!world->ground_items[i].active) {
 			drop = &world->ground_items[i];
 			break;
 		}
 	if (!drop) {
 		if (world->ground_item_count >= PH_MAX_GROUND_ITEMS) return -1;
 		drop = &world->ground_items[world->ground_item_count++];
 	}
 
 	drop->item_id = item_id;
 	drop->area_id = area_id;
 	drop->pos = pos;
 	drop->amount = amount;
 	drop->active = 1;
 
 	return (int)(drop - world->ground_items);
 }
 
 void
 ph_world_set_player(PhWorld *world, int entity_index)
 {
 	if (entity_index >= 0 && entity_index < world->entity_count) {
 		world->player_index = entity_index;
 	}
 }
 
 int
 ph_world_equip_item(PhWorld *world, int entity_index, int item_id)
 {
 	PhEntity *entity;
 	const PhItemDef *item;
 	PhStats before;
 	PhStats after;
 	int slot;
 
 	if (entity_index < 0 || entity_index >= world->entity_count) return -1;
 	item = ph_world_item_def(world, item_id);
 	if (!item) return -1;
 	slot = (int)item->equip_slot;
 	if (slot <= PH_EQUIP_NONE || slot >= PH_EQUIP_COUNT) return -1;
 	entity = &world->entities[entity_index];
 	before = ph_world_entity_stats(world, entity);
 	entity->equipment[slot] = item_id;
 	after = ph_world_entity_stats(world, entity);
 	entity->vitals.hp += after.max_hp - before.max_hp;
 	entity->vitals.mp += after.max_mp - before.max_mp;
 	if (entity->vitals.hp < 0) entity->vitals.hp = 0;
 	if (entity->vitals.hp > after.max_hp) entity->vitals.hp = after.max_hp;
 	if (entity->vitals.mp < 0) entity->vitals.mp = 0;
 	if (entity->vitals.mp > after.max_mp) entity->vitals.mp = after.max_mp;
 	return 0;
 }
 
 int
 ph_world_equip_inventory_item(PhWorld *world, int entity_index, int item_id)
 {
 	const PhItemDef *item = ph_world_item_def(world, item_id);
 	PhEntity *entity;
 	int item_index;
 	int old_index;
 	int old_item;
 
 	if (!item || entity_index < 0 || entity_index >= world->entity_count) return -1;
 	item_index = ph_item_def_index(world, item_id);
 	if (world->inventory[item_index] <= 0 || item->equip_slot <= PH_EQUIP_NONE ||
 			item->equip_slot >= PH_EQUIP_COUNT) return -1;
 	entity = &world->entities[entity_index];
 	old_item = entity->equipment[item->equip_slot];
 	if (ph_world_equip_item(world, entity_index, item_id) < 0) return -1;
 	--world->inventory[item_index];
 	old_index = ph_item_def_index(world, old_item);
 	if (old_index >= 0) ++world->inventory[old_index];
 	return 0;
 }
 
 int
 ph_world_use_inventory_item(PhWorld *world, int entity_index, int item_id)
 {
 	const PhItemDef *item = ph_world_item_def(world, item_id);
 	PhEntity *entity;
 	PhStats stats;
 	int item_index;
 
 	if (!item || entity_index < 0 || entity_index >= world->entity_count) return -1;
 	item_index = ph_item_def_index(world, item_id);
 	if (world->inventory[item_index] <= 0) return -1;
 	entity = &world->entities[entity_index];
 	stats = ph_world_entity_stats(world, entity);
 	if (item->use_power <= 0) return -1;
 	if (item->use == PH_ITEM_USE_HEAL && entity->vitals.hp < stats.max_hp) {
 		entity->vitals.hp += item->use_power;
 		if (entity->vitals.hp > stats.max_hp) entity->vitals.hp = stats.max_hp;
 	} else if (item->use == PH_ITEM_USE_RESTORE_MP && entity->vitals.mp < stats.max_mp) {
 		entity->vitals.mp += item->use_power;
 		if (entity->vitals.mp > stats.max_mp) entity->vitals.mp = stats.max_mp;
 	} else {
 		return -1;
 	}
 	--world->inventory[item_index];
 	return 0;
 }
 
 int
 ph_world_drop_inventory_item(PhWorld *world, int entity_index, int item_id)
 {
 	int item_index;
 
 	if (entity_index < 0 || entity_index >= world->entity_count) return -1;
 	item_index = ph_item_def_index(world, item_id);
 	if (item_index < 0 || world->inventory[item_index] <= 0) return -1;
 	if (ph_world_drop_item(world, item_id, world->entities[entity_index].pos, 1,
 			world->area_id) < 0)
 		return -1;
 	--world->inventory[item_index];
 	ph_world_emit_event(world, PH_WORLD_EVENT_ITEM_DROP,
 		world->entities[entity_index].pos, entity_index);
 	return 0;
 }
 
 int
 ph_world_buy_item(PhWorld *world, int entity_index, int item_id)
 {
 	PhEntity *entity;
 	const PhItemDef *item;
 	int item_index;
 
 	if (entity_index < 0 || entity_index >= world->entity_count) return -1;
 	item = ph_world_item_def(world, item_id);
 	item_index = ph_item_def_index(world, item_id);
 	if (!item || item_index < 0 || item->buy_value <= 0) return -1;
 	entity = &world->entities[entity_index];
 	if (entity->gold < item->buy_value) return -1;
 	entity->gold -= item->buy_value;
 	++world->inventory[item_index];
 	ph_world_emit_event(world, PH_WORLD_EVENT_BUY, entity->pos, entity_index);
 	return 0;
 }
 
 int
 ph_world_sell_item(PhWorld *world, int entity_index, int item_id)
 {
 	PhEntity *entity;
 	const PhItemDef *item;
 	int item_index;
 
 	if (entity_index < 0 || entity_index >= world->entity_count) return -1;
 	item = ph_world_item_def(world, item_id);
 	item_index = ph_item_def_index(world, item_id);
 	if (!item || item_index < 0 || item->sell_value <= 0 ||
 			world->inventory[item_index] <= 0) return -1;
 	entity = &world->entities[entity_index];
 	--world->inventory[item_index];
 	entity->gold += item->sell_value;
 	ph_world_emit_event(world, PH_WORLD_EVENT_SELL, entity->pos, entity_index);
 	return 0;
 }
 
 int
 ph_world_physical_attack(PhWorld *world, int attacker_index, int target_index)
 {
 	PhEntity *attacker;
 	PhEntity *target;
 	PhStats attack;
 	PhStats defense;
 	int accuracy;
 	int chance;
 	int damage;
 
 	if (attacker_index < 0 || attacker_index >= world->entity_count ||
 			target_index < 0 || target_index >= world->entity_count) return -1;
 	attacker = &world->entities[attacker_index];
 	target = &world->entities[target_index];
 	if (!attacker->active || !target->active || attacker->vitals.hp <= 0 || target->vitals.hp <= 0)
 		return -1;
 	attack = ph_world_entity_stats(world, attacker);
 	defense = ph_world_entity_stats(world, target);
 	accuracy = attack.accuracy * (100 -
 		ph_clampi(attacker->accuracy.value, 0, 100)) / 100;
 	chance = ph_clampi(accuracy + attack.luck / PH_ACCURACY_LUCK_DIVISOR -
 		defense.evasion, PH_HIT_CHANCE_MIN, PH_HIT_CHANCE_MAX);
 	if ((int)(ph_world_random(world) % 100u) >= chance) return 0;
 	damage = attack.strength + attack.luck / PH_DAMAGE_LUCK_DIVISOR -
 		defense.defense / PH_PHYSICAL_DEFENSE_DIVISOR;
 	damage = damage > 0 ? damage : 1;
 	target->vitals.hp = ph_clampi(target->vitals.hp - damage, 0, defense.max_hp);
 	return damage;
 }
 
 int
 ph_world_apply_accuracy_penalty(PhWorld *world, int entity_index,
 	int percent, int turns)
 {
 	PhEntity *entity;
 
 	if (entity_index < 0 || entity_index >= world->entity_count ||
 			percent <= 0 || turns <= 0) return -1;
 	entity = &world->entities[entity_index];
 	if (!entity->active) return -1;
 	entity->accuracy.value = ph_clampi(percent, 0, 100);
 	entity->accuracy.turns = turns;
 	return 0;
 }
 
 void
 ph_world_advance_effects(PhWorld *world, int entity_index)
 {
 	PhEntity *entity;
 
 	if (entity_index < 0 || entity_index >= world->entity_count) return;
 	entity = &world->entities[entity_index];
 	if (entity->accuracy.turns > 0 && --entity->accuracy.turns == 0)
 		entity->accuracy.value = 0;
 }
 
 int
 ph_world_magic_attack(PhWorld *world, int attacker_index, int target_index,
 	int mp_cost, int power)
 {
 	PhEntity *attacker;
 	PhEntity *target;
 	PhStats defense;
 	int damage;
 
 	if (attacker_index < 0 || attacker_index >= world->entity_count ||
 			target_index < 0 || target_index >= world->entity_count ||
 			mp_cost < 0 || power < 0) return -1;
 	attacker = &world->entities[attacker_index];
 	target = &world->entities[target_index];
 	if (!attacker->active || !target->active || attacker->vitals.hp <= 0 ||
 			target->vitals.hp <= 0 || attacker->vitals.mp < mp_cost) return -1;
 	defense = ph_world_entity_stats(world, target);
 	damage = ph_world_entity_stats(world, attacker).magic + power -
 		defense.magic_defense / PH_MAGIC_DEFENSE_DIVISOR;
 	damage = damage > 0 ? damage : 1;
 	attacker->vitals.mp -= mp_cost;
 	target->vitals.hp = ph_clampi(target->vitals.hp - damage, 0, defense.max_hp);
 	return damage;
 }
 
 int
 ph_world_finish_encounter(PhWorld *world, int enemy_index)
 {
 	PhEntity *player;
 	PhEntity *enemy;
 	const PhEntityDef *def;
 	int item_index = -1;
 
 	if (enemy_index < 0 || enemy_index >= world->entity_count ||
 			world->player_index < 0 || world->player_index >= world->entity_count)
 		return -1;
 	player = &world->entities[world->player_index];
 	enemy = &world->entities[enemy_index];
 	def = ph_world_entity_def(world, enemy->type_id);
 	if (!def || def->kind != PH_ENTITY_MONSTER || enemy->vitals.hp > 0) return -1;
 	if (def->reward.item_id && def->reward.amount > 0) {
 		item_index = ph_item_def_index(world, def->reward.item_id);
 		if (item_index < 0) return -1;
 	}
 	player->xp += def->reward.xp;
 	if (item_index >= 0) world->inventory[item_index] += def->reward.amount;
 	enemy->active = 0;
 	world->encounter_index = -1;
 	world->combat_active = 0;
 	return 0;
 }
 
 void
 ph_world_tick(PhWorld *world, PhInput input, float dt)
 {
 	PhEntity *player;
 	const PhEntityDef *def;
 	int was_moving;
 
 	if (world->player_index < 0 || world->player_index >= world->entity_count) {
 		return;
 	}
 
 	player = &world->entities[world->player_index];
 	def = ph_world_entity_def(world, player->type_id);
 	if (!player->active || !def) {
 		return;
 	}
 	if (world->notice.seconds > 0.0f) {
 		world->notice.seconds -= dt;
 		if (world->notice.seconds <= 0.0f) {
 			world->notice.seconds = 0.0f;
 			world->notice.text[0] = '\0';
 		}
 	}
 
 	input = ph_orthogonal_input(input);
 	world->interaction_id = 0;
 	was_moving = player->motion.moving;
 	if (!player->motion.moving && def->move_speed > 0)
 		ph_entity_begin_step(world, world->player_index,
 			input.move_x, input.move_y, 0);
 	ph_world_advance_movers(world, dt);
 	if (was_moving && !player->motion.moving && world->encounter_index < 0 &&
 			def->move_speed > 0)
 		ph_entity_begin_step(world, world->player_index,
 			input.move_x, input.move_y, 0);
 
 	if (input.interact) {
 		ph_try_pickup(world, player);
 		ph_try_interact(world, player);
 	}
 
 	ph_world_update_actors(world, dt);
 }
 
 int
 ph_entity_animation_frame(const PhEntityDef *def, const PhEntity *entity)
 {
 	int frames;
 
 	if (!def || !entity || !entity->motion.moving) return 0;
 	frames = def->animation_frames > 0 &&
 		def->animation_frames <= PH_ANIMATION_FRAMES ? def->animation_frames : 1;
 	return (int)(entity->motion.animation_distance /
 		PH_WORLD_ANIMATION_PIXELS_PER_FRAME) % frames;
 }
 
 const PhEntity *
 ph_world_player(const PhWorld *world)
 {
 	if (world->player_index < 0 || world->player_index >= world->entity_count) {
 		return NULL;
 	}
 	return &world->entities[world->player_index];
 }
 
 const PhEntityDef *
 ph_world_entity_def(const PhWorld *world, int type_id)
 {
 	int i = ph_entity_def_index(world, type_id);
 	return i >= 0 ? &world->content.entities[i] : NULL;
 }
 
 const PhItemDef *
 ph_world_item_def(const PhWorld *world, int item_id)
 {
 	int i = ph_item_def_index(world, item_id);
 	return i >= 0 ? &world->content.items[i] : NULL;
 }
 
 int
 ph_world_item_amount(const PhWorld *world, int item_id)
 {
 	int i = ph_item_def_index(world, item_id);
 	return i >= 0 ? world->inventory[i] : 0;
 }
 
 PhStats
 ph_world_entity_stats(const PhWorld *world, const PhEntity *entity)
 {
 	const PhEntityDef *def;
 	PhStats stats = { 0 };
 	int slot;
 
 	if (!entity || !(def = ph_world_entity_def(world, entity->type_id))) return stats;
 	stats = def->stats;
 	for (slot = PH_EQUIP_WEAPON; slot < PH_EQUIP_COUNT; ++slot) {
 		const PhItemDef *item = ph_world_item_def(world, entity->equipment[slot]);
 		PhStats bonus;
 
 		if (!item) continue;
 		bonus = item->bonuses;
 		stats.max_hp += bonus.max_hp;
 		stats.max_mp += bonus.max_mp;
 		stats.strength += bonus.strength;
 		stats.defense += bonus.defense;
 		stats.magic += bonus.magic;
 		stats.magic_defense += bonus.magic_defense;
 		stats.agility += bonus.agility;
 		stats.luck += bonus.luck;
 		stats.evasion += bonus.evasion;
 		stats.accuracy += bonus.accuracy;
 	}
 	return stats;
 }
 
 const PhTileDef *
 ph_area_tile_def(const PhArea *area, int tx, int ty)
 {
 	unsigned char tile;
 
 	if (tx < 0 || ty < 0 || tx >= area->width || ty >= area->height) {
 		return NULL;
 	}
 	tile = area->tiles[(size_t)ty * (size_t)area->width + (size_t)tx];
 	return tile < area->tile_def_count ? &area->tile_defs[tile] : NULL;
 }
 
 int
 ph_area_tile_blocked(const PhArea *area, int tx, int ty)
 {
 	const PhTileDef *def = ph_area_tile_def(area, tx, ty);
 	return !def || def->blocks_movement;
 }