Back to index

supertuxkart  0.5+dfsg1
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes
PlayerKart Class Reference

PlayerKart manages control events from the player and moves them to the Kart. More...

#include <player_kart.hpp>

Inheritance diagram for PlayerKart:
Inheritance graph
[legend]
Collaboration diagram for PlayerKart:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 PlayerKart (const std::string &kart_name, int position, Player *_player, sgCoord init_pos, int player_index)
int earlyStartPenalty ()
PlayergetPlayer ()
void update (float)
void addMessages ()
 This function is called by world to add any messages to the race gui.
void action (KartAction action, int value)
void crashed ()
void handleZipper ()
void collectedHerring (Herring *herring)
virtual void setPosition (int p)
 Checks if the kart was overtaken, and if so plays a sound.
int isPlayerKart () const
CameragetCamera ()
void reset ()
void loadData ()
void placeModel ()
const KartPropertiesgetKartProperties () const
void setKartProperties (const KartProperties *kp)
void attach (attachmentType attachment_, float time)
void setCollectable (CollectableType t, int n)
int getSector () const
float getDistanceDownTrack () const
float getDistanceToCenter () const
AttachmentgetAttachment ()
void setAttachmentType (attachmentType t, float time_left=0.0f, Kart *k=NULL)
CollectablegetCollectable ()
int getNumCollectables () const
int getNumHerring () const
int getLap () const
int getPosition () const
int getInitialPosition () const
void setFinishingState (float time)
float getFinishTime () const
bool raceIsFinished () const
void endRescue ()
 Drops a kart which was rescued back on the track.
float estimateFinishTime ()
void processSkidMarks ()
void getClosestKart (float *cdist, int *closest)
void updatePhysics (float dt)
const sgVec3 * getColor () const
float getMass () const
float getMaxPower () const
float getTimeFullSteer () const
float getBrakeFactor () const
float getWheelBase () const
float getHeightCOG () const
float getFrictionSlip () const
float getMaxSteerAngle () const
float getGravityCenterShift () const
float getWheelieMaxSpeedRatio () const
float getWheelieMaxPitch () const
float getWheeliePitchRate () const
float getWheelieRestoreRate () const
float getWheelieSpeedBoost () const
float getSteerAngle () const
float getSteerPercent () const
float getMaxSpeed () const
void setTimeAtLap (float t)
float getTimeAtLap () const
void createPhysics (ssgEntity *obj)
float getKartLength () const
float getKartHeight () const
float getWheelieAngle () const
btRaycastVehiclegetVehicle () const
btUprightConstraintgetUprightConstraint () const
void updateBulletPhysics (float dt)
void draw ()
bool isInRest () const
 Returns true if the kart is 'resting'.
float getSpeed () const
float handleWheelie (float dt)
 Returned an additional engine power boost when doing a wheele.
float getActualWheelForce ()
bool isOnGround () const
 The kart is on ground if all 4 wheels touch the ground.
bool isEliminated () const
void eliminate ()
bool isRescue () const
void resetBrakes ()
 This function is called when the race starts.
void adjustSpeedWeight (float f)
 Modifies the physics parameter to simulate an attached anvil.
void forceRescue (bool is_rescue=false)
void handleExplosion (const btVector3 &pos, bool direct_hit)
const std::string & getName () const
virtual void doLapCounting ()
virtual void update (const btVector3 &pos)
float getHoT () const
const MaterialgetMaterial () const
const btVector3getNormal () const
float getTerrainPitch (float heading) const
 Returns the pitch of the terrain depending on the heading.
ssgTransform * getModelTransform ()
virtual const btVector3getVelocity () const
const btVector3getVelocityLC () const
virtual void setVelocity (const btVector3 &v)
sgCoord * getCoord ()
const sgCoord * getCoord () const
const btVector3 getPos () const
const sgVec4 * getNormalHOT () const
void setCoord (sgCoord *pos)
void WriteHistory (char *s, int kartNumber, int indx)
void ReadHistory (char *s, int kartNumber, int indx)
btRigidBodygetBody () const
void createBody (float mass, btTransform &trans, btCollisionShape *shape)
const btTransformgetTrans () const
void setTrans (btTransform &t)

Protected Member Functions

void load_wheels (ssgBranch *obj)
 Search the given branch of objects that match the wheel names and if so assign them to wheel_* variables.

Protected Attributes

bool m_on_road
Attachment m_attachment
Collectable m_collectable
int m_grid_position
int m_race_position
int m_initial_position
KartControl m_controls
int m_track_sector
sgVec2 m_last_track_coords
sgVec3 m_curr_track_coords
float m_max_speed
float m_max_speed_reverse_ratio
float m_wheelie_angle
float m_zipper_time_left
float m_lap_start_time
char m_fastest_lap_message [255]
int m_shortcut_sector
btRaycastVehicle::btVehicleTuningm_tuning
btCompoundShape m_kart_chassis
btVehicleRaycasterm_vehicle_raycaster
btRaycastVehiclem_vehicle
btUprightConstraintm_uprightConstraint
float m_rescue_pitch
float m_rescue_roll
const KartPropertiesm_kart_properties
UserPointer m_user_pointer
sgCoord m_reset_pos
sgCoord m_curr_pos
sgVec4 * m_normal_hot
Materialm_material_hot
ssgTransform * m_model_transform
ssgTransform * m_shadow
int m_collided
int m_crashed
sgVec3 m_surface_avoidance_vector
int m_first_time
sgCoord * m_history_velocity
sgCoord * m_history_position
btRigidBodym_body
btDefaultMotionStatem_motion_state
btTransform m_transform

Private Member Functions

void steer (float, int)

Private Attributes

int m_steer_val
int m_steer_val_l
int m_steer_val_r
int m_accel_val
Playerm_player
float m_penalty_time
float m_time_last_crash_sound
Cameram_camera

Detailed Description

PlayerKart manages control events from the player and moves them to the Kart.

Definition at line 33 of file player_kart.hpp.


Constructor & Destructor Documentation

PlayerKart::PlayerKart ( const std::string &  kart_name,
int  position,
Player _player,
sgCoord  init_pos,
int  player_index 
)

Definition at line 34 of file player_kart.cpp.

                                                           :
            Kart(kart_name, position, init_pos)
{
    m_player       = player;
    m_penalty_time = 0.0f;
    m_camera       = scene->createCamera(player_index, this);
    m_camera->setMode(Camera::CM_NORMAL);
    reset();
}   // PlayerKart

Here is the call graph for this function:


Member Function Documentation

void PlayerKart::action ( KartAction  action,
int  value 
)

Definition at line 64 of file player_kart.cpp.

{
    switch (action)
    {
    case KA_LEFT:
        m_steer_val_l = -value;
        if (value)
          m_steer_val = -value;
        else
          m_steer_val = m_steer_val_r;

        break;
    case KA_RIGHT:
        m_steer_val_r = value;
        if (value)
          m_steer_val = value;
        else
          m_steer_val = m_steer_val_l;

        break;
    case KA_ACCEL:
        m_accel_val = value;
        break;
    case KA_BRAKE:
        if (value)
            m_accel_val = 0;
        m_controls.brake = (value!=0);  // This syntax avoid visual c++ warning (when brake=value)
        break;
    case KA_WHEELIE:
        m_controls.wheelie = (value!=0);
        break;
    case KA_RESCUE:
        m_controls.rescue = (value!=0);
        break;
    case KA_FIRE:
        m_controls.fire = (value!=0);
        break;
    case KA_LOOK_BACK:
        m_camera->setMode(value!=0 ? Camera::CM_REVERSE : Camera::CM_NORMAL);
        break;
    case KA_JUMP:
        m_controls.jump = (value!=0);
        break;
    }
}   // action

Here is the call graph for this function:

