enemy.c

#include <stdint.h>
#include <stdbool.h>
#include "system/system.h"
#include "math/math.h"
#include "physics/particle.h"
#include "physics/physics.h"
#include "physics/physicslist.h"
#include "camera/camera.h"
#include "audio/audio.h"
#include "assetmanager.h"
#include "enemy.h"

extern float fTimeStep;
extern ParticleSystem_t particleSystem;

void FireParticleEmitter(vec3 position, vec3 direction);
void ExplodeEmitterCallback(uint32_t index, uint32_t numParticles, Particle_t *particle);

// angles here are in cosine space (-1.0 to 1.0)
static const float MAX_SIGHT_DISTANCE=1000.0f;
static const float MAX_SIGHT_ANGLE=0.5f;
static const float TRACK_FORCE=2.0f;
static const float TRACK_RANGE=80.0f;
static const float ROTATION_FORCE=0.2f;
static const float ATTACK_ANGLE_THRESHOLD=0.5f;
static const float ATTACK_RANGE=100.0f;

void InitEnemy(Enemy_t *enemy, Camera_t *enemyCamera, const Camera_t playerCamera)
{
	// Set starting health
	enemy->health=100.0f;

	// Set initial state
	enemy->state=SEARCHING;

	// Assign camera pointer to "connect" it to a camera
	enemy->camera=enemyCamera;

	// Assign last known player camera
	enemy->lastKnownPlayer=playerCamera;
}

static bool HasLineOfSight(Enemy_t *enemy, const Camera_t player)
{
	// Calculate the direction from the camera to the target
	vec3 direction=Vec3_Subv(player.body.position, enemy->camera->body.position);
	const float distance=Vec3_Normalize(&direction);

	if(distance>MAX_SIGHT_DISTANCE)
		return false;

	const float theta=Vec3_Dot(enemy->camera->forward, direction);

	// Calculate the angle between the camera's forward vector and the direction to the target
	// Check if the angle is within half of the FOV angle
	return theta>MAX_SIGHT_ANGLE;
}

static float TrackPlayer(Enemy_t *enemy, const Camera_t player)
{
	vec3 direction=Vec3_Subv(player.body.position, enemy->camera->body.position);
	float distance=Vec3_Normalize(&direction);
	vec3 avoidanceDirection=Vec3b(0.0f);

	// Check for obstacles in the avoidance radius
	for(size_t i=0;i<numPhysicsObjects;i++)
	{
		const float avoidanceRadius=(enemy->camera->body.radius+physicsObjects[i].rigidBody->radius)*1.5f;
		const vec3 cameraToObstacle=Vec3_Subv(enemy->camera->body.position, physicsObjects[i].rigidBody->position);
		const float cameraToObstacleDistanceSq=Vec3_Dot(cameraToObstacle, cameraToObstacle);

		if(cameraToObstacleDistanceSq<avoidanceRadius*avoidanceRadius)
		{
			if(cameraToObstacleDistanceSq>0.0f)
			{
				// Adjust the camera trajectory to avoid the obstacle
				const float rMag=1.0f/sqrtf(cameraToObstacleDistanceSq);
				avoidanceDirection=Vec3_Muls(cameraToObstacle, rMag);
			}
		}
	}

	if(distance>TRACK_RANGE)
	{
		vec3 trackDistance=Vec3_Addv(direction, avoidanceDirection);
		Vec3_Normalize(&trackDistance);

		enemy->camera->body.force=Vec3_Addv(enemy->camera->body.force, Vec3_Muls(trackDistance, TRACK_FORCE));
	}

	vec3 rotationAxis=QuatRotate(QuatInverse(enemy->camera->body.orientation), Vec3_Cross(enemy->camera->forward, direction));
	float cosTheta=clampf(Vec3_Dot(enemy->camera->forward, direction), -1.0f, 1.0f);
	float theta=acosf(cosTheta);
	vec4 rotation=QuatAnglev(theta, rotationAxis);

	enemy->camera->body.angularVelocity=Vec3_Addv(enemy->camera->body.angularVelocity, Vec3_Muls(Vec3(rotation.x, rotation.y, rotation.z), ROTATION_FORCE));

	return distance;
}

