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

Switch from properties to characteristics

Browse Source
This commit is contained in:
Flakebi 2015-07-11 19:17:24 +02:00
parent 1ceab872b1
commit 9fc6f84545
33 changed files with 364 additions and 1102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
data/kart_characteristics.xml
View File

@ -61,7 +61,7 @@
0.5 * 0.25 + 0.5 * 0.15 = 0.2 ... which is overall the same
time we had previously. -->
<turn turn-radius="0:2.0 10:7.5 25:15 45:30"
time-full-steer ="0:0.15 0.5:0.15 0.5:0.25 1.0:0.25"
time-full-steer=""
time-reset-steer="0.1" />
<!-- Speed and acceleration
@ -233,7 +233,7 @@
in your face is removed. -->
<plunger band-max-length="50" band-force="1500" band-duration="1"
band-speed-increase="7" band-fade-out-time="3"
in-face-time="3 4 4.5 4.5" />
in-face-time="4" />
<!-- ********** Miscellaneous ********** -->
@ -304,14 +304,17 @@
<difficulties>
<characteristic name="easy">
<engine power="450" max-speed="17" />
<plunger in-face-time="3" />
</characteristic>
<characteristic name="medium">
</characteristic>
<characteristic name="hard">
<engine power="500" max-speed="23" />
<plunger in-face-time="4.5" />
</characteristic>
<characteristic name="best">
<engine power="510" max-speed="25" />
<plunger in-face-time="4.5" />
</characteristic>
</difficulties>

19
src/graphics/camera.cpp
View File

@ -25,6 +25,7 @@
#include "config/user_config.hpp"
#include "graphics/irr_driver.hpp"
#include "io/xml_node.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/explosion_animation.hpp"
#include "karts/kart.hpp"
@ -67,7 +68,7 @@ Camera::Camera(int camera_index, AbstractKart* kart) : m_kart(NULL)
setupCamera();
if (kart != NULL)
{
m_distance = kart->getKartProperties()->getCameraDistance();
m_distance = kart->getCharacteristic()->getCameraDistance();
setKart(kart);
}
else
@ -378,9 +379,9 @@ void Camera::smoothMoveCamera(float dt)
core::vector3df current_position = m_camera->getPosition();
// Smoothly interpolate towards the position and target
const KartProperties *kp = m_kart->getKartProperties();
float max_increase_with_zipper = kp->getZipperMaxSpeedIncrease();
float max_speed_without_zipper = kp->getMaxSpeed();
const AbstractCharacteristic *ch = m_kart->getCharacteristic();
float max_increase_with_zipper = ch->getZipperMaxSpeedIncrease();
float max_speed_without_zipper = ch->getEngineMaxSpeed();
float current_speed = m_kart->getSpeed();
const Skidding *ks = m_kart->getSkidding();
@ -452,7 +453,7 @@ void Camera::getCameraSettings(float *above_kart, float *cam_angle,
float *sideway, float *distance,
bool *smoothing)
{
const KartProperties *kp = m_kart->getKartProperties();
const AbstractCharacteristic *ch = m_kart->getCharacteristic();
switch(m_mode)
{
@ -475,7 +476,7 @@ void Camera::getCameraSettings(float *above_kart, float *cam_angle,
else
{
*above_kart = 0.75f;
*cam_angle = kp->getCameraForwardUpAngle();
*cam_angle = ch->getCameraForwardUpAngle();
*distance = -m_distance;
}
float steering = m_kart->getSteerPercent()
@ -490,7 +491,7 @@ void Camera::getCameraSettings(float *above_kart, float *cam_angle,
case CM_REVERSE: // Same as CM_NORMAL except it looks backwards
{
*above_kart = 0.75f;
*cam_angle = kp->getCameraBackwardUpAngle();
*cam_angle = ch->getCameraBackwardUpAngle();
*sideway = 0;
*distance = 2.0f*m_distance;
*smoothing = false;
@ -822,8 +823,8 @@ void Camera::handleEndCamera(float dt)
}
case EndCameraInformation::EC_AHEAD_OF_KART:
{
const KartProperties *kp=m_kart->getKartProperties();
float cam_angle = kp->getCameraBackwardUpAngle();
const AbstractCharacteristic *ch = m_kart->getCharacteristic();
float cam_angle = ch->getCameraBackwardUpAngle();
positionCamera(dt, /*above_kart*/0.75f,
cam_angle, /*side_way*/0,

29
src/graphics/slip_stream.cpp
View File

@ -25,8 +25,9 @@
#include "graphics/material_manager.hpp"
#include "graphics/stk_mesh_scene_node.hpp"
#include "io/file_manager.hpp"
#include "karts/controller/controller.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/controller.hpp"
#include "karts/kart_properties.hpp"
#include "karts/max_speed.hpp"
#include "modes/world.hpp"
@ -67,9 +68,9 @@ SlipStream::SlipStream(AbstractKart* kart) : MovingTexture(0, 0), m_kart(kart)
setTextureMatrix(&(m_node->getMaterial(0).getTextureMatrix(0)));
m_slipstream_time = 0.0f;
float length = m_kart->getKartProperties()->getSlipstreamLength();
float length = m_kart->getCharacteristic()->getSlipstreamLength();
float kw = m_kart->getKartWidth();
float ew = m_kart->getKartProperties()->getSlipstreamWidth();
float ew = m_kart->getCharacteristic()->getSlipstreamWidth();
float kl = m_kart->getKartLength();
Vec3 p[4];
@ -312,7 +313,7 @@ void SlipStream::setIntensity(float f, const AbstractKart *kart)
bool SlipStream::isSlipstreamReady() const
{
return m_slipstream_time>
m_kart->getKartProperties()->getSlipstreamCollectTime();
m_kart->getCharacteristic()->getSlipstreamCollectTime();
} // isSlipstreamReady
//-----------------------------------------------------------------------------
@ -326,12 +327,12 @@ void SlipStream::updateSlipstreamPower()
if(m_slipstream_mode==SS_USE)
{
setIntensity(2.0f, NULL);
const KartProperties *kp=m_kart->getKartProperties();
const AbstractCharacteristic *ch=m_kart->getCharacteristic();
m_kart->increaseMaxSpeed(MaxSpeed::MS_INCREASE_SLIPSTREAM,
kp->getSlipstreamMaxSpeedIncrease(),
kp->getSlipstreamAddPower(),
kp->getSlipstreamDuration(),
kp->getSlipstreamFadeOutTime());
ch->getSlipstreamMaxSpeedIncrease(),
ch->getSlipstreamAddPower(),
ch->getSlipstreamDuration(),
ch->getSlipstreamFadeOutTime());
}
} // upateSlipstreamPower
@ -387,7 +388,7 @@ void SlipStream::update(float dt)
// not moving. This is useful for debugging the graphics of SS-ing.
//#define DISPLAY_SLIPSTREAM_WITH_0_SPEED_FOR_DEBUGGING
#ifndef DISPLAY_SLIPSTREAM_WITH_0_SPEED_FOR_DEBUGGING
if(m_kart->getSpeed()<m_kart->getKartProperties()->getSlipstreamMinSpeed())
if(m_kart->getSpeed() < m_kart->getCharacteristic()->getSlipstreamMinSpeed())
{
setIntensity(0, NULL);
m_slipstream_mode = SS_NONE;
@ -429,7 +430,7 @@ void SlipStream::update(float dt)
// give karts different slipstream properties.
#ifndef DISPLAY_SLIPSTREAM_WITH_0_SPEED_FOR_DEBUGGING
if(m_target_kart->getSpeed() <
m_kart->getKartProperties()->getSlipstreamMinSpeed())
m_kart->getCharacteristic()->getSlipstreamMinSpeed())
{
if(UserConfigParams::m_slipstream_debug &&
m_kart->getController()->isPlayerController())
@ -443,7 +444,7 @@ void SlipStream::update(float dt)
// slipstream length+0.5*kart_length()+0.5*target_kart_length
// away from the other kart
Vec3 delta = m_kart->getXYZ() - m_target_kart->getXYZ();
float l = m_kart->getKartProperties()->getSlipstreamLength()
float l = m_kart->getCharacteristic()->getSlipstreamLength()
+ 0.5f*( m_target_kart->getKartLength()
+m_kart->getKartLength() );
if(delta.length2_2d() > l*l)
@ -484,7 +485,7 @@ void SlipStream::update(float dt)
m_slipstream_mode = SS_USE;
m_kart->handleZipper();
m_slipstream_time =
m_kart->getKartProperties()->getSlipstreamCollectTime();
m_kart->getCharacteristic()->getSlipstreamCollectTime();
return;
}
}
@ -505,7 +506,7 @@ void SlipStream::update(float dt)
setIntensity(m_slipstream_time, m_target_kart);
m_slipstream_mode = SS_COLLECT;
if(m_slipstream_time>m_kart->getKartProperties()->getSlipstreamCollectTime())
if(m_slipstream_time>m_kart->getCharacteristic()->getSlipstreamCollectTime())
{
setIntensity(1.0f, m_target_kart);
}

14
src/guiengine/widgets/kart_stats_widget.cpp
View File

@ -15,21 +15,19 @@
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "config/user_config.hpp"
#include "guiengine/engine.hpp"
#include "guiengine/widgets/kart_stats_widget.hpp"
#include "utils/string_utils.hpp"
#include <string.h>
#include "karts/abstract_characteristic.hpp"
#include "karts/kart_properties.hpp"
#include "karts/kart_properties_manager.hpp"
#include "utils/log.hpp"
#include "utils/string_utils.hpp"
#include "config/user_config.hpp"
#include <IGUIEnvironment.h>
#include <IGUIElement.h>
#include <IGUIButton.h>
#include <string>
using namespace GUIEngine;
using namespace irr::core;
@ -81,15 +79,15 @@ KartStatsWidget::KartStatsWidget(core::recti area, const int player_id,
m_children.push_back(skill_bar);
}
m_skills[SKILL_MASS]->setValue((int)(props->getMass()/5));
m_skills[SKILL_MASS]->setValue((int)(props->getCombinedCharacteristic()->getMass()/5));
m_skills[SKILL_MASS]->setLabel(_("WEIGHT"));
m_skills[SKILL_MASS]->m_properties[PROP_ID] = StringUtils::insertValues("@p%i_mass", m_player_id);
m_skills[SKILL_SPEED]->setValue((int)((props->getAbsMaxSpeed()-20)*9));
m_skills[SKILL_SPEED]->setValue((int)((props->getCombinedCharacteristic()->getEngineMaxSpeed()-20)*9));
m_skills[SKILL_SPEED]->setLabel(_("SPEED"));
m_skills[SKILL_SPEED]->m_properties[PROP_ID] = StringUtils::insertValues("@p%i_speed", m_player_id);
m_skills[SKILL_POWER]->setValue((int)(props->getAvgPower()));
m_skills[SKILL_POWER]->setValue((int)(props->getCombinedCharacteristic()->getEnginePower()));
m_skills[SKILL_POWER]->setLabel(_("POWER"));
m_skills[SKILL_POWER]->m_properties[PROP_ID] = StringUtils::insertValues("@p%i_power", m_player_id);

3
src/items/attachment.cpp
View File

@ -30,6 +30,7 @@
#include "items/item_manager.hpp"
#include "items/projectile_manager.hpp"
#include "items/swatter.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/controller.hpp"
#include "karts/explosion_animation.hpp"
@ -266,7 +267,7 @@ void Attachment::hitBanana(Item *item, int new_attachment)
// same banana again once the explosion animation is finished, giving
// the kart the same penalty twice.
float f = std::max(item->getDisableTime(),
m_kart->getKartProperties()->getExplosionTime() + 2.0f);
m_kart->getCharacteristic()->getExplosionDuration() + 2.0f);
item->setDisableTime(f);
break;
}

3
src/items/plunger.cpp
View File

@ -25,6 +25,7 @@
#include "io/xml_node.hpp"
#include "items/rubber_band.hpp"
#include "items/projectile_manager.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/controller.hpp"
#include "karts/kart_properties.hpp"
@ -178,7 +179,7 @@ bool Plunger::hit(AbstractKart *kart, PhysicalObject *obj)
}
else
{
m_keep_alive = m_owner->getKartProperties()->getRubberBandDuration();
m_keep_alive = m_owner->getCharacteristic()->getPlungerBandDuration();
// Make this object invisible by placing it faaar down. Not that if this
// objects is simply removed from the scene graph, it might be auto-deleted

3
src/items/powerup.cpp
View File

@ -28,6 +28,7 @@
#include "items/item_manager.hpp"
#include "items/projectile_manager.hpp"
#include "items/rubber_ball.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/controller.hpp"
#include "karts/kart_properties.hpp"
@ -222,7 +223,7 @@ void Powerup::use()
case PowerupManager::POWERUP_SWATTER:
m_owner->getAttachment()
->set(Attachment::ATTACH_SWATTER,
m_owner->getKartProperties()->getSwatterDuration());
m_owner->getCharacteristic()->getSwatterDuration());
break;
case PowerupManager::POWERUP_BUBBLEGUM:

9
src/items/rubber_band.cpp
View File

@ -26,6 +26,7 @@
#include "graphics/stk_mesh_scene_node.hpp"
#include "items/plunger.hpp"
#include "items/projectile_manager.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/kart_properties.hpp"
#include "karts/max_speed.hpp"
@ -149,7 +150,7 @@ void RubberBand::update(float dt)
// Check for rubber band snapping
// ------------------------------
float l = (m_end_position-k).length2();
float max_len = m_owner->getKartProperties()->getRubberBandMaxLength();
float max_len = m_owner->getCharacteristic()->getPlungerBandMaxLength();
if(l>max_len*max_len)
{
// Rubber band snaps
@ -162,7 +163,7 @@ void RubberBand::update(float dt)
// ----------------------------
if(m_attached_state!=RB_TO_PLUNGER)
{
float force = m_owner->getKartProperties()->getRubberBandForce();
float force = m_owner->getCharacteristic()->getPlungerBandForce();
Vec3 diff = m_end_position-k;
// detach rubber band if kart gets very close to hit point
@ -178,10 +179,10 @@ void RubberBand::update(float dt)
diff.normalize(); // diff can't be zero here
m_owner->getBody()->applyCentralForce(diff*force);
m_owner->increaseMaxSpeed(MaxSpeed::MS_INCREASE_RUBBER,
m_owner->getKartProperties()->getRubberBandSpeedIncrease(),
m_owner->getCharacteristic()->getPlungerBandSpeedIncrease(),
/*engine_force*/ 0.0f,
/*duration*/0.1f,
m_owner->getKartProperties()->getRubberBandFadeOutTime());
m_owner->getCharacteristic()->getPlungerBandFadeOutTime());
if(m_attached_state==RB_TO_KART)
m_hit_kart->getBody()->applyCentralForce(diff*(-force));
}

13
src/items/swatter.cpp
View File