Here is the caller graph for this function:

void PlayerKart::addMessages ( ) [virtual]

This function is called by world to add any messages to the race gui.

This can't be done (in some cases) in the update() function, since update can be called several times per frame, resulting in messages being displayed more than once.

Reimplemented from Kart.

Definition at line 243 of file player_kart.cpp.

{
    RaceGUI* m=menu_manager->getRaceMenu();
    // This can happen if the option menu is called, since the
    // racegui gets deleted
    if(!m) return;

    // 1) check if the player is going in the wrong direction
    // ------------------------------------------------------
    if(race_manager->getDifficulty()==RaceManager::RD_EASY)
    {
        float angle_diff = getCoord()->hpr[0] - world->m_track->m_angle[getSector()];
        if(angle_diff > 180.0f) angle_diff -= 360.0f;
        else if (angle_diff < -180.0f) angle_diff += 360.0f;
        // Display a warning message if the kart is going back way (unless
        // the kart has already finished the race).
        if ((angle_diff > 120.0f || angle_diff < -120.0f)   &&
            getVelocity().getY() > 0.0f  && !raceIsFinished() )
        {
            m->addMessage(_("WRONG WAY!"), this, -1.0f, 60);
        }  // if angle is too big
    }  // if difficulty easy

}   // addMessages

Here is the call graph for this function:

void Kart::adjustSpeedWeight ( float  f) [inherited]

Modifies the physics parameter to simulate an attached anvil.

The velocity is multiplicated by f, and the mass of the kart is increased.

Definition at line 272 of file kart.cpp.

{
    m_body->setLinearVelocity(m_body->getLinearVelocity()*f);
    // getMass returns the mass increased by the attachment
    btVector3 inertia;
    float m=getMass();
    m_kart_chassis.calculateLocalInertia(m, inertia);
    m_body->setMassProps(m, inertia);
}   // adjustSpeedWeight

Here is the call graph for this function:

Here is the caller graph for this function:

void Kart::attach ( attachmentType  attachment_,
float  time 
) [inline, inherited]

Definition at line 126 of file kart.hpp.

                                          { m_attachment.set(attachment_, time); }

Here is the call graph for this function:

Here is the caller graph for this function:

void PlayerKart::collectedHerring ( Herring herring) [virtual]

Reimplemented from Kart.

Definition at line 231 of file player_kart.cpp.

{
    Kart::collectedHerring(herring);
    sound_manager->playSfx ( ( herring->getType()==HE_GREEN ) ? SOUND_UGH:SOUND_GRAB);
}   // collectedHerring

Here is the call graph for this function:

void PlayerKart::crashed ( ) [virtual]

Reimplemented from Kart.

Definition at line 196 of file player_kart.cpp.

{
    Kart::crashed();
    // A collision is usually reported several times, even when hitting
    // something only once. This results in a kind of 'machine gun'
    // noise by playing the crash sound over and over again. To prevent
    // this, the crash sound is only played if there was at least 0.5
    // seconds since the last time it was played (for this kart)
    if(world->getTime() - m_time_last_crash_sound > 0.5f) 
    {
        sound_manager->playSfx( SOUND_CRASH );
        m_time_last_crash_sound = world->getTime();
    }
}   // crashed

Here is the call graph for this function:

void Moveable::createBody ( float  mass,
btTransform trans,
btCollisionShape shape 
) [inherited]

Definition at line 80 of file moveable.cpp.

                                                   {
    
    btVector3 inertia;
    shape->calculateLocalInertia(mass, inertia);
    m_motion_state = new btDefaultMotionState(trans);

    btRigidBody::btRigidBodyConstructionInfo info(mass, m_motion_state, shape, inertia);
    info.m_restitution=0.5f;

    // Then create a rigid body
    // ------------------------
    m_body = new btRigidBody(info);
    // The value of user_pointer must be set from the actual class, otherwise this
    // is only a pointer to moveable, not to (say) kart, and virtual 
    // functions are not called correctly. So only init the pointer to zero.
    m_user_pointer.zero();
    m_body->setUserPointer(&m_user_pointer);
}   // createBody

Here is the call graph for this function:

Here is the caller graph for this function:

void Kart::createPhysics ( ssgEntity *  obj) [inherited]

Definition at line 101 of file kart.cpp.

{
    // First: Create the chassis of the kart
    // -------------------------------------

    float kart_width  = m_kart_properties->getKartWidth();
    float kart_length = m_kart_properties->getKartLength();
    float kart_height = m_kart_properties->getKartHeight();

    btBoxShape *shape = new btBoxShape(btVector3(0.5f*kart_width,
                                                 0.5f*kart_length,
                                                 0.5f*kart_height));
    btTransform shiftCenterOfGravity;
    shiftCenterOfGravity.setIdentity();
    // Shift center of gravity downwards, so that the kart 
    // won't topple over too easy. This must be between 0 and 0.5
    // (it's in units of kart_height)
    const float CENTER_SHIFT = getGravityCenterShift();
    shiftCenterOfGravity.setOrigin(btVector3(0.0f,0.0f,CENTER_SHIFT*kart_height));

    m_kart_chassis.addChildShape(shiftCenterOfGravity, shape);

    // Set mass and inertia
    // --------------------
    float mass=getMass();

    // Position the chassis
    // --------------------
    btTransform trans;
    trans.setIdentity();
    createBody(mass, trans, &m_kart_chassis);
    m_user_pointer.set(this);
    m_body->setDamping(m_kart_properties->getChassisLinearDamping(), 
                       m_kart_properties->getChassisAngularDamping() );

    // Reset velocities
    // ----------------
    m_body->setLinearVelocity (btVector3(0.0f,0.0f,0.0f));
    m_body->setAngularVelocity(btVector3(0.0f,0.0f,0.0f));

    // Create the actual vehicle
    // -------------------------
    m_vehicle_raycaster = 
        new btDefaultVehicleRaycaster(world->getPhysics()->getPhysicsWorld());
    m_tuning  = new btRaycastVehicle::btVehicleTuning();
    m_vehicle = new btRaycastVehicle(*m_tuning, m_body, m_vehicle_raycaster);

    // never deactivate the vehicle
    m_body->setActivationState(DISABLE_DEACTIVATION);
    m_vehicle->setCoordinateSystem(/*right: */ 0,  /*up: */ 2,  /*forward: */ 1);
    
    // Add wheels
    // ----------
    float wheel_width  = m_kart_properties->getWheelWidth();
    float wheel_radius = m_kart_properties->getWheelRadius();
    float suspension_rest = m_kart_properties->getSuspensionRest();
    float connection_height = -(0.5f-CENTER_SHIFT)*kart_height;
    btVector3 wheel_direction(0.0f, 0.0f, -1.0f);
    btVector3 wheel_axle(1.0f,0.0f,0.0f);

    // right front wheel
    btVector3 wheel_coord(0.5f*kart_width-0.3f*wheel_width,
                          0.5f*kart_length-wheel_radius,
                          connection_height);
    m_vehicle->addWheel(wheel_coord, wheel_direction, wheel_axle,
                        suspension_rest, wheel_radius, *m_tuning,
                        /* isFrontWheel: */ true);

    // left front wheel
    wheel_coord = btVector3(-0.5f*kart_width+0.3f*wheel_width,
                            0.5f*kart_length-wheel_radius,
                            connection_height);
    m_vehicle->addWheel(wheel_coord, wheel_direction, wheel_axle,
                        suspension_rest, wheel_radius, *m_tuning,
                        /* isFrontWheel: */ true);

    // right rear wheel
    wheel_coord = btVector3(0.5f*kart_width-0.3f*wheel_width, 
                            -0.5f*kart_length+wheel_radius,
                            connection_height);
    m_vehicle->addWheel(wheel_coord, wheel_direction, wheel_axle,
                        suspension_rest, wheel_radius, *m_tuning,
                        /* isFrontWheel: */ false);

    // right rear wheel
    wheel_coord = btVector3(-0.5f*kart_width+0.3f*wheel_width,
                            -0.5f*kart_length+wheel_radius,
                            connection_height);
    m_vehicle->addWheel(wheel_coord, wheel_direction, wheel_axle,
                        suspension_rest, wheel_radius, *m_tuning,
                        /* isFrontWheel: */ false);

    for(int i=0; i<m_vehicle->getNumWheels(); i++)
    {
        btWheelInfo& wheel               = m_vehicle->getWheelInfo(i);
        wheel.m_suspensionStiffness      = m_kart_properties->getSuspensionStiffness();
        wheel.m_wheelsDampingRelaxation  = m_kart_properties->getWheelDampingRelaxation();
        wheel.m_wheelsDampingCompression = m_kart_properties->getWheelDampingCompression();
        wheel.m_frictionSlip             = m_kart_properties->getFrictionSlip();
        wheel.m_rollInfluence            = m_kart_properties->getRollInfluence();
    }
    // Obviously these allocs have to be properly managed/freed
    btTransform t;
    t.setIdentity();
    m_uprightConstraint=new btUprightConstraint(*m_body, t);
    m_uprightConstraint->setLimit(m_kart_properties->getUprightTolerance());
    m_uprightConstraint->setBounce(0.0f);
    m_uprightConstraint->setMaxLimitForce(m_kart_properties->getUprightMaxForce());
    m_uprightConstraint->setErp(1.0f);
    m_uprightConstraint->setLimitSoftness(1.0f);
    m_uprightConstraint->setDamping(0.0f);
    world->getPhysics()->addKart(this, m_vehicle);
}   // createPhysics

