// b_coopcam.c
// blinky
// Created: 2000/06
// Edited:  2000/07/17
//

#include "g_local.h"

#ifdef GAME_MOD
void Blinky_BeginClientThink(edict_t *ent, usercmd_t *ucmd)
{
	gclient_t * client = ent->client;
	BlinkyClient_t * bdata = &client->blinky_client;

// the runrun code - continuous running	
	if (bdata->runrun)
	{
		if (ucmd->forwardmove>0)
			bdata->runrun=1;
		else if (ucmd->forwardmove<0)
			bdata->runrun=2;
		else if (ucmd->sidemove>0)
			bdata->runrun=3;
		else if (ucmd->sidemove<0)
			bdata->runrun=4;
		switch(bdata->runrun)
		{
			case 1: ucmd->forwardmove = 400; break;
			case 2: ucmd->forwardmove = -400; break;
			case 3: ucmd->sidemove = 400; break;
			case 4: ucmd->sidemove = -400; break;
		}
	}
}

void Blinky_EndClientThink(edict_t *ent, usercmd_t *ucmd)
{
//	gclient_t * client = ent->client;
}

static void Blinky_BeginServerFrameClient(edict_t * ent)
{
	gclient_t * client = ent->client;
	edict_t * target = client->blinky_client.cam_target;
	edict_t * decoy = client->blinky_client.cam_decoy;
	if (target)
	{
/*
		decoy->modelindex = ent->modelindex;
		decoy->modelindex2 = ent->modelindex2;
		decoy->modelindex3 = ent->modelindex3;
		decoy->modelindex4 = ent->modelindex4;
		decoy->frame = ent->frame;
		decoy->skinnum = ent->skinnum;
*/
		decoy->s = ent->s;
	}

//	client->ps.viewangles[0] = client->ps.viewangles[1] = 0.0;
}

void Blinky_BeginRunFrame()
{
	int		i;
	edict_t	*ent;

	for (i=0 ; i<maxclients->value ; i++)
	{
		ent = g_edicts + 1 + i;
		if (!ent->inuse || !ent->client)
			continue;

		Blinky_BeginServerFrameClient(ent);
	}
}

void Blinky_ClientEndServerFrame(edict_t * ent)
{
//	gclient_t * client = ent->client;
}

static int IsSpectator(edict_t * ent) { return ent->client->pers.spectator; }

#define SCANNER_UNIT 10
static void
ShowStats(edict_t *ent, edict_t *player)
{
//	float dist = 0.0;
	vec3_t v;
	int j;
	char stats[500];
	BlinkyClient_t * bdata;
	char pname[11];
	int health, armor, armorpow;
	int xd,yd,zd;
	vec3_t dp, normal={0,0,-1};
	static int CellsIndex = -1;
	int index;

	j = 0;
	if (-1 == CellsIndex)
		CellsIndex = ITEM_INDEX(FindItem("cells"));

	bdata = &ent->client->blinky_client;

	VectorSubtract(ent->s.origin, player->s.origin, v);
	zd = -v[2]/SCANNER_UNIT; // save height differential
	v[2] = 0; // remove height component

	RotatePointAroundVector(dp, normal, v, ent->s.angles[1]);
	xd = -dp[0]/SCANNER_UNIT;
	yd = dp[1]/SCANNER_UNIT;
	if (player->client)
		strncpy(pname, player->client->pers.netname, sizeof(pname)-1);
	else
		strncpy(pname, player->classname, sizeof(pname)-1);
	pname[sizeof(pname)-1] = 0;
	health = player->health;

	armorpow = 0;
	if (PowerArmorType(ent))
		armorpow = ent->client->pers.inventory[CellsIndex];

	index = ArmorIndex (ent);
	if (index)
		armor = ent->client->pers.inventory[index];

	if (armorpow)
		sprintf(stats+j, "%s: armor=%3d(%3d), health=%3d (f=%+5d,r=%+5d,u=%+5d)\n"
			, pname, armor,armorpow,health,xd, yd, zd);
	else
		sprintf(stats+j, "%s: armor=%3d, health=%3d (f=%+5d,r=%+5d,u=%+5d)\n"
			, pname, armor,health,xd, yd, zd);
	gi.cprintf(ent, PRINT_CHAT, "%s", stats);
}

