cl_easymove.c

/*
Copyright (C) 2013 Anton (tonik) Gavrilov.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "quakedef.h"
#include "pmove.h"

cvar_t cl_easymove = {"cl_easymove", "0"};
cvar_t cl_autohop = {"cl_autohop", "0"};
qbool em_touch_wall;
qbool em_jump_held;

static float pm_frametime;

static float AngleMod (float a)
{
	if (a > 180)
		a -= 360;
	if (a <= - 180)
		a += 360;
	return a;
}


static float FindMax (float start, float end, float (*f)(float))
{
	float p1, p2;

	while (end - start > 0.01)
	{
		p1 = start + (end - start) / 3.0;
		p2 = start + (end - start) * 2.0 / 3.0;

		if (f(p1) > f(p2))
			end = p2;
		else
			start = p1;
	};

	return (end + start)/2;
};


static void Friction (vec3_t velocity)
{
	float speed, newspeed, control;
	float friction;
	float drop;
	
	speed = VectorLength(velocity);
	if (speed < 1)
	{
		velocity[0] = 0;
		velocity[1] = 0;
		return;
	}

	/* apply ground friction */
	friction = movevars.friction;

	control = speed < movevars.stopspeed ? movevars.stopspeed : speed;
	drop = control*friction*pm_frametime;

	/* scale the velocity */
	newspeed = speed - drop;
	if (newspeed < 0)
		newspeed = 0;

	VectorScale (velocity, newspeed / speed, velocity);
}

static void Accelerate (vec3_t wishdir, float wishspd, vec3_t velocity)
{
	int   i;
	float addspeed, accelspeed, currentspeed;
	float wishspd_orig = wishspd;

	currentspeed = DotProduct (velocity, wishdir); 
	addspeed = wishspd - currentspeed;
	if (addspeed <= 0)
		return;

	accelspeed = movevars.accelerate * wishspd_orig * pm_frametime;
	if (accelspeed > addspeed)
		accelspeed = addspeed;

	for (i=0 ; i<3 ; i++)
		velocity[i] += accelspeed*wishdir[i];
}

static vec3_t ra_curvel, ra_intentions;
static float RankAngle (float a)
{
	vec3_t wishdir;
	float  delta;
	vec3_t ang1, ang2;
	vec3_t newvel;

	wishdir[0] = cos(a / 180 * M_PI);
	wishdir[1] = sin(a / 180 * M_PI);
	wishdir[2] = 0;

	VectorCopy (ra_curvel, newvel);
	Friction (newvel);
	Accelerate (wishdir, movevars.maxspeed, newvel);

	vectoangles (newvel, ang1);
	vectoangles (ra_intentions, ang2);

	delta = AngleMod(ang2[YAW] - ang1[YAW]);

	return -fabs(delta);
}

static float BestAngle (vec3_t curvel, vec3_t intentions, qbool onground)
{
	float  a1, a2;
	vec3_t cross;
	vec3_t tmp;
	float  ba;
	float  max;

	a1 = 0;
	a2 = 95;
	CrossProduct (curvel, intentions, cross);
	if (cross[2] < 0)
	{
		a1 = -a1;
		a2 = -a2;
	}

	VectorCopy(curvel, ra_curvel);
	VectorCopy(intentions, ra_intentions);

	vectoangles (curvel, tmp);
	ba = tmp[YAW];

	if (a2 > a1)
		max = FindMax (ba + a1, ba + a2, RankAngle);
	else
		max = FindMax (ba + a2, ba + a1, RankAngle);

	return max;
}

static float ZeroAngle (float speed)
{
	if (!speed)
		return 0;

	return acos(30/speed)/M_PI*180;
}

static void TweakMovement (usercmd_t *cmd)
{
	vec3_t fw, rt;
	vec3_t movevec;
	vec3_t v1, ang;
	float a;
	float delta;
	vec3_t intentions;
	vec3_t intentions_a;
	vec3_t cmd_ang;
	qbool onground;
	static qbool locked = false;
	static double startlock = -1;
	static float olddelta;
	static qbool olddelta_valid = false;
	static short oldmove[2];

	if (!cl_easymove.value || cl.waterlevel)
		return;

	if (!cmd->forwardmove && !cmd->sidemove)
	{
		oldmove[0] = oldmove[1] = 0;
		return;
	}

	onground = (cl.onground && !((cmd->buttons & BUTTON_JUMP) && !em_jump_held));

	VectorCopy (cmd->angles, cmd_ang);
	cmd_ang[PITCH] = 0;
	cmd_ang[ROLL] = 0;
	AngleVectors (cmd_ang, fw, rt, NULL);
	VectorScale (fw, cmd->forwardmove, intentions);
	VectorMA (intentions, cmd->sidemove, rt, intentions);
	vectoangles (intentions, intentions_a);

	VectorCopy (cl.simvel, v1);

	v1[2] = 0;

	if (VectorLength(v1) < 30)
		return;

	vectoangles (v1, ang);
	delta = AngleMod(intentions_a[YAW] - ang[YAW]);

	if (!locked && startlock == -1)
		startlock = curtime;

	if ((cmd->forwardmove != oldmove[0] || cmd->sidemove != oldmove[1])
	&& (!onground || (oldmove[0] || oldmove[1]))) {
		locked = false;
		olddelta_valid = false;
		startlock = curtime;
	}
	oldmove[0] = cmd->forwardmove;
	oldmove[1] = cmd->sidemove;

	if (fabs(delta) < 0.5 || (olddelta_valid && (
		(olddelta >= 0 && delta <= 0) || (olddelta <= 0 && delta >= 0)
		|| fabs(delta) > fabs(olddelta) + 0.1)) ) {
			locked = true;
	}
	olddelta = delta;
	olddelta_valid = true;

	if (curtime - startlock > (onground ? 0.1 : 0.3))
		locked = true;

	if (fabs(delta) > 95) {
		locked = true;
		return;
	}

	if (!locked || em_touch_wall)
		return;

	if (onground)
	{
		if (fabs(delta) < 0.5)
			return;
		a = BestAngle (v1, intentions, onground);
	}
	else
	{
		a = intentions_a[YAW] + (delta > 0 ? 1 : -1)*ZeroAngle(VectorLength(v1));
	}

	VectorClear (ang);
	ang[YAW] = a;
	AngleVectors (ang, movevec, NULL, NULL);
	cmd->forwardmove = DotProduct (movevec, fw) * 500;
	cmd->sidemove = DotProduct (movevec, rt) * 500;
}

static void Autohop (usercmd_t *cmd)
{
	static float oldzvel;

	if (!(cmd->buttons & 2))
	{
		oldzvel = cl.simvel[2];
		return;
	}
	if (!cl_autohop.value)
		return;
	if (cl.simvel[2] <= 0 && oldzvel > 0)
		cmd->buttons &= ~2;
	oldzvel = cl.simvel[2];
}

void CL_EasyMove (usercmd_t *cmd)
{
	if (cl.spectator || cl.intermission || cl.stats[STAT_HEALTH] < 0)
		return;

	pm_frametime = cmd->msec * 0.001;
	TweakMovement (cmd);
	Autohop (cmd);
}