Here is the call graph for this function:

Here is the caller graph for this function:

void Kart::doLapCounting ( ) [virtual, inherited]

Reimplemented in TrafficDriver.

Definition at line 366 of file kart.cpp.

{
    bool newLap = m_last_track_coords[1] > 300.0f && m_curr_track_coords[1] <  20.0f;
    if ( newLap )
    {
        // Only increase the lap counter and set the new time if the
        // kart hasn't already finished the race (otherwise the race_gui
        // will begin another countdown).
        if(m_race_lap+1<=race_manager->getNumLaps())
        {
            setTimeAtLap(world->getTime());
            m_race_lap++ ;
        }
        // Only do timings if original time was set properly. Driving backwards
        // over the start line will cause the lap start time to be set to -1.
        if(m_lap_start_time>=0.0)
        {
            float time_per_lap;
            if (m_race_lap == 1) // just completed first lap
            {
              time_per_lap=world->getTime();
            }
            else //completing subsequent laps
            {
              time_per_lap=world->getTime()-m_lap_start_time;
            }
                        
            if(time_per_lap < world->getFastestLapTime() &&
                race_manager->raceHasLaps())
            {
                world->setFastestLap(this, time_per_lap);
                RaceGUI* m=(RaceGUI*)menu_manager->getRaceMenu();
                if(m)
                {
                    m->addMessage(_("New fastest lap"), NULL, 
                                  2.0f, 40, 100, 210, 100);
                    char s[20];
                    m->TimeToString(time_per_lap, s);
                    snprintf(m_fastest_lap_message, sizeof(m_fastest_lap_message),
                             "%s: %s",s, getName().c_str());
                    m->addMessage(m_fastest_lap_message, NULL, 
                                  2.0f, 40, 100, 210, 100);
                }   // if m
            }   // if time_per_lap < world->getFasterstLapTime()
            if(isPlayerKart())
            {
                // Put in in the highscore list???
                //printf("Time per lap: %s %f\n", getName().c_str(), time_per_lap);
            }
        }
        m_lap_start_time = world->getTime();
    }
    else if ( m_curr_track_coords[1] > 300.0f && m_last_track_coords[1] <  20.0f)
    {
        m_race_lap-- ;
        // Prevent cheating by setting time to a negative number, indicating
        // that the line wasn't crossed properly.
        m_lap_start_time = -1.0f;
    } else
    {   // Switch to fast music in case of follow the leader when only 3 karts are left
        if(race_manager->getRaceMode()==RaceManager::RM_FOLLOW_LEADER &&
            world->getCurrentNumKarts()==3)  
        {
            sound_manager->switchToFastMusic();
        }
    }
}   // doLapCounting

Here is the call graph for this function:

Here is the caller graph for this function:

void Kart::draw ( ) [inherited]

Definition at line 681 of file kart.cpp.

{
    float m[16];
    btTransform t=getTrans();
    t.getOpenGLMatrix(m);

    btVector3 wire_color(0.5f, 0.5f, 0.5f);
    world->getPhysics()->debugDraw(m, m_body->getCollisionShape(), 
                                   wire_color);
    btCylinderShapeX wheelShape( btVector3(0.3f,
                                        m_kart_properties->getWheelRadius(),
                                        m_kart_properties->getWheelRadius()));
    btVector3 wheelColor(1,0,0);
    for(int i=0; i<m_vehicle->getNumWheels(); i++)
    {
        m_vehicle->updateWheelTransform(i, true);
        float m[16];
        m_vehicle->getWheelInfo(i).m_worldTransform.getOpenGLMatrix(m);
        world->getPhysics()->debugDraw(m, &wheelShape, wheelColor);
    }
}   // draw

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 49 of file player_kart.hpp.

{return m_penalty_time>0; }

Here is the caller graph for this function:

void Kart::eliminate ( ) [inherited]

Definition at line 248 of file kart.cpp.

{
    m_eliminated = true;
    world->getPhysics()->removeKart(this);

    // make the kart invisible by placing it way under the track
    sgVec3 hell; hell[0]=0.0f; hell[1]=0.0f; hell[2] = -10000.0f;
    getModelTransform()->setTransform(hell);
}   // eliminate

Here is the call graph for this function:

Here is the caller graph for this function:

void Kart::endRescue ( ) [inherited]

Drops a kart which was rescued back on the track.

Definition at line 867 of file kart.cpp.

{
    if ( m_track_sector > 0 ) m_track_sector-- ;
    world ->m_track -> trackToSpatial ( m_curr_pos.xyz, m_track_sector ) ;
    m_curr_pos.hpr[0] = world->m_track->m_angle[m_track_sector] ;
    m_rescue = false ;

    m_body->setLinearVelocity (btVector3(0.0f,0.0f,0.0f));
    m_body->setAngularVelocity(btVector3(0.0f,0.0f,0.0f));
    // FIXME: This code positions the kart correctly back on the track
    // (nearest waypoint) - but if the kart is simply upside down,
    // it feels better if the kart is left where it was. Perhaps
    // this code should only be used if a rescue was not triggered
    // by the kart being upside down??
    btTransform pos;
    // A certain epsilon is added here to the Z coordinate (0.1), in case
    // that the drivelines are somewhat under the track. Otherwise, the
    // kart will be placed a little bit under the track, triggering
    // a rescue, ...
    pos.setOrigin(btVector3(m_curr_pos.xyz[0],m_curr_pos.xyz[1],
                            m_curr_pos.xyz[2]+0.5f*getKartHeight()+0.1f));
    pos.setRotation(btQuaternion(btVector3(0.0f, 0.0f, 1.0f), 
                                 DEGREE_TO_RAD(world->m_track->m_angle[m_track_sector])));
    m_body->setCenterOfMassTransform(pos);
    world->getPhysics()->addKart(this, m_vehicle);
    setTrans(pos);
}   // endRescue

Here is the call graph for this function:

Here is the caller graph for this function:

float Kart::estimateFinishTime ( ) [inherited]

Definition at line 1077 of file kart.cpp.