static void AttackPlayer(Enemy_t *enemy, const Camera_t player)
{
	static float fireCooldownTimer=0.0f;
	static float fireCooldown=0.0f;

	vec3 direction=Vec3_Subv(player.body.position, enemy->camera->body.position);
	float distance=Vec3_Normalize(&direction);
	vec3 forward=enemy->camera->forward;
	Vec3_Normalize(&forward);
	float theta=Vec3_Dot(direction, forward);

	if(theta>ATTACK_ANGLE_THRESHOLD&&distance<ATTACK_RANGE)
	{
		// Fire weapon
		fireCooldownTimer+=fTimeStep;

		if(fireCooldownTimer>fireCooldown)
		{
			fireCooldownTimer-=fireCooldown;
			fireCooldown=RandFloatRange(0.25f, 2.0f);

			FireParticleEmitter(Vec3_Addv(enemy->camera->body.position, Vec3_Muls(enemy->camera->forward, enemy->camera->body.radius)), enemy->camera->forward);
		}
	}
}

static bool IsInAttackRange(Enemy_t *enemy, const Camera_t player)
{
	const float distance=Vec3_Distance(enemy->camera->body.position, player.body.position);

	return distance<ATTACK_RANGE;
}

bool IsAlignedForAttack(Enemy_t *enemy, const Camera_t player)
{
	vec3 direction=Vec3_Subv(player.body.position, enemy->camera->body.position);
	Vec3_Normalize(&direction);

	return Vec3_Dot(enemy->camera->forward, direction)>ATTACK_ANGLE_THRESHOLD;
}

void UpdateEnemy(Enemy_t *enemy, Camera_t player)
{
	if(enemy->health<0.0f&&enemy->state!=DEAD)
	{
		Audio_PlaySample(&AssetManager_GetAsset(assets, RandRange(SOUND_EXPLODE1, SOUND_EXPLODE3))->sound, false, 1.0f, enemy->camera->body.position);

		ParticleSystem_AddEmitter(&particleSystem,
								  enemy->camera->body.position,	// Position
								  Vec3(1000.0f, 0.0f, 0.0f),	// Start color
								  Vec3(0.0f, 0.0f, 0.0f),		// End color
								  20.0f,						// Radius of particles
								  1000,							// Number of particles in system
								  PARTICLE_EMITTER_ONCE,		// Type?
								  ExplodeEmitterCallback		// Callback for particle generation
		);
		enemy->state=DEAD;
	}

	switch(enemy->state)
	{
		case PURSUING:
		{
			TrackPlayer(enemy, player);

			// Switch to attacking if within range and aligned
			if(IsInAttackRange(enemy, player)&&IsAlignedForAttack(enemy, player))
				enemy->state=ATTACKING;
			else if(!HasLineOfSight(enemy, player))
			{
				enemy->state=SEARCHING;
				enemy->lastKnownPlayer=player;
			}
			break;
		}

		case SEARCHING:
		{
			TrackPlayer(enemy, enemy->lastKnownPlayer);

			if(HasLineOfSight(enemy, player))
				enemy->state=PURSUING;
			break;
		}

		case ATTACKING:
		{
			TrackPlayer(enemy, player);
			AttackPlayer(enemy, player);

			// Stay in attack mode while aligned and within range
			if(!IsInAttackRange(enemy, player)||!IsAlignedForAttack(enemy, player))
			{
				enemy->state=PURSUING;
			}
			else if(!HasLineOfSight(enemy, player))
			{
				enemy->state=SEARCHING;
				enemy->lastKnownPlayer=player;
			}
			break;
		}

		case DEAD:
			break;
	}
}