void MoveToAngles(edict_t * ent, vec3_t pv1)
{
	int i;
	for (i=0 ; i<3 ; i++)
	{
		ent->client->ps.pmove.delta_angles[i] = ANGLE2SHORT(pv1[i] - ent->client->resp.cmd_angles[i]);
//		ent->client->ps.viewangles[i] = pv1[i];
	}
}

void StopCam(edict_t * ent)
{
	BlinkyClient_t * bdata = &ent->client->blinky_client;
		
	if (!bdata->cam_target)
		return;

	bdata->cam_target = 0;
	ent->svflags &= ~SVF_NOCLIENT;
	ent->client->ps.pmove.pm_flags &= ~PMF_NO_PREDICTION;
	bdata->cam_decoy->svflags |= SVF_NOCLIENT;
	VectorCopy(bdata->cam_decoy->s.origin, ent->s.origin);
	MoveToAngles(ent, bdata->cam_decoy->s.angles);
	ent->client->ps.fov = bdata->save_fov;
	ent->client->pers.hand = bdata->save_hand;
	gi.linkentity(ent); gi.linkentity(bdata->cam_decoy);
}

void StartCam(edict_t * ent, edict_t * target)
{
	BlinkyClient_t * bdata = &ent->client->blinky_client;
	edict_t * decoy = bdata->cam_decoy;

	bdata->cam_target = target;
	ent->svflags |= SVF_NOCLIENT;
	ent->client->ps.pmove.pm_flags |= PMF_NO_PREDICTION;
	if (!decoy)
	{
		bdata->cam_decoy = G_Spawn();
		decoy = bdata->cam_decoy;
		decoy->client = ent->client;
		decoy->s = ent->s;
//		VectorCopy(ent->mins, decoy->mins);
//		VectorCopy(ent->maxs, decoy->maxs);
//		decoy->solid = ent->solid;
//		decoy->health = ent->health;
	}
	bdata->cam_decoy->svflags &= ~SVF_NOCLIENT;
	VectorCopy(ent->s.origin, bdata->cam_decoy->s.origin);
	MoveToAngles(ent, target->s.angles);
	VectorCopy(ent->s.angles, bdata->cam_decoy->s.angles);
	bdata->save_fov = ent->client->ps.fov;
	bdata->save_hand = ent->client->pers.hand;
	ent->client->pers.hand = CENTER_HANDED;
	if (target->client)
		ent->client->ps.fov = target->client->ps.fov;
	gi.linkentity(ent); gi.linkentity(bdata->cam_decoy);
}


void Cmd_Stats_f(edict_t *ent)
{
	char * name = gi.args();
	edict_t * player;
	for (player = &g_edicts[0]+1; player< &g_edicts[0]+(int)(maxclients->value)+1; player++)
	{
		if (!player->inuse || !player->client || player->client->pers.spectator)
			continue;
//		if (player == ent)
//			continue;
		// if a specific name requested & doesn't match, skip
		if (name[0])
		{
			if (Q_stricmp(name, player->client->pers.netname))
				continue;
		}
		ShowStats(ent, player);
	}
}


void Cmd_Cam_f(edict_t *ent)
{
	char * name = gi.args();
 // obj1 is how to tell when we've looped
	edict_t * obj1;
	edict_t * target;
	BlinkyClient_t * bdata;

	bdata = &ent->client->blinky_client;
	obj1 = bdata->cam_target;

	if (!coop->value || IsSpectator(ent))
		return;

	if (!obj1)
		obj1 = ent;
	target = obj1;
	while(1)
	{
		// advance loop thru edicts
		// to do - this ought to cycle at maxclients instead of num_edicts
		if (target < &g_edicts[0]+(int)(maxclients->value)+1)
			target++;
		else
			target = g_edicts+1;
		if (target == obj1)
			break;
		// only look at (in use) players
		if (!target->inuse || !target->client || IsSpectator(target))
			continue;
		// if a specific name requested & doesn't match, skip
		if (name[0] && Q_stricmp(name, target->client->pers.netname))
			continue;

		// found cam target
		if (target == ent)
		{
			StopCam(ent);
		}
		else
		{
			StartCam(ent, target);
			ShowStats(ent, target);
		}
		break;
	}

}