{
    // Estimate the arrival time of any karts that haven't arrived
    // yet by using their average speed up to now and the distance
    // still to race. This approach guarantees that the order of 
    // the karts won't change anymore (karts ahead will have a 
    // higher average speed and therefore finish the race earlier 
    // than karts further behind), so the position doesn't have to
    // be updated to get the correct scoring.
    float distance_covered  = getLap()*world->m_track->getTrackLength()
                            + getDistanceDownTrack();
    // In case that a kart is rescued behind start line, or ...
    if(distance_covered<0) distance_covered =1.0f;

    float average_speed     = distance_covered/world->getTime();

    // Finish time is the time needed for the whole race with 
    // the average speed computed above.
    return race_manager->getNumLaps()*world->getTrack()->getTrackLength() 
          / average_speed;

}   // estimateFinishTime

Here is the call graph for this function:

void Kart::forceRescue ( bool  is_rescue = false) [inherited]

Definition at line 853 of file kart.cpp.

{
    m_rescue=true;
    // If rescue is triggered while doing a shortcut, reset the kart to the
    // segment where the shortcut started!! And then reset the shortcut
    // flag, so that this shortcut is not counted!
    if(is_shortcut)
    {
        m_track_sector   = m_shortcut_sector;
    } 
}   // forceRescue

Here is the caller graph for this function:

float Kart::getActualWheelForce ( ) [inherited]

Definition at line 459 of file kart.cpp.

{
    float zipperF=(m_zipper_time_left>0.0f) ? stk_config->m_zipper_force : 0.0f;
    const std::vector<float>& gear_ratio=m_kart_properties->getGearSwitchRatio();
    for(unsigned int i=0; i<gear_ratio.size(); i++)
    {
        if(m_speed <= m_max_speed*gear_ratio[i]) 
            return getMaxPower()*m_kart_properties->getGearPowerIncrease()[i]+zipperF;
    }
    return getMaxPower()+zipperF;

}   // getActualWheelForce

Here is the call graph for this function:

Here is the caller graph for this function:

Attachment* Kart::getAttachment ( ) [inline, inherited]

Definition at line 135 of file kart.hpp.

{ return &m_attachment;          }

Here is the caller graph for this function:

btRigidBody* Moveable::getBody ( ) const [inline, inherited]

Definition at line 77 of file moveable.hpp.

{return m_body; }

Here is the caller graph for this function:

float Kart::getBrakeFactor ( ) const [inline, inherited]

Definition at line 165 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 60 of file player_kart.hpp.

{return m_camera;}
void Kart::getClosestKart ( float *  cdist,
int *  closest 
) [inherited]
Collectable* Kart::getCollectable ( ) [inline, inherited]

Definition at line 139 of file kart.hpp.

{ return &m_collectable;         }

Here is the caller graph for this function:

const sgVec3* Kart::getColor ( ) const [inline, inherited]

Definition at line 157 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

sgCoord* Moveable::getCoord ( ) [inline, inherited]

Definition at line 66 of file moveable.hpp.

{return &m_curr_pos;                }

Here is the caller graph for this function:

const sgCoord* Moveable::getCoord ( ) const [inline, inherited]

Definition at line 68 of file moveable.hpp.

{return &m_curr_pos;                }
float Kart::getDistanceDownTrack ( ) const [inline, inherited]

Definition at line 133 of file kart.hpp.

{ return m_curr_track_coords[1]; }

Here is the caller graph for this function:

float Kart::getDistanceToCenter ( ) const [inline, inherited]

Definition at line 134 of file kart.hpp.

{ return m_curr_track_coords[0]; }

Here is the caller graph for this function:

float Kart::getFinishTime ( ) const [inline, inherited]

Definition at line 146 of file kart.hpp.

{ return m_finish_time;         }

Here is the caller graph for this function:

float Kart::getFrictionSlip ( ) const [inline, inherited]

Definition at line 168 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

float Kart::getGravityCenterShift ( ) const [inline, inherited]

Definition at line 170 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

float Kart::getHeightCOG ( ) const [inline, inherited]

Definition at line 167 of file kart.hpp.

Here is the call graph for this function:

float TerrainInfo::getHoT ( ) const [inline, inherited]

Definition at line 44 of file terrain_info.hpp.

{ return m_HoT;      }

Here is the caller graph for this function:

int Kart::getInitialPosition ( ) const [inline, inherited]

Definition at line 144 of file kart.hpp.

{ return  m_initial_position;    }

Here is the caller graph for this function:

float Kart::getKartHeight ( ) const [inline, inherited]

Definition at line 190 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

float Kart::getKartLength ( ) const [inline, inherited]

Definition at line 189 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

const KartProperties* Kart::getKartProperties ( ) const [inline, inherited]

Definition at line 123 of file kart.hpp.

{ return m_kart_properties; }

Here is the caller graph for this function:

int Kart::getLap ( ) const [inline, inherited]

Definition at line 142 of file kart.hpp.

{ return  m_race_lap;            }

Here is the caller graph for this function:

float Kart::getMass ( ) const [inline, inherited]

Definition at line 158 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

const Material* TerrainInfo::getMaterial ( ) const [inline, inherited]

Definition at line 45 of file terrain_info.hpp.

{ return m_material; }

Here is the caller graph for this function:

float Kart::getMaxPower ( ) const [inline, inherited]

Definition at line 163 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

float Kart::getMaxSpeed ( ) const [inline, inherited]

Definition at line 185 of file kart.hpp.

{return m_max_speed;              }

Here is the caller graph for this function:

float Kart::getMaxSteerAngle ( ) const [inline, inherited]

Definition at line 169 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

ssgTransform* Moveable::getModelTransform ( ) [inline, inherited]

Definition at line 62 of file moveable.hpp.

{return m_model_transform;          }

Here is the caller graph for this function:

const std::string& Kart::getName ( ) const [inline, inherited]

Definition at line 209 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

const btVector3& TerrainInfo::getNormal ( ) const [inline, inherited]

Definition at line 46 of file terrain_info.hpp.

{ return m_normal;   }
const sgVec4* Moveable::getNormalHOT ( ) const [inline, inherited]

Definition at line 69 of file moveable.hpp.

{return m_normal_hot;               }
int Kart::getNumCollectables ( ) const [inline, inherited]

Definition at line 140 of file kart.hpp.

{ return  m_collectable.getNum();}

Here is the call graph for this function:

Here is the caller graph for this function:

int Kart::getNumHerring ( ) const [inline, inherited]

Definition at line 141 of file kart.hpp.

Here is the caller graph for this function:

Definition at line 50 of file player_kart.hpp.

{return m_player;        }

Here is the caller graph for this function:

const btVector3 Moveable::getPos ( ) const [inline, inherited]

Definition at line 67 of file moveable.hpp.

{return m_transform.getOrigin();    }

Here is the call graph for this function:

Here is the caller graph for this function:

int Kart::getPosition ( ) const [inline, inherited]

Definition at line 143 of file kart.hpp.

{ return  m_race_position;       }

Here is the caller graph for this function:

int Kart::getSector ( ) const [inline, inherited]

Definition at line 132 of file kart.hpp.

{ return m_track_sector;         }

Here is the caller graph for this function:

float Kart::getSpeed ( ) const [inline, inherited]

Definition at line 198 of file kart.hpp.

{return m_speed;                 }

Here is the caller graph for this function:

float Kart::getSteerAngle ( ) const [inline, inherited]

Definition at line 182 of file kart.hpp.

Here is the call graph for this function:

float Kart::getSteerPercent ( ) const [inline, inherited]

Definition at line 184 of file kart.hpp.

{return m_controls.lr;            }

Here is the caller graph for this function:

float TerrainInfo::getTerrainPitch ( float  heading) const [inherited]

