#include "common.qh"
#include "protocol.qh"
#include "misc.qh"
#include "teleport.qh"

// ===================================================================== //

entity(string clname) spawn = {
	local entity e;

	e = BUILTIN_spawn();
	e.classname = clname;

	return e;
};

// ===================================================================== //

void() SUB_remove = { remove(self); };

void(entity e) safe_remove = {
	e.takedamage = DAMAGE_NO;
	e.solid = SOLID_NOT;
	e.model = NULL_string;
	e.modelindex = 0;

	e.think = SUB_remove;
	e.nextthink = time;
};

// ===================================================================== //

void() SUB_makestatic = { makestatic(self); };

void(entity e) safe_makestatic = {
	if (sv_spawning) {
		makestatic(self);
		return;
	}

	e.takedamage = DAMAGE_NO;
	e.solid = SOLID_NOT;

	e.think = SUB_makestatic;
	e.nextthink = time;
};

// ===================================================================== //

void() _sound_vector_think = {
	sound(self, CHAN_VOICE, self.noise1, self.volume, self.attenuation);
	remove(self);
};
void(vector org, string samp, float vol, float atten) sound_vector = {
	local entity e;

	e = spawn("SOUND");
	e.origin = org;
	e.noise1 = samp;
	e.volume = vol;
	e.attenuation = atten;

	e.think = _sound_vector_think;
	e.nextthink = time;
};

// ===================================================================== //

float(vector org) _missile_th_teleport = {
	self.owner = world;
	return TRUE;
};

void(entity mis) missile_check_teleport;
void() _missile_always_trigger = {
	self.think = SUB_remove;
	self.nextthink = self.attack_finished;

	if (self.movetype != MOVETYPE_FLYMISSILE && self.movetype != MOVETYPE_FLY)
		return;

	tl_proj_begin();
	/* Make sure we're still going to hit the thing */
	traceline(self.origin, self.origin + self.velocity * sv_maxtic*2, FALSE, self);
	if (trace_ent == self.enemy)	tl_touch(trace_ent, self);
	else				self.enemy = world;
	tl_proj_end();

	missile_check_teleport(self);
};

void(entity mis) missile_check_teleport = {
	local float duration;

	tl_proj_begin();

	trace_ent = mis;
	trace_endpos = mis.origin;
	duration = mis.attack_finished - time;

	while (duration > sv_maxtic) {
		traceline(trace_endpos, trace_endpos + mis.velocity*duration, FALSE, trace_ent);

		if (!trace_ent || trace_ent.solid == SOLID_BSP) {
			/* Don't bother tracing through BSP, it won't happen. */
			break;
		}

		if (tl_issolid(trace_ent) || mis.enemy == trace_ent || (duration*trace_fraction) <= sv_maxtic) {
			/* We hit a triggered trigger,
			   a solid ent, or something we _just_ hit */
			if (trace_fraction == 0) {
				/* We're not going anywhere. Fudge it. */
				break;
			}
			/* Trace on past it. */
			duration -= duration*trace_fraction;
			continue;
		}

		/* Reached a [new] trigger */
		mis.enemy = trace_ent;
		mis.think = _missile_always_trigger;
		mis.nextthink = time + duration*trace_fraction - sv_maxtic;
		break;
	}

	tl_proj_end();
};

entity(string clname, string mod, vector org, vector dir, float spd) spawn_missile = {
	newmis = spawn(clname);

	newmis.owner = self;
	newmis.goalentity = self;

	newmis.movetype = MOVETYPE_FLYMISSILE;
	newmis.solid = SOLID_BBOX;
	newmis.deadflag = DEAD_NONLIVING;

	newmis.th_teleport = _missile_th_teleport;

	setmodel(newmis, mod);
	setsize(newmis, '0 0 0', '0 0 0');
	setorigin(newmis, org);

	newmis.angles = vectoangles(dir);
	newmis.speed = spd;
	newmis.velocity = dir * spd;

	newmis.attack_finished = time + (6000 / spd);

	newmis.think = SUB_remove;
	newmis.nextthink = newmis.attack_finished;

	missile_check_teleport(newmis);

	return newmis;
};

// ===================================================================== //

entity tl_first;
.entity tl_next;
void() tl_proj_begin = {
	local entity walk;

	tl_first = world;
	for (walk = nextent(world); walk; walk = nextent(walk)) {
		if (walk.solid != SOLID_TRIGGER)
			continue;

		walk.tl_next = tl_first;
		tl_first = walk;

		walk.solid = SOLID_BBOX;
		walk.tl_notsolid = TRUE;
		setorigin(walk, walk.origin); // relink
	}
};

