Example #1
0
/*
==============
CL_CmdButtons
==============
*/
void CL_CmdButtons(usercmd_t* cmd) {
    int i;

    //
    // figure button bits
    // send a button bit even if the key was pressed and released in
    // less than a frame
    //
    for (i = 0; i < USERCMD_BUTTONS; ++i) {
        if (kb[KB_BUTTONS + i].active || kb[KB_BUTTONS + i].wasPressed) {
            usercmdPressButton(cmd->buttons, i);
        }

        kb[KB_BUTTONS + i].wasPressed = false;
    }

    if (cls.keyCatchers) {
        usercmdPressButton(cmd->buttons, BUTTON_TALK);
    }

    // allow the game to know if any key at all is
    // currently pressed, even if it isn't bound to anything
    if (anykeydown && (!cls.keyCatchers)) {
        usercmdPressButton(cmd->buttons, BUTTON_ANY);
    }

    // Arnout: clear 'waspressed' from double tap buttons
    for (i = 1; i < DT_NUM; i++) {
        if (dtmapping[i] != KB_BUTTONS) {
            kb[dtmapping[i]].wasPressed = false;
        }
    }
}
Example #2
0
void CL_Xbox360ControllerMove( usercmd_t *cmd )
{
//	int     movespeed;
	float anglespeed;

	if ( !( kb[ KB_SPEED ].active ^ cl_run->integer ) )
	{
		usercmdPressButton( cmd->buttons, BUTTON_WALKING );
	}

	if ( kb[ KB_SPEED ].active )
	{
		anglespeed = 0.001 * cls.frametime * cl_anglespeedkey->value;
	}
	else
	{
		anglespeed = 0.001 * cls.frametime;
	}

	cl.viewangles[ PITCH ] += anglespeed * cl_pitchspeed->value * ( cl.joystickAxis[ AXIS_PITCH ] / 127.0f );
	cl.viewangles[ YAW ] += anglespeed * cl_yawspeed->value * ( cl.joystickAxis[ AXIS_YAW ] / 127.0f );

	cmd->rightmove = ClampChar( cmd->rightmove + cl.joystickAxis[ AXIS_SIDE ] );
	cmd->forwardmove = ClampChar( cmd->forwardmove + cl.joystickAxis[ AXIS_FORWARD ] );
	cmd->upmove = ClampChar( cmd->upmove + cl.joystickAxis[ AXIS_UP ] );
}
Example #3
0
bool BotSprint( gentity_t *self, bool enable )
{
	usercmd_t *botCmdBuffer = &self->botMind->cmdBuffer;
	int       staminaJumpCost;

	if ( !enable )
	{
		usercmdReleaseButton( botCmdBuffer->buttons, BUTTON_SPRINT );
		return false;
	}

	staminaJumpCost = BG_Class( self->client->ps.stats[ STAT_CLASS ] )->staminaJumpCost;

	if ( self->client->pers.team == TEAM_HUMANS
	     && self->client->ps.stats[ STAT_STAMINA ] > staminaJumpCost
	     && self->botMind->botSkill.level >= 5 )
	{
		usercmdPressButton( botCmdBuffer->buttons, BUTTON_SPRINT );
		BotWalk( self, false );
		return true;
	}
	else
	{
		usercmdReleaseButton( botCmdBuffer->buttons, BUTTON_SPRINT );
		return false;
	}
}
Example #4
0
/*
=================
CL_JoystickMove
=================
*/
void CL_JoystickMove(usercmd_t* cmd) {
    //	int             movespeed;
    float anglespeed;

    if (kb[KB_SPEED].active == (cl_run->integer != 0)) {
        usercmdPressButton(cmd->buttons, BUTTON_WALKING);
    }

    if (kb[KB_SPEED].active) {
        anglespeed = 0.001 * cls.frametime * cl_anglespeedkey->value;
    } else {
        anglespeed = 0.001 * cls.frametime;
    }

#ifdef __MACOS__
    cmd->rightmove = ClampChar(cmd->rightmove + cl.joystickAxis[AXIS_SIDE]);
#else

    if (!kb[KB_STRAFE].active) {
        cl.viewangles[YAW] +=
                anglespeed * j_yaw->value * cl.joystickAxis[j_yaw_axis->integer];
        cmd->rightmove =
                ClampChar(cmd->rightmove +
                          (int) (j_side->value * cl.joystickAxis[j_side_axis->integer]));
    } else {
        cl.viewangles[YAW] +=
                anglespeed * j_side->value * cl.joystickAxis[j_side_axis->integer];
        cmd->rightmove =
                ClampChar(cmd->rightmove +
                          (int) (j_yaw->value * cl.joystickAxis[j_yaw_axis->integer]));
    }

#endif

    if (kb[KB_MLOOK].active) {
        cl.viewangles[PITCH] += anglespeed * j_forward->value *
                                cl.joystickAxis[j_forward_axis->integer];
        cmd->forwardmove = ClampChar(
                cmd->forwardmove +
                (int) (j_pitch->value * cl.joystickAxis[j_pitch_axis->integer]));
    } else {
        cl.viewangles[PITCH] +=
                anglespeed * j_pitch->value * cl.joystickAxis[j_pitch_axis->integer];
        cmd->forwardmove = ClampChar(
                cmd->forwardmove +
                (int) (j_forward->value * cl.joystickAxis[j_forward_axis->integer]));
    }

    cmd->upmove = ClampChar(
            cmd->upmove + (int) (j_up->value * cl.joystickAxis[j_up_axis->integer]));
}
Example #5
0
void BotWalk( gentity_t *self, bool enable )
{
	usercmd_t *botCmdBuffer = &self->botMind->cmdBuffer;

	if ( !enable )
	{
		if ( usercmdButtonPressed( botCmdBuffer->buttons, BUTTON_WALKING ) )
		{
			usercmdReleaseButton( botCmdBuffer->buttons, BUTTON_WALKING );
			botCmdBuffer->forwardmove *= 2;
			botCmdBuffer->rightmove *= 2;
		}
		return;
	}

	if ( !usercmdButtonPressed( botCmdBuffer->buttons, BUTTON_WALKING ) )
	{
		usercmdPressButton( botCmdBuffer->buttons, BUTTON_WALKING );
		botCmdBuffer->forwardmove /= 2;
		botCmdBuffer->rightmove /= 2;
	}
}
Example #6
0
/*
================
CL_KeyMove

Sets the usercmd_t based on key states
================
*/
void CL_KeyMove( usercmd_t *cmd )
{
	int movespeed;
	int forward, side, up;

	//
	// adjust for speed key / running
	// the walking flag is to keep animations consistent
	// even during acceleration and deceleration
	//
	if ( kb[ KB_SPEED ].active ^ cl_run->integer )
	{
		movespeed = 127;
		usercmdReleaseButton( cmd->buttons, BUTTON_WALKING );
	}
	else
	{
		usercmdPressButton( cmd->buttons, BUTTON_WALKING );
		movespeed = 64;
	}

	forward = 0;
	side = 0;
	up = 0;

	if ( kb[ KB_STRAFE ].active )
	{
		side += movespeed * CL_KeyState( &kb[ KB_RIGHT ] );
		side -= movespeed * CL_KeyState( &kb[ KB_LEFT ] );
	}

	side += movespeed * CL_KeyState( &kb[ KB_MOVERIGHT ] );
	side -= movespeed * CL_KeyState( &kb[ KB_MOVELEFT ] );

	up += movespeed * CL_KeyState( &kb[ KB_UP ] );
	up -= movespeed * CL_KeyState( &kb[ KB_DOWN ] );

	forward += movespeed * CL_KeyState( &kb[ KB_FORWARD ] );
	forward -= movespeed * CL_KeyState( &kb[ KB_BACK ] );

	// fretn - moved this to bg_pmove.c
	//if (!(cl.snap.ps.persistant[PERS_HWEAPON_USE]))
	//{
	cmd->forwardmove = ClampChar( forward );
	cmd->rightmove = ClampChar( side );
	cmd->upmove = ClampChar( up );
	//}

	// Arnout: double tap
	cmd->doubleTap = DT_NONE; // reset

	if ( !cl.doubleTap.lastdoubleTap || com_frameTime - cl.doubleTap.lastdoubleTap > cl_doubletapdelay->integer + cls.frametime )
	{
		int      i;
		qboolean key_down;

		int          lastKey = 0;
		unsigned int lastKeyTime = 0;

		// Which was last pressed or released?
		for ( i = 1; i < DT_NUM; i++ )
		{
			if ( cl.doubleTap.pressedTime[ i ] > lastKeyTime )
			{
				lastKeyTime = cl.doubleTap.pressedTime[ i ];
				lastKey = i;
			}
			if ( cl.doubleTap.releasedTime[ i ] > lastKeyTime )
			{
				lastKeyTime = cl.doubleTap.releasedTime[ i ];
				lastKey = i;
			}
		}

		// Clear the others; don't want e.g. left-right-left causing dodge left
		if ( lastKey )
		{
			for ( i = 1; i < DT_NUM; i++ )
			{
				if ( i != lastKey )
				{
					cl.doubleTap.pressedTime[ i ] = cl.doubleTap.releasedTime[ i ] = 0;
				}
			}
		}

		for ( i = 1; i < DT_NUM; i++ )
		{
			key_down = dtmapping[ i ] == -1 || kb[ dtmapping[ i ] ].active || kb[ dtmapping[ i ] ].wasPressed;

			if ( key_down && !cl.doubleTap.pressedTime[ i ] )
			{
				cl.doubleTap.pressedTime[ i ] = com_frameTime;
			}
			else if ( !key_down &&
			          cl.doubleTap.pressedTime[ i ] &&
			          !cl.doubleTap.releasedTime[ i ] &&
			          com_frameTime - cl.doubleTap.pressedTime[ i ] < cl_doubletapdelay->integer + cls.frametime )
			{
				cl.doubleTap.releasedTime[ i ] = com_frameTime;
			}
			else if ( key_down &&
			          cl.doubleTap.pressedTime[ i ] &&
			          cl.doubleTap.releasedTime[ i ] &&
			          com_frameTime - cl.doubleTap.pressedTime[ i ] < cl_doubletapdelay->integer + cls.frametime &&
			          com_frameTime - cl.doubleTap.releasedTime[ i ] < cl_doubletapdelay->integer + cls.frametime )
			{
				cl.doubleTap.pressedTime[ i ] = cl.doubleTap.releasedTime[ i ] = 0;
				cmd->doubleTap = i;
				cl.doubleTap.lastdoubleTap = com_frameTime;
			}
			else if ( !key_down && ( cl.doubleTap.pressedTime[ i ] || cl.doubleTap.releasedTime[ i ] ) )
			{
				if ( com_frameTime - cl.doubleTap.pressedTime[ i ] >= ( cl_doubletapdelay->integer + cls.frametime ) )
				{
					cl.doubleTap.pressedTime[ i ] = cl.doubleTap.releasedTime[ i ] = 0;
				}
			}
		}
	}
}