Returns the pitch of the terrain depending on the heading.

Definition at line 49 of file terrain_info.cpp.

                                                      {
    if(m_HoT==Track::NOHIT) return 0.0f;

    const float X =-sin(heading);
    const float Y = cos(heading);
    // Compute the angle between the normal of the plane and the line to
    // (x,y,0).  (x,y,0) is normalised, so are the coordinates of the plane,
    // simplifying the computation of the scalar product.
    float pitch = ( m_normal.getX()*X + m_normal.getY()*Y );  // use ( x,y,0)
        
    // The actual angle computed above is between the normal and the (x,y,0)
    // line, so to compute the actual angles 90 degrees must be subtracted.
    pitch = acosf(pitch) - NINETY_DEGREE_RAD;
    return pitch;
}   // getTerrainPitch

Here is the call graph for this function:

Here is the caller graph for this function:

float Kart::getTimeAtLap ( ) const [inline, inherited]

Definition at line 187 of file kart.hpp.

{return m_time_at_last_lap;       }

Here is the caller graph for this function:

float Kart::getTimeFullSteer ( ) const [inline, inherited]

Definition at line 164 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

const btTransform& Moveable::getTrans ( ) const [inline, inherited]

Definition at line 80 of file moveable.hpp.

{return m_transform;}

Here is the caller graph for this function:

btUprightConstraint* Kart::getUprightConstraint ( ) const [inline, inherited]

Definition at line 193 of file kart.hpp.

Here is the caller graph for this function:

btRaycastVehicle* Kart::getVehicle ( ) const [inline, inherited]

Definition at line 192 of file kart.hpp.

{return m_vehicle;                }

Here is the caller graph for this function:

virtual const btVector3& Moveable::getVelocity ( ) const [inline, virtual, inherited]

Reimplemented in Homing.

Definition at line 63 of file moveable.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

const btVector3& Moveable::getVelocityLC ( ) const [inline, inherited]

Definition at line 64 of file moveable.hpp.

{return m_velocityLC;               }

Here is the caller graph for this function:

float Kart::getWheelBase ( ) const [inline, inherited]

Definition at line 166 of file kart.hpp.

Here is the call graph for this function:

float Kart::getWheelieAngle ( ) const [inline, inherited]

Definition at line 191 of file kart.hpp.

{return m_wheelie_angle;          }
float Kart::getWheelieMaxPitch ( ) const [inline, inherited]

Definition at line 174 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

float Kart::getWheelieMaxSpeedRatio ( ) const [inline, inherited]

Definition at line 172 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

float Kart::getWheeliePitchRate ( ) const [inline, inherited]

Definition at line 176 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

float Kart::getWheelieRestoreRate ( ) const [inline, inherited]

Definition at line 178 of file kart.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

float Kart::getWheelieSpeedBoost ( ) const [inline, inherited]

Definition at line 180 of file kart.hpp.

Here is the call graph for this function:

void Kart::handleExplosion ( const btVector3 pos,
bool  direct_hit 
) [inherited]

Definition at line 483 of file kart.cpp.

{
    if(direct_hit) 
    {
        btVector3 diff((float)(rand()%16/16), (float)(rand()%16/16), 2.0f);
        diff.normalize();
        diff*=stk_config->m_explosion_impulse/5.0f;
        this->m_uprightConstraint->setDisableTime(10.0f);
        getVehicle()->getRigidBody()->applyCentralImpulse(diff);
        getVehicle()->getRigidBody()->applyTorqueImpulse(btVector3(float(rand()%32*5),
                                                                   float(rand()%32*5),
                                                                   float(rand()%32*5)));
    }
    else  // only affected by a distant explosion
    {
        btVector3 diff=getPos()-pos;
        //if the z component is negative, the resulting impulse could push the 
        // kart through the floor. So in this case ignore z.
        if(diff.getZ()<0) diff.setZ(0.0f);
        float len2=diff.length2();

        // The correct formhale would be to first normalise diff,
        // then apply the impulse (which decreases 1/r^2 depending
        // on the distance r), so:
        // diff/len(diff) * impulseSize/len(diff)^2
        // = diff*impulseSize/len(diff)^3
        // We use diff*impulseSize/len(diff)^2 here, this makes the impulse
        // somewhat larger, which is actually more fun :)
        diff *= stk_config->m_explosion_impulse/len2;
        getVehicle()->getRigidBody()->applyCentralImpulse(diff);
    }
}   // handleExplosion

Here is the call graph for this function:

Here is the caller graph for this function:

float Kart::handleWheelie ( float  dt) [inherited]

Returned an additional engine power boost when doing a wheele.

Definition at line 707 of file kart.cpp.

{
    // Handle wheelies
    // ===============
    if ( m_controls.wheelie && 
         m_speed >= getMaxSpeed()*getWheelieMaxSpeedRatio())
    {
        // Disable the upright constraint, since it will otherwise
        // work against the wheelie
        m_uprightConstraint->setLimit(M_PI);

        if ( m_wheelie_angle < getWheelieMaxPitch() )
            m_wheelie_angle += getWheeliePitchRate() * dt;
        else
            m_wheelie_angle = getWheelieMaxPitch();
    }
    else if ( m_wheelie_angle > 0.0f )
    {
        m_wheelie_angle -= getWheelieRestoreRate() * dt;
        if ( m_wheelie_angle <= 0.0f ) m_wheelie_angle = 0.0f ;
    }
    if(m_wheelie_angle <=0.0f) 
    {
        m_uprightConstraint->setLimit(m_kart_properties->getUprightTolerance());
        return 0.0f;
    }

    const btTransform& chassisTrans = getTrans();
    btVector3 targetUp(0.0f, 0.0f, 1.0f);
    btVector3 forwardW (chassisTrans.getBasis()[0][1],
                        chassisTrans.getBasis()[1][1],
                        chassisTrans.getBasis()[2][1]);
    btVector3 crossProd = targetUp.cross(forwardW);
    crossProd.normalize();

    return m_kart_properties->getWheeliePowerBoost() * getMaxPower()
          * m_wheelie_angle/getWheelieMaxPitch();
}   // handleWheelie

Here is the call graph for this function:

Here is the caller graph for this function:

void PlayerKart::handleZipper ( ) [virtual]

Reimplemented from Kart.

Definition at line 224 of file player_kart.cpp.

{
    Kart::handleZipper();
    sound_manager->playSfx ( SOUND_WEE );
}   // handleZipper

Here is the call graph for this function:

bool Kart::isEliminated ( ) const [inline, inherited]

Definition at line 202 of file kart.hpp.

{return m_eliminated;}

Here is the caller graph for this function:

bool Kart::isInRest ( ) const [inherited]

Returns true if the kart is 'resting'.

Returns true if the kart is 'resting', i.e. (nearly) not moving.

Definition at line 263 of file kart.cpp.

{
    return fabs(m_body->getLinearVelocity ().z())<0.2;
}  // isInRest

Here is the call graph for this function:

bool Kart::isOnGround ( ) const [inherited]

The kart is on ground if all 4 wheels touch the ground.

Definition at line 475 of file kart.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

int PlayerKart::isPlayerKart ( ) const [inline, virtual]

Reimplemented from Kart.

Definition at line 59 of file player_kart.hpp.

{return 1;}
bool Kart::isRescue ( ) const [inline, inherited]

Definition at line 204 of file kart.hpp.

{return m_rescue;}

Here is the caller graph for this function:

void Kart::load_wheels ( ssgBranch *  obj) [protected, inherited]

Search the given branch of objects that match the wheel names and if so assign them to wheel_* variables.

Definition at line 934 of file kart.cpp.