void() tl_proj_end = {
	local entity walk;

	for (walk = tl_first; walk; walk = walk.tl_next) {
		walk.solid = SOLID_TRIGGER;
		walk.tl_notsolid = FALSE;
		setorigin(walk, walk.origin); // relink
	}
};

void(entity trigger, entity fake_proj) tl_touch = {
	local entity oldself, oldother;

	if (!trigger.touch)
		return;

	tl_proj_end();

	oldself = self;
	oldother = other;

	self = trigger;
	other = fake_proj;

	self.touch();

	self = oldself;
	other = oldother;

	tl_proj_begin();
};

// ===================================================================== //

string(entity e) name = {
	if (e.netname) return e.netname;
	if (e.classname) return e.classname;

	if (e.velocity)
		return "an unidentified flying object";
	return "an unidentified stationary object";
};

// ===================================================================== //

void(.string fld, string match, void(entity e) func) foreach = {
	local entity ent;

	ent = world;
	while ((ent = find(ent, fld, match))) {
		if (!func) {
			dprint("NULL function in foreach, classname: ", ent.classname, "\n");
			continue;
		}

		func(ent);
	}
};

void(.string fld, string match, .void() func) foreach_field = {
	local entity oldself;

	oldself = self;

	self = world;
	while ((self = find(self, fld, match))) {
		if (!self.func) {
			dprint("NULL function in foreach_field, classname: ", self.classname, "\n");
			continue;
		}

		self.func();
	}

	self = oldself;
};

// ===================================================================== //

float(entity newself, entity newother, float() func) switcheroo = {
	local entity oldself, oldother;
	local float ret;

	oldself = self;
	oldother = other;

	self = newself;
	other = newother;

	ret = func();

	self = oldself;
	other = oldother;

	return ret;
};

// ===================================================================== //

float(float current, float increment, float max) increase_bound = {
	local float diff;

	diff = max - current;
	if (diff <= 0) return current;
	if (diff > increment) diff = increment;
	return current + diff;
};

float(.float fld, float increment, float max) increase_field = {
	local float new;

	new = increase_bound(self.fld, increment, max);
	if (new == self.fld)
		return FALSE;

	self.fld = new;

	return TRUE;
};

// ===================================================================== //

/* Not to be confused with maxspeed */
float(entity e) calc_max_speed = {
	local float spd;

	spd = e.maxspeed;

	if (self.waterlevel >= 2)
		spd = spd * 0.7;	// Bah.  Hard coded in engine.
	else if (!self.waterlevel && !(self.flags & FL_ONGROUND)) {
		if (spd > 30)
			spd = 30;	// Also hard coded.
	}
	
	return spd;
};

// ===================================================================== //

entity _xprint_client;
float _xprint_level;
void(entity client, float level) xprint_start = {
	_xprint_client = client;
	_xprint_level = level;
};

void(string str) xprint_str = {
	msg_entity = _xprint_client;
	WriteByte(MSG_ONE, SVC_PRINT);
	WriteByte(MSG_ONE, _xprint_level);
	WriteString(MSG_ONE, str);
};

// ===================================================================== //

entity(.string fld, string str) find_random = {
	local float r, numents;
	local entity ent;

	numents = 0;
	r = floor(random() * 512);

	while (1) {
		ent = find(world, fld, str);
		if (!ent) return world;

		while (ent) {
			numents++;

			r--;
			if (r <= 0) return ent;

			ent = find(ent, fld, str);
		}

		r -= numents * floor(r / numents);
	}

	return world;
};

// ===================================================================== //

entity(entity ech) random_enemy_chain = {
	local entity walk;
	local float tot, r;

	r = floor(random()*64) + 1;

	tot = 1;
	for (walk = ech.enemy; walk != ech; walk = walk.enemy) {
		r--;
		if (r <= 0)
			return walk;

		tot++;
	}

	if (!tot)
		return ech;

	/* Ok, only look at half the remaining ones */
	tot = floor(tot * 0.5);
	if (!tot)
		return ech.enemy;

	r -= tot * floor(r / tot);

	for (walk = ech.enemy; walk; walk = walk.enemy) {
		if (r <= 0)
			return walk;

		r--;
	}

	return world;
};

// ===================================================================== //