@ -34,6 +34,7 @@
#include "io/file_manager.hpp"
#include "items/attachment.hpp"
#include "items/projectile_manager.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/controller/controller.hpp"
#include "karts/explosion_animation.hpp"
#include "karts/kart_properties.hpp"
@ -156,7 +157,7 @@ bool Swatter::updateAndTestFinished(float dt)
(m_target->getXYZ()- Vec3(m_scene_node->getAbsolutePosition()))
.length2();
float min_dist2
= m_kart->getKartProperties()->getSwatterDistance2();
= m_kart->getCharacteristic()->getSwatterDistance();
if(dist_to_target2 < min_dist2)
{
// Start squashing
@ -264,10 +265,10 @@ void Swatter::pointToTarget()
*/
void Swatter::squashThingsAround()
{
const KartProperties* kp = m_kart->getKartProperties();
const AbstractCharacteristic *ch = m_kart->getCharacteristic();
// Square of the minimum distance
float min_dist2 = kp->getSwatterDistance2();
const World* world = World::getWorld();
float min_dist2 = ch->getSwatterDistance();
const World* world = World::getWorld();
// Get the node corresponding to the joint at the center of the swatter
// (by swatter, I mean the thing hold in the hand, not the whole thing)
@ -279,7 +280,7 @@ void Swatter::squashThingsAround()
m_swat_sound->play();
// Squash karts around
for(unsigned int i=0; i<world->getNumKarts(); i++)
for(unsigned int i = 0; i < world->getNumKarts(); i++)
{
AbstractKart *kart = world->getKart(i);
// TODO: isSwatterReady()
@ -293,7 +294,7 @@ void Swatter::squashThingsAround()
if(dist2 >= min_dist2) continue; // too far away, ignore this kart
kart->setSquash(kp->getSquashDuration(), kp->getSquashSlowdown());
kart->setSquash(ch->getSwatterSquashDuration(), ch->getSwatterSquashSlowdown());
//Handle achievement if the swatter is used by the current player
const StateManager::ActivePlayer *const ap = m_kart->getController()

82
src/karts/abstract_characteristic.cpp
View File

@ -45,7 +45,7 @@ AbstractCharacteristic::ValueType AbstractCharacteristic::getType(Characteristic
case CHARACTERISTIC_COUNT:
Log::fatal("AbstractCharacteristic::getType", "Can't get type of COUNT");
break;
// Script-generated content
// Script-generated content get-prop first part
case SUSPENSION_STIFFNESS:
return TYPE_FLOAT;
case SUSPENSION_REST:
@ -53,7 +53,7 @@ AbstractCharacteristic::ValueType AbstractCharacteristic::getType(Characteristic
case SUSPENSION_TRAVEL_CM:
return TYPE_FLOAT;
case SUSPENSION_EXP_SPRING_RESPONSE:
return TYPE_FLOAT;
return TYPE_BOOL;
case SUSPENSION_MAX_FORCE:
return TYPE_FLOAT;
case STABILITY_ROLL_INFLUENCE:
@ -144,7 +144,7 @@ AbstractCharacteristic::ValueType AbstractCharacteristic::getType(Characteristic
return TYPE_FLOAT;
case ZIPPER_SPEED_GAIN:
return TYPE_FLOAT;
case ZIPPER_SPEED_INCREASE:
case ZIPPER_MAX_SPEED_INCREASE:
return TYPE_FLOAT;
case ZIPPER_FADE_OUT_TIME:
return TYPE_FLOAT;
@ -156,15 +156,15 @@ AbstractCharacteristic::ValueType AbstractCharacteristic::getType(Characteristic
return TYPE_FLOAT;
case SWATTER_SQUASH_SLOWDOWN:
return TYPE_FLOAT;
case PLUNGER_MAX_LENGTH:
case PLUNGER_BAND_MAX_LENGTH:
return TYPE_FLOAT;
case PLUNGER_FORCE:
case PLUNGER_BAND_FORCE:
return TYPE_FLOAT;
case PLUNGER_DURATION:
case PLUNGER_BAND_DURATION:
return TYPE_FLOAT;
case PLUNGER_SPEED_INCREASE:
case PLUNGER_BAND_SPEED_INCREASE:
return TYPE_FLOAT;
case PLUNGER_FADE_OUT_TIME:
case PLUNGER_BAND_FADE_OUT_TIME:
return TYPE_FLOAT;
case PLUNGER_IN_FACE_TIME:
return TYPE_FLOAT;
@ -229,7 +229,7 @@ std::string AbstractCharacteristic::getName(CharacteristicType type)
{
case CHARACTERISTIC_COUNT:
return "CHARACTERISTIC_COUNT";
// Script-generated content
// Script-generated content get-prop second part
case SUSPENSION_STIFFNESS:
return "SUSPENSION_STIFFNESS";
case SUSPENSION_REST:
@ -328,8 +328,8 @@ std::string AbstractCharacteristic::getName(CharacteristicType type)
return "ZIPPER_FORCE";
case ZIPPER_SPEED_GAIN:
return "ZIPPER_SPEED_GAIN";
case ZIPPER_SPEED_INCREASE:
return "ZIPPER_SPEED_INCREASE";
case ZIPPER_MAX_SPEED_INCREASE:
return "ZIPPER_MAX_SPEED_INCREASE";
case ZIPPER_FADE_OUT_TIME:
return "ZIPPER_FADE_OUT_TIME";
case SWATTER_DURATION:
@ -340,16 +340,16 @@ std::string AbstractCharacteristic::getName(CharacteristicType type)
return "SWATTER_SQUASH_DURATION";
case SWATTER_SQUASH_SLOWDOWN:
return "SWATTER_SQUASH_SLOWDOWN";
case PLUNGER_MAX_LENGTH:
return "PLUNGER_MAX_LENGTH";
case PLUNGER_FORCE:
return "PLUNGER_FORCE";
case PLUNGER_DURATION:
return "PLUNGER_DURATION";
case PLUNGER_SPEED_INCREASE:
return "PLUNGER_SPEED_INCREASE";
case PLUNGER_FADE_OUT_TIME:
return "PLUNGER_FADE_OUT_TIME";
case PLUNGER_BAND_MAX_LENGTH:
return "PLUNGER_BAND_MAX_LENGTH";
case PLUNGER_BAND_FORCE:
return "PLUNGER_BAND_FORCE";
case PLUNGER_BAND_DURATION:
return "PLUNGER_BAND_DURATION";
case PLUNGER_BAND_SPEED_INCREASE:
return "PLUNGER_BAND_SPEED_INCREASE";
case PLUNGER_BAND_FADE_OUT_TIME:
return "PLUNGER_BAND_FADE_OUT_TIME";
case PLUNGER_IN_FACE_TIME:
return "PLUNGER_IN_FACE_TIME";
case STARTUP_TIME:
@ -438,9 +438,9 @@ float AbstractCharacteristic::getSuspensionTravelCm() const
return result;
}
float AbstractCharacteristic::getSuspensionExpSpringResponse() const
bool AbstractCharacteristic::getSuspensionExpSpringResponse() const
{
float result;
bool result;
bool is_set = false;
process(SUSPENSION_EXP_SPRING_RESPONSE, &result, &is_set);
if (!is_set)
@ -898,13 +898,13 @@ float AbstractCharacteristic::getZipperSpeedGain() const
return result;
}
float AbstractCharacteristic::getZipperSpeedIncrease() const
float AbstractCharacteristic::getZipperMaxSpeedIncrease() const
{
float result;
bool is_set = false;
process(ZIPPER_SPEED_INCREASE, &result, &is_set);
process(ZIPPER_MAX_SPEED_INCREASE, &result, &is_set);
if (!is_set)
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(ZIPPER_SPEED_INCREASE).c_str());
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(ZIPPER_MAX_SPEED_INCREASE).c_str());
return result;
}
@ -958,53 +958,53 @@ float AbstractCharacteristic::getSwatterSquashSlowdown() const
return result;
}
float AbstractCharacteristic::getPlungerMaxLength() const
float AbstractCharacteristic::getPlungerBandMaxLength() const
{
float result;
bool is_set = false;
process(PLUNGER_MAX_LENGTH, &result, &is_set);
process(PLUNGER_BAND_MAX_LENGTH, &result, &is_set);
if (!is_set)
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(PLUNGER_MAX_LENGTH).c_str());
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(PLUNGER_BAND_MAX_LENGTH).c_str());
return result;
}
float AbstractCharacteristic::getPlungerForce() const
float AbstractCharacteristic::getPlungerBandForce() const
{
float result;
bool is_set = false;
process(PLUNGER_FORCE, &result, &is_set);
process(PLUNGER_BAND_FORCE, &result, &is_set);
if (!is_set)
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(PLUNGER_FORCE).c_str());
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(PLUNGER_BAND_FORCE).c_str());
return result;
}
float AbstractCharacteristic::getPlungerDuration() const
float AbstractCharacteristic::getPlungerBandDuration() const
{
float result;
bool is_set = false;
process(PLUNGER_DURATION, &result, &is_set);
process(PLUNGER_BAND_DURATION, &result, &is_set);
if (!is_set)
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(PLUNGER_DURATION).c_str());
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(PLUNGER_BAND_DURATION).c_str());
return result;
}
float AbstractCharacteristic::getPlungerSpeedIncrease() const
float AbstractCharacteristic::getPlungerBandSpeedIncrease() const
{
float result;
bool is_set = false;
process(PLUNGER_SPEED_INCREASE, &result, &is_set);
process(PLUNGER_BAND_SPEED_INCREASE, &result, &is_set);
if (!is_set)
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(PLUNGER_SPEED_INCREASE).c_str());
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(PLUNGER_BAND_SPEED_INCREASE).c_str());
return result;
}
float AbstractCharacteristic::getPlungerFadeOutTime() const
float AbstractCharacteristic::getPlungerBandFadeOutTime() const
{
float result;
bool is_set = false;
process(PLUNGER_FADE_OUT_TIME, &result, &is_set);
process(PLUNGER_BAND_FADE_OUT_TIME, &result, &is_set);
if (!is_set)
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(PLUNGER_FADE_OUT_TIME).c_str());
Log::fatal("AbstractCharacteristic", "Can't get characteristic %s", getName(PLUNGER_BAND_FADE_OUT_TIME).c_str());
return result;
}

31
src/karts/abstract_characteristic.hpp
View File

@ -46,10 +46,12 @@ public:
union Value
{
float *f;
bool *b;
std::vector<float> *fv;
InterpolationArray *ia;
Value(float *f) : f(f) {}
Value(bool *b) : b(b) {}
Value(std::vector<float> *fv) : fv(fv) {}
Value(InterpolationArray *ia) : ia(ia) {}
};
@ -57,6 +59,7 @@ public:
enum ValueType
{
TYPE_FLOAT,
TYPE_BOOL,
TYPE_FLOAT_VECTOR,
TYPE_INTERPOLATION_ARRAY
};
@ -81,8 +84,8 @@ public:
// Turn
TURN_RADIUS,
TURN_TIME_FULL_STEER,
TURN_TIME_RESET_STEER,
TURN_TIME_FULL_STEER,
// Engine
ENGINE_POWER,
@ -140,7 +143,7 @@ public:
ZIPPER_DURATION,
ZIPPER_FORCE,
ZIPPER_SPEED_GAIN,
ZIPPER_SPEED_INCREASE,
ZIPPER_MAX_SPEED_INCREASE,
ZIPPER_FADE_OUT_TIME,
// Swatter
@ -150,11 +153,11 @@ public:
SWATTER_SQUASH_SLOWDOWN,
// Plunger
PLUNGER_MAX_LENGTH,
PLUNGER_FORCE,
PLUNGER_DURATION,
PLUNGER_SPEED_INCREASE,
PLUNGER_FADE_OUT_TIME,
PLUNGER_BAND_MAX_LENGTH,
PLUNGER_BAND_FORCE,
PLUNGER_BAND_DURATION,
PLUNGER_BAND_SPEED_INCREASE,
PLUNGER_BAND_FADE_OUT_TIME,
PLUNGER_IN_FACE_TIME,
// Startup
@ -229,7 +232,7 @@ public:
float getSuspensionStiffness() const;
float getSuspensionRest() const;
float getSuspensionTravelCm() const;
float getSuspensionExpSpringResponse() const;
bool getSuspensionExpSpringResponse() const;
float getSuspensionMaxForce() const;
float getStabilityRollInfluence() const;
@ -288,7 +291,7 @@ public:
float getZipperDuration() const;
float getZipperForce() const;
float getZipperSpeedGain() const;
float getZipperSpeedIncrease() const;
float getZipperMaxSpeedIncrease() const;
float getZipperFadeOutTime() const;
float getSwatterDuration() const;
@ -296,11 +299,11 @@ public:
float getSwatterSquashDuration() const;
float getSwatterSquashSlowdown() const;
float getPlungerMaxLength() const;
float getPlungerForce() const;
float getPlungerDuration() const;
float getPlungerSpeedIncrease() const;
float getPlungerFadeOutTime() const;
float getPlungerBandMaxLength() const;
float getPlungerBandForce() const;
float getPlungerBandDuration() const;
float getPlungerBandSpeedIncrease() const;
float getPlungerBandFadeOutTime() const;
float getPlungerInFaceTime() const;
std::vector<float> getStartupTime() const;

3
src/karts/cannon_animation.cpp
View File

@ -21,6 +21,7 @@
#include "animations/animation_base.hpp"
#include "animations/ipo.hpp"
#include "animations/three_d_animation.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/kart_properties.hpp"
#include "modes/world.hpp"
@ -69,7 +70,7 @@ CannonAnimation::~CannonAnimation()
m_kart->getHeading() ));
m_kart->getBody()->setCenterOfMassTransform(pos);
Vec3 v(0, 0, m_kart->getKartProperties()->getMaxSpeed());
Vec3 v(0, 0, m_kart->getCharacteristic()->getEngineMaxSpeed());
m_kart->setVelocity(pos.getBasis()*v);
} // ~CannonAnimation

3
src/karts/controller/network_player_controller.cpp
View File