{
    if (!branch) return;

    for(ssgEntity* i = branch->getKid(0); i != NULL; i = branch->getNextKid())
    {
        if (i->getName())
        { // We found something that might be a wheel
            if (strcmp(i->getName(), "WheelFront.L") == 0)
            {
                m_wheel_front_l = add_transform(dynamic_cast<ssgTransform*>(i));
            }
            else if (strcmp(i->getName(), "WheelFront.R") == 0)
            {
                m_wheel_front_r = add_transform(dynamic_cast<ssgTransform*>(i));
            }
            else if (strcmp(i->getName(), "WheelRear.L") == 0)
            {
                m_wheel_rear_l = add_transform(dynamic_cast<ssgTransform*>(i));
            }
            else if (strcmp(i->getName(), "WheelRear.R") == 0)
            {
                m_wheel_rear_r = add_transform(dynamic_cast<ssgTransform*>(i));
            }
            else
            {
                // Wasn't a wheel, continue searching
                load_wheels(dynamic_cast<ssgBranch*>(i));
            }
        }
        else
        { // Can't be a wheel,continue searching
            load_wheels(dynamic_cast<ssgBranch*>(i));
        }
    }   // for i
}   // load_wheels

Here is the call graph for this function:

Here is the caller graph for this function:

void Kart::loadData ( ) [inherited]

Definition at line 972 of file kart.cpp.

{
    float r [ 2 ] = { -10.0f, 100.0f } ;

    m_smokepuff = new ssgSimpleState ();
    m_smokepuff->setTexture(material_manager->getMaterial("smoke.rgb")->getState()->getTexture());
    m_smokepuff -> setTranslucent    () ;
    m_smokepuff -> enable            ( GL_TEXTURE_2D ) ;
    m_smokepuff -> setShadeModel     ( GL_SMOOTH ) ;
    m_smokepuff -> enable            ( GL_CULL_FACE ) ;
    m_smokepuff -> enable            ( GL_BLEND ) ;
    m_smokepuff -> enable            ( GL_LIGHTING ) ;
    m_smokepuff -> setColourMaterial ( GL_EMISSION ) ;
    m_smokepuff -> setMaterial       ( GL_AMBIENT, 0, 0, 0, 1 ) ;
    m_smokepuff -> setMaterial       ( GL_DIFFUSE, 0, 0, 0, 1 ) ;
    m_smokepuff -> setMaterial       ( GL_SPECULAR, 0, 0, 0, 1 ) ;
    m_smokepuff -> setShininess      (  0 ) ;

    ssgEntity *obj = m_kart_properties->getModel();
    createPhysics(obj);

    load_wheels(dynamic_cast<ssgBranch*>(obj));

    // Optimize the model, this can't be done while loading the model
    // because it seems that it removes the name of the wheels or something
    // else needed to load the wheels as a separate object.
    ssgFlatten(obj);

    createDisplayLists(obj);  // create all display lists
    ssgRangeSelector *lod = new ssgRangeSelector ;

    lod -> addKid ( obj ) ;
    lod -> setRanges ( r, 2 ) ;

    this-> getModelTransform() -> addKid ( lod ) ;

    // Attach Particle System
    //JH  sgCoord pipe_pos = {{0, 0, .3}, {0, 0, 0}} ;
    m_smoke_system = new Smoke(this, 50, 100.0f, true, 0.35f, 1000);
    m_smoke_system -> init(5);
    //JH      m_smoke_system -> setState (getMaterial ("smoke.png")-> getState() );
    //m_smoke_system -> setState ( m_smokepuff ) ;
    //      m_exhaust_pipe = new ssgTransform (&pipe_pos);
    //      m_exhaust_pipe -> addKid (m_smoke_system) ;
    //      comp_model-> addKid (m_exhaust_pipe) ;

    // 
    m_skidmark_left  = new SkidMark(/* angle sign */ -1);
    m_skidmark_right = new SkidMark(/* angle sign */  1);

    m_shadow = createShadow(m_kart_properties->getShadowFile(), -1, 1, -1, 1);
    m_shadow->ref();
    m_model_transform->addKid ( m_shadow );
}   // loadData

Here is the call graph for this function:

Here is the caller graph for this function:

void Kart::placeModel ( ) [virtual, inherited]

Reimplemented from Moveable.

Definition at line 1028 of file kart.cpp.

{
    sgMat4 wheel_front;
    sgMat4 wheel_steer;
    sgMat4 wheel_rot;

    sgMakeRotMat4( wheel_rot, 0, RAD_TO_DEGREE(-m_wheel_rotation), 0);
    sgMakeRotMat4( wheel_steer, m_controls.lr * 30.0f , 0, 0);

    sgMultMat4(wheel_front, wheel_steer, wheel_rot);

    if (m_wheel_front_l) m_wheel_front_l->setTransform(wheel_front);
    if (m_wheel_front_r) m_wheel_front_r->setTransform(wheel_front);

    if (m_wheel_rear_l) m_wheel_rear_l->setTransform(wheel_rot);
    if (m_wheel_rear_r) m_wheel_rear_r->setTransform(wheel_rot);

    // Only transfer the bullet data to the plib tree if no history is being
    // replayed.
    if(!user_config->m_replay_history)
    {
        float m[4][4];
        getTrans().getOpenGLMatrix((float*)&m);
        
        //printf(" is %f %f %f\n",t.getOrigin().x(),t.getOrigin().y(),t.getOrigin().z());
        // Transfer the new position and hpr to m_curr_pos
        sgSetCoord(&m_curr_pos, m);
    }
    sgCoord c ;
    sgCopyCoord ( &c, &m_curr_pos );
    const float CENTER_SHIFT  = getGravityCenterShift();
    const float offset_pitch  = m_wheelie_angle;
    const float offset_z      = 0.3f*fabs(sin(m_wheelie_angle*SG_DEGREES_TO_RADIANS))
                              - (0.5f-CENTER_SHIFT)*getKartHeight();
    
    m_curr_pos.xyz[2] += offset_z;
    m_curr_pos.hpr[1] += offset_pitch;
    Moveable::placeModel();
    m_curr_pos.xyz[2] -= offset_z;
    m_curr_pos.hpr[1] -= offset_pitch;
}   // placeModel

Here is the call graph for this function:

Here is the caller graph for this function:

void Kart::processSkidMarks ( ) [inherited]

Definition at line 896 of file kart.cpp.

{
    // FIXME: disable skidmarks for now, they currently look ugly, and are
    //        sometimes hovering in the air
    return;
    assert(m_skidmark_left);
    assert(m_skidmark_right);
    const float threshold = 0.3f;
    const float ANGLE     = 43.0f;
    const float LENGTH    = 0.57f;
    bool skid_front = m_vehicle->getWheelInfo(0).m_skidInfo < threshold ||
                      m_vehicle->getWheelInfo(1).m_skidInfo < threshold;
    bool skid_rear  = m_vehicle->getWheelInfo(2).m_skidInfo < threshold ||
                      m_vehicle->getWheelInfo(3).m_skidInfo < threshold;
    if(skid_rear || skid_front)
    {
        if(isOnGround())
        {
            m_skidmark_left ->add(*getCoord(),  ANGLE, LENGTH);
            m_skidmark_right->add(*getCoord(),  ANGLE, LENGTH);            
        }
        else
        {   // not on ground
            m_skidmark_left->addBreak(*getCoord(),  ANGLE, LENGTH);
            m_skidmark_right->addBreak(*getCoord(), ANGLE, LENGTH);
        }   // on ground
    }
    else
    {   // !skid_rear && !skid_front    
        if(m_skidmark_left->wasSkidMarking())
            m_skidmark_left->addBreak(*getCoord(),  ANGLE, LENGTH);

        if(m_skidmark_right->wasSkidMarking())
            m_skidmark_right->addBreak(*getCoord(), ANGLE, LENGTH);
    }
}   // processSkidMarks

Here is the call graph for this function:

