diff --git a/src/flyable.cpp b/src/flyable.cpp new file mode 100644 index 000000000..d1287afb6 --- /dev/null +++ b/src/flyable.cpp @@ -0,0 +1,253 @@ +// $Id: flyable.cpp 1284 2007-11-08 12:31:54Z hikerstk $ +// +// SuperTuxKart - a fun racing game with go-kart +// Copyright (C) 2007 Joerg Henrichs +// +// 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 + +#include "flyable.hpp" +#include "constants.hpp" +#include "world.hpp" +#include "kart.hpp" +#include "projectile_manager.hpp" +#include "sound_manager.hpp" +#include "scene.hpp" +#include "ssg_help.hpp" + +// static variables: +float Flyable::m_st_speed[COLLECT_MAX]; +ssgEntity* Flyable::m_st_model[COLLECT_MAX]; +float Flyable::m_st_min_height[COLLECT_MAX]; +float Flyable::m_st_max_height[COLLECT_MAX]; +float Flyable::m_st_force_updown[COLLECT_MAX]; +btVector3 Flyable::m_st_extend[COLLECT_MAX]; +// ---------------------------------------------------------------------------- + +Flyable::Flyable(Kart *kart, CollectableType type) : Moveable(false) +{ + // get the appropriate data from the static fields + m_speed = m_st_speed[type]; + m_extend = m_st_extend[type]; + m_max_height = m_st_max_height[type]; + m_min_height = m_st_min_height[type]; + m_force_updown = m_st_force_updown[type]; + + m_owner = kart; + m_has_hit_something = false; + m_last_radar_beep = -1; + m_exploded = false; + m_shape = NULL; + m_mass = 1.0f; + + // Add the graphical model + ssgTransform *m = getModelTransform(); + m->addKid(m_st_model[type]); + scene->add(m); +} // Flyable +// ---------------------------------------------------------------------------- +void Flyable::createPhysics(const btVector3& offset, const btVector3 velocity) +{ + // The actual transform is determined as follows: + // 1) Compute the heading of the kart + // 2) Compute the pitch of the terrain. This avoids the problem of the + // rocket hitting the floor (e.g. if the kart is braking and therefore + // pointing downwards). + btTransform trans; + m_owner->getTrans(&trans); + + // Compute heading so that straight forward (direction=(0,1,0)) is 0: + btVector3 forwards(0.0f, 1.0f, 0.0f); + btVector3 direction=trans.getBasis()*forwards; + float heading=atan2(-direction.getX(), direction.getY()); + + btVector3 normal; + float pitch=0.0f; + if(world->getTerrainNormal(trans.getOrigin(),&normal)) + { + 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. + pitch = ( normal.getX()*X + 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; + } + btMatrix3x3 m; + m.setEulerZYX(pitch, 0.0f, heading); + trans.setBasis(m); + + // Apply rotation and offset + btTransform offset_transform; + offset_transform.setIdentity(); + offset_transform.setOrigin(offset); + + trans *= offset_transform; + + m_shape = createShape(); // get shape + createBody(m_mass, trans, m_shape, Moveable::MOV_PROJECTILE); + world->getPhysics()->addBody(getBody()); + + // Simplified rockets: no gravity + m_body->setGravity(btVector3(0.0f, 0.0f, 0.0f)); + + // Rotate velocity to point in the right direction + btVector3 v=trans.getBasis()*velocity; + + if(m_mass!=0.0f) // Don't set velocity for kinematic or static objects + { + m_body->setLinearVelocity(v); + m_body->setAngularFactor(0.0f); // prevent rotations + } + m_body->setCollisionFlags(btCollisionObject::CF_NO_CONTACT_RESPONSE); + + // FIXME: for now it is necessary to synch the graphical position with the + // physical position, since 'hot' computation is done using the + // graphical position (and hot can trigger an explosion when no + // terrain is under the rocket). Once hot is done with bullet as + // well, this shouldn't be necessary anymore. + placeModel(); + //FIXME m_current_HAT = world->getHAT(offset.getOrigin()); + m_HAT_counter = 0; + +} // createPhysics + +// ----------------------------------------------------------------------------- +void Flyable::init(const lisp::Lisp* lisp, ssgEntity *model, + CollectableType type) +{ + m_st_speed[type] = 25.0f; + m_st_max_height[type] = 1.0f; + m_st_min_height[type] = 3.0f; + m_st_force_updown[type] = 15.0f; + lisp->get("speed", m_st_speed[type] ); + lisp->get("min-height", m_st_min_height[type] ); + lisp->get("max-height", m_st_max_height[type] ); + lisp->get("force-updown", m_st_force_updown[type]); + + // Store the size of the model + float x_min, x_max, y_min, y_max, z_min, z_max; + MinMax(model, &x_min, &x_max, &y_min, &y_max, &z_min, &z_max); + m_st_extend[type] = btVector3(x_max-x_min,y_max-y_min, z_max-z_min); + m_st_model[type] = model; +} // init + +//----------------------------------------------------------------------------- +Flyable::~Flyable() +{ + if(m_shape) delete m_shape; + world->getPhysics()->removeBody(getBody()); +} // ~Flyable + +//----------------------------------------------------------------------------- +void Flyable::getClosestKart(const Kart **minKart, float *minDist, btVector3 *minDelta) const +{ + btTransform tProjectile; + getTrans(&tProjectile); + *minDist = 99999.9f; + for(unsigned int i=0 ; igetNumKarts(); i++ ) + { + Kart *kart = world -> getKart(i); + if(kart == m_owner) continue; + btTransform t; + kart->getTrans(&t); + + btVector3 delta = t.getOrigin()-tProjectile.getOrigin(); + float distance2 = delta.length2(); + + if(distance2 < *minDist) + { + *minDist = sqrt(distance2); + *minKart = kart; + *minDelta = delta; + } + } // for igetWorldTransform(); + m_current_HAT = world->getHAT(trans.getOrigin()); + m_HAT_counter = 0; + printf("pos: %f %f %f height %f min %f max %f\n", + trans.getOrigin().getX(),trans.getOrigin().getY(),trans.getOrigin().getZ(), + m_current_HAT, m_min_height, m_max_height); + if(m_current_HAT!=Physics::NOHIT) + { + if(m_current_HATm_max_height) + {printf("down \n");too_high(dt);} + else + right_height(dt); + } + else explode(NULL); + } + Moveable::update(dt); +} // update + +// ----------------------------------------------------------------------------- +void Flyable::placeModel() +{ + btTransform t; + getTrans(&t); + float m[4][4]; + t.getOpenGLMatrix((float*)&m); + sgSetCoord(&m_curr_pos, m); + const btVector3 &v=m_body->getLinearVelocity(); + sgSetVec3(m_velocity.xyz, v.x(), v.y(), v.z()); + m_model_transform->setTransform(&m_curr_pos); + +} // placeModel + +// ----------------------------------------------------------------------------- +void Flyable::explode(Kart *kart_hit) +{ + if(m_exploded) return; + + m_has_hit_something=true; + m_curr_pos.xyz[2] += 1.2f ; + // Notify the projectile manager that this rocket has hit something. + // The manager will create the appropriate explosion object. + projectile_manager->explode(); + + // Now remove this projectile from the graph: + ssgTransform *m = getModelTransform(); + m->removeAllKids(); + scene->remove(m); + + world->getPhysics()->removeBody(getBody()); + m_exploded=true; + + for ( unsigned int i = 0 ; i < world->getNumKarts() ; i++ ) + { + Kart *kart = world -> getKart(i); + // handle the actual explosion. Set a flag it if was a direct hit. + kart->handleExplosion(m_curr_pos.xyz, kart==kart_hit); + } + +} // explode + +/* EOF */ diff --git a/src/flyable.hpp b/src/flyable.hpp new file mode 100644 index 000000000..e233e1a01 --- /dev/null +++ b/src/flyable.hpp @@ -0,0 +1,87 @@ +// $Id: flyable.hpp 1284 2007-11-08 12:31:54Z hikerstk $ +// +// SuperTuxKart - a fun racing game with go-kart +// Copyright (C) 2007 Joerg Henrichs +// +// 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. + +#ifndef HEADER_FLYABLE_H +#define HEADER_FLYABLE_H + +#include "moveable.hpp" +#include "kart.hpp" + +class Flyable : public Moveable +{ + sgCoord m_last_pos; + bool m_has_hit_something; + int m_last_radar_beep; + bool m_exploded; + int m_HAT_counter; // compute HAT only every N timesteps + +protected: + const Kart* m_owner; // the kart which released this flyable + btCollisionShape *m_shape; + float m_max_height; + float m_min_height; + float m_force_updown; + float m_speed; + float m_mass; + btVector3 m_extend; + // The flyable class stores the values for each flyable type, e.g. + // speed, min_height, max_height. These variables must be static, + // so we need arrays of these variables to have different values + // for sparks, missiles, ... + static float m_st_speed[COLLECT_MAX]; // Speed of the projectile + static ssgEntity* m_st_model[COLLECT_MAX]; // 3d model + static float m_st_min_height[COLLECT_MAX]; // min height above track + static float m_st_max_height[COLLECT_MAX]; // max height above track + static float m_st_force_updown[COLLECT_MAX]; // force pushing up/down + static btVector3 m_st_extend[COLLECT_MAX]; // size of the model + + float m_current_HAT; // height above terrain + void getClosestKart(const Kart **minKart, float *minDist, + btVector3 *minDelta) const; + virtual btCollisionShape *createShape()=0; + virtual void too_low (float dt) + {m_body->applyCentralForce( + btVector3(0.0f, 0.0f, m_force_updown)); } + virtual void too_high(float dt) + {m_body->applyCentralForce( + btVector3(0.0f, 0.0f, -m_force_updown)); } + virtual void right_height(float dt) + {btVector3 v=m_body->getLinearVelocity(); + v.setZ(0.0f); + m_body->setLinearVelocity(v); } + void createPhysics(const btVector3& offset, + const btVector3 velocity); +public: + + Flyable (Kart* kart, CollectableType type); + virtual ~Flyable (); + static void init (const lisp::Lisp* lisp, ssgEntity *model, + CollectableType type); + virtual void update (float); + + void placeModel (); + virtual void hitTrack () {}; + void explode (Kart* kart); + bool hasHit () { return m_has_hit_something; } + void reset () { Moveable::reset(); + sgCopyCoord(&m_last_pos,&m_reset_pos ); } + void OutsideTrack (int isReset) { explode(NULL); } +}; // Flyable + +#endif diff --git a/src/homing.cpp b/src/homing.cpp new file mode 100644 index 000000000..2a54095de --- /dev/null +++ b/src/homing.cpp @@ -0,0 +1,100 @@ +// $Id: homing.cpp 1284 2007-11-08 12:31:54Z hikerstk $ +// +// SuperTuxKart - a fun racing game with go-kart +// Copyright (C) 2007 Joerg Henrichs +// +// 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 "homing.hpp" +#include "constants.hpp" + +float Homing::m_st_max_distance; +float Homing::m_st_max_turn_angle; + +// ----------------------------------------------------------------------------- +Homing::Homing (Kart *kart) : Flyable(kart, COLLECT_HOMING) +{ + m_mass = 0.0f; // a kinematik object must have mass=0, otherwise warnings + // will be printed during bullet collision handling. + btVector3 offset(0.0f, + kart->getKartLength()+2.0f*m_extend.getY(), + 0.3f ); + // The cylinder needs to be rotated by 90 degrees to face in the right direction: + m_initial_velocity = btVector3(0.0f, m_speed, 0.0f); + createPhysics(offset, m_initial_velocity); + m_body->setCollisionFlags(m_body->getCollisionFlags() | + btCollisionObject::CF_KINEMATIC_OBJECT ); + m_body->setActivationState(DISABLE_DEACTIVATION); +} // Homing + +// ----------------------------------------------------------------------------- +void Homing::init(const lisp::Lisp* lisp, ssgEntity *homing) +{ + Flyable::init(lisp, homing, COLLECT_HOMING); + m_st_max_turn_angle = 15.0f; + m_st_max_distance = 20.0f; + lisp->get("max-distance", m_st_max_distance ); + lisp->get("max-turn-angle", m_st_max_turn_angle); +} // init +// ----------------------------------------------------------------------------- +btCollisionShape *Homing::createShape() +{ + return new btCylinderShape(0.5f*m_extend); +} // createShape + +// ----------------------------------------------------------------------------- +void Homing::update(float dt) +{ + Flyable::update(dt); + + const Kart *kart=0; + btVector3 direction; + float minDistance; + + getClosestKart(&kart, &minDistance, &direction); + btTransform my_trans; + getTrans(&my_trans); + if(minDistancegetTrans(&target); + getTrans(&my_trans); + + float steer=steerTowards(my_trans, target.getOrigin()); + if(fabsf(steer)>90.0f) steer=0.0f; + if(steer<-m_st_max_turn_angle) steer = -m_st_max_turn_angle; + if(steer> m_st_max_turn_angle) steer = m_st_max_turn_angle; + btMatrix3x3 steerMatrix(btQuaternion(0.0f,0.0f,DEGREE_TO_RAD(steer))); + my_trans.setBasis(my_trans.getBasis()*steerMatrix); + } // minDistance 180.0f) angle=angle-360.0f; + if(angle<-180.0f) angle=angle+360.0f; + return angle; +} // steerTowards \ No newline at end of file diff --git a/src/homing.hpp b/src/homing.hpp new file mode 100644 index 000000000..755322afa --- /dev/null +++ b/src/homing.hpp @@ -0,0 +1,47 @@ +// $Id: missile.hpp 1284 2007-11-08 12:31:54Z hikerstk $ +// +// SuperTuxKart - a fun racing game with go-kart +// Copyright (C) 2007 Joerg Henrichs +// +// 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. + +#ifndef HEADER_HOMING_H +#define HEADER_HOMING_H + +#include "flyable.hpp" + +class Homing : public Flyable +{ +private: + static float m_st_max_distance; // maximum distance for a spark to be attracted + static float m_st_max_turn_angle; + btVector3 m_initial_velocity; + float steerTowards(btTransform& trans, btVector3& target); + +protected: + virtual btCollisionShape *createShape(); + virtual void too_low (float dt) {m_initial_velocity.setZ(m_force_updown*dt);} + virtual void too_high(float dt) {m_initial_velocity.setZ(-m_force_updown*dt);} + virtual void right_height(float dt) {m_initial_velocity.setZ(0.0f); } + +public: + Homing (Kart *kart); + static void init (const lisp::Lisp* lisp, ssgEntity* homing); + virtual void update (float dt); + virtual void hitTrack () { explode(NULL); } + +}; // Homing + +#endif diff --git a/src/missile.cpp b/src/missile.cpp new file mode 100644 index 000000000..b4f7edda3 --- /dev/null +++ b/src/missile.cpp @@ -0,0 +1,49 @@ +// $Id: missile.cpp 1284 2007-11-08 12:31:54Z hikerstk $ +// +// SuperTuxKart - a fun racing game with go-kart +// Copyright (C) 2007 Joerg Henrichs +// +// 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 "missile.hpp" +#include "constants.hpp" + +// ----------------------------------------------------------------------------- +Missile::Missile(Kart *kart) : Flyable(kart, COLLECT_MISSILE) +{ + btVector3 offset(0.0f, + kart->getKartLength()+2.0f*m_extend.getY(), + 0.3f ); + createPhysics(offset, btVector3(0.0f, m_speed, 0.0f)); +} // Missile + +// ----------------------------------------------------------------------------- +void Missile::init(const lisp::Lisp* lisp, ssgEntity *missile) +{ + Flyable::init(lisp, missile, COLLECT_MISSILE); +} // init + +// ----------------------------------------------------------------------------- +btCollisionShape *Missile::createShape() +{ + return new btCylinderShape(0.5f*m_extend); +} // createShape + +// ----------------------------------------------------------------------------- +void Missile::update(float dt) +{ + Flyable::update(dt); +} // update +// ----------------------------------------------------------------------------- diff --git a/src/missile.hpp b/src/missile.hpp new file mode 100644 index 000000000..d69fe14d0 --- /dev/null +++ b/src/missile.hpp @@ -0,0 +1,37 @@ +// $Id: missile.hpp 1284 2007-11-08 12:31:54Z hikerstk $ +// +// SuperTuxKart - a fun racing game with go-kart +// Copyright (C) 2007 Joerg Henrichs +// +// 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. + +#ifndef HEADER_MISSILE_H +#define HEADER_MISSILE_H + +#include "flyable.hpp" + +class Missile : public Flyable +{ +protected: + virtual btCollisionShape *createShape(); +public: + Missile(Kart *kart); + static void init (const lisp::Lisp* lisp, ssgEntity* missile); + virtual void update (float dt); + virtual void hitTrack () { explode(NULL); } + +}; // Missile + +#endif diff --git a/src/spark.cpp b/src/spark.cpp new file mode 100644 index 000000000..4a61dfcc3 --- /dev/null +++ b/src/spark.cpp @@ -0,0 +1,102 @@ +// $Id: spark.cpp 1284 2007-11-08 12:31:54Z hikerstk $ +// +// SuperTuxKart - a fun racing game with go-kart +// Copyright (C) 2007 Joerg Henrichs +// +// 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 "spark.hpp" +float Spark::m_st_max_distance; // maximum distance for a spark to be attracted +float Spark::m_st_force_to_target; + +// ----------------------------------------------------------------------------- +Spark::Spark(Kart *kart) : Flyable(kart, COLLECT_SPARK) +{ + btVector3 offset(0.0f, + -0.5f*kart->getKartLength()-2.0f*m_extend.getY(), + 0.5f*kart->getKartHeight()); + float speed=-m_speed; + // if the kart is driving backwards, release from the front + if(m_owner->getSpeed()<0) + { + offset.setY(0.5f*kart->getKartLength()+2.0f*m_extend.getY()); + speed = m_speed; + } + + createPhysics(offset, btVector3(0.0f, speed, 0.0f)); + + // unset no_contact_response flags, so that the spark + // will bounce off the track + int flag = getBody()->getCollisionFlags(); + flag = flag & (~ btCollisionObject::CF_NO_CONTACT_RESPONSE); + getBody()->setCollisionFlags(flag); +} // Spark + +// ----------------------------------------------------------------------------- +void Spark::init(const lisp::Lisp* lisp, ssgEntity *spark) +{ + Flyable::init(lisp, spark, COLLECT_SPARK); + m_st_max_distance = 20.0f; + m_st_force_to_target = 10.0f; + + lisp->get("max-distance", m_st_max_distance ); + lisp->get("force-to-target", m_st_force_to_target); +} // init + +// ----------------------------------------------------------------------------- +btCollisionShape *Spark::createShape() +{ + return new btSphereShape(0.5f*m_extend.getY()); + +} // createShape + +// ----------------------------------------------------------------------------- +void Spark::update(float dt) +{ + Flyable::update(dt); + const Kart *kart=0; + btVector3 direction; + float minDistance; + getClosestKart(&kart, &minDistance, &direction); + if(minDistanceapplyCentralForce(direction); + } + else + { // Sparks lose energy (e.g. when hitting the track), so increase the + // speed if the spark is too slow, but only if it's not too high (if + // the spark is too high, it is 'pushed down', which can reduce the + // speed, which causes the speed to increase, which in turn causes + // the spark to fly higher and higher. + btVector3 v=m_body->getLinearVelocity(); + if (m_current_HAT<= m_max_height) + { + float vlen = v.length2(); + if(vlen<0.8*m_speed*m_speed) + { // spark lost energy (less than 80%), i.e. it's too slow - speed it up: + if(vlen==0.0f) { + v = btVector3(.5f, .5f, .5f); // avoid 0 div. + vlen = 0.75; + } + else + { + m_body->setLinearVelocity(v*m_speed/sqrt(vlen)); + } + } // vlen < 0.8*m_speed*m_speed + } // m_current_HAT < m_max_height + } // spar lose energy +} // update +// ----------------------------------------------------------------------------- diff --git a/src/spark.hpp b/src/spark.hpp new file mode 100644 index 000000000..afee14ca9 --- /dev/null +++ b/src/spark.hpp @@ -0,0 +1,40 @@ +// $Id: spark.hpp 1284 2007-11-08 12:31:54Z hikerstk $ +// +// SuperTuxKart - a fun racing game with go-kart +// Copyright (C) 2007 Joerg Henrichs +// +// 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. + +#ifndef HEADER_SPARK_H +#define HEADER_SPARK_H + +#include "flyable.hpp" + +class Spark : public Flyable +{ +private: + static float m_st_max_distance; // maximum distance for a spark to be attracted + static float m_st_force_to_target; +protected: + virtual btCollisionShape *createShape(); + +public: + Spark(Kart* kart); + static void init(const lisp::Lisp* lisp, ssgEntity* spark); + virtual void update(float dt); + +}; // Spark + +#endif