ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed the going backwards bug by remaking of accelerating and brake algorithm

Browse Source 
including a defineable max-speed-reverse-ratio (bullet only).

Added a getsProjectile() when get hit by a homing missile (bullet only).

Modified forceCrash() for bullet.


git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/trunk/supertuxkart@1205 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
hansthefarmer 2007-08-17 17:07:12 +00:00
parent 954cbe2c5f
commit e5037c3cb2
4 changed files with 76 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
src/kart.cpp
View File

@ -143,10 +143,11 @@ Kart::Kart (const KartProperties* kartProperties_, int position_ ,
// to the air resistance), maximum speed is reached when the engine
// power equals the air resistance force, resulting in this formula:
#ifdef BULLET
m_max_speed = m_kart_properties->getMaximumSpeed();
m_speed = 0.0f;
m_max_speed = m_kart_properties->getMaximumSpeed();
m_max_speed_reverse_ratio = m_kart_properties->getMaxSpeedReverseRatio();
m_speed = 0.0f;
#else
m_max_speed = sqrt(getMaxPower()/getAirResistance());
m_max_speed = sqrt(getMaxPower()/getAirResistance());
#endif
m_wheel_position = 0;
@ -493,6 +494,9 @@ void Kart::doObjectInteractions ()
sgVec3 xyz ;
Kart *other_kart = world->getKart(i);
sgSubVec3(xyz, getCoord()->xyz, other_kart->getCoord()->xyz );
//FIXME
// the dist calculation is very very basic, and 1.1f is far too low
// must be from 2.4f to 3.0f
float dist = sgLengthSquaredVec3(xyz);
if ( dist < 1.1f )
{
@ -563,14 +567,37 @@ void Kart::doZipperProcessing (float delta)
else m_zipper_time_left = 0.0f ;
} // doZipperProcessing
//-----------------------------------------------------------------------------
void Kart::getsProjectile ()
{
#ifdef BULLET
btVector3 velocity = m_kart_body->getLinearVelocity();
velocity.setX( 0.0f );
velocity.setY( 0.0f );
velocity.setZ( 3.5f );
getVehicle()->getRigidBody()->setLinearVelocity( velocity );
#else
forceCrash();
#endif
}
//-----------------------------------------------------------------------------
void Kart::forceCrash ()
{
m_wheelie_angle = CRASH_PITCH ;
#ifdef BULLET
btVector3 velocity = m_kart_body->getLinearVelocity();
velocity.setY( 0.0f );
velocity.setX( 0.0f );
getVehicle()->getRigidBody()->setLinearVelocity( velocity );
#else
m_velocity.xyz[0] = m_velocity.xyz[1] = m_velocity.xyz[2] =
m_velocity.hpr[0] = m_velocity.hpr[1] = m_velocity.hpr[2] = 0.0f ;
#endif
} // forceCrash
//-----------------------------------------------------------------------------
@ -846,35 +873,39 @@ void Kart::updatePhysics (float dt)
float engine_power = getMaxPower() + handleWheelie(dt);
if(m_attachment.getType()==ATTACH_PARACHUTE) engine_power*=0.2;
if(m_controls.brake)
{
//only apply braking force when moving forward
if(m_speed > 0.f)
{
m_vehicle->setBrake(getBrakeForce(), 2);
m_vehicle->setBrake(getBrakeForce(), 3);
}
//should probably not allow the kart to reverse at same velocity as forward
else
{
m_vehicle->applyEngineForce(-m_controls.brake*engine_power, 2);
m_vehicle->applyEngineForce(-m_controls.brake*engine_power, 3);
}
if(m_controls.accel)
{ // accelerating
m_vehicle->applyEngineForce(engine_power, 2);
m_vehicle->applyEngineForce(engine_power, 3);
}
else
{ // not braking
if(m_speed < 0.0f) // if going backwards, accelerating is braking
{
m_vehicle->setBrake(getBrakeForce(), 2);
m_vehicle->setBrake(getBrakeForce(), 3);
{ // not accelerating
if(m_controls.brake)
{ // braking or moving backwards
if(m_speed > 0.f)
{ // going forward, apply brake force
m_vehicle->applyEngineForce(-1.0f*getBrakeFactor()*engine_power, 2);
m_vehicle->applyEngineForce(-1.0f*getBrakeFactor()*engine_power, 3);
}
else
{ // going backward, apply reverse gear ratio
if ( fabs(m_speed) < m_max_speed*m_max_speed_reverse_ratio )
{
m_vehicle->applyEngineForce(-m_controls.brake*engine_power, 2);
m_vehicle->applyEngineForce(-m_controls.brake*engine_power, 3);
}
else
{
m_vehicle->applyEngineForce(0.f, 2);
m_vehicle->applyEngineForce(0.f, 3);
}
}
}
else
{
m_vehicle->applyEngineForce(m_controls.accel*engine_power, 2);
m_vehicle->applyEngineForce(m_controls.accel*engine_power, 3);
{ // lift the foot from throttle, brakes with 10% engine_power
m_vehicle->applyEngineForce(-m_controls.accel*engine_power*0.1f, 2);
m_vehicle->applyEngineForce(-m_controls.accel*engine_power*0.1f, 3);
}
}
if(m_controls.jump)
{ // ignore gravity down when jumping
@ -887,6 +918,16 @@ void Kart::updatePhysics (float dt)
//store current velocity
m_speed = getVehicle()->getRigidBody()->getLinearVelocity().length();
// calculate direction of m_speed
const btTransform& chassisTrans = getVehicle()->getChassisWorldTransform();
btVector3 forwardW (
chassisTrans.getBasis()[0][1],
chassisTrans.getBasis()[1][1],
chassisTrans.getBasis()[2][1]);
if (forwardW.dot(getVehicle()->getRigidBody()->getLinearVelocity()) < btScalar(0.))
m_speed *= -1.f;
//cap at maximum velocity
const float max_speed = m_kart_properties->getMaximumSpeed();
if ( m_speed > max_speed )
@ -902,20 +943,8 @@ void Kart::updatePhysics (float dt)
}
//at low velocity, forces on kart push it back and forth so we ignore this
if(m_speed > 0.13f) {
const btTransform& chassisTrans = getVehicle()->getChassisWorldTransform();
btVector3 forwardW (
chassisTrans.getBasis()[0][1],
chassisTrans.getBasis()[1][1],
chassisTrans.getBasis()[2][1]);
if ( forwardW.dot(getVehicle()->getRigidBody()->getLinearVelocity()) < 0.f )
m_speed *= -1.f;
}
else
if(fabsf(m_speed) < 0.13f)
m_speed = 0;
#else // ! BULLET
m_skid_front = m_skid_rear = false;

2
src/kart.hpp
View File

@ -87,6 +87,7 @@ protected:
bool m_skid_front; // true if front tires are skidding
bool m_skid_rear; // true if rear tires are skidding
float m_max_speed; // maximum speed of the kart, computed from
float m_max_speed_reverse_ratio;
float m_wheelie_angle ;
float m_current_friction; // current friction
float m_lap_start_time; // Time at start of a new lap
@ -255,6 +256,7 @@ public:
virtual void doCollisionAnalysis(float dt, float hot );
virtual void doObjectInteractions();
virtual void OutsideTrack (int isReset) {m_rescue=true;}
virtual void getsProjectile ();
};
class TrafficDriver : public Kart

2
src/kart_properties.cpp
View File

@ -151,6 +151,7 @@ void KartProperties::getAllData(const lisp::Lisp* lisp)
lisp->get("wheel-width", m_wheel_width );
lisp->get("chassis-linear-damping", m_chassis_linear_damping );
lisp->get("chassis-angular-damping", m_chassis_angular_damping );
lisp->get("max-speed-reverse-ratio", m_max_speed_reverse_ratio );
lisp->get("maximum-speed", m_maximum_speed );
lisp->get("gravity-center-shift", m_gravity_center_shift );
lisp->get("suspension-rest", m_suspension_rest );
@ -204,6 +205,7 @@ void KartProperties::init_defaults()
m_chassis_linear_damping = stk_config->m_chassis_linear_damping;
m_chassis_angular_damping = stk_config->m_chassis_angular_damping;
m_maximum_speed = stk_config->m_maximum_speed;
m_max_speed_reverse_ratio = stk_config->m_max_speed_reverse_ratio;
m_gravity_center_shift = stk_config->m_gravity_center_shift;
m_suspension_rest = stk_config->m_suspension_rest;

2
src/kart_properties.hpp
View File

@ -84,6 +84,7 @@ protected:
float m_chassis_linear_damping;
float m_chassis_angular_damping;
float m_maximum_speed;
float m_max_speed_reverse_ratio;
float m_gravity_center_shift;
float m_suspension_rest;
public:
@ -116,6 +117,7 @@ public:
float getCornerStiffF () const {return m_corn_f; }
float getCornerStiffR () const {return m_corn_r; }
float getInertia () const {return m_inertia; }
float getMaxSpeedReverseRatio() const {return m_max_speed_reverse_ratio;}
float getWheelieMaxSpeedRatio() const {return m_wheelie_max_speed_ratio;}
float getWheelieMaxPitch () const {return m_wheelie_max_pitch; }
float getWheeliePitchRate () const {return m_wheelie_pitch_rate; }