Here is the caller graph for this function:

bool Kart::raceIsFinished ( ) const [inline, inherited]

Definition at line 147 of file kart.hpp.

{ return m_finished_race;       }

Here is the caller graph for this function:

void Moveable::ReadHistory ( char *  s,
int  kartNumber,
int  indx 
) [inherited]

Definition at line 193 of file moveable.cpp.

{
    int k;
    sscanf(s, "Kart %d: v=%f,%f,%f,%f,%f,%f, p=%f,%f,%f,%f,%f,%f", &k,
           m_history_velocity[indx].xyz+0,
           m_history_velocity[indx].xyz+1,
           m_history_velocity[indx].xyz+2,
           m_history_velocity[indx].hpr+0,
           m_history_velocity[indx].hpr+1,
           m_history_velocity[indx].hpr+2,
           m_history_position[indx].xyz+0,
           m_history_position[indx].xyz+1,
           m_history_position[indx].xyz+2,
           m_history_position[indx].hpr+0,
           m_history_position[indx].hpr+1,
           m_history_position[indx].hpr+2);
    if(k!=kartNumber)
    {
        fprintf(stderr,"WARNING: tried reading data for kart %d, found:\n",
                kartNumber);
        fprintf(stderr,"%s\n",s);
        exit(-2);
    }
}   // ReadHistory

Here is the caller graph for this function:

void PlayerKart::reset ( ) [virtual]

Reimplemented from Kart.

Definition at line 46 of file player_kart.cpp.

{
    m_steer_val_l = 0;
    m_steer_val_r = 0;
    m_steer_val = 0;
    m_accel_val = 0;
    m_controls.accel = 0.0;
    m_controls.brake =false;
    m_controls.fire = false;
    m_controls.wheelie = false;
    m_controls.jump = false;
    m_penalty_time = 0;
    m_time_last_crash_sound = -10.0f;
    m_camera->setMode(Camera::CM_NORMAL);   // can be changed if camera was eliminated
    Kart::reset();
}   // reset

Here is the call graph for this function:

Here is the caller graph for this function:

void Kart::resetBrakes ( ) [inherited]

This function is called when the race starts.

Up to then all brakes are braking (to avoid the kart from rolling downhill), but they need to be set to zero (otherwise the brakes will be braking whenever no engine force is set, i.e. the kart is not accelerating).

Definition at line 752 of file kart.cpp.

{
    for(int i=0; i<4; i++) m_vehicle->setBrake(0.0f, i);
}   // resetBrakes

Here is the call graph for this function:

void Kart::setAttachmentType ( attachmentType  t,
float  time_left = 0.0f,
Kart k = NULL 
) [inline, inherited]

Definition at line 136 of file kart.hpp.

                                          { m_attachment.set(t, time_left, k);   }

Here is the call graph for this function:

Here is the caller graph for this function:

void Kart::setCollectable ( CollectableType  t,
int  n 
) [inline, inherited]

Definition at line 128 of file kart.hpp.

                                          { m_collectable.set(t, n);             }

Here is the call graph for this function:

Here is the caller graph for this function:

void Moveable::setCoord ( sgCoord *  pos) [inline, inherited]

Definition at line 70 of file moveable.hpp.

{sgCopyCoord ( &m_curr_pos,pos);    }
void Kart::setFinishingState ( float  time) [inherited]

Definition at line 1070 of file kart.cpp.

{
    m_finished_race = true;
    m_finish_time   = time;
}   // setFinishingState
void Kart::setKartProperties ( const KartProperties kp) [inline, inherited]

Definition at line 124 of file kart.hpp.

void PlayerKart::setPosition ( int  p) [virtual]

Checks if the kart was overtaken, and if so plays a sound.

Reimplemented from Kart.

Definition at line 214 of file player_kart.cpp.

{
    if(getPosition()<p)
    {
        sound_manager->playSfx(SOUND_BEEP);
    }
    Kart::setPosition(p);
}   // setPosition

Here is the call graph for this function:

void Kart::setTimeAtLap ( float  t) [inline, inherited]

Definition at line 186 of file kart.hpp.

Here is the caller graph for this function:

void Moveable::setTrans ( btTransform t) [inline, inherited]

Definition at line 81 of file moveable.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void Moveable::setVelocity ( const btVector3 v) [inline, virtual, inherited]

Reimplemented in Homing.

Definition at line 65 of file moveable.hpp.

Here is the call graph for this function:

Here is the caller graph for this function:

void PlayerKart::steer ( float  dt,
int  steer_val 
) [private]

Definition at line 111 of file player_kart.cpp.

{
    const float STEER_CHANGE = dt/getTimeFullSteer();  // amount the steering is changed
    if (steer_val < 0)
    {
      // If we got analog values do not cumulate.
      if (steer_val > -32767)
        m_controls.lr = -steer_val/32767.0f;
      else
        m_controls.lr += STEER_CHANGE;
    }
    else if(steer_val > 0)
    {
      // If we got analog values do not cumulate.
      if (steer_val < 32767)
        m_controls.lr = -steer_val/32767.0f;
      else
        m_controls.lr -= STEER_CHANGE;
    }
    else
    {   // no key is pressed
        if(m_controls.lr>0.0f)
        {
            m_controls.lr -= STEER_CHANGE;
            if(m_controls.lr<0.0f) m_controls.lr=0.0f;
        }
        else
        {   // m_controls.lr<=0.0f;
            m_controls.lr += STEER_CHANGE;
            if(m_controls.lr>0.0f) m_controls.lr=0.0f;
        }   // if m_controls.lr<=0.0f
    }   // no key is pressed

    m_controls.lr = std::min(1.0f, std::max(-1.0f, m_controls.lr));

}   // steer

Here is the call graph for this function:

Here is the caller graph for this function:

void TerrainInfo::update ( const btVector3 pos) [virtual, inherited]

Definition at line 34 of file terrain_info.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

void PlayerKart::update ( float  dt) [virtual]

Reimplemented from Kart.

Definition at line 149 of file player_kart.cpp.

{
    steer(dt, m_steer_val);

    m_controls.accel = m_accel_val / 32768.0f;

    if(world->isStartPhase())
    {
        if(m_controls.accel!=0.0 || m_controls.brake!=false ||
           m_controls.fire|m_controls.wheelie|m_controls.jump)
        {
            //JH Some sound here?
            m_penalty_time=1.0;
            // A warning gets displayed in RaceGUI
        }
        placeModel();
        return;
    }
    if(m_penalty_time>0.0)
    {
        m_penalty_time-=dt;
        return;
    }

    if ( m_controls.fire && !isRescue())
    {
        if (m_collectable.getType()==COLLECT_NOTHING) sound_manager->playSfx(SOUND_BEEP);
        // use() needs to be called even if there currently is no collecteable
        // since use() can test if something needs to be switched on/off.
        m_collectable.use() ;
        m_controls.fire = false;
    }

    // We can't restrict rescue to fulfil isOnGround() (which would be more like
    // MK), since e.g. in the City track it is possible for the kart to end
    // up sitting on a brick wall, with all wheels in the air :((
    if ( m_controls.rescue )
    {
        sound_manager -> playSfx ( SOUND_BEEP ) ;
        forceRescue();
        m_controls.rescue=false;
    }

    Kart::update(dt);
}   // update

Here is the call graph for this function:

void Kart::updateBulletPhysics ( float  dt) [inherited]
void Kart::updatePhysics ( float  dt) [inherited]

Definition at line 757 of file kart.cpp.