static void Summon(edict_t *ent, edict_t *other)
{
	vec3_t offset, forward, right, start;
	trace_t		tr;

	if (other->client->blinky_client.nosummon)
		return;

	VectorSet(offset, 40, 0, ent->viewheight-8);
	AngleVectors (ent->client->v_angle, forward, right, NULL);
	P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
	
	// code mostly copied from KillBox

	// unlink to make sure it can't possibly interfere with KillBox
	gi.unlinkentity (other);

	tr = gi.trace (start, other->mins, other->maxs, start, NULL, MASK_PLAYERSOLID);
	if (tr.fraction < 1.0)
	{
		gi.linkentity (other);
		return;
	}


	VectorCopy (start, other->s.origin);
	VectorCopy (start, other->s.old_origin);
	other->s.origin[2] += 10;

	// clear the velocity and hold them in place briefly
	VectorClear (other->velocity);
	other->client->ps.pmove.pm_time = 160>>3;		// hold time
	other->client->ps.pmove.pm_flags |= PMF_TIME_TELEPORT;

	// draw the teleport splash at source and on the player
	other->s.event = EV_PLAYER_TELEPORT;

	// set angles
	MoveToAngles(other, ent->s.angles);

	VectorClear (other->s.angles);
	VectorClear (other->client->ps.viewangles);
	VectorClear (other->client->v_angle);

	// kill anything at the destination
	KillBox (other);

	gi.linkentity (other);
}


void Cmd_NoSummon_f(edict_t *ent)
{
	BlinkyClient_t * bdata = &ent->client->blinky_client;
	bdata->nosummon = !bdata->nosummon;
}

void Cmd_Runrun_f(edict_t *ent)
{
//	char buffer[64];
	int runrun = !ent->client->blinky_client.runrun;
	ent->client->blinky_client.runrun = runrun;
//	sprintf(buffer, "runrun is %s", runrun ? "on" : "off");
}

void Cmd_Summon_f(edict_t *ent)
{
	char * name = gi.args();
	edict_t * target;
	int i;

	for (i = 1; i < (int)(maxclients->value)+1; i++)
	{
		target = &g_edicts[i];

		if (!target->inuse || !target->client || IsSpectator(target))
			continue;
		if (target == ent)
			continue;
		// if a specific name requested & doesn't match, skip
		if (name[0] && Q_stricmp(name, target->client->pers.netname))
			continue;

		Summon(ent, target);
		return;
	}
}


void Blinky_OnClientTerminate(edict_t *self)
{
// disconnect any cams
	edict_t * player;
	BlinkyClient_t * bdata;
	
	for (player = &g_edicts[0]+1; player< &g_edicts[0]+(int)(maxclients->value)+1; player++)
	{
		if (!player->client || !player->inuse)
			continue;
		bdata = &player->client->blinky_client;
		if (bdata->cam_target == self)
			StopCam(player);
	}
#if 0
	StopCam(self);
#endif
}

void Blinky_CalcViewOffsets(edict_t * ent, vec3_t v)
{
	int i;
	BlinkyClient_t * bdata = &ent->client->blinky_client;
	vec3_t forward;
	edict_t * target = bdata->cam_target;
	int offset = camoffset->value;
	
//	ent->client->ps.gunindex = bdata->cam_target->client->ps.gunindex;

	VectorSet(v,0,0,0);
	for (i=0; i<3; i++)
	{
		ent->client->ps.pmove.origin[i] = target->s.origin[i]*8;
	}
	VectorCopy(target->s.angles, ent->client->ps.viewangles);
// 2000/07/01 MoveToAngles doesn't work
//	MoveToAngles(ent, bdata->cam_target->s.angles);
// 2000/07/01 changing from adding viewheight, to adding viewoffset

// shift cam up
// 2000/07/02 - adding viewoffset does not work
//              but adding viewheight to v[2] works
//	VectorAdd(v,ent->client->ps.viewoffset,v);
	v[2] += target->viewheight;

// move cam forward
	if (offset)
	{
		AngleVectors (target->client->v_angle, forward, NULL, NULL);
		VectorMA (v, offset, forward, v);
	}
}

void Blinky_SpawnEntities()
{
	
	gi.dprintf ("Blinky - CoopCam version of 3.20, 2000/08/23\n");
	gi.dprintf ("\x02""Use cam <name> to see through your buddy eyes, cam to turn back\n");
	
	srand( (unsigned)time( NULL ) );
}
#endif