@ -7,6 +7,7 @@
#include "items/attachment.hpp"
#include "items/item.hpp"
#include "items/powerup.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/kart_properties.hpp"
#include "karts/skidding.hpp"
@ -197,7 +198,7 @@ void NetworkPlayerController::steer(float dt, int steer_val)
// change speed is used.
const float STEER_CHANGE = ( (steer_val<=0 && m_controls->m_steer<0) ||
(steer_val>=0 && m_controls->m_steer>0) )
? dt/m_kart->getKartProperties()->getTimeResetSteer()
? dt/m_kart->getCharacteristic()->getTurnTimeResetSteer()
: dt/m_kart->getTimeFullSteer(fabsf(m_controls->m_steer));
if (steer_val < 0)
{

7
src/karts/controller/player_controller.cpp
View File

@ -29,6 +29,7 @@
#include "items/attachment.hpp"
#include "items/item.hpp"
#include "items/powerup.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/kart_properties.hpp"
#include "karts/skidding.hpp"
@ -254,7 +255,7 @@ void PlayerController::steer(float dt, int steer_val)
// change speed is used.
const float STEER_CHANGE = ( (steer_val<=0 && m_controls->m_steer<0) ||
(steer_val>=0 && m_controls->m_steer>0) )
? dt/m_kart->getKartProperties()->getTimeResetSteer()
? dt/m_kart->getCharacteristic()->getTurnTimeResetSteer()
: dt/m_kart->getTimeFullSteer(fabsf(m_controls->m_steer));
if (steer_val < 0)
{
@ -464,8 +465,8 @@ void PlayerController::handleZipper(bool play_sound)
*/
void PlayerController::collectedItem(const Item &item, int add_info, float old_energy)
{
if (old_energy < m_kart->getKartProperties()->getNitroMax() &&
m_kart->getEnergy() == m_kart->getKartProperties()->getNitroMax())
if (old_energy < m_kart->getCharacteristic()->getNitroMax() &&
m_kart->getEnergy() == m_kart->getCharacteristic()->getNitroMax())
{
m_full_sound->play();
}

13
src/karts/controller/skidding_ai.cpp
View File

@ -45,6 +45,7 @@
#include "items/item_manager.hpp"
#include "items/powerup.hpp"
#include "items/projectile_manager.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/kart_control.hpp"
#include "karts/controller/ai_properties.hpp"
@ -1065,8 +1066,8 @@ void SkiddingAI::evaluateItems(const Item *item, float kart_aim_angle,
case Item::ITEM_NITRO_BIG:
// Only collect nitro, if it can actually be stored.
if(m_kart->getEnergy() +
m_kart->getKartProperties()->getNitroBigContainer()
> m_kart->getKartProperties()->getNitroMax())
m_kart->getCharacteristic()->getNitroBigContainer()
> m_kart->getCharacteristic()->getNitroMax())
return;
// fall through: if we have enough space to store a big
// container, we can also store a small container, and
@ -1074,8 +1075,8 @@ void SkiddingAI::evaluateItems(const Item *item, float kart_aim_angle,
case Item::ITEM_NITRO_SMALL: avoid = false;
// Only collect nitro, if it can actually be stored.
if (m_kart->getEnergy() +
m_kart->getKartProperties()->getNitroSmallContainer()
> m_kart->getKartProperties()->getNitroMax())
m_kart->getCharacteristic()->getNitroSmallContainer()
> m_kart->getCharacteristic()->getNitroMax())
return;
case Item::ITEM_BONUS_BOX:
break;
@ -1105,7 +1106,7 @@ void SkiddingAI::evaluateItems(const Item *item, float kart_aim_angle,
// be if the kart would need to turn sharper, therefore stops
// skidding, and will get the bonus speed.
bool high_speed = (m_kart->getCurrentMaxSpeed() >
m_kart->getKartProperties()->getMaxSpeed() ) ||
m_kart->getCharacteristic()->getEngineMaxSpeed() ) ||
m_kart->getSkidding()->getSkidBonusReady();
float max_angle = high_speed
? m_ai_properties->m_max_item_angle_high_speed
@ -1390,7 +1391,7 @@ void SkiddingAI::handleItems(const float dt)
case PowerupManager::POWERUP_SWATTER:
{
// Squared distance for which the swatter works
float d2 = m_kart->getKartProperties()->getSwatterDistance2();
float d2 = m_kart->getCharacteristic()->getSwatterDistance();
// if the kart has a shield, do not break it by using a swatter.
if(m_kart->getShieldTime() > min_bubble_time)
break;

7
src/karts/explosion_animation.cpp
View File

@ -22,6 +22,7 @@
#include "graphics/callbacks.hpp"
#include "graphics/camera.hpp"
#include "items/attachment.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/kart_properties.hpp"
#include "modes/world.hpp"
@ -40,7 +41,7 @@ ExplosionAnimation *ExplosionAnimation::create(AbstractKart *kart,
{
if(kart->isInvulnerable()) return NULL;
float r = kart->getKartProperties()->getExplosionRadius();
float r = kart->getCharacteristic()->getExplosionRadius();
// Ignore explosion that are too far away.
if(!direct_hit && pos.distance2(kart->getXYZ())>r*r) return NULL;
@ -78,7 +79,7 @@ ExplosionAnimation::ExplosionAnimation(AbstractKart *kart,
m_xyz = m_kart->getXYZ();
m_orig_y = m_xyz.getY();
m_kart->playCustomSFX(SFXManager::CUSTOM_EXPLODE);
m_timer = m_kart->getKartProperties()->getExplosionTime();
m_timer = m_kart->getCharacteristic()->getExplosionDuration();
// Non-direct hits will be only affected half as much.
if(!direct_hit) m_timer*=0.5f;
@ -105,7 +106,7 @@ ExplosionAnimation::ExplosionAnimation(AbstractKart *kart,
m_add_rotation.setRoll( (rand()%(2*max_rotation+1)-max_rotation)*f );
// Set invulnerable time, and graphical effects
float t = m_kart->getKartProperties()->getExplosionInvulnerabilityTime();
float t = m_kart->getCharacteristic()->getExplosionInvulnerabilityTime();
m_kart->setInvulnerableTime(t);
if ( UserConfigParams::m_graphical_effects )
{

150
src/karts/kart.cpp
View File

@ -39,6 +39,7 @@
#include "graphics/stars.hpp"
#include "guiengine/scalable_font.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/combined_characteristic.hpp"
#include "karts/explosion_animation.hpp"
#include "karts/kart_gfx.hpp"
#include "karts/rescue_animation.hpp"
@ -363,8 +364,8 @@ void Kart::reset()
// In case that the kart was in the air, in which case its
// linear damping is 0
if(m_body)
m_body->setDamping(m_kart_properties->getChassisLinearDamping(),
m_kart_properties->getChassisAngularDamping() );
m_body->setDamping(m_characteristic->getStabilityChassisLinearDamping(),
m_characteristic->getStabilityChassisAngularDamping() );
if(m_terrain_sound)
{
@ -537,7 +538,7 @@ void Kart::blockViewWithPlunger()
{
// Avoid that a plunger extends the plunger time
if(m_view_blocked_by_plunger<=0 && !isShielded())
m_view_blocked_by_plunger = m_kart_properties->getPlungerInFaceTime();
m_view_blocked_by_plunger = m_characteristic->getPlungerInFaceTime();
if(isShielded())
{
decreaseShieldTime();
@ -568,6 +569,12 @@ btTransform Kart::getAlignedTransform(const float custom_pitch)
return trans;
} // getAlignedTransform
// ----------------------------------------------------------------------------
float Kart::getTimeFullSteer(float steer) const
{
return m_characteristic->getTurnTimeFullSteer().get(steer);
} // getTimeFullSteer
// ----------------------------------------------------------------------------
/** Creates the physical representation of this kart. Atm it uses the actual
* extention of the kart model to determine the size of the collision body.
@ -618,7 +625,7 @@ void Kart::createPhysics()
// All wheel positions are relative to the center of
// the collision shape.
wheel_pos[index].setX(x*0.5f*kart_width);
float radius = getKartProperties()->getWheelRadius();
float radius = m_characteristic->getWheelsRadius();
// The y position of the wheels (i.e. the points where
// the suspension is attached to) is just at the
// bottom of the kart. That is half the kart height
@ -653,7 +660,7 @@ void Kart::createPhysics()
// Set mass and inertia
// --------------------
float mass = m_kart_properties->getMass();
float mass = m_characteristic->getMass();
// Position the chassis
// --------------------
@ -662,8 +669,8 @@ void Kart::createPhysics()
createBody(mass, trans, &m_kart_chassis,
m_kart_properties->getRestitution());
m_user_pointer.set(this);
m_body->setDamping(m_kart_properties->getChassisLinearDamping(),
m_kart_properties->getChassisAngularDamping() );
m_body->setDamping(m_characteristic->getStabilityChassisLinearDamping(),
m_characteristic->getStabilityChassisAngularDamping() );
// Reset velocities
// ----------------
@ -683,17 +690,17 @@ void Kart::createPhysics()
// Add wheels
// ----------
float wheel_radius = m_kart_properties->getWheelRadius();
float suspension_rest = m_kart_properties->getSuspensionRest();
float wheel_radius = m_characteristic->getWheelsRadius();
float suspension_rest = m_characteristic->getSuspensionRest();
btVector3 wheel_direction(0.0f, -1.0f, 0.0f);
btVector3 wheel_axle(-1.0f, 0.0f, 0.0f);
btKart::btVehicleTuning tuning;
tuning.m_maxSuspensionTravelCm =
m_kart_properties->getSuspensionTravelCM();
m_characteristic->getSuspensionTravelCm();
tuning.m_maxSuspensionForce =
m_kart_properties->getMaxSuspensionForce();
m_characteristic->getSuspensionMaxForce();
const Vec3 &cs = getKartProperties()->getGravityCenterShift();
for(unsigned int i=0; i<4; i++)
@ -703,11 +710,11 @@ void Kart::createPhysics()
wheel_pos[i]+cs,
wheel_direction, wheel_axle, suspension_rest,
wheel_radius, tuning, is_front_wheel);
wheel.m_suspensionStiffness = m_kart_properties->getSuspensionStiffness();
wheel.m_wheelsDampingRelaxation = m_kart_properties->getWheelDampingRelaxation();
wheel.m_wheelsDampingCompression = m_kart_properties->getWheelDampingCompression();
wheel.m_suspensionStiffness = m_characteristic->getSuspensionStiffness();
wheel.m_wheelsDampingRelaxation = m_characteristic->getWheelsDampingRelaxation();
wheel.m_wheelsDampingCompression = m_characteristic->getWheelsDampingCompression();
wheel.m_frictionSlip = m_kart_properties->getFrictionSlip();
wheel.m_rollInfluence = m_kart_properties->getRollInfluence();
wheel.m_rollInfluence = m_characteristic->getStabilityRollInfluence();
}
// Obviously these allocs have to be properly managed/freed
btTransform t;
@ -793,7 +800,7 @@ void Kart::adjustSpeed(float f)
*/
void Kart::updateWeight()
{
float mass = m_kart_properties->getMass() + m_attachment->weightAdjust();
float mass = m_characteristic->getMass() + m_attachment->weightAdjust();
btVector3 inertia;
m_kart_chassis.calculateLocalInertia(mass, inertia);
@ -907,10 +914,10 @@ void Kart::collectedItem(Item *item, int add_info)
m_attachment->hitBanana(item, add_info);
break;
case Item::ITEM_NITRO_SMALL:
m_collected_energy += m_kart_properties->getNitroSmallContainer();
m_collected_energy += m_characteristic->getNitroSmallContainer();
break;
case Item::ITEM_NITRO_BIG:
m_collected_energy += m_kart_properties->getNitroBigContainer();
m_collected_energy += m_characteristic->getNitroBigContainer();
break;
case Item::ITEM_BONUS_BOX :
{
@ -922,13 +929,13 @@ void Kart::collectedItem(Item *item, int add_info)
item->getEmitter()->getIdent() == "nolok");
// slow down
m_bubblegum_time = m_kart_properties->getBubblegumTime();
m_bubblegum_time = m_characteristic->getBubblegumDuration();
m_bubblegum_torque = ((rand()%2)
? m_kart_properties->getBubblegumTorque()
: -m_kart_properties->getBubblegumTorque());
? m_characteristic->getBubblegumTorque()
: -m_characteristic->getBubblegumTorque());
m_max_speed->setSlowdown(MaxSpeed::MS_DECREASE_BUBBLE,
m_kart_properties->getBubblegumSpeedFraction() ,
m_kart_properties->getBubblegumFadeInTime(),
m_characteristic->getBubblegumSpeedFraction() ,
m_characteristic->getBubblegumFadeInTime(),
m_bubblegum_time);
m_goo_sound->setPosition(getXYZ());
m_goo_sound->play();
@ -938,12 +945,31 @@ void Kart::collectedItem(Item *item, int add_info)
default : break;
} // switch TYPE
if ( m_collected_energy > m_kart_properties->getNitroMax())
m_collected_energy = m_kart_properties->getNitroMax();
if ( m_collected_energy > m_characteristic->getNitroMax())
m_collected_energy = m_characteristic->getNitroMax();
m_controller->collectedItem(*item, add_info, old_energy);
} // collectedItem
//-----------------------------------------------------------------------------
/** Called the first time a kart accelerates after 'ready-set-go'. It searches
* through the startup times to find the appropriate slot, and returns the
* speed-boost from the corresponding entry.
* If the kart started too slow (i.e. slower than the longest time in the
* startup times list), it returns 0.
*/
float Kart::getStartupBoost() const
{
float t = World::getWorld()->getTime();
std::vector<float> startup_times = m_characteristic->getStartupTime();
for (unsigned int i = 0; i < startup_times.size(); i++)
{
if (t <= startup_times[i])
return m_characteristic->getStartupBoost()[i];
}
return 0;
} // getStartupBoost
//-----------------------------------------------------------------------------
/** Simulates gears by adjusting the force of the engine. It also takes the
* effect of the zipper into account.
@ -952,20 +978,20 @@ float Kart::getActualWheelForce()
{
float add_force = m_max_speed->getCurrentAdditionalEngineForce();
assert(!isnan(add_force));
const std::vector<float>& gear_ratio=m_kart_properties->getGearSwitchRatio();
const std::vector<float>& gear_ratio=m_characteristic->getGearSwitchRatio();
for(unsigned int i=0; i<gear_ratio.size(); i++)
{
if(m_speed <= m_kart_properties->getMaxSpeed() * gear_ratio[i])
if(m_speed <= m_characteristic->getEngineMaxSpeed() * gear_ratio[i])
{
assert(!isnan(m_kart_properties->getMaxPower()));
assert(!isnan(m_kart_properties->getGearPowerIncrease()[i]));
return m_kart_properties->getMaxPower()
* m_kart_properties->getGearPowerIncrease()[i]
assert(!isnan(m_characteristic->getEnginePower()));
assert(!isnan(m_characteristic->getGearPowerIncrease()[i]));
return m_characteristic->getEnginePower()
* m_characteristic->getGearPowerIncrease()[i]
+ add_force;
}
}
assert(!isnan(m_kart_properties->getMaxPower()));
return m_kart_properties->getMaxPower() + add_force * 2;
assert(!isnan(m_characteristic->getEnginePower()));
return m_characteristic->getEnginePower() + add_force * 2;
} // getActualWheelForce
@ -1165,16 +1191,16 @@ void Kart::update(float dt)
// When the kart is jumping, linear damping reduces the falling speed
// of a kart so much that it can appear to be in slow motion. So
// disable linear damping if a kart is in the air
m_body->setDamping(0, m_kart_properties->getChassisAngularDamping());
m_body->setDamping(0, m_characteristic->getStabilityChassisAngularDamping());
}
else
{
m_body->setDamping(m_kart_properties->getChassisLinearDamping(),
m_kart_properties->getChassisAngularDamping());
m_body->setDamping(m_characteristic->getStabilityChassisLinearDamping(),
m_characteristic->getStabilityChassisAngularDamping());
}
//m_wheel_rotation gives the rotation around the X-axis
m_wheel_rotation_dt = m_speed*dt / m_kart_properties->getWheelRadius();
m_wheel_rotation_dt = m_speed*dt / m_characteristic->getWheelsRadius();
m_wheel_rotation += m_wheel_rotation_dt;
m_wheel_rotation = fmodf(m_wheel_rotation, 2*M_PI);
@ -1363,7 +1389,7 @@ void Kart::update(float dt)
// Jump if either the jump is estimated to be long enough, or
// the texture has the jump property set.
if (t > getKartProperties()->getJumpAnimationTime() ||
if (t > m_characteristic->getJumpAnimationTime() ||
last_m->isJumpTexture())
{
m_kart_model->setAnimation(KartModel::AF_JUMP_START);
@ -1669,23 +1695,23 @@ void Kart::handleZipper(const Material *material, bool play_sound)
material->getZipperParameter(&max_speed_increase, &duration,
&speed_gain, &fade_out_time, &engine_force);
if(max_speed_increase<0)
max_speed_increase = m_kart_properties->getZipperMaxSpeedIncrease();
max_speed_increase = m_characteristic->getZipperMaxSpeedIncrease();
if(duration<0)
duration = m_kart_properties->getZipperTime();
duration = m_characteristic->getZipperDuration();
if(speed_gain<0)
speed_gain = m_kart_properties->getZipperSpeedGain();
speed_gain = m_characteristic->getZipperSpeedGain();
if(fade_out_time<0)
fade_out_time = m_kart_properties->getZipperFadeOutTime();
fade_out_time = m_characteristic->getZipperFadeOutTime();
if(engine_force<0)
engine_force = m_kart_properties->getZipperForce();
engine_force = m_characteristic->getZipperForce();
}
else
{
max_speed_increase = m_kart_properties->getZipperMaxSpeedIncrease();
duration = m_kart_properties->getZipperTime();
speed_gain = m_kart_properties->getZipperSpeedGain();
fade_out_time = m_kart_properties->getZipperFadeOutTime();
engine_force = m_kart_properties->getZipperForce();
max_speed_increase = m_characteristic->getZipperMaxSpeedIncrease();
duration = m_characteristic->getZipperDuration();
speed_gain = m_characteristic->getZipperSpeedGain();
fade_out_time = m_characteristic->getZipperFadeOutTime();
engine_force = m_characteristic->getZipperForce();
}
// Ignore a zipper that's activated while braking
if(m_controls.m_brake || m_speed<0) return;
@ -1723,7 +1749,7 @@ void Kart::updateNitro(float dt)
{
return;
}
m_collected_energy -= dt * m_kart_properties->getNitroConsumption();
m_collected_energy -= dt * m_characteristic->getNitroConsumption();
if (m_collected_energy < 0)
{
m_collected_energy = 0;
@ -1733,10 +1759,10 @@ void Kart::updateNitro(float dt)
if (increase_speed)
{
m_max_speed->increaseMaxSpeed(MaxSpeed::MS_INCREASE_NITRO,
m_kart_properties->getNitroMaxSpeedIncrease(),
getCharacteristic()->getNitroEngineForce(),
m_kart_properties->getNitroDuration(),
m_kart_properties->getNitroFadeOutTime());
m_characteristic->getNitroMaxSpeedIncrease(),
m_characteristic->getNitroEngineForce(),
m_characteristic->getNitroDuration(),
m_characteristic->getNitroFadeOutTime());
}
} // updateNitro
@ -2041,7 +2067,7 @@ void Kart::updatePhysics(float dt)
if(!m_has_started && m_controls.m_accel)
{
m_has_started = true;
float f = m_kart_properties->getStartupBoost();
float f = getStartupBoost();
m_max_speed->instantSpeedIncrease(MaxSpeed::MS_INCREASE_ZIPPER,
0.9f*f, f,
/*engine_force*/200.0f,
@ -2109,11 +2135,11 @@ void Kart::updatePhysics(float dt)
// Only apply if near ground instead of purely based on speed avoiding
// the "parachute on top" look.
const Vec3 &v = m_body->getLinearVelocity();
if(/*isNearGround() &&*/ v.getY() < - m_kart_properties->getSuspensionTravelCM()*0.01f*60)
if(/*isNearGround() &&*/ v.getY() < - m_characteristic->getSuspensionTravelCm()*0.01f*60)
{
Vec3 v_clamped = v;
// clamp the speed to 99% of the maxium falling speed.
v_clamped.setY(-m_kart_properties->getSuspensionTravelCM()*0.01f*60 * 0.99f);
v_clamped.setY(-m_characteristic->getSuspensionTravelCm()*0.01f*60 * 0.99f);
//m_body->setLinearVelocity(v_clamped);
}
@ -2239,8 +2265,8 @@ void Kart::updateEnginePowerAndBrakes(float dt)
m_brake_time += dt;
// Apply the brakes - include the time dependent brake increase
float f = 1 + m_brake_time
* m_kart_properties->getBrakeTimeIncrease();
m_vehicle->setAllBrakes(m_kart_properties->getBrakeFactor() * f);
* m_characteristic->getEngineBrakeTimeIncrease();
m_vehicle->setAllBrakes(m_characteristic->getEngineBrakeFactor() * f);
}
else // m_speed < 0
{
@ -2248,7 +2274,7 @@ void Kart::updateEnginePowerAndBrakes(float dt)
// going backward, apply reverse gear ratio (unless he goes
// too fast backwards)
if ( -m_speed < m_max_speed->getCurrentMaxSpeed()
*m_kart_properties->getMaxSpeedReverseRatio())
*m_characteristic->getEngineMaxSpeedReverseRatio())
{
// The backwards acceleration is artificially increased to
// allow players to get "unstuck" quicker if they hit e.g.
@ -2509,7 +2535,7 @@ void Kart::updateGraphics(float dt, const Vec3& offset_xyz,
{
// fabs(speed) is important, otherwise the negative number will
// become a huge unsigned number in the particle scene node!
nitro_frac = fabsf(getSpeed())/(m_kart_properties->getMaxSpeed());
nitro_frac = fabsf(getSpeed()) / (m_characteristic->getEngineMaxSpeed());
// The speed of the kart can be higher (due to powerups) than
// the normal maximum speed of the kart.
if(nitro_frac>1.0f) nitro_frac = 1.0f;
@ -2524,7 +2550,7 @@ void Kart::updateGraphics(float dt, const Vec3& offset_xyz,
// leaning might get less if a kart gets a special that increases
// its maximum speed, but not the current speed (by much). On the
// other hand, that ratio can often be greater than 1.
float speed_frac = m_speed / m_kart_properties->getMaxSpeed();
float speed_frac = m_speed / m_characteristic->getEngineMaxSpeed();
if(speed_frac>1.0f)
speed_frac = 1.0f;
else if (speed_frac < 0.0f) // no leaning when backwards driving
@ -2580,7 +2606,7 @@ void Kart::updateGraphics(float dt, const Vec3& offset_xyz,
float lean_height = tan(fabsf(m_current_lean)) * getKartWidth()*0.5f;
float heading = m_skidding->getVisualSkidRotation();
float xx = fabsf(m_speed)* getKartProperties()->getDownwardImpulseFactor()*0.0006f;
float xx = fabsf(m_speed) * m_characteristic->getStabilityDownwardImpulseFactor() * 0.0006f;
Vec3 center_shift = Vec3(0, m_skidding->getGraphicalJumpOffset()
+ lean_height +m_graphical_y_offset+xx, 0);

7
src/karts/kart.hpp
View File

@ -259,6 +259,8 @@ public:
float fade_in_time);
virtual float getSpeedIncreaseTimeLeft(unsigned int category) const;
virtual void collectedItem(Item *item, int random_attachment);
virtual float getStartupBoost() const;
virtual const Material *getMaterial() const;
virtual const Material *getLastMaterial() const;
/** Returns the pitch of the terrain depending on the heading. */
@ -339,10 +341,7 @@ public:
/** Returns the time till full steering is reached for this kart.
* \param steer Current steer value (must be >=0), on which the time till
* full steer depends. */
virtual float getTimeFullSteer(float steer) const
{
return m_kart_properties->getTimeFullSteer(steer);
} // getTimeFullSteer
virtual float getTimeFullSteer(float steer) const;
// ------------------------------------------------------------------------
/** Returns the maximum steering angle for this kart, which depends on the
* speed. */

3
src/karts/kart_gfx.cpp
View File

@ -24,6 +24,7 @@
#include "graphics/particle_emitter.hpp"
#include "graphics/particle_kind.hpp"
#include "graphics/particle_kind_manager.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/controller.hpp"
#include "karts/kart.hpp"
@ -321,7 +322,7 @@ void KartGFX::updateTerrain(const ParticleKind *pk)
if (skidding > 1.0f && on_ground)
rate = fabsf(m_kart->getControls().m_steer) > 0.8 ? skidding - 1 : 0;
else if (speed >= 0.5f && on_ground)
rate = speed/m_kart->getKartProperties()->getMaxSpeed();
rate = speed/m_kart->getCharacteristic()->getEngineMaxSpeed();
else
{
pe->setCreationRateAbsolute(0);

387
src/karts/kart_properties.cpp
View File

@ -73,53 +73,21 @@ KartProperties::KartProperties(const std::string &filename)
m_shadow_x_offset = 0.0f;
m_shadow_z_offset = 0.0f;
m_characteristic = NULL;
m_combined_characteristic = NULL;
m_groups.clear();
m_custom_sfx_id.resize(SFXManager::NUM_CUSTOMS);
// Set all other values to undefined, so that it can later be tested
// if everything is defined properly.
m_mass = m_brake_factor = m_brake_time_increase =
m_time_reset_steer = m_nitro_consumption = m_nitro_engine_force =
m_nitro_small_container = m_nitro_big_container = m_nitro_max =
m_nitro_max_speed_increase = m_nitro_duration = m_nitro_fade_out_time =
m_suspension_stiffness = m_wheel_damping_relaxation = m_wheel_base =
m_wheel_damping_compression = m_friction_slip = m_roll_influence =
m_wheel_radius = m_chassis_linear_damping = m_max_suspension_force =
m_chassis_angular_damping = m_suspension_rest =
m_max_speed_reverse_ratio = m_rescue_vert_offset =
m_collision_terrain_impulse = m_collision_impulse = m_restitution =
m_collision_impulse_time = m_suspension_travel_cm =
m_track_connection_accel = m_rubber_band_max_length =
m_rubber_band_force = m_rubber_band_duration =
m_rubber_band_speed_increase = m_rubber_band_fade_out_time =
m_zipper_time = m_zipper_force = m_zipper_speed_gain =
m_zipper_max_speed_increase = m_zipper_fade_out_time =
m_slipstream_length = m_slipstream_width = m_slipstream_collect_time =
m_slipstream_use_time = m_slipstream_add_power =
m_slipstream_min_speed = m_slipstream_max_speed_increase =
m_slipstream_duration = m_slipstream_fade_out_time =
m_camera_distance = m_camera_forward_up_angle =
m_camera_backward_up_angle = m_explosion_invulnerability_time =
m_rescue_time = m_rescue_height = m_explosion_time =
m_explosion_radius = m_max_lean = m_lean_speed =
m_swatter_distance2 = m_swatter_duration = m_squash_slowdown =
m_squash_duration = m_downward_impulse_factor =
m_bubblegum_fade_in_time = m_bubblegum_speed_fraction =
m_bubblegum_time = m_bubblegum_torque = m_jump_animation_time =
m_smooth_flying_impulse = m_physical_wheel_position =
m_graphical_y_offset =
UNDEFINED;
m_engine_power.resize(RaceManager::DIFFICULTY_COUNT, UNDEFINED);
m_max_speed.resize(RaceManager::DIFFICULTY_COUNT, UNDEFINED);
m_plunger_in_face_duration.resize(RaceManager::DIFFICULTY_COUNT,
UNDEFINED);
m_wheel_base = m_friction_slip = m_collision_terrain_impulse =
m_collision_impulse = m_restitution = m_collision_impulse_time =
m_max_lean = m_lean_speed = m_physical_wheel_position =
m_graphical_y_offset = UNDEFINED;
m_terrain_impulse_type = IMPULSE_NONE;
m_gravity_center_shift = Vec3(UNDEFINED);
m_bevel_factor = Vec3(UNDEFINED);
m_exp_spring_response = false;
m_prevent_chassis_in_terrain = false;
m_version = 0;
m_color = video::SColor(255, 0, 0, 0);
@ -153,6 +121,8 @@ KartProperties::~KartProperties()
delete m_skidding_properties;
if (m_characteristic)
delete m_characteristic;
if (m_combined_characteristic)
delete m_combined_characteristic;
for(unsigned int i=0; i<RaceManager::DIFFICULTY_COUNT; i++)
if(m_ai_properties[i])
delete m_ai_properties[i];
@ -180,6 +150,9 @@ void KartProperties::copyFrom(const KartProperties *source)
m_characteristic = new XmlCharacteristic();
assert(m_characteristic);
*m_characteristic = *source->m_characteristic;
// Combine the characteristics for this object. We can't copy it because
// this object has other pointers (to m_characteristic).
combineCharacteristics();
}
for(unsigned int i=0; i<RaceManager::DIFFICULTY_COUNT; i++)
@ -243,6 +216,7 @@ void KartProperties::load(const std::string &filename, const std::string &node)
}
getAllData(root);
m_characteristic = new XmlCharacteristic(root);
combineCharacteristics();
}
catch(std::exception& err)
{
@ -316,8 +290,9 @@ void KartProperties::load(const std::string &filename, const std::string &node)
// stable, the physical wheel position (i.e. location of raycast) were
// moved to be on the corner of the shape. In order to retain the same
// steering behaviour, the wheel base (which in turn determines the
// turn angle at certain speeds) is shortened by 2*wheel_radius
m_wheel_base = fabsf(m_kart_model->getLength() - 2*m_wheel_radius);
// turn angle at certain speeds) is shortened by 2 * wheel_radius
m_wheel_base = fabsf(m_kart_model->getLength() - 2 *
m_combined_characteristic->getWheelsRadius());
// Now convert the turn radius into turn angle:
for(unsigned int i=0; i<m_turn_angle_at_speed.size(); i++)
@ -334,6 +309,17 @@ void KartProperties::load(const std::string &filename, const std::string &node)
} // load
//-----------------------------------------------------------------------------
void KartProperties::combineCharacteristics()
{
if (m_combined_characteristic)
delete m_combined_characteristic;
m_combined_characteristic = new CombinedCharacteristic();
m_combined_characteristic->addCharacteristic(kart_properties_manager->
getBaseCharacteristic());
m_combined_characteristic->addCharacteristic(m_characteristic);
} // combineCharacteristics
//-----------------------------------------------------------------------------
/** Actually reads in the data from the xml file.
* \param root Root of the xml tree.
@ -378,22 +364,6 @@ void KartProperties::getAllData(const XMLNode * root)
m_ai_properties[RaceManager::DIFFICULTY_BEST]->load(best);
}
if(const XMLNode *suspension_node = root->getNode("suspension"))
{
suspension_node->get("stiffness", &m_suspension_stiffness);
suspension_node->get("rest", &m_suspension_rest );
suspension_node->get("travel-cm", &m_suspension_travel_cm);
suspension_node->get("exp-spring-response", &m_exp_spring_response );
suspension_node->get("max-force", &m_max_suspension_force);
}
if(const XMLNode *wheels_node = root->getNode("wheels"))
{
wheels_node->get("damping-relaxation", &m_wheel_damping_relaxation );
wheels_node->get("damping-compression", &m_wheel_damping_compression);
wheels_node->get("radius", &m_wheel_radius );
}
if(const XMLNode *speed_weighted_objects_node = root->getNode("speed-weighted-objects"))
{
m_speed_weighted_object_properties.loadFromXMLNode(speed_weighted_objects_node);
@ -402,21 +372,6 @@ void KartProperties::getAllData(const XMLNode * root)
if(const XMLNode *friction_node = root->getNode("friction"))
friction_node->get("slip", &m_friction_slip);
if(const XMLNode *stability_node = root->getNode("stability"))
{
stability_node->get("roll-influence",
&m_roll_influence );
stability_node->get("chassis-linear-damping",
&m_chassis_linear_damping );
stability_node->get("chassis-angular-damping",
&m_chassis_angular_damping);
stability_node->get("downward-impulse-factor",
&m_downward_impulse_factor);
stability_node->get("track-connection-accel",
&m_track_connection_accel );
stability_node->get("smooth-flying-impulse", &m_smooth_flying_impulse);
}
if(const XMLNode *collision_node = root->getNode("collision"))
{
collision_node->get("impulse", &m_collision_impulse );
@ -442,25 +397,18 @@ void KartProperties::getAllData(const XMLNode * root)
}
}
if(const XMLNode *turn_node = root->getNode("turn"))
{
turn_node->get("turn-radius", &m_turn_angle_at_speed );
// For now store the turn radius in turn angle, the correct
// value can only be determined later in ::load
}
//TODO: wheel front right and wheel front left is not loaded, yet is
//TODO: listed as an attribute in the xml file after wheel-radius
//TODO: same goes for their rear equivalents
if(const XMLNode *jump_node= root->getNode("jump"))
{
jump_node->get("animation-time", &m_jump_animation_time);
}
if(const XMLNode *camera_node= root->getNode("camera"))
{
camera_node->get("distance", &m_camera_distance);
camera_node->get("forward-up-angle", &m_camera_forward_up_angle);
m_camera_forward_up_angle *= DEGREE_TO_RAD;
camera_node->get("backward-up-angle", &m_camera_backward_up_angle);
m_camera_backward_up_angle *= DEGREE_TO_RAD;
}
if(const XMLNode *sounds_node= root->getNode("sounds"))
{
std::string s;
@ -506,138 +454,12 @@ void KartProperties::getAllData(const XMLNode * root)
#endif
} // if sounds-node exist
if(const XMLNode *nitro_node = root->getNode("nitro"))
{
nitro_node->get("consumption", &m_nitro_consumption );
nitro_node->get("small-container", &m_nitro_small_container );
nitro_node->get("big-container", &m_nitro_big_container );
nitro_node->get("max-speed-increase", &m_nitro_max_speed_increase);
nitro_node->get("engine-force", &m_nitro_engine_force );
nitro_node->get("duration", &m_nitro_duration );
nitro_node->get("fade-out-time", &m_nitro_fade_out_time );
nitro_node->get("max", &m_nitro_max );
nitro_node->get("min-consumption-time", &m_nitro_min_consumption );
}
if(const XMLNode *bubble_node = root->getNode("bubblegum"))
{
bubble_node->get("time", &m_bubblegum_time );
bubble_node->get("speed-fraction", &m_bubblegum_speed_fraction);
bubble_node->get("fade-in-time", &m_bubblegum_fade_in_time );
bubble_node->get("torque", &m_bubblegum_torque );
}
if(const XMLNode *rescue_node = root->getNode("rescue"))
{
rescue_node->get("vert-offset", &m_rescue_vert_offset);
rescue_node->get("time", &m_rescue_time );
rescue_node->get("height", &m_rescue_height );
}
if(const XMLNode *explosion_node = root->getNode("explosion"))
{
explosion_node->get("time", &m_explosion_time );
explosion_node->get("radius", &m_explosion_radius);
explosion_node->get("invulnerability-time",
&m_explosion_invulnerability_time);
}
if(const XMLNode *skid_node = root->getNode("skid"))
{
m_skidding_properties->load(skid_node);
}
if(const XMLNode *slipstream_node = root->getNode("slipstream"))
{
slipstream_node->get("length", &m_slipstream_length );
slipstream_node->get("width", &m_slipstream_width );
slipstream_node->get("collect-time", &m_slipstream_collect_time );
slipstream_node->get("use-time", &m_slipstream_use_time );
slipstream_node->get("add-power", &m_slipstream_add_power );
slipstream_node->get("min-speed", &m_slipstream_min_speed );
slipstream_node->get("max-speed-increase",
&m_slipstream_max_speed_increase);
slipstream_node->get("duration", &m_slipstream_duration );
slipstream_node->get("fade-out-time",&m_slipstream_fade_out_time );
}
if(const XMLNode *turn_node = root->getNode("turn"))
{
turn_node->get("time-full-steer", &m_time_full_steer );
turn_node->get("time-reset-steer", &m_time_reset_steer );
turn_node->get("turn-radius", &m_turn_angle_at_speed );
// For now store the turn radius in turn angle, the correct
// value can only be determined later in ::load
}
if(const XMLNode *engine_node = root->getNode("engine"))
{
engine_node->get("brake-factor", &m_brake_factor);
engine_node->get("brake-time-increase", &m_brake_time_increase);
engine_node->get("max-speed-reverse-ratio", &m_max_speed_reverse_ratio);
engine_node->get("power", &m_engine_power);
if(m_engine_power.size()!=RaceManager::DIFFICULTY_COUNT)
{
Log::fatal("[KartProperties]",
"Incorrect engine-power specifications for kart '%s'",
getIdent().c_str());
}
engine_node->get("max-speed", &m_max_speed);
if(m_max_speed.size()!=RaceManager::DIFFICULTY_COUNT)
{
Log::fatal("[KartProperties]",
"Incorrect max-speed specifications for kart '%s'",
getIdent().c_str());
}
} // if getNode("engine")
if(const XMLNode *gear_node = root->getNode("gear"))
{
gear_node->get("switch-ratio", &m_gear_switch_ratio );
gear_node->get("power-increase", &m_gear_power_increase);
}
if(const XMLNode *mass_node = root->getNode("mass"))
mass_node->get("value", &m_mass);
if(const XMLNode *plunger_node= root->getNode("plunger"))
{
plunger_node->get("band-max-length", &m_rubber_band_max_length );
plunger_node->get("band-force", &m_rubber_band_force );
plunger_node->get("band-duration", &m_rubber_band_duration );
plunger_node->get("band-speed-increase",&m_rubber_band_speed_increase);
plunger_node->get("band-fade-out-time", &m_rubber_band_fade_out_time );
plunger_node->get("in-face-time", &m_plunger_in_face_duration);
if(m_plunger_in_face_duration.size()!=RaceManager::DIFFICULTY_COUNT)
{
Log::fatal("KartProperties",
"Invalid plunger in-face-time specification.");
}
}
if(const XMLNode *zipper_node= root->getNode("zipper"))
{
zipper_node->get("time", &m_zipper_time );
zipper_node->get("fade-out-time", &m_zipper_fade_out_time );
zipper_node->get("force", &m_zipper_force );
zipper_node->get("speed-gain", &m_zipper_speed_gain );
zipper_node->get("max-speed-increase", &m_zipper_max_speed_increase);
}
if(const XMLNode *swatter_node= root->getNode("swatter"))
{
swatter_node->get("duration", &m_swatter_duration );
swatter_node->get("squash-duration", &m_squash_duration );
swatter_node->get("squash-slowdown", &m_squash_slowdown );
if(swatter_node->get("distance", &m_swatter_distance2) )
{
// Avoid squaring if distance is not defined, so that
// distance2 remains UNDEFINED (which is a negative value)
m_swatter_distance2 *= m_swatter_distance2;
}
}
if(const XMLNode *lean_node= root->getNode("lean"))
{
lean_node->get("max", &m_max_lean );
@ -646,12 +468,6 @@ void KartProperties::getAllData(const XMLNode * root)
m_lean_speed *= DEGREE_TO_RAD;
}
if(const XMLNode *startup_node= root->getNode("startup"))
{
startup_node->get("time", &m_startup_times);
startup_node->get("boost", &m_startup_boost);
}
if(const XMLNode *graphics_node = root->getNode("graphics"))
{
graphics_node->get("y-offset", &m_graphical_y_offset);
@ -671,122 +487,22 @@ void KartProperties::getAllData(const XMLNode * root)
*/
void KartProperties::checkAllSet(const std::string &filename)
{
if(m_gear_switch_ratio.size()==0)
{
Log::fatal("[KartProperties]",
"Missing default value for 'gear-switch-ratio' in '%s'.",
filename.c_str());
}
if(m_gear_power_increase.size()==0)
{
Log::fatal("[KartProperties]",
"Missing default value for 'gear-power-increase' in '%s'.",
filename.c_str());
}
if(m_gear_switch_ratio.size()!=m_gear_power_increase.size()) {
Log::error("KartProperties",
"Number of entries for 'gear-switch-ratio' and "
"'gear-power-increase");
Log::fatal("KartProperties", "in '%s' must be equal.",
filename.c_str());
}
if(m_startup_boost.size()!=m_startup_times.size())
{
Log::error("[KartProperties]",
"Number of entried for 'startup times' and 'startup-boost");
Log::fatal("KartProperties", "must be identical.");
}
#define CHECK_NEG( a,strA) if(a<=UNDEFINED) { \
Log::fatal("[KartProperties]", \
"Missing default value for '%s' in '%s'.", \
strA,filename.c_str()); \
}
CHECK_NEG(m_mass, "mass" );
CHECK_NEG(m_time_reset_steer, "turn time-reset-steer" );
CHECK_NEG(m_wheel_damping_relaxation, "wheels damping-relaxation" );
CHECK_NEG(m_wheel_damping_compression, "wheels damping-compression" );
CHECK_NEG(m_wheel_radius, "wheels radius" );
CHECK_NEG(m_friction_slip, "friction slip" );
CHECK_NEG(m_roll_influence, "stability roll-influence" );
CHECK_NEG(m_chassis_linear_damping, "stability chassis-linear-damping" );
CHECK_NEG(m_chassis_angular_damping, "stability chassis-angular-damping");
CHECK_NEG(m_downward_impulse_factor, "stability downward-impulse-factor");
CHECK_NEG(m_track_connection_accel, "stability track-connection-accel" );
CHECK_NEG(m_smooth_flying_impulse, "smooth-flying-impulse" );
CHECK_NEG(m_max_speed_reverse_ratio, "engine max-speed-reverse-ratio");
CHECK_NEG(m_brake_factor, "engine brake-factor" );
CHECK_NEG(m_brake_time_increase, "engine brake-time-increase" );
CHECK_NEG(m_suspension_stiffness, "suspension stiffness" );
CHECK_NEG(m_suspension_rest, "suspension rest" );
CHECK_NEG(m_suspension_travel_cm, "suspension travel-cm" );
CHECK_NEG(m_max_suspension_force, "suspension max-force" );
CHECK_NEG(m_collision_terrain_impulse, "collision terrain-impulse" );
CHECK_NEG(m_collision_impulse, "collision impulse" );
CHECK_NEG(m_collision_impulse_time, "collision impulse-time" );
CHECK_NEG(m_restitution, "collision restitution" );
CHECK_NEG(m_collision_terrain_impulse, "collision terrain-impulse" );
CHECK_NEG(m_bevel_factor.getX(), "collision bevel-factor" );
CHECK_NEG(m_bevel_factor.getY(), "collision bevel-factor" );
CHECK_NEG(m_bevel_factor.getZ(), "collision bevel-factor" );
CHECK_NEG(m_physical_wheel_position, "collision physical-wheel-position");
CHECK_NEG(m_rubber_band_max_length, "plunger band-max-length" );
CHECK_NEG(m_rubber_band_force, "plunger band-force" );
CHECK_NEG(m_rubber_band_duration, "plunger band-duration" );
CHECK_NEG(m_rubber_band_speed_increase, "plunger band-speed-increase" );
CHECK_NEG(m_rubber_band_fade_out_time, "plunger band-fade-out-time" );
CHECK_NEG(m_zipper_time, "zipper-time" );
CHECK_NEG(m_zipper_fade_out_time, "zipper-fade-out-time" );
CHECK_NEG(m_zipper_force, "zipper-force" );
CHECK_NEG(m_zipper_speed_gain, "zipper-speed-gain" );
CHECK_NEG(m_zipper_max_speed_increase, "zipper-max-speed-increase" );
CHECK_NEG(m_slipstream_length, "slipstream length" );
CHECK_NEG(m_slipstream_width, "slipstream width" );
CHECK_NEG(m_slipstream_collect_time, "slipstream collect-time" );
CHECK_NEG(m_slipstream_use_time, "slipstream use-time" );
CHECK_NEG(m_slipstream_add_power, "slipstream add-power" );
CHECK_NEG(m_slipstream_min_speed, "slipstream min-speed" );
CHECK_NEG(m_slipstream_max_speed_increase,
"slipstream max-speed-increase" );
CHECK_NEG(m_slipstream_duration, "slipstream duration" );
CHECK_NEG(m_slipstream_fade_out_time, "slipstream fade-out-time" );
CHECK_NEG(m_camera_distance, "camera distance" );
CHECK_NEG(m_camera_forward_up_angle, "camera forward-up-angle" );
CHECK_NEG(m_camera_backward_up_angle, "camera forward-up-angle" );
CHECK_NEG(m_nitro_consumption, "nitro consumption" );
CHECK_NEG(m_nitro_big_container, "nitro big-container" );
CHECK_NEG(m_nitro_small_container, "nitro small-container" );
CHECK_NEG(m_nitro_max_speed_increase, "nitro max-speed-increase" );
CHECK_NEG(m_nitro_engine_force, "nitro engine-force" );
CHECK_NEG(m_nitro_duration, "nitro duration" );
CHECK_NEG(m_nitro_fade_out_time, "nitro fade-out-time" );
CHECK_NEG(m_nitro_max, "nitro max" );
CHECK_NEG(m_bubblegum_time, "bubblegum time" );
CHECK_NEG(m_bubblegum_speed_fraction, "bubblegum speed-fraction" );
CHECK_NEG(m_bubblegum_fade_in_time , "bubblegum fade-in-time" );
CHECK_NEG(m_bubblegum_torque, "bubblegum torque" );
CHECK_NEG(m_swatter_distance2, "swatter distance" );
CHECK_NEG(m_swatter_duration, "swatter duration" );
CHECK_NEG(m_squash_duration, "swatter squash-duration" );
CHECK_NEG(m_squash_slowdown, "swatter squash-slowdown" );
CHECK_NEG(m_max_lean, "lean max" );
CHECK_NEG(m_lean_speed, "lean speed" );
CHECK_NEG(m_rescue_height, "rescue height" );
CHECK_NEG(m_rescue_time, "rescue time" );
CHECK_NEG(m_rescue_vert_offset, "rescue vert-offset" );
CHECK_NEG(m_explosion_time, "explosion time" );
CHECK_NEG(m_explosion_invulnerability_time,
"explosion invulnerability-time");
CHECK_NEG(m_explosion_radius, "explosion radius" );
CHECK_NEG(m_graphical_y_offset, "graphics y-offset" );
for(unsigned int i=RaceManager::DIFFICULTY_FIRST;
i<=RaceManager::DIFFICULTY_LAST; i++)
{
CHECK_NEG(m_max_speed[i], "engine maximum-speed[0]");
CHECK_NEG(m_engine_power[i], "engine power" );
CHECK_NEG(m_plunger_in_face_duration[i],"plunger in-face-time");
}
m_speed_weighted_object_properties.checkAllSet();
@ -815,7 +531,13 @@ bool KartProperties::operator<(const KartProperties &other) const
const AbstractCharacteristic* KartProperties::getCharacteristic() const
{
return m_characteristic;
}
} // getCharacteristic
// ----------------------------------------------------------------------------
const AbstractCharacteristic* KartProperties::getCombinedCharacteristic() const
{
return m_combined_characteristic;
} // getCombinedCharacteristic
// ----------------------------------------------------------------------------
bool KartProperties::isInGroup(const std::string &group) const
@ -823,32 +545,3 @@ bool KartProperties::isInGroup(const std::string &group) const
return std::find(m_groups.begin(), m_groups.end(), group) != m_groups.end();
} // isInGroups
// ----------------------------------------------------------------------------
/** Called the first time a kart accelerates after 'ready-set-go'. It searches
* through m_startup_times to find the appropriate slot, and returns the
* speed-boost from the corresponding entry in m_startup_boost.
* If the kart started too slow (i.e. slower than the longest time in
* m_startup_times, it returns 0.
*/
float KartProperties::getStartupBoost() const
{
float t = World::getWorld()->getTime();
for(unsigned int i=0; i<m_startup_times.size(); i++)
{
if(t<=m_startup_times[i]) return m_startup_boost[i];
}
return 0;
} // getStartupBoost
// ----------------------------------------------------------------------------
const float KartProperties::getAvgPower() const
{
float sum = 0.0;
for (unsigned int i = 0; i < m_gear_power_increase.size(); ++i)
{
sum += m_gear_power_increase[i]*m_max_speed[0];
}
return sum/m_gear_power_increase.size();
} // getAvgPower

532
src/karts/kart_properties.hpp
View File

@ -39,6 +39,7 @@ using namespace irr;
class AbstractCharacteristic;
class AIProperties;
class CombinedCharacteristic;
class Material;
class SkiddingProperties;
class XmlCharacteristic;
@ -126,31 +127,11 @@ private:
* from the xml file.
*/
XmlCharacteristic *m_characteristic;
/** The base characteristics combined with the characteristics of this kart. */
CombinedCharacteristic *m_combined_characteristic;
// Physic properties
// -----------------
/** Weight of kart. */
float m_mass;
/** Maximum force from engine for each difficulty. */
std::vector<float> m_engine_power;
/** Braking factor * engine_power braking force. */
float m_brake_factor;
/** Brake_time * m_brake_time_increase will increase the break time
* over time. */
float m_brake_time_increase;
/** Time for player karts to reach full steer angle. */
InterpolationArray m_time_full_steer;
/** Time for steering to go back to zero from full steer. */
float m_time_reset_steer;
/** A torque impulse applied to keep the kart parallel to the ground. */
float m_smooth_flying_impulse;;
/** The turn angle depending on speed. */
InterpolationArray m_turn_angle_at_speed;
@ -167,39 +148,6 @@ private:
*/
float m_physical_wheel_position;
/** Time a kart is moved upwards after when it is rescued. */
float m_rescue_time;
/** Distance the kart is raised before dropped. */
float m_rescue_height;
/** Time an animated explosion is shown. Longer = more delay for kart. */
float m_explosion_time;
/** How far away from an explosion karts will still be affected. */
float m_explosion_radius;
/** How long a kart is invulnerable after it is hit by an explosion. */
float m_explosion_invulnerability_time;
/** Duration a zipper is active. */
float m_zipper_time;
/** Fade out time for a zipper. */
float m_zipper_fade_out_time;
/** Additional force added to the acceleration. */
float m_zipper_force;
/** Initial one time speed gain. */
float m_zipper_speed_gain;
/** Absolute increase of the kart's maximum speed (in m/s). */
float m_zipper_max_speed_increase;
/** Vertical offset after rescue. */
float m_rescue_vert_offset;
/** Minimum time during which nitro is consumed when pressing
* the nitro key (to prevent using in very small bursts)
*/
@ -210,8 +158,6 @@ private:
/** Filename of the wheel models. */
std::string m_wheel_filename[4];
/** Radius of the graphical wheels. */
float m_wheel_graphics_radius[4];
/** An additional Y offset added to the y position of the graphical
* chassis. Useful for karts that don't have enough space for suspension
* compression. */
@ -221,58 +167,8 @@ private:
bool m_prevent_chassis_in_terrain;
/** If the kart is supposed to have random wheel rotation at start. */
bool m_has_rand_wheels;
/** Max. length of plunger rubber band. */
float m_rubber_band_max_length;
/** Force of an attached rubber band. */
/** Duration a rubber band works. */
float m_rubber_band_force;
/** How long the rubber band will fly. */
float m_rubber_band_duration;
/** Increase of maximum speed of the kart when the rubber band pulls. */
float m_rubber_band_speed_increase;
/** Fade out time when the rubber band is removed. */
float m_rubber_band_fade_out_time;
/**Duration of plunger in face depending on difficulty. */
std::vector<float> m_plunger_in_face_duration;
/** Wheel base of the kart. */
float m_wheel_base;
/** Nitro consumption. */
float m_nitro_consumption;
/** Nitro amount for small bottle. */
float m_nitro_small_container;
/** Nitro amount for big bittle. */
float m_nitro_big_container;
/** How much the speed of a kart might exceed its maximum speed (in m/s). */
float m_nitro_max_speed_increase;
/** Additional engine force to affect the kart. */
float m_nitro_engine_force;
/** How long the increased nitro max speed will be valid after
* the kart stops using nitro (and the fade-out-time starts). */
float m_nitro_duration;
/** Duration during which the increased maximum speed
* due to nitro fades out. */
float m_nitro_fade_out_time;
/** Maximum nitro a kart can collect. */
float m_nitro_max;
/** Bubble gum diration. */
float m_bubblegum_time;
/** Torque to add when a bubble gum was hit in order to make the kart go
* sideways a bit. */
float m_bubblegum_torque;
/** Fraction of top speed that can be reached maximum after hitting a
* bubble gum. */
float m_bubblegum_speed_fraction;
/** How long to fade in the slowdown for a bubble gum. */
float m_bubblegum_fade_in_time;
/** Square of the maximum distance a swatter can operate. */
float m_swatter_distance2;
/** How long the swatter lasts. */
float m_swatter_duration;
/** How long a kart will remain squashed. */
float m_squash_duration;
/** The slowdown to apply while a kart is squashed. The new maxspeed
* is max_speed*m_squash_slowdown. */
float m_squash_slowdown;
/** The maximum roll a kart graphics should show when driving in a fast
* curve. This is read in as degrees, but stored in radians. */
@ -282,58 +178,19 @@ private:
* (in radians/second). */
float m_lean_speed;
/** How long a jump must be in order to trigger the jump animation. */
float m_jump_animation_time;
/** Engine sound effect. */
std::string m_engine_sfx_type;
// bullet physics data
// -------------------
float m_suspension_stiffness;
float m_wheel_damping_relaxation;
float m_wheel_damping_compression;
float m_max_suspension_force;
float m_friction_slip;
float m_roll_influence;
float m_wheel_radius;
/** Parameters for the speed-weighted objects */
SpeedWeightedObject::Properties m_speed_weighted_object_properties;
/** An impulse pushing the kart down which is proportional to speed. So
* the actual impulse is speed * m_downward_impulse_factor. Set it to
* 0 to disable completely. Based on
* http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?f=9&t=6059\
* &p=21240&hilit=vehicle#p21240 */
float m_downward_impulse_factor;
/** Artifical acceleration that pulls a kart down onto the track if one
* axis loses contact with the track. */
float m_track_connection_accel;
/** Linear damping of the chassis to prevent it from toppling over. */
float m_chassis_linear_damping;
/** Angular damping to prevent it from turning too easily. */
float m_chassis_angular_damping;
/** The maximum speed at each difficulty. */
std::vector<float> m_max_speed;
float m_max_speed_reverse_ratio;
/** Shift of center of gravity. */
Vec3 m_gravity_center_shift;
/** The suspension reaction is dampened to reach an exponential behaviour.
* See http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?f=9&t=7369\
* &p=25236&hilit=vehicle#p25236 for details. */
bool m_exp_spring_response;
float m_suspension_rest;
float m_suspension_travel_cm;
public:
/** STK can add an impulse to push karts away from the track in case
* of a kart-track collision. This can be done in two ways: either
@ -359,57 +216,10 @@ private:
/** The restitution factor to be used in collsions for this kart. */
float m_restitution;
/** How far behind a kart slipstreaming is effective. */
float m_slipstream_length;
/** How wide the slipstream area is at the end. */
float m_slipstream_width;
/** Time after which sstream gives a bonus. */
float m_slipstream_collect_time;
/** Time slip-stream bonus is effective. */
float m_slipstream_use_time;
/** Additional power due to sstreaming. */
float m_slipstream_add_power;
/** Minimum speed for slipstream to take effect. */
float m_slipstream_min_speed;
/** How much the speed of the kart might exceed its
* normal maximum speed. */
float m_slipstream_max_speed_increase;
/** How long the higher speed lasts after slipstream stopped working. */
float m_slipstream_duration;
/** How long the slip stream speed increase will gradually be reduced. */
float m_slipstream_fade_out_time;
/** Distance of normal camera from kart. */
float m_camera_distance;
/** Up angle of the camera in relation to the pitch of the kart when
* driving forwards. */
float m_camera_forward_up_angle;
/** Up angle of the camera in relation to the pitch of the kart when
* driving backwards. */
float m_camera_backward_up_angle;
/** The following two vectors define at what ratio of the maximum speed what
* gear is selected. E.g. 0.25 means: if speed <=0.25*maxSpeed --> gear 1,
* 0.5 means: if speed <=0.5 *maxSpeed --> gear 2 */
std::vector<float> m_gear_switch_ratio;
/** This vector contains the increase in max power (to simulate different
* gears), e.g. 2.5 as first entry means: 2.5*maxPower in gear 1. See
m_gear_switch_ratio). */
std::vector<float> m_gear_power_increase;
/** If the kart starts within the specified time at index I after 'go',
* it receives the speed boost from m_startup_boost[I]. */
std::vector<float> m_startup_times;
/** The startup boost is the kart starts fast enough. */
std::vector<float> m_startup_boost;
void load (const std::string &filename,
const std::string &node);
void combineCharacteristics();
public:
/** Returns the string representation of a per-player difficulty. */
@ -420,13 +230,18 @@ public:
void copyFrom (const KartProperties *source);
void getAllData (const XMLNode * root);
void checkAllSet (const std::string &filename);
float getStartupBoost () const;
bool isInGroup (const std::string &group) const;
bool operator<(const KartProperties &other) const;
// ------------------------------------------------------------------------
/** Returns the characteristics for this kart. */
const AbstractCharacteristic* getCharacteristic() const;
// ------------------------------------------------------------------------
/** Returns the characteristics for this kart combined with the base
* characteristic. This value isn't used for the race, because the
* difficulty is missing, but it can be used e.g. for the kart stats widget.
*/
const AbstractCharacteristic* getCombinedCharacteristic() const;
// ------------------------------------------------------------------------
/** Returns the (maximum) speed for a given turn radius.
@ -517,47 +332,6 @@ public:
/** Returns the list of groups this kart belongs to. */
const std::vector<std::string>&
getGroups () const {return m_groups; }
// ------------------------------------------------------------------------
/** Returns the mass of this kart. */
float getMass () const {return m_mass; }
// ------------------------------------------------------------------------
/** Returns the maximum engine power depending on difficulty. */
float getMaxPower () const
{return m_engine_power[race_manager->getDifficulty()];}
// ------------------------------------------------------------------------
/** Returns the time the kart needs to fully steer in one direction from
* steering straight depending on the current steering value.
* \param steer Current steering value, must be >=0. */
float getTimeFullSteer(float steer) const
{
assert(steer>=0);
return m_time_full_steer.get(steer);
} // getTimeFullSteer
// ------------------------------------------------------------------------
/** Returns the time the kart needs to go back to steering straight from
* full steer. */
float getTimeResetSteer () const { return m_time_reset_steer; }
// ------------------------------------------------------------------------
/** Get braking information. */
float getBrakeFactor () const {return m_brake_factor; }
// ------------------------------------------------------------------------
/** Returns the additional brake factor which depends on time. */
float getBrakeTimeIncrease() const { return m_brake_time_increase; }
// ------------------------------------------------------------------------
/** Returns the torque scaling factor used to keep the karts parallel to
* the ground when flying. */
float getSmoothFlyingImpulse() const
{
return m_smooth_flying_impulse;
} // getSmoothFlyingImpulse
// ------------------------------------------------------------------------
/** Get maximum reverse speed ratio. */
float getMaxSpeedReverseRatio() const {return m_max_speed_reverse_ratio; }
// ------------------------------------------------------------------------
/** Returns the engine type (used to change sfx depending on kart size). */
@ -565,35 +339,9 @@ public:
// Bullet physics get functions
//-----------------------------
/** Returns the suspension stiffness. */
float getSuspensionStiffness () const {return m_suspension_stiffness; }
// ------------------------------------------------------------------------
/** Returns damping relaxation. */
float getWheelDampingRelaxation () const
{return m_wheel_damping_relaxation; }
// ------------------------------------------------------------------------
/** Returns the wheel damping compression. */
float getWheelDampingCompression() const
{return m_wheel_damping_compression;}
// ------------------------------------------------------------------------
/** Returns maximum suspension force. */
float getMaxSuspensionForce() const {return m_max_suspension_force; }
// ------------------------------------------------------------------------
/** Returns friction slip. */
float getFrictionSlip () const {return m_friction_slip; }
// ------------------------------------------------------------------------
/** Returns roll influence. */
float getRollInfluence () const {return m_roll_influence; }
// ------------------------------------------------------------------------
/** Returns wheel radius. */
float getWheelRadius () const {return m_wheel_radius; }
// ------------------------------------------------------------------------
/** Return the additional Y offset added to the y position of the graphical
* chassis. Useful for karts that don't have enough space for suspension
@ -617,99 +365,11 @@ public:
/** Returns the wheel base (distance front to rear axis). */
float getWheelBase () const {return m_wheel_base; }
// ------------------------------------------------------------------------
/** Returns linear damping of chassis. */
float getChassisLinearDamping () const {return m_chassis_linear_damping;}
// ------------------------------------------------------------------------
/** Returns angular damping of chassis. */
float getChassisAngularDamping () const
{return m_chassis_angular_damping; }
// ------------------------------------------------------------------------
/** Artifical downward impulse every frame. */
float getDownwardImpulseFactor() const { return m_downward_impulse_factor;}
// ------------------------------------------------------------------------
/** Returns artificial acceleration to keep wheels on track. */
float getTrackConnectionAccel () const {return m_track_connection_accel;}
// ------------------------------------------------------------------------
/** Returns the maximum speed dependent on the difficult level. */
float getMaxSpeed () const
{
return m_max_speed[race_manager->getDifficulty()];
}
// ------------------------------------------------------------------------
/** Return the absolute maximum speed, independent on the difficulty. */
float getAbsMaxSpeed () const
{
return m_max_speed[m_max_speed.size()-1];
}
// ------------------------------------------------------------------------
/** Returns the nitro consumption. */
float getNitroConsumption () const {return m_nitro_consumption; }
// ------------------------------------------------------------------------
/** Returns the amount of nitro for a small container. */
float getNitroSmallContainer () const {return m_nitro_small_container; }
// ------------------------------------------------------------------------
/** Returns the amount of nitro for a big container. */
float getNitroBigContainer () const {return m_nitro_big_container; }
// ------------------------------------------------------------------------
/** Returns the increase of maximum speed due to nitro. */
float getNitroMaxSpeedIncrease () const
{return m_nitro_max_speed_increase; }
// ------------------------------------------------------------------------
float getNitroEngineForce () const {return m_nitro_engine_force; }
// ------------------------------------------------------------------------
/** Returns how long the increased nitro max speed will be valid after
* the kart stops using nitro (and the fade-out-time starts). */
float getNitroDuration () const {return m_nitro_duration; }
// ------------------------------------------------------------------------
/** Returns the duration during which the increased maximum speed
* due to nitro fades out. */
float getNitroFadeOutTime () const {return m_nitro_fade_out_time; }
// ------------------------------------------------------------------------
/** Returns the maximum amount of nitro a kart can store. */
float getNitroMax () const {return m_nitro_max; }
// ------------------------------------------------------------------------
/** Returns how long a bubble gum is active. */
float getBubblegumTime() const { return m_bubblegum_time; }
// ------------------------------------------------------------------------
/** Returns the torque to add when a bubble gum was hit . */
float getBubblegumTorque() const { return m_bubblegum_torque; }
// ------------------------------------------------------------------------
/** Returns the fraction of top speed that can be reached maximum after
* hitting a bubble gum. */
float getBubblegumSpeedFraction() const {return m_bubblegum_speed_fraction;}
// ------------------------------------------------------------------------
/** Returns how long to fade in the slowdown for a bubble gum. */
float getBubblegumFadeInTime() const { return m_bubblegum_fade_in_time; }
// ------------------------------------------------------------------------
/** Returns a shift of the center of mass (lowering the center of mass
* makes the karts more stable. */
const Vec3&getGravityCenterShift() const {return m_gravity_center_shift; }
// ------------------------------------------------------------------------
/** Retusn suspension rest length. */
float getSuspensionRest () const {return m_suspension_rest; }
// ------------------------------------------------------------------------
/** Returns the amount the suspension can extend. */
float getSuspensionTravelCM () const {return m_suspension_travel_cm; }
// ------------------------------------------------------------------------
/** Returns if the spring should be exponentially dampened. */
bool getExpSpringResponse() const {return m_exp_spring_response; }
// ------------------------------------------------------------------------
/** Returns an artificial impulse to push karts away from the terrain
* it hits. */
@ -734,128 +394,6 @@ public:
/** Returns the restitution factor for this kart. */
float getRestitution () const { return m_restitution; }
// ------------------------------------------------------------------------
/** Returns the vertical offset when rescuing karts to avoid karts being
* rescued in (or under) the track. */
float getVertRescueOffset () const {return m_rescue_vert_offset; }
// ------------------------------------------------------------------------
/** Returns the time a kart is rised during a rescue. */
float getRescueTime () const {return m_rescue_time; }
// ------------------------------------------------------------------------
/** Returns the height a kart is moved to during a rescue. */
float getRescueHeight () const {return m_rescue_height; }
// ------------------------------------------------------------------------
/** Returns the time an explosion animation is shown. */
float getExplosionTime () const {return m_explosion_time; }
// ------------------------------------------------------------------------
/** Returns the height of the explosion animation. */
float getExplosionRadius () const {return m_explosion_radius; }
// ------------------------------------------------------------------------
/** Returns how long a kart is invulnerable after being hit by an
explosion. */
float getExplosionInvulnerabilityTime() const
{ return m_explosion_invulnerability_time; }
// ------------------------------------------------------------------------
/** Returns the maximum length of a rubber band before it breaks. */
float getRubberBandMaxLength () const {return m_rubber_band_max_length;}
// ------------------------------------------------------------------------
/** Returns force a rubber band has when attached to a kart. */
float getRubberBandForce () const {return m_rubber_band_force; }
// ------------------------------------------------------------------------
/** Returns the duration a rubber band is active for. */
float getRubberBandDuration () const {return m_rubber_band_duration; }
// ------------------------------------------------------------------------
/** Returns the increase of maximum speed while a rubber band is
* pulling. */
float getRubberBandSpeedIncrease() const
{
return m_rubber_band_speed_increase;
}
// ------------------------------------------------------------------------
/** Return the fade out time once a rubber band is removed. */
float getRubberBandFadeOutTime() const
{
return m_rubber_band_fade_out_time;
}
// ------------------------------------------------------------------------
/** Returns duration of a plunger in your face. */
float getPlungerInFaceTime () const
{return m_plunger_in_face_duration[race_manager->getDifficulty()];}
// ------------------------------------------------------------------------
/** Returns the time a zipper is active. */
float getZipperTime () const {return m_zipper_time; }
// ------------------------------------------------------------------------
/** Returns the time a zipper is active. */
float getZipperFadeOutTime () const {return m_zipper_fade_out_time; }
// ------------------------------------------------------------------------
/** Returns the additional force added applied to the kart. */
float getZipperForce () const { return m_zipper_force; }
// ------------------------------------------------------------------------
/** Returns the initial zipper speed gain. */
float getZipperSpeedGain () const { return m_zipper_speed_gain; }
// ------------------------------------------------------------------------
/** Returns the increase of the maximum speed of the kart
* if a zipper is active. */
float getZipperMaxSpeedIncrease () const
{ return m_zipper_max_speed_increase;}
// ------------------------------------------------------------------------
/** Returns how far behind a kart slipstreaming works. */
float getSlipstreamLength () const {return m_slipstream_length; }
// ------------------------------------------------------------------------
/** Returns how wide the slipstream area is at the end. */
float getSlipstreamWidth () const {return m_slipstream_width; }
// ------------------------------------------------------------------------
/** Returns time after which slipstream has maximum effect. */
float getSlipstreamCollectTime () const
{return m_slipstream_collect_time; }
// ------------------------------------------------------------------------
/** Returns time after which slipstream has maximum effect. */
float getSlipstreamUseTime () const {return m_slipstream_use_time; }
// ------------------------------------------------------------------------
/** Returns additional power due to slipstreaming. */
float getSlipstreamAddPower () const {return m_slipstream_add_power; }
// ------------------------------------------------------------------------
/** Returns the minimum slipstream speed. */
float getSlipstreamMinSpeed () const {return m_slipstream_min_speed; }
// ------------------------------------------------------------------------
/** Returns the increase of the maximum speed of a kart
* due to slipstream. */
float getSlipstreamMaxSpeedIncrease() const
{ return m_slipstream_max_speed_increase; }
// ------------------------------------------------------------------------
/** Returns how long the higher speed lasts after slipstream
* stopped working. */
float getSlipstreamDuration () const { return m_slipstream_duration; }
// ------------------------------------------------------------------------
/** Returns how long the slip stream speed increase will gradually
* be reduced. */
float getSlipstreamFadeOutTime () const
{ return m_slipstream_fade_out_time; }
// ------------------------------------------------------------------------
/** Returns the scale factor by which the shadow plane
* had to be set. */
@ -883,56 +421,10 @@ public:
return m_ai_properties[race_manager->getDifficulty()];
} // getAIProperties
// ------------------------------------------------------------------------
/** Returns ratio of current speed to max speed at which the gear will
* change (for our simualated gears = simple change of engine power). */
const std::vector<float>&
getGearSwitchRatio () const {return m_gear_switch_ratio; }
// ------------------------------------------------------------------------
/** Returns the power increase depending on gear. */
const std::vector<float>&
getGearPowerIncrease () const {return m_gear_power_increase; }
// ------------------------------------------------------------------------
/** Returns the average power of the kart (in all gears). */
const float getAvgPower () const;
// ------------------------------------------------------------------------
/** Returns distance between kart and camera. */
float getCameraDistance () const {return m_camera_distance; }
// ------------------------------------------------------------------------
/** Returns the angle the camera has relative to the pitch of the kart. */
float getCameraForwardUpAngle () const
{return m_camera_forward_up_angle; }
// ------------------------------------------------------------------------
/** Returns the angle the camera has relative to the pitch of the kart. */
float getCameraBackwardUpAngle () const
{return m_camera_backward_up_angle; }
// ------------------------------------------------------------------------
/** Returns the full path where the files for this kart are stored. */
const std::string& getKartDir () const {return m_root; }
// ------------------------------------------------------------------------
/** Returns the square of the maximum distance at which a swatter
* can hit karts. */
float getSwatterDistance2() const { return m_swatter_distance2; }
// ------------------------------------------------------------------------
/** Returns how long a swatter will stay attached/ready to be used. */
float getSwatterDuration() const { return m_swatter_duration; }
// ------------------------------------------------------------------------
/** Returns how long a kart remains squashed. */
float getSquashDuration() const {return m_squash_duration; }
// ------------------------------------------------------------------------
/** Returns the slowdown of a kart that is squashed. */
float getSquashSlowdown() const {return m_squash_slowdown; }
// ------------------------------------------------------------------------
/** The maximum leaning a kart should show (In radians). */
float getMaxLean() const { return m_max_lean; }
@ -941,10 +433,6 @@ public:
/** The speed with which a kart should lean (in radians/s). */
float getLeanSpeed() const { return m_lean_speed; }
// ------------------------------------------------------------------------
/** Return show long a jump must last in order to play the jump
* animation. */
float getJumpAnimationTime() const { return m_jump_animation_time; }
// ------------------------------------------------------------------------
/** Returns true if wheels should have random rotation at start. */
bool hasRandomWheels() const { return m_has_rand_wheels; }
// ------------------------------------------------------------------------

5
src/karts/max_speed.cpp
View File

@ -21,6 +21,7 @@
#include <algorithm>
#include <assert.h>
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/kart_properties.hpp"
#include "physics/btKart.hpp"
@ -62,7 +63,7 @@ MaxSpeed::MaxSpeed(AbstractKart *kart)
*/
void MaxSpeed::reset()
{
m_current_max_speed = m_kart->getKartProperties()->getMaxSpeed();
m_current_max_speed = m_kart->getCharacteristic()->getEngineMaxSpeed();
m_min_speed = -1.0f;
for(unsigned int i=MS_DECREASE_MIN; i<MS_DECREASE_MAX; i++)
@ -242,7 +243,7 @@ void MaxSpeed::update(float dt)
}
m_add_engine_force = 0;
m_current_max_speed = m_kart->getKartProperties()->getMaxSpeed();
m_current_max_speed = m_kart->getCharacteristic()->getEngineMaxSpeed();
// Then add the speed increase from each category
// ----------------------------------------------

5
src/karts/rescue_animation.cpp
View File

@ -22,6 +22,7 @@
#include "graphics/camera.hpp"
#include "graphics/referee.hpp"
#include "items/attachment.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/kart_properties.hpp"
#include "modes/three_strikes_battle.hpp"
@ -39,8 +40,8 @@ RescueAnimation::RescueAnimation(AbstractKart *kart, bool is_auto_rescue)
{
m_referee = new Referee(*m_kart);
m_kart->getNode()->addChild(m_referee->getSceneNode());
m_timer = m_kart->getKartProperties()->getRescueTime();
m_velocity = m_kart->getKartProperties()->getRescueHeight() / m_timer;
m_timer = m_kart->getCharacteristic()->getRescueDuration();
m_velocity = m_kart->getCharacteristic()->getRescueHeight() / m_timer;
m_xyz = m_kart->getXYZ();
m_kart->getAttachment()->clear();

49
src/karts/xml_characteristic.cpp
View File

@ -33,11 +33,18 @@ XmlCharacteristic::XmlCharacteristic(const XMLNode *node) :
void XmlCharacteristic::process(CharacteristicType type, Value value, bool *is_set) const
{
if (m_values[type].empty())
// That value was not changed in this configuration
return;
switch (getType(type))
{
case TYPE_FLOAT:
processFloat(m_values[type], value.f, is_set);
break;
case TYPE_BOOL:
processBool(m_values[type], value.b, is_set);
break;
case TYPE_FLOAT_VECTOR:
{
const std::vector<std::string> processors =
@ -162,15 +169,13 @@ void XmlCharacteristic::process(CharacteristicType type, Value value, bool *is_s
}
break;
}
default:
Log::fatal("XmlCharacteristic::process", "Unknown type for %s", getName(type).c_str());
}
}
void XmlCharacteristic::processFloat(const std::string &processor, float *value, bool *is_set)
{
if (processor.empty())
// That value was not changed in this configuration
return;
// Split the string by operators
static const std::string operators = "*/+-";
std::vector<std::string> parts;
@ -223,7 +228,7 @@ void XmlCharacteristic::processFloat(const std::string &processor, float *value,
else if (!StringUtils::fromString(parts[index], val))
{
Log::fatal("XmlCharacteristic::processFloat",
"Can't process %s: Not a float", parts[index].c_str());
"Can't parse %s: Not a float", parts[index].c_str());
return;
}
if (operations[index - 1] == "*")
@ -241,9 +246,25 @@ void XmlCharacteristic::processFloat(const std::string &processor, float *value,
*is_set = true;
}
void XmlCharacteristic::processBool(const std::string &processor, bool *value, bool *is_set)
{
if (processor == "true")
{
*value = true;
*is_set = true;
}
else if (processor == "false")
{
*value = false;
*is_set = true;
}
else
Log::error("XmlCharacteristic::processBool", "Can't parse %s: Not a bool", processor);
}
void XmlCharacteristic::load(const XMLNode *node)
{
// Script-generated content
// Script-generated content getXml
if (const XMLNode *sub_node = node->getNode("suspension"))
{
sub_node->get("stiffness", &m_values[SUSPENSION_STIFFNESS]);
@ -285,9 +306,9 @@ void XmlCharacteristic::load(const XMLNode *node)
sub_node->get("power-increase", &m_values[GEAR_POWER_INCREASE]);
}
if (const XMLNode *sub_node = node->getNode(""))
if (const XMLNode *sub_node = node->getNode("mass"))
{
sub_node->get("mass", &m_values[MASS]);
sub_node->get("value", &m_values[MASS]);
}
if (const XMLNode *sub_node = node->getNode("wheels"))
@ -347,7 +368,7 @@ void XmlCharacteristic::load(const XMLNode *node)
sub_node->get("duration", &m_values[ZIPPER_DURATION]);
sub_node->get("force", &m_values[ZIPPER_FORCE]);
sub_node->get("speed-gain", &m_values[ZIPPER_SPEED_GAIN]);
sub_node->get("speed-increase", &m_values[ZIPPER_SPEED_INCREASE]);
sub_node->get("max-speed-increase", &m_values[ZIPPER_MAX_SPEED_INCREASE]);
sub_node->get("fade-out-time", &m_values[ZIPPER_FADE_OUT_TIME]);
}
@ -361,11 +382,11 @@ void XmlCharacteristic::load(const XMLNode *node)
if (const XMLNode *sub_node = node->getNode("plunger"))
{
sub_node->get("max-length", &m_values[PLUNGER_MAX_LENGTH]);
sub_node->get("force", &m_values[PLUNGER_FORCE]);
sub_node->get("duration", &m_values[PLUNGER_DURATION]);
sub_node->get("speed-increase", &m_values[PLUNGER_SPEED_INCREASE]);
sub_node->get("fade-out-time", &m_values[PLUNGER_FADE_OUT_TIME]);
sub_node->get("band-max-length", &m_values[PLUNGER_BAND_MAX_LENGTH]);
sub_node->get("band-force", &m_values[PLUNGER_BAND_FORCE]);
sub_node->get("band-duration", &m_values[PLUNGER_BAND_DURATION]);
sub_node->get("band-speed-increase", &m_values[PLUNGER_BAND_SPEED_INCREASE]);
sub_node->get("band-fade-out-time", &m_values[PLUNGER_BAND_FADE_OUT_TIME]);
sub_node->get("in-face-time", &m_values[PLUNGER_IN_FACE_TIME]);
}

1
src/karts/xml_characteristic.hpp
View File

@ -40,6 +40,7 @@ public:
private:
static void processFloat(const std::string &processor, float *value, bool *is_set);
static void processBool(const std::string &processor, bool *value, bool *is_set);
};
#endif

3
src/modes/soccer_world.cpp
View File

@ -21,6 +21,7 @@
#include "audio/sfx_base.hpp"
#include "io/file_manager.hpp"
#include "graphics/irr_driver.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/kart.hpp"
#include "karts/kart_model.hpp"
@ -386,7 +387,7 @@ void SoccerWorld::moveKartAfterRescue(AbstractKart* kart)
if (kart_over_ground)
{
//add vertical offset so that the kart starts off above the track
float vertical_offset = kart->getKartProperties()->getVertRescueOffset() *
float vertical_offset = kart->getCharacteristic()->getRescueVertOffset() *
kart->getKartHeight();
kart->getBody()->translate(btVector3(0, vertical_offset, 0));
}

9
src/physics/btKart.cpp
View File

@ -22,6 +22,7 @@
#include "LinearMath/btIDebugDraw.h"
#include "BulletDynamics/ConstraintSolver/btContactConstraint.h"
#include "karts/abstract_characteristic.hpp"
#include "karts/kart.hpp"
#include "modes/world.hpp"
#include "physics/triangle_mesh.hpp"
@ -444,7 +445,7 @@ void btKart::updateVehicle( btScalar step )
btVector3 terrain_up(0,1,0);
btVector3 axis = kart_up.cross(terrain_up);
// Give a nicely balanced feeling for rebalancing the kart
m_chassisBody->applyTorqueImpulse(axis * m_kart->getKartProperties()->getSmoothFlyingImpulse());
m_chassisBody->applyTorqueImpulse(axis * m_kart->getCharacteristic()->getStabilitySmoothFlyingImpulse());
}
// Work around: make sure that either both wheels on one axis
@ -538,7 +539,7 @@ void btKart::updateVehicle( btScalar step )
// If configured, add a force to keep karts on the track
// -----------------------------------------------------
float dif = m_kart->getKartProperties()->getDownwardImpulseFactor();
float dif = m_kart->getCharacteristic()->getStabilityDownwardImpulseFactor();
if(dif!=0 && m_num_wheels_on_ground==4)
{
float f = -fabsf(m_kart->getSpeed()) * dif;
@ -650,7 +651,7 @@ void btKart::updateSuspension(btScalar deltaTime)
// is already guaranteed that either both or no wheels on one axis
// are on the ground, so we have to test only one of the wheels
wheel_info.m_wheelsSuspensionForce =
-m_kart->getKartProperties()->getTrackConnectionAccel()
-m_kart->getCharacteristic()->getStabilityTrackConnectionAccel()
* chassisMass;
continue;
}
@ -661,7 +662,7 @@ void btKart::updateSuspension(btScalar deltaTime)
btScalar susp_length = wheel_info.getSuspensionRestLength();
btScalar current_length = wheel_info.m_raycastInfo.m_suspensionLength;
btScalar length_diff = (susp_length - current_length);
if(m_kart->getKartProperties()->getExpSpringResponse())
if(m_kart->getCharacteristic()->getSuspensionExpSpringResponse())
length_diff *= fabsf(length_diff)/susp_length;
float f = (1.0f + fabsf(length_diff) / susp_length);
// Scale the length diff. This results that in uphill sections, when

19
src/physics/physics.cpp
View File

@ -26,6 +26,7 @@
#include "graphics/irr_driver.hpp"
#include "graphics/stars.hpp"
#include "items/flyable.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/kart_properties.hpp"
#include "karts/rescue_animation.hpp"
#include "karts/controller/player_controller.hpp"
@ -218,9 +219,9 @@ void Physics::update(float dt)
}
else if (obj->isFlattenKartObject())
{
const KartProperties* kp = kart->getKartProperties();
kart->setSquash(kp->getSquashDuration(),
kp->getSquashSlowdown());
const AbstractCharacteristic *ch = kart->getCharacteristic();
kart->setSquash(ch->getSwatterSquashDuration(),
ch->getSwatterSquashSlowdown());
}
else if(obj->isSoccerBall() &&
race_manager->getMinorMode() == RaceManager::MINOR_MODE_SOCCER)
@ -248,9 +249,9 @@ void Physics::update(float dt)
else if (anim->isFlattenKartObject())
{
AbstractKart *kart = p->getUserPointer(1)->getPointerKart();
const KartProperties* kp = kart->getKartProperties();
kart->setSquash(kp->getSquashDuration(),
kp->getSquashSlowdown());
const AbstractCharacteristic *ch = kart->getCharacteristic();
kart->setSquash(ch->getSwatterSquashDuration(),
ch->getSwatterSquashSlowdown());
}
continue;
@ -397,9 +398,9 @@ void Physics::KartKartCollision(AbstractKart *kart_a,
// Add a scaling factor depending on the mass (avoid div by zero).
// The value of f_right is applied to the right kart, and f_left
// to the left kart. f_left = 1 / f_right
float f_right = right_kart->getKartProperties()->getMass() > 0
? left_kart->getKartProperties()->getMass()
/ right_kart->getKartProperties()->getMass()
float f_right = right_kart->getCharacteristic()->getMass() > 0
? left_kart->getCharacteristic()->getMass()
/ right_kart->getCharacteristic()->getMass()
: 1.5f;
// Add a scaling factor depending on speed (avoid div by 0)
f_right *= right_kart->getSpeed() > 0

10
src/states_screens/kart_selection.cpp
View File

@ -31,6 +31,7 @@
#include "input/input_manager.hpp"
#include "input/device_manager.hpp"
#include "items/item_manager.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/kart_properties.hpp"
#include "karts/kart_properties_manager.hpp"
#include "modes/overworld.hpp"
@ -810,9 +811,12 @@ void KartSelectionScreen::updateKartStats(uint8_t widget_id,
kart_properties_manager->getKart(selection);
if (kp != NULL)
{
w->setValue(KartStatsWidget::SKILL_MASS, (int)(kp->getMass()/5));
w->setValue(KartStatsWidget::SKILL_SPEED, (int)((kp->getAbsMaxSpeed()-20)*9));
w->setValue(KartStatsWidget::SKILL_POWER, (int)(kp->getAvgPower()));
w->setValue(KartStatsWidget::SKILL_MASS, (int)
(kp->getCombinedCharacteristic()->getMass() / 5));
w->setValue(KartStatsWidget::SKILL_SPEED, (int)
((kp->getCombinedCharacteristic()->getEngineMaxSpeed() - 20) * 9));
w->setValue(KartStatsWidget::SKILL_POWER, (int)
kp->getCombinedCharacteristic()->getEnginePower());
w->update(0);
}
}

5
src/states_screens/race_gui.cpp
View File

@ -38,6 +38,7 @@ using namespace irr;
#include "items/attachment.hpp"
#include "items/attachment_manager.hpp"
#include "items/powerup_manager.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/controller.hpp"
#include "karts/kart_properties.hpp"
@ -412,7 +413,7 @@ void RaceGUI::drawEnergyMeter(int x, int y, const AbstractKart *kart,
int gauge_height = (int)(GAUGEWIDTH*min_ratio);
float state = (float)(kart->getEnergy())
/ kart->getKartProperties()->getNitroMax();
/ kart->getCharacteristic()->getNitroMax();
if (state < 0.0f) state = 0.0f;
else if (state > 1.0f) state = 1.0f;
@ -435,7 +436,7 @@ void RaceGUI::drawEnergyMeter(int x, int y, const AbstractKart *kart,
if (race_manager->getCoinTarget() > 0)
{
float coin_target = (float)race_manager->getCoinTarget()
/ kart->getKartProperties()->getNitroMax();
/ kart->getCharacteristic()->getNitroMax();
video::S3DVertex vertices[5];
unsigned int count=2;

5
src/states_screens/race_gui_overworld.cpp
View File

@ -36,6 +36,7 @@
#include "items/attachment.hpp"
#include "items/attachment_manager.hpp"
#include "items/powerup_manager.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/controller.hpp"
#include "karts/kart_properties.hpp"
@ -551,7 +552,7 @@ void RaceGUIOverworld::drawEnergyMeter(int x, int y, const AbstractKart *kart,
const core::vector2df &scaling)
{
float state = (float)(kart->getEnergy())
/ kart->getKartProperties()->getNitroMax();
/ kart->getCharacteristic()->getNitroMax();
if (state < 0.0f) state = 0.0f;
else if (state > 1.0f) state = 1.0f;
@ -572,7 +573,7 @@ void RaceGUIOverworld::drawEnergyMeter(int x, int y, const AbstractKart *kart,
if (race_manager->getCoinTarget() > 0)
{
float coin_target = (float)race_manager->getCoinTarget()
/ kart->getKartProperties()->getNitroMax();
/ kart->getCharacteristic()->getNitroMax();
const int EMPTY_TOP_PIXELS = 4;
const int EMPTY_BOTTOM_PIXELS = 3;

5
src/tracks/track.cpp
View File

@ -44,6 +44,7 @@
#include "io/xml_node.hpp"
#include "items/item.hpp"
#include "items/item_manager.hpp"
#include "karts/abstract_characteristic.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/kart_properties.hpp"
#include "modes/linear_world.hpp"
@ -2444,8 +2445,8 @@ bool Track::findGround(AbstractKart *kart)
// length of the suspension with the weight of the kart resting on
// it). On the other hand this initial bouncing looks nice imho
// - so I'll leave it in for now.
float offset = kart->getKartProperties()->getSuspensionRest() +
kart->getKartProperties()->getWheelRadius();
float offset = kart->getCharacteristic()->getSuspensionRest() +
kart->getCharacteristic()->getWheelsRadius();
t.setOrigin(hit_point+Vec3(0, offset, 0) );
kart->getBody()->setCenterOfMassTransform(t);
kart->setTrans(t);

25
tools/create_kart_properties.py
View File

@ -25,7 +25,7 @@ import sys
# Input data
#FIXME is wheelPosition needed?
characteristics = """Suspension: stiffness, rest, travelCm, expSpringResponse, maxForce
characteristics = """Suspension: stiffness, rest, travelCm, expSpringResponse(bool), maxForce
Stability: rollInfluence, chassisLinearDamping, chassisAngularDamping, downwardImpulseFactor, trackConnectionAccel, smoothFlyingImpulse
Turn: radius(InterpolationArray), timeResetSteer, timeFullSteer(InterpolationArray)
Engine: power, maxSpeed, brakeFactor, brakeTimeIncrease, maxSpeedReverseRatio
@ -38,9 +38,9 @@ Lean: max, speed
Anvil: duration, weight, speedFactor
Parachute: friction, duration, durationOther, lboundFranction, uboundFranction, maxSpeed
Bubblegum: duration, speedFraction, torque, fadeInTime, shieldDuration
Zipper: duration, force, speedGain, speedIncrease, fadeOutTime
Zipper: duration, force, speedGain, maxSpeedIncrease, fadeOutTime
Swatter: duration, distance, squashDuration, squashSlowdown
Plunger: maxLength, force, duration, speedIncrease, fadeOutTime, inFaceTime
Plunger: bandMaxLength, bandForce, bandDuration, bandSpeedIncrease, bandFadeOutTime, inFaceTime
Startup: time(std::vector<float>/floatVector), boost(std::vector<float>/floatVector)
Rescue: duration, vertOffset, height
Explosion: duration, radius, invulnerabilityTime
@ -51,12 +51,19 @@ Slipstream: duration, length, width, collectTime, useTime, addPower, minSpeed, m
class GroupMember:
def __init__(self, name, typeC, typeStr):
self.name = name
if name == "value":
self.getName = ""
else:
self.getName = name
self.typeC = typeC
self.typeStr = typeStr
"""E.g. power(std::vector<float>/floatVector)
or speed(InterpolationArray)
The default type is float"""
The default type is float
The name 'value' is special: Only the group name will be used to access
the member but in the xml file it will be still value (because we
need a name)."""
def parse(content):
typeC = "float"
typeStr = typeC
@ -84,8 +91,6 @@ class Group:
self.members.append(GroupMember.parse(content))
def getBaseName(self):
if len(self.baseName) == 0 and len(self.members) > 0:
return self.members[0].name
return self.baseName
"""E.g. engine: power, gears(std::vector<Gear>/Gears)
@ -93,8 +98,8 @@ class Group:
def parse(content):
pos = content.find(":")
if pos == -1:
group = Group("")
group.addMember(content)
group = Group(content)
group.addMember("value")
return group
else:
group = Group(content[:pos].strip())
@ -118,7 +123,7 @@ def toList(name):
"""titleCase: true = result is titlecase
false = result has underscores"""
def joinSubName(group, member, titleCase):
words = toList(group.baseName) + toList(member.name)
words = toList(group.baseName) + toList(member.getName)
first = True
if titleCase:
words = [w.title() for w in words]
@ -129,7 +134,7 @@ def joinSubName(group, member, titleCase):
def main():
# Find out what to do
if len(sys.argv) == 1:
print("Please specify what you want to know [enum/defs/getter/getProp/getXml]")
print("Please specify what you want to know [enum|defs|getter|getProp|getXml]")
return
task = sys.argv[1]