{
    float engine_power = getActualWheelForce() + handleWheelie(dt);
    if(m_attachment.getType()==ATTACH_PARACHUTE) engine_power*=0.2f;

    if(m_controls.accel)
    {   // accelerating
        m_vehicle->applyEngineForce(engine_power, 2);
        m_vehicle->applyEngineForce(engine_power, 3);
    }
    else
    {   // not accelerating
        if(m_controls.brake)
        {   // braking or moving backwards
            if(m_speed > 0.f)
            {   // going forward, apply brake force
                m_vehicle->applyEngineForce(-getBrakeFactor()*engine_power, 2);
                m_vehicle->applyEngineForce(-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(-engine_power*m_controls.brake, 2);
                    m_vehicle->applyEngineForce(-engine_power*m_controls.brake, 3);
                }
                else
                {
                    m_vehicle->applyEngineForce(0.f, 2);
                    m_vehicle->applyEngineForce(0.f, 3);
                }
            }
        }
        else
        {   // 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(isOnGround() && m_controls.jump)
    { 
      //Vector3 impulse(0.0f, 0.0f, 10.0f);
      //        getVehicle()->getRigidBody()->applyCentralImpulse(impulse);
        btVector3 velocity         = m_body->getLinearVelocity();
        velocity.setZ( m_kart_properties->getJumpVelocity() );

        getBody()->setLinearVelocity( velocity );

    }
    if(m_wheelie_angle<=0.0f)
    {
        const float steering = DEGREE_TO_RAD(getMaxSteerAngle()) * m_controls.lr;
        m_vehicle->setSteeringValue(steering, 0);
        m_vehicle->setSteeringValue(steering, 1);
    } 
    else 
    {
        m_vehicle->setSteeringValue(0.0f, 0);
        m_vehicle->setSteeringValue(0.0f, 1);
    }

    //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 )
    {
        const float velocity_ratio = max_speed/m_speed;
        m_speed                    = max_speed;
        btVector3 velocity         = m_body->getLinearVelocity();

        velocity.setY( velocity.getY() * velocity_ratio );
        velocity.setX( velocity.getX() * velocity_ratio );

        getVehicle()->getRigidBody()->setLinearVelocity( velocity );

    }
    //at low velocity, forces on kart push it back and forth so we ignore this
    if(fabsf(m_speed) < 0.2f) // quick'n'dirty workaround for bug 1776883
         m_speed = 0;
}   // updatePhysics

Here is the call graph for this function:

Here is the caller graph for this function:

void Moveable::WriteHistory ( char *  s,
int  kartNumber,
int  indx 
) [inherited]

Definition at line 175 of file moveable.cpp.

{
    sprintf(s, "Kart %d: v=%f,%f,%f,%f,%f,%f, p=%f,%f,%f,%f,%f,%f", kartNumber,
            m_history_velocity[indx].xyz[0],
            m_history_velocity[indx].xyz[1],
            m_history_velocity[indx].xyz[2],
            m_history_velocity[indx].hpr[0],
            m_history_velocity[indx].hpr[1],
            m_history_velocity[indx].hpr[2],
            m_history_position[indx].xyz[0],
            m_history_position[indx].xyz[1],
            m_history_position[indx].xyz[2],
            m_history_position[indx].hpr[0],
            m_history_position[indx].hpr[1],
            m_history_position[indx].hpr[2]);
}   // WriteHistory

Here is the caller graph for this function:


Member Data Documentation

int PlayerKart::m_accel_val [private]

Definition at line 36 of file player_kart.hpp.

Attachment Kart::m_attachment [protected, inherited]

Definition at line 56 of file kart.hpp.

btRigidBody* Moveable::m_body [protected, inherited]

Definition at line 53 of file moveable.hpp.

Definition at line 41 of file player_kart.hpp.

Collectable Kart::m_collectable [protected, inherited]

Definition at line 57 of file kart.hpp.

int Moveable::m_collided [protected, inherited]

Definition at line 47 of file moveable.hpp.

KartControl Kart::m_controls [protected, inherited]

Definition at line 62 of file kart.hpp.

int Moveable::m_crashed [protected, inherited]

Definition at line 48 of file moveable.hpp.

sgCoord Moveable::m_curr_pos [protected, inherited]

Definition at line 42 of file moveable.hpp.

sgVec3 Kart::m_curr_track_coords [protected, inherited]

Definition at line 66 of file kart.hpp.

char Kart::m_fastest_lap_message[255] [protected, inherited]

Definition at line 72 of file kart.hpp.

int Moveable::m_first_time [protected, inherited]

Definition at line 50 of file moveable.hpp.

int Kart::m_grid_position [protected, inherited]

Definition at line 59 of file kart.hpp.

sgCoord* Moveable::m_history_position [protected, inherited]

Definition at line 52 of file moveable.hpp.

sgCoord* Moveable::m_history_velocity [protected, inherited]

Definition at line 51 of file moveable.hpp.

int Kart::m_initial_position [protected, inherited]

Definition at line 61 of file kart.hpp.

btCompoundShape Kart::m_kart_chassis [protected, inherited]

Definition at line 78 of file kart.hpp.

const KartProperties* Kart::m_kart_properties [protected, inherited]

Definition at line 110 of file kart.hpp.

float Kart::m_lap_start_time [protected, inherited]

Definition at line 71 of file kart.hpp.

sgVec2 Kart::m_last_track_coords [protected, inherited]

Definition at line 65 of file kart.hpp.

Material* Moveable::m_material_hot [protected, inherited]

Definition at line 44 of file moveable.hpp.

float Kart::m_max_speed [protected, inherited]

Definition at line 67 of file kart.hpp.

float Kart::m_max_speed_reverse_ratio [protected, inherited]

Definition at line 68 of file kart.hpp.

ssgTransform* Moveable::m_model_transform [protected, inherited]

Definition at line 45 of file moveable.hpp.

Definition at line 54 of file moveable.hpp.

sgVec4* Moveable::m_normal_hot [protected, inherited]

Definition at line 43 of file moveable.hpp.

bool Kart::m_on_road [protected, inherited]

Definition at line 54 of file kart.hpp.

float PlayerKart::m_penalty_time [private]

Definition at line 39 of file player_kart.hpp.

Definition at line 38 of file player_kart.hpp.

int Kart::m_race_position [protected, inherited]

Definition at line 60 of file kart.hpp.

float Kart::m_rescue_pitch [protected, inherited]

Definition at line 109 of file kart.hpp.

float Kart::m_rescue_roll [protected, inherited]

Definition at line 109 of file kart.hpp.

sgCoord Moveable::m_reset_pos [protected, inherited]

Definition at line 41 of file moveable.hpp.

ssgTransform* Moveable::m_shadow [protected, inherited]

Definition at line 46 of file moveable.hpp.

int Kart::m_shortcut_sector [protected, inherited]

Definition at line 74 of file kart.hpp.

int PlayerKart::m_steer_val [private]

Definition at line 36 of file player_kart.hpp.

Definition at line 36 of file player_kart.hpp.

Definition at line 36 of file player_kart.hpp.

sgVec3 Moveable::m_surface_avoidance_vector [protected, inherited]

Definition at line 49 of file moveable.hpp.

Definition at line 40 of file player_kart.hpp.

int Kart::m_track_sector [protected, inherited]

Definition at line 63 of file kart.hpp.

btTransform Moveable::m_transform [protected, inherited]

Definition at line 55 of file moveable.hpp.

Definition at line 77 of file kart.hpp.

Definition at line 81 of file kart.hpp.

UserPointer Moveable::m_user_pointer [protected, inherited]

Definition at line 40 of file moveable.hpp.

btRaycastVehicle* Kart::m_vehicle [protected, inherited]

Definition at line 80 of file kart.hpp.

Definition at line 79 of file kart.hpp.

float Kart::m_wheelie_angle [protected, inherited]

Definition at line 69 of file kart.hpp.

float Kart::m_zipper_time_left [protected, inherited]

Definition at line 70 of file kart.hpp.


The documentation for this class was generated from the following files: