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

Refactored KartControl to use setters/getters instead of

Browse Source 
just public variables.
This commit is contained in:
hiker 2016-08-15 17:26:07 +10:00
parent 239881ef5e
commit 7c899c943c
22 changed files with 372 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/items/bowling.cpp
View File

@ -40,7 +40,7 @@ Bowling::Bowling(AbstractKart *kart)
float y_offset = 0.5f*kart->getKartLength() + m_extend.getZ()*0.5f; float y_offset = 0.5f*kart->getKartLength() + m_extend.getZ()*0.5f;
// if the kart is looking backwards, release from the back // if the kart is looking backwards, release from the back
if( kart->getControls().m_look_back ) if( kart->getControls().getLookBack())
{ {
y_offset = -y_offset; y_offset = -y_offset;
m_speed = -m_speed*2; m_speed = -m_speed*2;

2
src/items/cake.cpp
View File

@ -61,7 +61,7 @@ Cake::Cake (AbstractKart *kart) : Flyable(kart, PowerupManager::POWERUP_CAKE)
float pitch = kart->getTerrainPitch(heading); float pitch = kart->getTerrainPitch(heading);
// Find closest kart in front of the current one // Find closest kart in front of the current one
const bool backwards = kart->getControls().m_look_back; const bool backwards = kart->getControls().getLookBack();
const AbstractKart *closest_kart=NULL; const AbstractKart *closest_kart=NULL;
Vec3 direction; Vec3 direction;
float kart_dist_squared; float kart_dist_squared;

2
src/items/plunger.cpp
View File

@ -46,7 +46,7 @@ Plunger::Plunger(AbstractKart *kart)
float plunger_speed = 2 * m_speed; float plunger_speed = 2 * m_speed;
// if the kart is looking backwards, release from the back // if the kart is looking backwards, release from the back
m_reverse_mode = kart->getControls().m_look_back; m_reverse_mode = kart->getControls().getLookBack();
// find closest kart in front of the current one // find closest kart in front of the current one
const AbstractKart *closest_kart=0; const AbstractKart *closest_kart=0;

2
src/items/powerup.cpp
View File

@ -272,7 +272,7 @@ void Powerup::use()
case PowerupManager::POWERUP_BUBBLEGUM: case PowerupManager::POWERUP_BUBBLEGUM:
// use the bubble gum the traditional way, if the kart is looking back // use the bubble gum the traditional way, if the kart is looking back
if (m_kart->getControls().m_look_back) if (m_kart->getControls().getLookBack())
{ {
Vec3 hit_point; Vec3 hit_point;
Vec3 normal; Vec3 normal;

2
src/karts/abstract_kart.hpp
View File

@ -109,7 +109,7 @@ public:
// Functions related to controlling the kart // Functions related to controlling the kart
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
/** Returns the current steering value for this kart. */ /** Returns the current steering value for this kart. */
float getSteerPercent() const { return m_controls.m_steer; } float getSteerPercent() const { return m_controls.getSteer(); }
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
/** Returns all controls of this kart. */ /** Returns all controls of this kart. */
KartControl& getControls() { return m_controls; } KartControl& getControls() { return m_controls; }

16
src/karts/controller/ai_base_controller.cpp
View File

@ -186,11 +186,11 @@ void AIBaseController::setSteering(float angle, float dt)
{ {
float steer_fraction = angle / m_kart->getMaxSteerAngle(); float steer_fraction = angle / m_kart->getMaxSteerAngle();
if(!canSkid(steer_fraction)) if(!canSkid(steer_fraction))
m_controls->m_skid = KartControl::SC_NONE; m_controls->setSkidControl(KartControl::SC_NONE);
else else
m_controls->m_skid = steer_fraction > 0 ? KartControl::SC_RIGHT m_controls->setSkidControl(steer_fraction > 0 ? KartControl::SC_RIGHT
: KartControl::SC_LEFT; : KartControl::SC_LEFT );
float old_steer = m_controls->m_steer; float old_steer = m_controls->getSteer();
if (steer_fraction > 1.0f) steer_fraction = 1.0f; if (steer_fraction > 1.0f) steer_fraction = 1.0f;
else if(steer_fraction < -1.0f) steer_fraction = -1.0f; else if(steer_fraction < -1.0f) steer_fraction = -1.0f;
@ -205,13 +205,13 @@ void AIBaseController::setSteering(float angle, float dt)
float max_steer_change = dt/m_ai_properties->m_time_full_steer; float max_steer_change = dt/m_ai_properties->m_time_full_steer;
if(old_steer < steer_fraction) if(old_steer < steer_fraction)
{ {
m_controls->m_steer = (old_steer+max_steer_change > steer_fraction) m_controls->setSteer(( old_steer+max_steer_change > steer_fraction)
? steer_fraction : old_steer+max_steer_change; ? steer_fraction : old_steer+max_steer_change);
} }
else else
{ {
m_controls->m_steer = (old_steer-max_steer_change < steer_fraction) m_controls->setSteer( (old_steer-max_steer_change < steer_fraction)
? steer_fraction : old_steer-max_steer_change; ? steer_fraction : old_steer-max_steer_change );
} }
} // setSteering } // setSteering

54
src/karts/controller/arena_ai.cpp
View File

@ -86,8 +86,8 @@ void ArenaAI::reset()
void ArenaAI::update(float dt) void ArenaAI::update(float dt)
{ {
// This is used to enable firing an item backwards. // This is used to enable firing an item backwards.
m_controls->m_look_back = false; m_controls->setLookBack(false);
m_controls->m_nitro = false; m_controls->setNitro(false);
m_avoiding_banana = false; m_avoiding_banana = false;
// Don't do anything if there is currently a kart animations shown. // Don't do anything if there is currently a kart animations shown.
@ -114,7 +114,7 @@ void ArenaAI::update(float dt)
if (m_kart->getSpeed() > 15.0f && m_turn_angle < 20) if (m_kart->getSpeed() > 15.0f && m_turn_angle < 20)
{ {
// Only use nitro when turn angle is big (180 - angle) // Only use nitro when turn angle is big (180 - angle)
m_controls->m_nitro = true; m_controls->setNitro(true);
} }
if (m_is_uturn) if (m_is_uturn)
@ -298,15 +298,15 @@ void ArenaAI::checkIfStuck(const float dt)
void ArenaAI::handleArenaAcceleration(const float dt) void ArenaAI::handleArenaAcceleration(const float dt)
{ {
if (m_controls->m_brake) if (m_controls->getBrake())
{ {
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
return; return;
} }
const float handicap = const float handicap =
(m_cur_difficulty == RaceManager::DIFFICULTY_EASY ? 0.7f : 1.0f); (m_cur_difficulty == RaceManager::DIFFICULTY_EASY ? 0.7f : 1.0f);
m_controls->m_accel = stk_config->m_ai_acceleration * handicap; m_controls->setAccel(stk_config->m_ai_acceleration * handicap);
} // handleArenaAcceleration } // handleArenaAcceleration
@ -318,9 +318,9 @@ void ArenaAI::handleArenaUTurn(const float dt)
if (fabsf(m_kart->getSpeed()) > if (fabsf(m_kart->getSpeed()) >
(m_kart->getKartProperties()->getEngineMaxSpeed() / 5) (m_kart->getKartProperties()->getEngineMaxSpeed() / 5)
&& m_kart->getSpeed() < 0) // Try to emulate reverse like human players && m_kart->getSpeed() < 0) // Try to emulate reverse like human players
m_controls->m_accel = -0.06f; m_controls->setAccel(-0.06f);
else else
m_controls->m_accel = -5.0f; m_controls->setAccel(-5.0f);
if (m_time_since_uturn >= if (m_time_since_uturn >=
(m_cur_difficulty == RaceManager::DIFFICULTY_EASY ? 2.0f : 1.5f)) (m_cur_difficulty == RaceManager::DIFFICULTY_EASY ? 2.0f : 1.5f))
@ -351,9 +351,9 @@ bool ArenaAI::handleArenaUnstuck(const float dt)
if (fabsf(m_kart->getSpeed()) > if (fabsf(m_kart->getSpeed()) >
(m_kart->getKartProperties()->getEngineMaxSpeed() / 5) (m_kart->getKartProperties()->getEngineMaxSpeed() / 5)
&& m_kart->getSpeed() < 0) && m_kart->getSpeed() < 0)
m_controls->m_accel = -0.06f; m_controls->setAccel(-0.06f);
else else
m_controls->m_accel = -4.0f; m_controls->setAccel(-4.0f);
m_time_since_reversing += dt; m_time_since_reversing += dt;
@ -423,11 +423,11 @@ void ArenaAI::handleArenaBraking()
if (forceBraking() && m_kart->getSpeed() > MIN_SPEED) if (forceBraking() && m_kart->getSpeed() > MIN_SPEED)
{ {
// Brake now // Brake now
m_controls->m_brake = true; m_controls->setBrake(true);
return; return;
} }
m_controls->m_brake = false; m_controls->setBrake(false);
if (getCurrentNode() == BattleGraph::UNKNOWN_POLY || if (getCurrentNode() == BattleGraph::UNKNOWN_POLY ||
m_target_node == BattleGraph::UNKNOWN_POLY) return; m_target_node == BattleGraph::UNKNOWN_POLY) return;
@ -437,10 +437,10 @@ void ArenaAI::handleArenaBraking()
const float max_turn_speed = m_kart->getSpeedForTurnRadius(m_turn_radius); const float max_turn_speed = m_kart->getSpeedForTurnRadius(m_turn_radius);
if (m_kart->getSpeed() > 1.25f * max_turn_speed && if (m_kart->getSpeed() > 1.25f * max_turn_speed &&
fabsf(m_controls->m_steer) > 0.95f && fabsf(m_controls->getSteer()) > 0.95f &&
m_kart->getSpeed() > MIN_SPEED) m_kart->getSpeed() > MIN_SPEED)
{ {
m_controls->m_brake = true; m_controls->setBrake(true);
} }
} // handleArenaBraking } // handleArenaBraking
@ -502,7 +502,7 @@ float ArenaAI::findAngleFrom3Edges(float a, float b, float c)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ArenaAI::handleArenaItems(const float dt) void ArenaAI::handleArenaItems(const float dt)
{ {
m_controls->m_fire = false; m_controls->setFire(false);
if (m_kart->getKartAnimation() || if (m_kart->getKartAnimation() ||
m_kart->getPowerup()->getType() == PowerupManager::POWERUP_NOTHING) m_kart->getPowerup()->getType() == PowerupManager::POWERUP_NOTHING)
return; return;
@ -544,8 +544,8 @@ void ArenaAI::handleArenaItems(const float dt)
) )
) )
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_controls->m_look_back = false; m_controls->setLookBack(false);
break; break;
} }
@ -558,8 +558,8 @@ void ArenaAI::handleArenaItems(const float dt)
m_closest_kart_pos_data.distance > 3.0f) || m_closest_kart_pos_data.distance > 3.0f) ||
m_time_since_last_shot > 15.0f) m_time_since_last_shot > 15.0f)
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_controls->m_look_back = true; m_controls->setLookBack(true);
break; break;
} }
@ -577,8 +577,8 @@ void ArenaAI::handleArenaItems(const float dt)
if (m_closest_kart_pos_data.distance < 25.0f && if (m_closest_kart_pos_data.distance < 25.0f &&
!m_closest_kart->isInvulnerable()) !m_closest_kart->isInvulnerable())
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_controls->m_look_back = fire_behind; m_controls->setLookBack(fire_behind);
break; break;
} }
@ -598,8 +598,8 @@ void ArenaAI::handleArenaItems(const float dt)
(difficulty || perfect_aim) && (difficulty || perfect_aim) &&
!m_closest_kart->isInvulnerable()) !m_closest_kart->isInvulnerable())
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_controls->m_look_back = fire_behind; m_controls->setLookBack(fire_behind);
break; break;
} }
@ -618,8 +618,8 @@ void ArenaAI::handleArenaItems(const float dt)
m_closest_kart_pos_data.distance < d2 && m_closest_kart_pos_data.distance < d2 &&
m_closest_kart->getSpeed() < m_kart->getSpeed()) m_closest_kart->getSpeed() < m_kart->getSpeed())
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_controls->m_look_back = false; m_controls->setLookBack(false);
break; break;
} }
break; break;
@ -633,7 +633,7 @@ void ArenaAI::handleArenaItems(const float dt)
break; // POWERUP_PLUNGER break; // POWERUP_PLUNGER
case PowerupManager::POWERUP_SWITCH: // Don't handle switch case PowerupManager::POWERUP_SWITCH: // Don't handle switch
m_controls->m_fire = true; // (use it no matter what) for now m_controls->setFire(true); // (use it no matter what) for now
break; // POWERUP_SWITCH break; // POWERUP_SWITCH
case PowerupManager::POWERUP_PARACHUTE: case PowerupManager::POWERUP_PARACHUTE:
@ -651,7 +651,7 @@ void ArenaAI::handleArenaItems(const float dt)
m_kart->getPowerup()->getType()); m_kart->getPowerup()->getType());
assert(false); assert(false);
} }
if (m_controls->m_fire) if (m_controls->getFire())
m_time_since_last_shot = 0.0f; m_time_since_last_shot = 0.0f;
} // handleArenaItems } // handleArenaItems

12
src/karts/controller/end_controller.cpp
View File

@ -174,10 +174,10 @@ void EndController::action(PlayerAction action, int value)
void EndController::update(float dt) void EndController::update(float dt)
{ {
// This is used to enable firing an item backwards. // This is used to enable firing an item backwards.
m_controls->m_look_back = false; m_controls->setLookBack(false);
m_controls->m_nitro = false; m_controls->setNitro(false);
m_controls->m_brake = false; m_controls->setBrake(false);
m_controls->m_accel = 1.0f; m_controls->setAccel(1.0f);
AIBaseLapController::update(dt); AIBaseLapController::update(dt);
@ -186,10 +186,10 @@ void EndController::update(float dt)
race_manager->getMinorMode()==RaceManager::MINOR_MODE_SOCCER || race_manager->getMinorMode()==RaceManager::MINOR_MODE_SOCCER ||
race_manager->getMinorMode()==RaceManager::MINOR_MODE_EASTER_EGG) race_manager->getMinorMode()==RaceManager::MINOR_MODE_EASTER_EGG)
{ {
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
// Brake while we are still driving forwards (if we keep // Brake while we are still driving forwards (if we keep
// on braking, the kart will reverse otherwise) // on braking, the kart will reverse otherwise)
m_controls->m_brake = m_kart->getSpeed()>0; m_controls->setBrake(m_kart->getSpeed()>0);
return; return;
} }
/*Get information that is needed by more than 1 of the handling funcs*/ /*Get information that is needed by more than 1 of the handling funcs*/

4
src/karts/controller/ghost_controller.cpp
View File

@ -54,7 +54,7 @@ void GhostController::update(float dt)
if(camera->getKart()!=m_kart) continue; if(camera->getKart()!=m_kart) continue;
if (camera->getType() != Camera::CM_TYPE_END) if (camera->getType() != Camera::CM_TYPE_END)
{ {
if (m_controls->m_look_back) if (m_controls->getLookBack())
{ {
camera->setMode(Camera::CM_REVERSE); camera->setMode(Camera::CM_REVERSE);
} }
@ -85,5 +85,5 @@ void GhostController::action(PlayerAction action, int value)
{ {
// Watching replay use only // Watching replay use only
if (action == PA_LOOK_BACK) if (action == PA_LOOK_BACK)
m_controls->m_look_back = (value!=0); m_controls->setLookBack(value!=0);
} // action } // action

66
src/karts/controller/kart_control.hpp
View File

@ -29,6 +29,12 @@
class KartControl class KartControl
{ {
public: public:
/** The skidding control state: SC_NONE: not pressed;
* SC_NO_DIRECTION: pressed, but no steering;
* SC_LEFT/RIGHT: pressed in the specified direction. */
enum SkidControl {SC_NONE, SC_NO_DIRECTION, SC_LEFT, SC_RIGHT};
private:
/** The current steering value in [-1, 1]. */ /** The current steering value in [-1, 1]. */
float m_steer; float m_steer;
/** Acceleration, in [0, 1]. */ /** Acceleration, in [0, 1]. */
@ -37,17 +43,15 @@ public:
bool m_brake; bool m_brake;
/** True if the kart activates nitro. */ /** True if the kart activates nitro. */
bool m_nitro; bool m_nitro;
/** The skidding control state: SC_NONE: not pressed; /** Skidding control state. */
SC_NO_DIRECTION: pressed, but no steering; SkidControl m_skid;
SC_LEFT/RIGHT: pressed in the specified direction. */
enum SkidControl {SC_NONE, SC_NO_DIRECTION, SC_LEFT, SC_RIGHT}
m_skid;
/** True if rescue is selected. */ /** True if rescue is selected. */
bool m_rescue; bool m_rescue;
/** True if fire is selected. */ /** True if fire is selected. */
bool m_fire; bool m_fire;
/** True if the kart looks (and shoots) backwards. */ /** True if the kart looks (and shoots) backwards. */
bool m_look_back; bool m_look_back;
public:
KartControl() KartControl()
{ {
@ -126,6 +130,58 @@ public:
m_look_back = (c & 16) != 0; m_look_back = (c & 16) != 0;
m_skid = (SkidControl)((c & 96) >> 5); m_skid = (SkidControl)((c & 96) >> 5);
} // setButtonsCompressed } // setButtonsCompressed
// ------------------------------------------------------------------------
/** Returns the current steering value. */
float getSteer() const { return m_steer; }
// ------------------------------------------------------------------------
/** Sets the current steering value. */
void setSteer(float f) { m_steer = f; }
// ------------------------------------------------------------------------
/** Returns current acceleration. */
float getAccel() const { return m_accel; }
// ------------------------------------------------------------------------
/** Sets the acceleration. */
void setAccel(float f) { m_accel = f; }
// ------------------------------------------------------------------------
/** Returns if the kart is braking. */
bool getBrake() const { return m_brake; }
// ------------------------------------------------------------------------
/** Sets if the kart is braking. */
void setBrake(bool b) { m_brake = b; }
// ------------------------------------------------------------------------
/** Returns if the kart activates nitro. */
bool getNitro() const { return m_nitro; }
// ------------------------------------------------------------------------
/** Sets if the kart activates nitro. */
void setNitro(bool b) { m_nitro = b; }
// ------------------------------------------------------------------------
/** Returns the skidding control state: SC_NONE: not pressed;
* SC_NO_DIRECTION: pressed, but no steering;
* SC_LEFT/RIGHT: pressed in the specified direction. */
SkidControl getSkidControl() const { return m_skid; }
// ------------------------------------------------------------------------
/** Sets the skid control for this kart. */
void setSkidControl(SkidControl sc) { m_skid = sc; }
// ------------------------------------------------------------------------
/** Returns true if the kart triggered rescue. */
bool getRescue() const { return m_rescue; }
// ------------------------------------------------------------------------
/** Returns if this kart wants to get rescued. */
void setRescue(bool b) { m_rescue = b; }
// ------------------------------------------------------------------------
/** Returns if fire is selected. */
bool getFire() const { return m_fire; }
// ------------------------------------------------------------------------
/** Sets if the kart wants to fire. */
void setFire(bool b) { m_fire = b; }
// ------------------------------------------------------------------------
/** Returns if the kart wants to look back (which also implies that it
* will fire backwards. */
bool getLookBack() const { return m_look_back; }
// ------------------------------------------------------------------------
/** Sets if the kart wants to look (and therefore also fires) backwards. */
void setLookBack(bool b) { m_look_back = b; }
}; };
#endif #endif

5
src/karts/controller/local_player_controller.cpp
View File

@ -147,7 +147,8 @@ void LocalPlayerController::steer(float dt, int steer_val)
if(UserConfigParams::m_gamepad_debug) if(UserConfigParams::m_gamepad_debug)
{ {
Log::debug("LocalPlayerController", " set to: %f\n", m_controls->m_steer); Log::debug("LocalPlayerController", " set to: %f\n",
m_controls->getSteer());
} }
} // steer } // steer
@ -170,7 +171,7 @@ void LocalPlayerController::update(float dt)
Camera *camera = Camera::getCamera(m_camera_index); Camera *camera = Camera::getCamera(m_camera_index);
if (camera->getType() != Camera::CM_TYPE_END) if (camera->getType() != Camera::CM_TYPE_END)
{ {
if (m_controls->m_look_back || (UserConfigParams::m_reverse_look_threshold > 0 && if (m_controls->getLookBack() || (UserConfigParams::m_reverse_look_threshold > 0 &&
m_kart->getSpeed() < -UserConfigParams::m_reverse_look_threshold)) m_kart->getSpeed() < -UserConfigParams::m_reverse_look_threshold))
{ {
camera->setMode(Camera::CM_REVERSE); camera->setMode(Camera::CM_REVERSE);

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

@ -103,8 +103,8 @@ void PlayerController::action(PlayerAction action, int value)
if (value) if (value)
{ {
m_steer_val = value; m_steer_val = value;
if(m_controls->m_skid==KartControl::SC_NO_DIRECTION) if(m_controls->getSkidControl()==KartControl::SC_NO_DIRECTION)
m_controls->m_skid = KartControl::SC_LEFT; m_controls->setSkidControl(KartControl::SC_LEFT);
} }
else else
m_steer_val = m_steer_val_r; m_steer_val = m_steer_val_r;
@ -115,8 +115,8 @@ void PlayerController::action(PlayerAction action, int value)
if (value) if (value)
{ {
m_steer_val = -value; m_steer_val = -value;
if(m_controls->m_skid==KartControl::SC_NO_DIRECTION) if(m_controls->getSkidControl()==KartControl::SC_NO_DIRECTION)
m_controls->m_skid = KartControl::SC_RIGHT; m_controls->setSkidControl(KartControl::SC_RIGHT);
} }
else else
m_steer_val = m_steer_val_l; m_steer_val = m_steer_val_l;
@ -126,15 +126,15 @@ void PlayerController::action(PlayerAction action, int value)
m_prev_accel = value; m_prev_accel = value;
if (value && !(m_penalty_time > 0.0f)) if (value && !(m_penalty_time > 0.0f))
{ {
m_controls->m_accel = value/32768.0f; m_controls->setAccel(value/32768.0f);
m_controls->m_brake = false; m_controls->setBrake(false);
m_controls->m_nitro = m_prev_nitro; m_controls->setNitro(m_prev_nitro);
} }
else else
{ {
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
m_controls->m_brake = m_prev_brake; m_controls->setBrake(m_prev_brake);
m_controls->m_nitro = false; m_controls->setNitro(false);
} }
break; break;
case PA_BRAKE: case PA_BRAKE:
@ -142,44 +142,44 @@ void PlayerController::action(PlayerAction action, int value)
// let's consider below that to be a deadzone // let's consider below that to be a deadzone
if(value > 32768/2) if(value > 32768/2)
{ {
m_controls->m_brake = true; m_controls->setBrake(true);
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
m_controls->m_nitro = false; m_controls->setNitro(false);
} }
else else
{ {
m_controls->m_brake = false; m_controls->setBrake(false);
m_controls->m_accel = m_prev_accel/32768.0f; m_controls->setAccel(m_prev_accel/32768.0f);
// Nitro still depends on whether we're accelerating // Nitro still depends on whether we're accelerating
m_controls->m_nitro = (m_prev_nitro && m_prev_accel); m_controls->setNitro(m_prev_nitro && m_prev_accel);
} }
break; break;
case PA_NITRO: case PA_NITRO:
// This basically keeps track whether the button still is being pressed // This basically keeps track whether the button still is being pressed
m_prev_nitro = (value != 0); m_prev_nitro = (value != 0);
// Enable nitro only when also accelerating // Enable nitro only when also accelerating
m_controls->m_nitro = ((value!=0) && m_controls->m_accel); m_controls->setNitro( ((value!=0) && m_controls->getAccel()) );
break; break;
case PA_RESCUE: case PA_RESCUE:
m_controls->m_rescue = (value!=0); m_controls->setRescue(value!=0);
break; break;
case PA_FIRE: case PA_FIRE:
m_controls->m_fire = (value!=0); m_controls->setFire(value!=0);
break; break;
case PA_LOOK_BACK: case PA_LOOK_BACK:
m_controls->m_look_back = (value!=0); m_controls->setLookBack(value!=0);
break; break;
case PA_DRIFT: case PA_DRIFT:
if(value==0) if(value==0)
m_controls->m_skid = KartControl::SC_NONE; m_controls->setSkidControl(KartControl::SC_NONE);
else else
{ {
if(m_steer_val==0) if(m_steer_val==0)
m_controls->m_skid = KartControl::SC_NO_DIRECTION; m_controls->setSkidControl(KartControl::SC_NO_DIRECTION);
else else
m_controls->m_skid = m_steer_val<0 m_controls->setSkidControl(m_steer_val<0
? KartControl::SC_RIGHT ? KartControl::SC_RIGHT
: KartControl::SC_LEFT; : KartControl::SC_LEFT );
} }
break; break;
case PA_PAUSE_RACE: case PA_PAUSE_RACE:
@ -196,52 +196,54 @@ void PlayerController::action(PlayerAction action, int value)
*/ */
void PlayerController::steer(float dt, int steer_val) void PlayerController::steer(float dt, int steer_val)
{ {
// Get the old value, compute the new steering value,
// and set it at the end of this function
float steer = m_controls->getSteer();
if(stk_config->m_disable_steer_while_unskid && if(stk_config->m_disable_steer_while_unskid &&
m_controls->m_skid==KartControl::SC_NONE && m_controls->getSkidControl()==KartControl::SC_NONE &&
m_kart->getSkidding()->getVisualSkidRotation()!=0) m_kart->getSkidding()->getVisualSkidRotation()!=0)
{ {
m_controls->m_steer = 0; steer = 0;
} }
// Amount the steering is changed for digital devices. // Amount the steering is changed for digital devices.
// If the steering is 'back to straight', a different steering // If the steering is 'back to straight', a different steering
// change speed is used. // change speed is used.
const float STEER_CHANGE = ( (steer_val<=0 && m_controls->m_steer<0) || const float STEER_CHANGE = ( (steer_val<=0 && steer<0) ||
(steer_val>=0 && m_controls->m_steer>0) ) (steer_val>=0 && steer>0) )
? dt/m_kart->getKartProperties()->getTurnTimeResetSteer() ? dt/m_kart->getKartProperties()->getTurnTimeResetSteer()
: dt/m_kart->getTimeFullSteer(fabsf(m_controls->m_steer)); : dt/m_kart->getTimeFullSteer(fabsf(steer));
if (steer_val < 0) if (steer_val < 0)
{ {
// If we got analog values do not cumulate. // If we got analog values do not cumulate.
if (steer_val > -32767) if (steer_val > -32767)
m_controls->m_steer = -steer_val/32767.0f; steer = -steer_val/32767.0f;
else else
m_controls->m_steer += STEER_CHANGE; steer += STEER_CHANGE;
} }
else if(steer_val > 0) else if(steer_val > 0)
{ {
// If we got analog values do not cumulate. // If we got analog values do not cumulate.
if (steer_val < 32767) if (steer_val < 32767)
m_controls->m_steer = -steer_val/32767.0f; steer = -steer_val/32767.0f;
else else
m_controls->m_steer -= STEER_CHANGE; steer -= STEER_CHANGE;
} }
else else
{ // no key is pressed { // no key is pressed
if(m_controls->m_steer>0.0f) if(steer>0.0f)
{ {
m_controls->m_steer -= STEER_CHANGE; steer -= STEER_CHANGE;
if(m_controls->m_steer<0.0f) m_controls->m_steer=0.0f; if(steer<0.0f) steer=0.0f;
} }
else else
{ // m_controls->m_steer<=0.0f; { // steer<=0.0f;
m_controls->m_steer += STEER_CHANGE; steer += STEER_CHANGE;
if(m_controls->m_steer>0.0f) m_controls->m_steer=0.0f; if(steer>0.0f) steer=0.0f;
} // if m_controls->m_steer<=0.0f } // if steer<=0.0f
} // no key is pressed } // no key is pressed
m_controls->m_steer = std::min(1.0f, std::max(-1.0f, m_controls->m_steer)); m_controls->setSteer(std::min(1.0f, std::max(-1.0f, steer)) );
} // steer } // steer
@ -251,7 +253,7 @@ void PlayerController::steer(float dt, int steer_val)
*/ */
void PlayerController::skidBonusTriggered() void PlayerController::skidBonusTriggered()
{ {
m_controls->m_steer = 0; m_controls->setSteer(0);
} // skidBonusTriggered } // skidBonusTriggered
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -267,15 +269,15 @@ void PlayerController::update(float dt)
if (World::getWorld()->getPhase() == World::GOAL_PHASE) if (World::getWorld()->getPhase() == World::GOAL_PHASE)
{ {
m_controls->m_brake = false; m_controls->setBrake(false);
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
return; return;
} }
if (World::getWorld()->isStartPhase()) if (World::getWorld()->isStartPhase())
{ {
if (m_controls->m_accel || m_controls->m_brake || if (m_controls->getAccel() || m_controls->getBrake()||
m_controls->m_fire || m_controls->m_nitro) m_controls->getFire() || m_controls->getNitro())
{ {
// Only give penalty time in SET_PHASE. // Only give penalty time in SET_PHASE.
// Penalty time check makes sure it doesn't get rendered on every // Penalty time check makes sure it doesn't get rendered on every
@ -287,8 +289,8 @@ void PlayerController::update(float dt)
m_penalty_time = stk_config->m_penalty_time; m_penalty_time = stk_config->m_penalty_time;
} // if penalty_time = 0 } // if penalty_time = 0
m_controls->m_brake = false; m_controls->setBrake(false);
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
} // if key pressed } // if key pressed
return; return;
@ -303,10 +305,10 @@ void PlayerController::update(float dt)
// Only accept rescue if there is no kart animation is already playing // Only accept rescue if there is no kart animation is already playing
// (e.g. if an explosion happens, wait till the explosion is over before // (e.g. if an explosion happens, wait till the explosion is over before
// starting any other animation). // starting any other animation).
if ( m_controls->m_rescue && !m_kart->getKartAnimation() ) if ( m_controls->getRescue() && !m_kart->getKartAnimation() )
{ {
new RescueAnimation(m_kart); new RescueAnimation(m_kart);
m_controls->m_rescue=false; m_controls->setRescue(false);
} }
} // update } // update

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

@ -222,8 +222,8 @@ unsigned int SkiddingAI::getNextSector(unsigned int index)
void SkiddingAI::update(float dt) void SkiddingAI::update(float dt)
{ {
// This is used to enable firing an item backwards. // This is used to enable firing an item backwards.
m_controls->m_look_back = false; m_controls->setLookBack(false);
m_controls->m_nitro = false; m_controls->setNitro(false);
// Don't do anything if there is currently a kart animations shown. // Don't do anything if there is currently a kart animations shown.
if(m_kart->getKartAnimation()) if(m_kart->getKartAnimation())
@ -323,8 +323,8 @@ void SkiddingAI::update(float dt)
m_kart_ahead ) m_kart_ahead )
{ {
// Use nitro if the kart is far ahead, or faster than this kart // Use nitro if the kart is far ahead, or faster than this kart
m_controls->m_nitro = m_distance_ahead>10.0f || m_controls->setNitro(m_distance_ahead>10.0f ||
m_kart_ahead->getSpeed() > m_kart->getSpeed(); m_kart_ahead->getSpeed() > m_kart->getSpeed());
// If we are close enough, try to hit this kart // If we are close enough, try to hit this kart
if(m_distance_ahead<=10) if(m_distance_ahead<=10)
{ {
@ -354,12 +354,12 @@ void SkiddingAI::update(float dt)
handleRescue(dt); handleRescue(dt);
handleBraking(); handleBraking();
// If a bomb is attached, nitro might already be set. // If a bomb is attached, nitro might already be set.
if(!m_controls->m_nitro) if(!m_controls->getNitro())
handleNitroAndZipper(); handleNitroAndZipper();
} }
// If we are supposed to use nitro, but have a zipper, // If we are supposed to use nitro, but have a zipper,
// use the zipper instead (unless there are items to avoid cloe by) // use the zipper instead (unless there are items to avoid cloe by)
if(m_controls->m_nitro && if(m_controls->getNitro() &&
m_kart->getPowerup()->getType()==PowerupManager::POWERUP_ZIPPER && m_kart->getPowerup()->getType()==PowerupManager::POWERUP_ZIPPER &&
m_kart->getSpeed()>1.0f && m_kart->getSpeed()>1.0f &&
m_kart->getSpeedIncreaseTimeLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0 && m_kart->getSpeedIncreaseTimeLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0 &&
@ -371,8 +371,8 @@ void SkiddingAI::update(float dt)
if(race_manager->getMinorMode()!=RaceManager::MINOR_MODE_TIME_TRIAL || if(race_manager->getMinorMode()!=RaceManager::MINOR_MODE_TIME_TRIAL ||
(m_world->getTime()<3.0f && rand()%50==1) ) (m_world->getTime()<3.0f && rand()%50==1) )
{ {
m_controls->m_nitro = false; m_controls->setNitro(false);
m_controls->m_fire = true; m_controls->setFire(true);
} }
} }
@ -390,7 +390,7 @@ void SkiddingAI::update(float dt)
*/ */
void SkiddingAI::handleBraking() void SkiddingAI::handleBraking()
{ {
m_controls->m_brake = false; m_controls->setBrake(false);
// In follow the leader mode, the kart should brake if they are ahead of // In follow the leader mode, the kart should brake if they are ahead of
// the leader (and not the leader, i.e. don't have initial position 1) // the leader (and not the leader, i.e. don't have initial position 1)
if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_FOLLOW_LEADER && if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_FOLLOW_LEADER &&
@ -403,7 +403,7 @@ void SkiddingAI::handleBraking()
m_kart->getIdent().c_str()); m_kart->getIdent().c_str());
#endif #endif
m_controls->m_brake = true; m_controls->setBrake(true);
return; return;
} }
@ -423,7 +423,7 @@ void SkiddingAI::handleBraking()
"%s not aligned with track.", "%s not aligned with track.",
m_kart->getIdent().c_str()); m_kart->getIdent().c_str());
#endif #endif
m_controls->m_brake = true; m_controls->setBrake(true);
return; return;
} }
if(m_current_track_direction==GraphNode::DIR_LEFT || if(m_current_track_direction==GraphNode::DIR_LEFT ||
@ -434,9 +434,9 @@ void SkiddingAI::handleBraking()
if(m_kart->getSpeed() > 1.5f*max_turn_speed && if(m_kart->getSpeed() > 1.5f*max_turn_speed &&
m_kart->getSpeed()>MIN_SPEED && m_kart->getSpeed()>MIN_SPEED &&
fabsf(m_controls->m_steer) > 0.95f ) fabsf(m_controls->getSteer()) > 0.95f )
{ {
m_controls->m_brake = true; m_controls->setBrake(true);
#ifdef DEBUG #ifdef DEBUG
if(m_ai_debug) if(m_ai_debug)
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
@ -1141,7 +1141,7 @@ void SkiddingAI::evaluateItems(const Item *item, float kart_aim_angle,
*/ */
void SkiddingAI::handleItems(const float dt) void SkiddingAI::handleItems(const float dt)
{ {
m_controls->m_fire = false; m_controls->setFire(false);
if(m_kart->getKartAnimation() || if(m_kart->getKartAnimation() ||
m_kart->getPowerup()->getType() == PowerupManager::POWERUP_NOTHING ) m_kart->getPowerup()->getType() == PowerupManager::POWERUP_NOTHING )
return; return;
@ -1150,12 +1150,12 @@ void SkiddingAI::handleItems(const float dt)
if (m_superpower == RaceManager::SUPERPOWER_NOLOK_BOSS) if (m_superpower == RaceManager::SUPERPOWER_NOLOK_BOSS)
{ {
m_controls->m_look_back = (m_kart->getPowerup()->getType() == m_controls->setLookBack(m_kart->getPowerup()->getType() ==
PowerupManager::POWERUP_BOWLING ); PowerupManager::POWERUP_BOWLING );
if( m_time_since_last_shot > 3.0f ) if( m_time_since_last_shot > 3.0f )
{ {
m_controls->m_fire = true; m_controls->setFire(true);
if (m_kart->getPowerup()->getType() == PowerupManager::POWERUP_SWATTER) if (m_kart->getPowerup()->getType() == PowerupManager::POWERUP_SWATTER)
m_time_since_last_shot = 3.0f; m_time_since_last_shot = 3.0f;
else else
@ -1166,7 +1166,7 @@ void SkiddingAI::handleItems(const float dt)
} }
else else
{ {
m_controls->m_fire = false; m_controls->setFire(false);
} }
return; return;
} }
@ -1177,7 +1177,7 @@ void SkiddingAI::handleItems(const float dt)
{ {
if( m_time_since_last_shot > 10.0f ) if( m_time_since_last_shot > 10.0f )
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_time_since_last_shot = 0.0f; m_time_since_last_shot = 0.0f;
} }
return; return;
@ -1202,8 +1202,8 @@ void SkiddingAI::handleItems(const float dt)
projectile_manager->projectileIsClose(m_kart, projectile_manager->projectileIsClose(m_kart,
m_ai_properties->m_shield_incoming_radius) ) m_ai_properties->m_shield_incoming_radius) )
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_controls->m_look_back = false; m_controls->setLookBack(false);
break; break;
} }
@ -1218,8 +1218,8 @@ void SkiddingAI::handleItems(const float dt)
// overtaken kart to overtake us again. // overtaken kart to overtake us again.
if(m_distance_behind < 15.0f && m_distance_behind > 3.0f ) if(m_distance_behind < 15.0f && m_distance_behind > 3.0f )
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_controls->m_look_back = true; m_controls->setLookBack(true);
break; break;
} }
@ -1231,8 +1231,8 @@ void SkiddingAI::handleItems(const float dt)
lin_world->getKartLaps(m_kart->getWorldKartId()) lin_world->getKartLaps(m_kart->getWorldKartId())
== race_manager->getNumLaps()-1) == race_manager->getNumLaps()-1)
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_controls->m_look_back = true; m_controls->setLookBack(true);
break; break;
} }
break; // POWERUP_BUBBLEGUM break; // POWERUP_BUBBLEGUM
@ -1278,10 +1278,10 @@ void SkiddingAI::handleItems(const float dt)
: m_distance_ahead; : m_distance_ahead;
// Since cakes can be fired all around, just use a sane distance // Since cakes can be fired all around, just use a sane distance
// with a bit of extra for backwards, as enemy will go towards cake // with a bit of extra for backwards, as enemy will go towards cake
m_controls->m_fire = (fire_backwards && distance < 25.0f) || m_controls->setFire( (fire_backwards && distance < 25.0f) ||
(!fire_backwards && distance < 20.0f); (!fire_backwards && distance < 20.0f) );
if(m_controls->m_fire) if(m_controls->getFire())
m_controls->m_look_back = fire_backwards; m_controls->setLookBack(fire_backwards);
break; break;
} // POWERUP_CAKE } // POWERUP_CAKE
@ -1324,12 +1324,12 @@ void SkiddingAI::handleItems(const float dt)
float distance = fire_backwards ? m_distance_behind float distance = fire_backwards ? m_distance_behind
: m_distance_ahead; : m_distance_ahead;
m_controls->m_fire = ( (fire_backwards && distance < 30.0f) || m_controls->setFire( ( (fire_backwards && distance < 30.0f) ||
(!fire_backwards && distance <10.0f) ) && (!fire_backwards && distance <10.0f) ) &&
m_time_since_last_shot > 3.0f && m_time_since_last_shot > 3.0f &&
(straight_behind || straight_ahead); (straight_behind || straight_ahead) );
if(m_controls->m_fire) if(m_controls->getFire())
m_controls->m_look_back = fire_backwards; m_controls->setLookBack(fire_backwards);
break; break;
} // POWERUP_BOWLING } // POWERUP_BOWLING
@ -1355,10 +1355,10 @@ void SkiddingAI::handleItems(const float dt)
!m_kart_ahead; !m_kart_ahead;
float distance = fire_backwards ? m_distance_behind float distance = fire_backwards ? m_distance_behind
: m_distance_ahead; : m_distance_ahead;
m_controls->m_fire = distance < 30.0f || m_controls->setFire(distance < 30.0f ||
m_time_since_last_shot > 10.0f; m_time_since_last_shot > 10.0f );
if(m_controls->m_fire) if(m_controls->getFire())
m_controls->m_look_back = fire_backwards; m_controls->setLookBack(fire_backwards);
break; break;
} // POWERUP_PLUNGER } // POWERUP_PLUNGER
@ -1368,13 +1368,13 @@ void SkiddingAI::handleItems(const float dt)
// after a waiting an appropriate time // after a waiting an appropriate time
if(m_kart->getPosition()>1 && if(m_kart->getPosition()>1 &&
m_time_since_last_shot > stk_config->m_item_switch_time+2.0f) m_time_since_last_shot > stk_config->m_item_switch_time+2.0f)
m_controls->m_fire = true; m_controls->setFire(true);
break; // POWERUP_SWITCH break; // POWERUP_SWITCH
case PowerupManager::POWERUP_PARACHUTE: case PowerupManager::POWERUP_PARACHUTE:
// Wait one second more than a previous parachute // Wait one second more than a previous parachute
if(m_time_since_last_shot > m_kart->getKartProperties()->getParachuteDurationOther() + 1.0f) if(m_time_since_last_shot > m_kart->getKartProperties()->getParachuteDurationOther() + 1.0f)
m_controls->m_fire = true; m_controls->setFire(true);
break; // POWERUP_PARACHUTE break; // POWERUP_PARACHUTE
case PowerupManager::POWERUP_ANVIL: case PowerupManager::POWERUP_ANVIL:
@ -1383,13 +1383,13 @@ void SkiddingAI::handleItems(const float dt)
if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER) if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER)
{ {
m_controls->m_fire = m_world->getTime()<1.0f && m_controls->setFire(m_world->getTime()<1.0f &&
m_kart->getPosition()>2; m_kart->getPosition()>2 );
} }
else else
{ {
m_controls->m_fire = m_time_since_last_shot > 3.0f && m_controls->setFire(m_time_since_last_shot > 3.0f &&
m_kart->getPosition()>1; m_kart->getPosition()>1 );
} }
break; // POWERUP_ANVIL break; // POWERUP_ANVIL
@ -1410,7 +1410,7 @@ void SkiddingAI::handleItems(const float dt)
m_kart_ahead->getSpeed() < m_kart->getSpeed() ) || m_kart_ahead->getSpeed() < m_kart->getSpeed() ) ||
( m_kart_behind && !m_kart_behind->isSquashed() && ( m_kart_behind && !m_kart_behind->isSquashed() &&
(m_kart_behind->getXYZ()-m_kart->getXYZ()).length2()<d2) ) (m_kart_behind->getXYZ()-m_kart->getXYZ()).length2()<d2) )
m_controls->m_fire = true; m_controls->setFire(true);
break; break;
} }
case PowerupManager::POWERUP_RUBBERBALL: case PowerupManager::POWERUP_RUBBERBALL:
@ -1420,7 +1420,7 @@ void SkiddingAI::handleItems(const float dt)
// Perhaps some more sophisticated algorithm might be useful. // Perhaps some more sophisticated algorithm might be useful.
// For now: fire if there is a kart ahead (which means that // For now: fire if there is a kart ahead (which means that
// this kart is certainly not the first kart) // this kart is certainly not the first kart)
m_controls->m_fire = m_kart_ahead != NULL; m_controls->setFire(m_kart_ahead != NULL);
break; break;
default: default:
Log::error(getControllerName().c_str(), Log::error(getControllerName().c_str(),
@ -1428,7 +1428,7 @@ void SkiddingAI::handleItems(const float dt)
m_kart->getPowerup()->getType()); m_kart->getPowerup()->getType());
assert(false); assert(false);
} }
if(m_controls->m_fire) m_time_since_last_shot = 0.0f; if(m_controls->getFire()) m_time_since_last_shot = 0.0f;
} // handleItems } // handleItems
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -1504,26 +1504,26 @@ void SkiddingAI::handleAcceleration( const float dt)
if( m_start_delay > 0.0f ) if( m_start_delay > 0.0f )
{ {
m_start_delay -= dt; m_start_delay -= dt;
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
return; return;
} }
if( m_controls->m_brake ) if( m_controls->getBrake())
{ {
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
return; return;
} }
if(m_kart->getBlockedByPlungerTime()>0) if(m_kart->getBlockedByPlungerTime()>0)
{ {
if(m_kart->getSpeed() < m_kart->getCurrentMaxSpeed() / 2) if(m_kart->getSpeed() < m_kart->getCurrentMaxSpeed() / 2)
m_controls->m_accel = 0.05f; m_controls->setAccel(0.05f);
else else
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
return; return;
} }
m_controls->m_accel = stk_config->m_ai_acceleration; m_controls->setAccel(stk_config->m_ai_acceleration);
} // handleAcceleration } // handleAcceleration
@ -1580,7 +1580,7 @@ void SkiddingAI::handleRescue(const float dt)
*/ */
void SkiddingAI::handleNitroAndZipper() void SkiddingAI::handleNitroAndZipper()
{ {
m_controls->m_nitro = false; m_controls->setNitro(false);
// If we are already very fast, save nitro. // If we are already very fast, save nitro.
if(m_kart->getSpeed() > 0.95f*m_kart->getCurrentMaxSpeed()) if(m_kart->getSpeed() > 0.95f*m_kart->getCurrentMaxSpeed())
return; return;
@ -1588,7 +1588,7 @@ void SkiddingAI::handleNitroAndZipper()
if(m_kart->getBlockedByPlungerTime()>0) return; if(m_kart->getBlockedByPlungerTime()>0) return;
// Don't use nitro if we are braking // Don't use nitro if we are braking
if(m_controls->m_brake) return; if(m_controls->getBrake()) return;
// Don't use nitro if the kart is not on ground or has finished the race // Don't use nitro if the kart is not on ground or has finished the race
if(!m_kart->isOnGround() || m_kart->hasFinishedRace()) return; if(!m_kart->isOnGround() || m_kart->hasFinishedRace()) return;
@ -1618,7 +1618,7 @@ void SkiddingAI::handleNitroAndZipper()
// If the kart is very slow (e.g. after rescue), use nitro // If the kart is very slow (e.g. after rescue), use nitro
if(m_kart->getSpeed()<5) if(m_kart->getSpeed()<5)
{ {
m_controls->m_nitro = true; m_controls->setNitro(true);
return; return;
} }
@ -1629,7 +1629,7 @@ void SkiddingAI::handleNitroAndZipper()
if(m_kart->getPosition()== (int)num_karts && if(m_kart->getPosition()== (int)num_karts &&
num_karts>1 && m_kart->getEnergy()>2.0f) num_karts>1 && m_kart->getEnergy()>2.0f)
{ {
m_controls->m_nitro = true; m_controls->setNitro(true);
return; return;
} }
@ -1645,7 +1645,7 @@ void SkiddingAI::handleNitroAndZipper()
m_world->getEstimatedFinishTime(m_kart->getWorldKartId()); m_world->getEstimatedFinishTime(m_kart->getWorldKartId());
if( 1.5f*m_kart->getEnergy() >= finish - m_world->getTime() ) if( 1.5f*m_kart->getEnergy() >= finish - m_world->getTime() )
{ {
m_controls->m_nitro = true; m_controls->setNitro(true);
return; return;
} }
} }
@ -1661,7 +1661,7 @@ void SkiddingAI::handleNitroAndZipper()
m_distance_ahead < overtake_distance && m_distance_ahead < overtake_distance &&
m_kart_ahead->getSpeed()+5.0f > m_kart->getSpeed() ) m_kart_ahead->getSpeed()+5.0f > m_kart->getSpeed() )
{ {
m_controls->m_nitro = true; m_controls->setNitro(true);
return; return;
} }
@ -1670,8 +1670,8 @@ void SkiddingAI::handleNitroAndZipper()
m_kart_behind->getSpeed() > m_kart->getSpeed() ) m_kart_behind->getSpeed() > m_kart->getSpeed() )
{ {
// Only prevent overtaking on highest level // Only prevent overtaking on highest level
m_controls->m_nitro = m_ai_properties->m_nitro_usage m_controls->setNitro(m_ai_properties->m_nitro_usage
== AIProperties::NITRO_ALL; == AIProperties::NITRO_ALL);
return; return;
} }
@ -1689,7 +1689,7 @@ void SkiddingAI::handleNitroAndZipper()
- QuadGraph::get()->getDistanceFromStart(m_track_node); - QuadGraph::get()->getDistanceFromStart(m_track_node);
if(diff<0) diff+=World::getWorld()->getTrack()->getTrackLength(); if(diff<0) diff+=World::getWorld()->getTrack()->getTrackLength();
if(diff>m_ai_properties->m_straight_length_for_zipper) if(diff>m_ai_properties->m_straight_length_for_zipper)
m_controls->m_fire = true; m_controls->setFire(true);
} }
} }
@ -2222,7 +2222,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
// If the kart has to do a sharp turn, but is already skidding, find // If the kart has to do a sharp turn, but is already skidding, find
// a good time to release the skid button, since this will turn the // a good time to release the skid button, since this will turn the
// kart more sharply: // kart more sharply:
if(m_controls->m_skid) if(m_controls->getSkidControl())
{ {
#ifdef DEBUG #ifdef DEBUG
if(m_ai_debug) if(m_ai_debug)
@ -2247,7 +2247,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_current_track_direction==GraphNode::DIR_UNDEFINED ) m_current_track_direction==GraphNode::DIR_UNDEFINED )
{ {
#ifdef DEBUG #ifdef DEBUG
if(m_controls->m_skid && m_ai_debug) if(m_controls->getSkidControl() && m_ai_debug)
{ {
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
"%s stops skidding on straight.", "%s stops skidding on straight.",
@ -2283,7 +2283,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
// If the remaining estimated time for skidding is too short, stop // If the remaining estimated time for skidding is too short, stop
// it. This code will mostly trigger the bonus at the end of a skid. // it. This code will mostly trigger the bonus at the end of a skid.
if(m_controls->m_skid && duration < 1.0f) if(m_controls->getSkidControl() && duration < 1.0f)
{ {
if(m_ai_debug) if(m_ai_debug)
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
@ -2301,7 +2301,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_current_track_direction==GraphNode::DIR_RIGHT) ) m_current_track_direction==GraphNode::DIR_RIGHT) )
{ {
#ifdef DEBUG #ifdef DEBUG
if(m_controls->m_skid && m_ai_debug) if(m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
"%s skidding against track direction.", "%s skidding against track direction.",
m_kart->getIdent().c_str()); m_kart->getIdent().c_str());
@ -2313,7 +2313,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_kart->getKartProperties()->getSkidTimeTillBonus()[0] < duration) m_kart->getKartProperties()->getSkidTimeTillBonus()[0] < duration)
{ {
#ifdef DEBUG #ifdef DEBUG
if(!m_controls->m_skid && m_ai_debug) if(!m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
"%s start skid, duration %f.", "%s start skid, duration %f.",
m_kart->getIdent().c_str(), duration); m_kart->getIdent().c_str(), duration);
@ -2323,7 +2323,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
} // if curve long enough for skidding } // if curve long enough for skidding
#ifdef DEBUG #ifdef DEBUG
if(m_controls->m_skid && m_ai_debug) if(m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
"%s has no reasons to skid anymore.", "%s has no reasons to skid anymore.",
m_kart->getIdent().c_str()); m_kart->getIdent().c_str());
@ -2354,7 +2354,7 @@ void SkiddingAI::setSteering(float angle, float dt)
if(!canSkid(steer_fraction)) if(!canSkid(steer_fraction))
{ {
m_skid_probability_state = SKID_PROBAB_NOT_YET; m_skid_probability_state = SKID_PROBAB_NOT_YET;
m_controls->m_skid = KartControl::SC_NONE; m_controls->setSkidControl(KartControl::SC_NONE);
} }
else else
{ {
@ -2377,8 +2377,8 @@ void SkiddingAI::setSteering(float angle, float dt)
sc= ? "no" : sc==KartControl::SC_LEFT ? "left" : "right"); sc= ? "no" : sc==KartControl::SC_LEFT ? "left" : "right");
#endif #endif
} }
m_controls->m_skid = m_skid_probability_state == SKID_PROBAB_SKID m_controls->setSkidControl(m_skid_probability_state == SKID_PROBAB_SKID
? sc : KartControl::SC_NONE; ? sc : KartControl::SC_NONE );
} }
// Adjust steer fraction in case to be in [-1,1] // Adjust steer fraction in case to be in [-1,1]
@ -2402,7 +2402,7 @@ void SkiddingAI::setSteering(float angle, float dt)
if((ss==Skidding::SKID_ACCUMULATE_LEFT && steer_fraction>0.2f ) || if((ss==Skidding::SKID_ACCUMULATE_LEFT && steer_fraction>0.2f ) ||
(ss==Skidding::SKID_ACCUMULATE_RIGHT && steer_fraction<-0.2f) ) (ss==Skidding::SKID_ACCUMULATE_RIGHT && steer_fraction<-0.2f) )
{ {
m_controls->m_skid = KartControl::SC_NONE; m_controls->setSkidControl(KartControl::SC_NONE);
#ifdef DEBUG #ifdef DEBUG
if(m_ai_debug) if(m_ai_debug)
Log::info(getControllerName().c_str(), Log::info(getControllerName().c_str(),
@ -2411,7 +2411,7 @@ void SkiddingAI::setSteering(float angle, float dt)
#endif #endif
} }
if(m_controls->m_skid!=KartControl::SC_NONE && if(m_controls->getSkidControl()!=KartControl::SC_NONE &&
( ss==Skidding::SKID_ACCUMULATE_LEFT || ( ss==Skidding::SKID_ACCUMULATE_LEFT ||
ss==Skidding::SKID_ACCUMULATE_RIGHT ) ) ss==Skidding::SKID_ACCUMULATE_RIGHT ) )
{ {
@ -2425,7 +2425,7 @@ void SkiddingAI::setSteering(float angle, float dt)
"%s steering too much (%f).", "%s steering too much (%f).",
m_kart->getIdent().c_str(), steer_fraction); m_kart->getIdent().c_str(), steer_fraction);
#endif #endif
m_controls->m_skid = KartControl::SC_NONE; m_controls->setSkidControl(KartControl::SC_NONE);
} }
if(steer_fraction<-1.0f) if(steer_fraction<-1.0f)
steer_fraction = -1.0f; steer_fraction = -1.0f;
@ -2433,19 +2433,19 @@ void SkiddingAI::setSteering(float angle, float dt)
steer_fraction = 1.0f; steer_fraction = 1.0f;
} }
float old_steer = m_controls->m_steer; float old_steer = m_controls->getSteer();
// The AI has its own 'time full steer' value (which is the time // The AI has its own 'time full steer' value (which is the time
float max_steer_change = dt/m_ai_properties->m_time_full_steer; float max_steer_change = dt/m_ai_properties->m_time_full_steer;
if(old_steer < steer_fraction) if(old_steer < steer_fraction)
{ {
m_controls->m_steer = (old_steer+max_steer_change > steer_fraction) m_controls->setSteer( (old_steer+max_steer_change > steer_fraction)
? steer_fraction : old_steer+max_steer_change; ? steer_fraction : old_steer+max_steer_change );
} }
else else
{ {
m_controls->m_steer = (old_steer-max_steer_change < steer_fraction) m_controls->setSteer( (old_steer-max_steer_change < steer_fraction)
? steer_fraction : old_steer-max_steer_change; ? steer_fraction : old_steer-max_steer_change );
} }

4
src/karts/controller/soccer_ai.cpp
View File

@ -118,8 +118,8 @@ void SoccerAI::update(float dt)
if (m_world->getPhase() == World::GOAL_PHASE) if (m_world->getPhase() == World::GOAL_PHASE)
{ {
resetAfterStop(); resetAfterStop();
m_controls->m_brake = false; m_controls->setBrake(false);
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
AIBaseController::update(dt); AIBaseController::update(dt);
return; return;
} }

160
src/karts/controller/test_ai.cpp
View File

@ -228,8 +228,8 @@ unsigned int SkiddingAI::getNextSector(unsigned int index)
void SkiddingAI::update(float dt) void SkiddingAI::update(float dt)
{ {
// This is used to enable firing an item backwards. // This is used to enable firing an item backwards.
m_controls->m_look_back = false; m_controls->setLookBack(false);
m_controls->m_nitro = false; m_controls->setNitro(false);
// Don't do anything if there is currently a kart animations shown. // Don't do anything if there is currently a kart animations shown.
if(m_kart->getKartAnimation()) if(m_kart->getKartAnimation())
@ -329,8 +329,8 @@ void SkiddingAI::update(float dt)
m_kart_ahead ) m_kart_ahead )
{ {
// Use nitro if the kart is far ahead, or faster than this kart // Use nitro if the kart is far ahead, or faster than this kart
m_controls->m_nitro = m_distance_ahead>10.0f || m_controls->setNitro(m_distance_ahead>10.0f ||
m_kart_ahead->getSpeed() > m_kart->getSpeed(); m_kart_ahead->getSpeed() > m_kart->getSpeed());
// If we are close enough, try to hit this kart // If we are close enough, try to hit this kart
if(m_distance_ahead<=10) if(m_distance_ahead<=10)
{ {
@ -360,12 +360,12 @@ void SkiddingAI::update(float dt)
handleRescue(dt); handleRescue(dt);
handleBraking(); handleBraking();
// If a bomb is attached, nitro might already be set. // If a bomb is attached, nitro might already be set.
if(!m_controls->m_nitro) if(!m_controls->getNitro())
handleNitroAndZipper(); handleNitroAndZipper();
} }
// If we are supposed to use nitro, but have a zipper, // If we are supposed to use nitro, but have a zipper,
// use the zipper instead (unless there are items to avoid cloe by) // use the zipper instead (unless there are items to avoid cloe by)
if(m_controls->m_nitro && if(m_controls->getNitro() &&
m_kart->getPowerup()->getType()==PowerupManager::POWERUP_ZIPPER && m_kart->getPowerup()->getType()==PowerupManager::POWERUP_ZIPPER &&
m_kart->getSpeed()>1.0f && m_kart->getSpeed()>1.0f &&
m_kart->getSpeedIncreaseTimeLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0 && m_kart->getSpeedIncreaseTimeLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0 &&
@ -377,8 +377,8 @@ void SkiddingAI::update(float dt)
if(race_manager->getMinorMode()!=RaceManager::MINOR_MODE_TIME_TRIAL || if(race_manager->getMinorMode()!=RaceManager::MINOR_MODE_TIME_TRIAL ||
(m_world->getTime()<3.0f && rand()%50==1) ) (m_world->getTime()<3.0f && rand()%50==1) )
{ {
m_controls->m_nitro = false; m_controls->setNitro(false);
m_controls->m_fire = true; m_controls->setFire(true);
} }
} }
@ -396,7 +396,7 @@ void SkiddingAI::update(float dt)
*/ */
void SkiddingAI::handleBraking() void SkiddingAI::handleBraking()
{ {
m_controls->m_brake = false; m_controls->setBrake(false);
// In follow the leader mode, the kart should brake if they are ahead of // In follow the leader mode, the kart should brake if they are ahead of
// the leader (and not the leader, i.e. don't have initial position 1) // the leader (and not the leader, i.e. don't have initial position 1)
if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_FOLLOW_LEADER && if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_FOLLOW_LEADER &&
@ -409,7 +409,7 @@ void SkiddingAI::handleBraking()
m_kart->getIdent().c_str()); m_kart->getIdent().c_str());
#endif #endif
m_controls->m_brake = true; m_controls->setBrake(true);
return; return;
} }
@ -429,7 +429,7 @@ void SkiddingAI::handleBraking()
"%s not aligned with track.", "%s not aligned with track.",
m_kart->getIdent().c_str()); m_kart->getIdent().c_str());
#endif #endif
m_controls->m_brake = true; m_controls->setBrake(true);
return; return;
} }
if(m_current_track_direction==GraphNode::DIR_LEFT || if(m_current_track_direction==GraphNode::DIR_LEFT ||
@ -440,9 +440,9 @@ void SkiddingAI::handleBraking()
if(m_kart->getSpeed() > 1.5f*max_turn_speed && if(m_kart->getSpeed() > 1.5f*max_turn_speed &&
m_kart->getSpeed()>MIN_SPEED && m_kart->getSpeed()>MIN_SPEED &&
fabsf(m_controls->m_steer) > 0.95f ) fabsf(m_controls->getSteer()) > 0.95f )
{ {
m_controls->m_brake = true; m_controls->setBrake(true);
#ifdef DEBUG #ifdef DEBUG
if(m_ai_debug) if(m_ai_debug)
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
@ -1147,7 +1147,7 @@ void SkiddingAI::evaluateItems(const Item *item, float kart_aim_angle,
*/ */
void SkiddingAI::handleItems(const float dt) void SkiddingAI::handleItems(const float dt)
{ {
m_controls->m_fire = false; m_controls->setFire(false);
if(m_kart->getKartAnimation() || if(m_kart->getKartAnimation() ||
m_kart->getPowerup()->getType() == PowerupManager::POWERUP_NOTHING ) m_kart->getPowerup()->getType() == PowerupManager::POWERUP_NOTHING )
return; return;
@ -1156,12 +1156,12 @@ void SkiddingAI::handleItems(const float dt)
if (m_superpower == RaceManager::SUPERPOWER_NOLOK_BOSS) if (m_superpower == RaceManager::SUPERPOWER_NOLOK_BOSS)
{ {
m_controls->m_look_back = (m_kart->getPowerup()->getType() == m_controls->setLookBack(m_kart->getPowerup()->getType() ==
PowerupManager::POWERUP_BOWLING ); PowerupManager::POWERUP_BOWLING );
if( m_time_since_last_shot > 3.0f ) if( m_time_since_last_shot > 3.0f )
{ {
m_controls->m_fire = true; m_controls->setFire(true);
if (m_kart->getPowerup()->getType() == PowerupManager::POWERUP_SWATTER) if (m_kart->getPowerup()->getType() == PowerupManager::POWERUP_SWATTER)
m_time_since_last_shot = 3.0f; m_time_since_last_shot = 3.0f;
else else
@ -1172,7 +1172,7 @@ void SkiddingAI::handleItems(const float dt)
} }
else else
{ {
m_controls->m_fire = false; m_controls->setFire(false);
} }
return; return;
} }
@ -1183,7 +1183,7 @@ void SkiddingAI::handleItems(const float dt)
{ {
if( m_time_since_last_shot > 10.0f ) if( m_time_since_last_shot > 10.0f )
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_time_since_last_shot = 0.0f; m_time_since_last_shot = 0.0f;
} }
return; return;
@ -1208,8 +1208,8 @@ void SkiddingAI::handleItems(const float dt)
projectile_manager->projectileIsClose(m_kart, projectile_manager->projectileIsClose(m_kart,
m_ai_properties->m_shield_incoming_radius) ) m_ai_properties->m_shield_incoming_radius) )
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_controls->m_look_back = false; m_controls->setLookBack(false);
break; break;
} }
@ -1224,8 +1224,8 @@ void SkiddingAI::handleItems(const float dt)
// overtaken kart to overtake us again. // overtaken kart to overtake us again.
if(m_distance_behind < 15.0f && m_distance_behind > 3.0f ) if(m_distance_behind < 15.0f && m_distance_behind > 3.0f )
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_controls->m_look_back = true; m_controls->setLookBack(true);
break; break;
} }
@ -1237,8 +1237,8 @@ void SkiddingAI::handleItems(const float dt)
lin_world->getKartLaps(m_kart->getWorldKartId()) lin_world->getKartLaps(m_kart->getWorldKartId())
== race_manager->getNumLaps()-1) == race_manager->getNumLaps()-1)
{ {
m_controls->m_fire = true; m_controls->setFire(true);
m_controls->m_look_back = true; m_controls->setLookBack(true);
break; break;
} }
break; // POWERUP_BUBBLEGUM break; // POWERUP_BUBBLEGUM
@ -1284,10 +1284,10 @@ void SkiddingAI::handleItems(const float dt)
: m_distance_ahead; : m_distance_ahead;
// Since cakes can be fired all around, just use a sane distance // Since cakes can be fired all around, just use a sane distance
// with a bit of extra for backwards, as enemy will go towards cake // with a bit of extra for backwards, as enemy will go towards cake
m_controls->m_fire = (fire_backwards && distance < 25.0f) || m_controls->setFire( (fire_backwards && distance < 25.0f) ||
(!fire_backwards && distance < 20.0f); (!fire_backwards && distance < 20.0f) );
if(m_controls->m_fire) if(m_controls->getFire())
m_controls->m_look_back = fire_backwards; m_controls->setLookBack(fire_backwards);
break; break;
} // POWERUP_CAKE } // POWERUP_CAKE
@ -1330,12 +1330,12 @@ void SkiddingAI::handleItems(const float dt)
float distance = fire_backwards ? m_distance_behind float distance = fire_backwards ? m_distance_behind
: m_distance_ahead; : m_distance_ahead;
m_controls->m_fire = ( (fire_backwards && distance < 30.0f) || m_controls->setFire( ( (fire_backwards && distance < 30.0f) ||
(!fire_backwards && distance <10.0f) ) && (!fire_backwards && distance <10.0f) ) &&
m_time_since_last_shot > 3.0f && m_time_since_last_shot > 3.0f &&
(straight_behind || straight_ahead); (straight_behind || straight_ahead) );
if(m_controls->m_fire) if(m_controls->getFire())
m_controls->m_look_back = fire_backwards; m_controls->setLookBack(fire_backwards);
break; break;
} // POWERUP_BOWLING } // POWERUP_BOWLING
@ -1361,10 +1361,10 @@ void SkiddingAI::handleItems(const float dt)
!m_kart_ahead; !m_kart_ahead;
float distance = fire_backwards ? m_distance_behind float distance = fire_backwards ? m_distance_behind
: m_distance_ahead; : m_distance_ahead;
m_controls->m_fire = distance < 30.0f || m_controls->setFire(distance < 30.0f ||
m_time_since_last_shot > 10.0f; m_time_since_last_shot > 10.0f );
if(m_controls->m_fire) if(m_controls->getFire())
m_controls->m_look_back = fire_backwards; m_controls->setLookBack(fire_backwards);
break; break;
} // POWERUP_PLUNGER } // POWERUP_PLUNGER
@ -1374,13 +1374,13 @@ void SkiddingAI::handleItems(const float dt)
// after a waiting an appropriate time // after a waiting an appropriate time
if(m_kart->getPosition()>1 && if(m_kart->getPosition()>1 &&
m_time_since_last_shot > stk_config->m_item_switch_time+2.0f) m_time_since_last_shot > stk_config->m_item_switch_time+2.0f)
m_controls->m_fire = true; m_controls->setFire(true);
break; // POWERUP_SWITCH break; // POWERUP_SWITCH
case PowerupManager::POWERUP_PARACHUTE: case PowerupManager::POWERUP_PARACHUTE:
// Wait one second more than a previous parachute // Wait one second more than a previous parachute
if(m_time_since_last_shot > m_kart->getKartProperties()->getParachuteDurationOther() + 1.0f) if(m_time_since_last_shot > m_kart->getKartProperties()->getParachuteDurationOther() + 1.0f)
m_controls->m_fire = true; m_controls->setFire(true);
break; // POWERUP_PARACHUTE break; // POWERUP_PARACHUTE
case PowerupManager::POWERUP_ANVIL: case PowerupManager::POWERUP_ANVIL:
@ -1389,13 +1389,13 @@ void SkiddingAI::handleItems(const float dt)
if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER) if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER)
{ {
m_controls->m_fire = m_world->getTime()<1.0f && m_controls->setFire(m_world->getTime()<1.0f &&
m_kart->getPosition()>2; m_kart->getPosition()>2 );
} }
else else
{ {
m_controls->m_fire = m_time_since_last_shot > 3.0f && m_controls->setFire(m_time_since_last_shot > 3.0f &&
m_kart->getPosition()>1; m_kart->getPosition()>1 );
} }
break; // POWERUP_ANVIL break; // POWERUP_ANVIL
@ -1416,7 +1416,7 @@ void SkiddingAI::handleItems(const float dt)
m_kart_ahead->getSpeed() < m_kart->getSpeed() ) || m_kart_ahead->getSpeed() < m_kart->getSpeed() ) ||
( m_kart_behind && !m_kart_behind->isSquashed() && ( m_kart_behind && !m_kart_behind->isSquashed() &&
(m_kart_behind->getXYZ()-m_kart->getXYZ()).length2()<d2) ) (m_kart_behind->getXYZ()-m_kart->getXYZ()).length2()<d2) )
m_controls->m_fire = true; m_controls->setFire(true);
break; break;
} }
case PowerupManager::POWERUP_RUBBERBALL: case PowerupManager::POWERUP_RUBBERBALL:
@ -1426,7 +1426,7 @@ void SkiddingAI::handleItems(const float dt)
// Perhaps some more sophisticated algorithm might be useful. // Perhaps some more sophisticated algorithm might be useful.
// For now: fire if there is a kart ahead (which means that // For now: fire if there is a kart ahead (which means that
// this kart is certainly not the first kart) // this kart is certainly not the first kart)
m_controls->m_fire = m_kart_ahead != NULL; m_controls->setFire(m_kart_ahead != NULL);
break; break;
default: default:
Log::error(getControllerName().c_str(), Log::error(getControllerName().c_str(),
@ -1434,7 +1434,7 @@ void SkiddingAI::handleItems(const float dt)
m_kart->getPowerup()->getType()); m_kart->getPowerup()->getType());
assert(false); assert(false);
} }
if(m_controls->m_fire) m_time_since_last_shot = 0.0f; if(m_controls->getFire()) m_time_since_last_shot = 0.0f;
} // handleItems } // handleItems
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -1510,7 +1510,7 @@ void SkiddingAI::handleAcceleration( const float dt)
if( m_start_delay > 0.0f ) if( m_start_delay > 0.0f )
{ {
m_start_delay -= dt; m_start_delay -= dt;
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
return; return;
} }
@ -1518,22 +1518,22 @@ void SkiddingAI::handleAcceleration( const float dt)
// m_brake has not been reset from the previous frame, which can // m_brake has not been reset from the previous frame, which can
// cause too long slow downs. On the other hand removing it appears // cause too long slow downs. On the other hand removing it appears
// to decrease performance in some narrower tracks // to decrease performance in some narrower tracks
if( m_controls->m_brake ) if( m_controls->getBrake())
{ {
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
return; return;
} }
if(m_kart->getBlockedByPlungerTime()>0) if(m_kart->getBlockedByPlungerTime()>0)
{ {
if(m_kart->getSpeed() < m_kart->getCurrentMaxSpeed() / 2) if(m_kart->getSpeed() < m_kart->getCurrentMaxSpeed() / 2)
m_controls->m_accel = 0.05f; m_controls->setAccel(0.05f);
else else
m_controls->m_accel = 0.0f; m_controls->setAccel(0.0f);
return; return;
} }
m_controls->m_accel = stk_config->m_ai_acceleration; m_controls->setAccel(stk_config->m_ai_acceleration);
} // handleAcceleration } // handleAcceleration
@ -1590,7 +1590,7 @@ void SkiddingAI::handleRescue(const float dt)
*/ */
void SkiddingAI::handleNitroAndZipper() void SkiddingAI::handleNitroAndZipper()
{ {
m_controls->m_nitro = false; m_controls->setNitro(false);
// The next line prevents usage of nitro on long straights, where the kart // The next line prevents usage of nitro on long straights, where the kart
// is already fast. // is already fast.
@ -1599,14 +1599,14 @@ void SkiddingAI::handleNitroAndZipper()
if(m_kart->getSpeed() > 0.95f*m_kart->getCurrentMaxSpeed()) if(m_kart->getSpeed() > 0.95f*m_kart->getCurrentMaxSpeed())
return; return;
// About the above: removing this line might enable the AI to better use // About the above: removing this line might enable the AI to better use
// nitro and zippers . // nitro and zippers.
// This works well for some tracks (math, lighthouse // This works well for some tracks (math, lighthouse
// sandtrack), but worse in others (zen, xr591). The good result // sandtrack), but worse in others (zen, xr591). The good result
// is caused by long straights in which the AI will now use zippers, // is caused by long straights in which the AI will now use zippers,
// but in the other tracks the high speed causes karts to crash in // but in the other tracks the high speed causes karts to crash in
// tight corners. In some cases it would need a reasonable large 'lookahead' // tight corners. In some cases it would need a reasonable large 'lookahead'
// to know that at a certain spot a zipper or skidding should not be used // to know that at a certain spot a zipper or skidding should not be used
// (e.g. in xr591, left at the fork - new AI will nearly always fell of the // (e.g. in xr591, left at the fork - new AI will nearly always fall off the
// track after the curve). Here the summarised results of 10 laps runs with // track after the curve). Here the summarised results of 10 laps runs with
// 4 old against 4 new AIs in time trail mode. The 'gain' is the sum of all // 4 old against 4 new AIs in time trail mode. The 'gain' is the sum of all
// (star_positions-end_positions). So a gain of -10 means that basically // (star_positions-end_positions). So a gain of -10 means that basically
@ -1637,7 +1637,7 @@ void SkiddingAI::handleNitroAndZipper()
if(m_kart->getBlockedByPlungerTime()>0) return; if(m_kart->getBlockedByPlungerTime()>0) return;
// Don't use nitro if we are braking // Don't use nitro if we are braking
if(m_controls->m_brake) return; if(m_controls->getBrake()) return;
// Don't use nitro if the kart is not on ground or has finished the race // Don't use nitro if the kart is not on ground or has finished the race
if(!m_kart->isOnGround() || m_kart->hasFinishedRace()) return; if(!m_kart->isOnGround() || m_kart->hasFinishedRace()) return;
@ -1667,7 +1667,7 @@ void SkiddingAI::handleNitroAndZipper()
// If the kart is very slow (e.g. after rescue), use nitro // If the kart is very slow (e.g. after rescue), use nitro
if(m_kart->getSpeed()<5) if(m_kart->getSpeed()<5)
{ {
m_controls->m_nitro = true; m_controls->setNitro(true);
return; return;
} }
@ -1678,7 +1678,7 @@ void SkiddingAI::handleNitroAndZipper()
if(m_kart->getPosition()== (int)num_karts && if(m_kart->getPosition()== (int)num_karts &&
num_karts>1 && m_kart->getEnergy()>2.0f) num_karts>1 && m_kart->getEnergy()>2.0f)
{ {
m_controls->m_nitro = true; m_controls->setNitro(true);
return; return;
} }
@ -1694,7 +1694,7 @@ void SkiddingAI::handleNitroAndZipper()
m_world->getEstimatedFinishTime(m_kart->getWorldKartId()); m_world->getEstimatedFinishTime(m_kart->getWorldKartId());
if( 1.5f*m_kart->getEnergy() >= finish - m_world->getTime() ) if( 1.5f*m_kart->getEnergy() >= finish - m_world->getTime() )
{ {
m_controls->m_nitro = true; m_controls->setNitro(true);
return; return;
} }
} }
@ -1710,7 +1710,7 @@ void SkiddingAI::handleNitroAndZipper()
m_distance_ahead < overtake_distance && m_distance_ahead < overtake_distance &&
m_kart_ahead->getSpeed()+5.0f > m_kart->getSpeed() ) m_kart_ahead->getSpeed()+5.0f > m_kart->getSpeed() )
{ {
m_controls->m_nitro = true; m_controls->setNitro(true);
return; return;
} }
@ -1719,8 +1719,8 @@ void SkiddingAI::handleNitroAndZipper()
m_kart_behind->getSpeed() > m_kart->getSpeed() ) m_kart_behind->getSpeed() > m_kart->getSpeed() )
{ {
// Only prevent overtaking on highest level // Only prevent overtaking on highest level
m_controls->m_nitro = m_ai_properties->m_nitro_usage m_controls->setNitro(m_ai_properties->m_nitro_usage
== AIProperties::NITRO_ALL; == AIProperties::NITRO_ALL );
return; return;
} }
@ -1738,7 +1738,7 @@ void SkiddingAI::handleNitroAndZipper()
- QuadGraph::get()->getDistanceFromStart(m_track_node); - QuadGraph::get()->getDistanceFromStart(m_track_node);
if(diff<0) diff+=World::getWorld()->getTrack()->getTrackLength(); if(diff<0) diff+=World::getWorld()->getTrack()->getTrackLength();
if(diff>m_ai_properties->m_straight_length_for_zipper) if(diff>m_ai_properties->m_straight_length_for_zipper)
m_controls->m_fire = true; m_controls->setFire(true);
} }
} }
@ -2271,7 +2271,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
// If the kart has to do a sharp turn, but is already skidding, find // If the kart has to do a sharp turn, but is already skidding, find
// a good time to release the skid button, since this will turn the // a good time to release the skid button, since this will turn the
// kart more sharply: // kart more sharply:
if(m_controls->m_skid) if(m_controls->getSkidControl())
{ {
#ifdef DEBUG #ifdef DEBUG
if(m_ai_debug) if(m_ai_debug)
@ -2296,7 +2296,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_current_track_direction==GraphNode::DIR_UNDEFINED ) m_current_track_direction==GraphNode::DIR_UNDEFINED )
{ {
#ifdef DEBUG #ifdef DEBUG
if(m_controls->m_skid && m_ai_debug) if(m_controls->getSkidControl() && m_ai_debug)
{ {
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
"%s stops skidding on straight.", "%s stops skidding on straight.",
@ -2332,7 +2332,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
// If the remaining estimated time for skidding is too short, stop // If the remaining estimated time for skidding is too short, stop
// it. This code will mostly trigger the bonus at the end of a skid. // it. This code will mostly trigger the bonus at the end of a skid.
if(m_controls->m_skid && duration < 1.0f) if(m_controls->getSkidControl() && duration < 1.0f)
{ {
if(m_ai_debug) if(m_ai_debug)
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
@ -2350,7 +2350,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_current_track_direction==GraphNode::DIR_RIGHT) ) m_current_track_direction==GraphNode::DIR_RIGHT) )
{ {
#ifdef DEBUG #ifdef DEBUG
if(m_controls->m_skid && m_ai_debug) if(m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
"%s skidding against track direction.", "%s skidding against track direction.",
m_kart->getIdent().c_str()); m_kart->getIdent().c_str());
@ -2362,7 +2362,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_kart->getKartProperties()->getSkidTimeTillBonus()[0] < duration) m_kart->getKartProperties()->getSkidTimeTillBonus()[0] < duration)
{ {
#ifdef DEBUG #ifdef DEBUG
if(!m_controls->m_skid && m_ai_debug) if(!m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
"%s start skid, duration %f.", "%s start skid, duration %f.",
m_kart->getIdent().c_str(), duration); m_kart->getIdent().c_str(), duration);
@ -2372,7 +2372,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
} // if curve long enough for skidding } // if curve long enough for skidding
#ifdef DEBUG #ifdef DEBUG
if(m_controls->m_skid && m_ai_debug) if(m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(), Log::debug(getControllerName().c_str(),
"%s has no reasons to skid anymore.", "%s has no reasons to skid anymore.",
m_kart->getIdent().c_str()); m_kart->getIdent().c_str());
@ -2403,7 +2403,7 @@ void SkiddingAI::setSteering(float angle, float dt)
if(!canSkid(steer_fraction)) if(!canSkid(steer_fraction))
{ {
m_skid_probability_state = SKID_PROBAB_NOT_YET; m_skid_probability_state = SKID_PROBAB_NOT_YET;
m_controls->m_skid = KartControl::SC_NONE; m_controls->setSkidControl(KartControl::SC_NONE);
} }
else else
{ {
@ -2426,8 +2426,8 @@ void SkiddingAI::setSteering(float angle, float dt)
sc= ? "no" : sc==KartControl::SC_LEFT ? "left" : "right"); sc= ? "no" : sc==KartControl::SC_LEFT ? "left" : "right");
#endif #endif
} }
m_controls->m_skid = m_skid_probability_state == SKID_PROBAB_SKID m_controls->setSkidControl(m_skid_probability_state == SKID_PROBAB_SKID
? sc : KartControl::SC_NONE; ? sc : KartControl::SC_NONE );
} }
// Adjust steer fraction in case to be in [-1,1] // Adjust steer fraction in case to be in [-1,1]
@ -2451,7 +2451,7 @@ void SkiddingAI::setSteering(float angle, float dt)
if((ss==Skidding::SKID_ACCUMULATE_LEFT && steer_fraction>0.2f ) || if((ss==Skidding::SKID_ACCUMULATE_LEFT && steer_fraction>0.2f ) ||
(ss==Skidding::SKID_ACCUMULATE_RIGHT && steer_fraction<-0.2f) ) (ss==Skidding::SKID_ACCUMULATE_RIGHT && steer_fraction<-0.2f) )
{ {
m_controls->m_skid = KartControl::SC_NONE; m_controls->setSkidControl(KartControl::SC_NONE);
#ifdef DEBUG #ifdef DEBUG
if(m_ai_debug) if(m_ai_debug)
Log::info(getControllerName().c_str(), Log::info(getControllerName().c_str(),
@ -2460,7 +2460,7 @@ void SkiddingAI::setSteering(float angle, float dt)
#endif #endif
} }
if(m_controls->m_skid!=KartControl::SC_NONE && if(m_controls->getSkidControl()!=KartControl::SC_NONE &&
( ss==Skidding::SKID_ACCUMULATE_LEFT || ( ss==Skidding::SKID_ACCUMULATE_LEFT ||
ss==Skidding::SKID_ACCUMULATE_RIGHT ) ) ss==Skidding::SKID_ACCUMULATE_RIGHT ) )
{ {
@ -2474,7 +2474,7 @@ void SkiddingAI::setSteering(float angle, float dt)
"%s steering too much (%f).", "%s steering too much (%f).",
m_kart->getIdent().c_str(), steer_fraction); m_kart->getIdent().c_str(), steer_fraction);
#endif #endif
m_controls->m_skid = KartControl::SC_NONE; m_controls->setSkidControl(KartControl::SC_NONE);
} }
if(steer_fraction<-1.0f) if(steer_fraction<-1.0f)
steer_fraction = -1.0f; steer_fraction = -1.0f;
@ -2482,19 +2482,19 @@ void SkiddingAI::setSteering(float angle, float dt)
steer_fraction = 1.0f; steer_fraction = 1.0f;
} }
float old_steer = m_controls->m_steer; float old_steer = m_controls->getSteer();
// The AI has its own 'time full steer' value (which is the time // The AI has its own 'time full steer' value (which is the time
float max_steer_change = dt/m_ai_properties->m_time_full_steer; float max_steer_change = dt/m_ai_properties->m_time_full_steer;
if(old_steer < steer_fraction) if(old_steer < steer_fraction)
{ {
m_controls->m_steer = (old_steer+max_steer_change > steer_fraction) m_controls->setSteer( (old_steer+max_steer_change > steer_fraction)
? steer_fraction : old_steer+max_steer_change; ? steer_fraction : old_steer+max_steer_change );
} }
else else
{ {
m_controls->m_steer = (old_steer-max_steer_change < steer_fraction) m_controls->setSteer( (old_steer-max_steer_change < steer_fraction)
? steer_fraction : old_steer-max_steer_change; ? steer_fraction : old_steer-max_steer_change );
} }

40
src/karts/kart.cpp
View File

@ -1277,9 +1277,9 @@ void Kart::update(float dt)
updatePhysics(dt); updatePhysics(dt);
PROFILER_POP_CPU_MARKER(); PROFILER_POP_CPU_MARKER();
if(!m_controls.m_fire) m_fire_clicked = 0; if(!m_controls.getFire()) m_fire_clicked = 0;
if(m_controls.m_fire && !m_fire_clicked && !m_kart_animation) if(m_controls.getFire() && !m_fire_clicked && !m_kart_animation)
{ {
// use() needs to be called even if there currently is no collecteable // use() needs to be called even if there currently is no collecteable
// since use() can test if something needs to be switched on/off. // since use() can test if something needs to be switched on/off.
@ -1791,7 +1791,7 @@ void Kart::handleZipper(const Material *material, bool play_sound)
engine_force = m_kart_properties->getZipperForce(); engine_force = m_kart_properties->getZipperForce();
} }
// Ignore a zipper that's activated while braking // Ignore a zipper that's activated while braking
if(m_controls.m_brake || m_speed<0) return; if(m_controls.getBrake() || m_speed<0) return;
m_max_speed->instantSpeedIncrease(MaxSpeed::MS_INCREASE_ZIPPER, m_max_speed->instantSpeedIncrease(MaxSpeed::MS_INCREASE_ZIPPER,
max_speed_increase, speed_gain, max_speed_increase, speed_gain,
@ -1807,7 +1807,7 @@ void Kart::handleZipper(const Material *material, bool play_sound)
*/ */
void Kart::updateNitro(float dt) void Kart::updateNitro(float dt)
{ {
if (m_controls.m_nitro && m_min_nitro_time <= 0.0f) if (m_controls.getNitro() && m_min_nitro_time <= 0.0f)
{ {
m_min_nitro_time = m_kart_properties->getNitroMinConsumptionTime(); m_min_nitro_time = m_kart_properties->getNitroMinConsumptionTime();
} }
@ -1817,11 +1817,11 @@ void Kart::updateNitro(float dt)
// when pressing the key, don't allow the min time to go under zero. // when pressing the key, don't allow the min time to go under zero.
// If it went under zero, it would be reset // If it went under zero, it would be reset
if (m_controls.m_nitro && m_min_nitro_time <= 0.0f) if (m_controls.getNitro() && m_min_nitro_time <= 0.0f)
m_min_nitro_time = 0.1f; m_min_nitro_time = 0.1f;
} }
bool increase_speed = (m_controls.m_nitro && isOnGround()); bool increase_speed = (m_controls.getNitro() && isOnGround());
if (!increase_speed && m_min_nitro_time <= 0.0f) if (!increase_speed && m_min_nitro_time <= 0.0f)
{ {
if(m_nitro_sound->getStatus() == SFXBase::SFX_PLAYING) if(m_nitro_sound->getStatus() == SFXBase::SFX_PLAYING)
@ -2132,7 +2132,7 @@ void Kart::updatePhysics(float dt)
// Check if accel is pressed for the first time. The actual timing // Check if accel is pressed for the first time. The actual timing
// is done in getStartupBoost - it returns 0 if the start was actually // is done in getStartupBoost - it returns 0 if the start was actually
// too slow to qualify for a boost. // too slow to qualify for a boost.
if(!m_has_started && m_controls.m_accel) if(!m_has_started && m_controls.getAccel())
{ {
m_has_started = true; m_has_started = true;
float f = getStartupBoost(); float f = getStartupBoost();
@ -2155,8 +2155,8 @@ void Kart::updatePhysics(float dt)
if (m_flying) if (m_flying)
updateFlying(); updateFlying();
m_skidding->update(dt, isOnGround(), m_controls.m_steer, m_skidding->update(dt, isOnGround(), m_controls.getSteer(),
m_controls.m_skid); m_controls.getSkidControl());
m_vehicle->setVisualRotation(m_skidding->getVisualSkidRotation()); m_vehicle->setVisualRotation(m_skidding->getVisualSkidRotation());
if(( m_skidding->getSkidState() == Skidding::SKID_ACCUMULATE_LEFT || if(( m_skidding->getSkidState() == Skidding::SKID_ACCUMULATE_LEFT ||
m_skidding->getSkidState() == Skidding::SKID_ACCUMULATE_RIGHT ) && m_skidding->getSkidState() == Skidding::SKID_ACCUMULATE_RIGHT ) &&
@ -2296,7 +2296,7 @@ void Kart::updateEnginePowerAndBrakes(float dt)
m_body->applyTorque(btVector3(0.0, m_bubblegum_torque, 0.0)); m_body->applyTorque(btVector3(0.0, m_bubblegum_torque, 0.0));
} }
if(m_controls.m_accel) // accelerating if(m_controls.getAccel()) // accelerating
{ {
// For a short time after a collision disable the engine, // For a short time after a collision disable the engine,
// so that the karts can bounce back a bit from the obstacle. // so that the karts can bounce back a bit from the obstacle.
@ -2309,11 +2309,11 @@ void Kart::updateEnginePowerAndBrakes(float dt)
engine_power *= 5.0f; engine_power *= 5.0f;
// Lose some traction when skidding, to balance the advantage // Lose some traction when skidding, to balance the advantage
if (m_controls.m_skid && if (m_controls.getSkidControl() &&
m_kart_properties->getSkidVisualTime() == 0) m_kart_properties->getSkidVisualTime() == 0)
engine_power *= 0.5f; engine_power *= 0.5f;
applyEngineForce(engine_power*m_controls.m_accel); applyEngineForce(engine_power*m_controls.getAccel());
// Either all or no brake is set, so test only one to avoid // Either all or no brake is set, so test only one to avoid
// resetting all brakes most of the time. // resetting all brakes most of the time.
@ -2324,7 +2324,7 @@ void Kart::updateEnginePowerAndBrakes(float dt)
} }
else else
{ // not accelerating { // not accelerating
if(m_controls.m_brake) if(m_controls.getBrake())
{ // check if the player is currently only slowing down { // check if the player is currently only slowing down
// or moving backwards // or moving backwards
if(m_speed > 0.0f) if(m_speed > 0.0f)
@ -2360,9 +2360,9 @@ void Kart::updateEnginePowerAndBrakes(float dt)
{ {
m_brake_time = 0; m_brake_time = 0;
// lift the foot from throttle, brakes with 10% engine_power // lift the foot from throttle, brakes with 10% engine_power
assert(!std::isnan(m_controls.m_accel)); assert(!std::isnan(m_controls.getAccel()));
assert(!std::isnan(engine_power)); assert(!std::isnan(engine_power));
applyEngineForce(-m_controls.m_accel*engine_power*0.1f); applyEngineForce(-m_controls.getAccel()*engine_power*0.1f);
// If not giving power (forward or reverse gear), and speed is low // If not giving power (forward or reverse gear), and speed is low
// we are "parking" the kart, so in battle mode we can ambush people // we are "parking" the kart, so in battle mode we can ambush people
@ -2431,7 +2431,7 @@ void Kart::updateFlying()
{ {
m_body->setLinearVelocity(m_body->getLinearVelocity() * 0.99f); m_body->setLinearVelocity(m_body->getLinearVelocity() * 0.99f);
if (m_controls.m_accel) if (m_controls.getAccel())
{ {
btVector3 velocity = m_body->getLinearVelocity(); btVector3 velocity = m_body->getLinearVelocity();
if (velocity.length() < 25) if (velocity.length() < 25)
@ -2441,7 +2441,7 @@ void Kart::updateFlying()
100.0f*cos(orientation))); 100.0f*cos(orientation)));
} }
} }
else if (m_controls.m_brake) else if (m_controls.getBrake())
{ {
btVector3 velocity = m_body->getLinearVelocity(); btVector3 velocity = m_body->getLinearVelocity();
if (velocity.length() > -15) if (velocity.length() > -15)
@ -2452,9 +2452,9 @@ void Kart::updateFlying()
} }
} }
if (m_controls.m_steer != 0.0f) if (m_controls.getSteer()!= 0.0f)
{ {
m_body->applyTorque(btVector3(0.0, m_controls.m_steer * 3500.0f, 0.0)); m_body->applyTorque(btVector3(0.0, m_controls.getSteer()*3500.0f, 0.0));
} }
// dampen any roll while flying, makes the kart hard to control // dampen any roll while flying, makes the kart hard to control
@ -2690,7 +2690,7 @@ void Kart::updateGraphics(float dt, const Vec3& offset_xyz,
// depending on speed) // depending on speed)
// -------------------------------------------------------- // --------------------------------------------------------
float nitro_frac = 0; float nitro_frac = 0;
if ( (m_controls.m_nitro || m_min_nitro_time > 0.0f) && if ( (m_controls.getNitro() || m_min_nitro_time > 0.0f) &&
isOnGround() && m_collected_energy > 0 ) isOnGround() && m_collected_energy > 0 )
{ {
// fabs(speed) is important, otherwise the negative number will // fabs(speed) is important, otherwise the negative number will

2
src/karts/kart_gfx.cpp
View File

@ -324,7 +324,7 @@ void KartGFX::updateTerrain(const ParticleKind *pk)
bool on_ground = m_kart->isOnGround() && bool on_ground = m_kart->isOnGround() &&
m_kart->getSkidding()->getGraphicalJumpOffset()==0; m_kart->getSkidding()->getGraphicalJumpOffset()==0;
if (skidding > 1.0f && on_ground) if (skidding > 1.0f && on_ground)
rate = fabsf(m_kart->getControls().m_steer) > 0.8 ? skidding - 1 : 0; rate = fabsf(m_kart->getControls().getSteer()) > 0.8 ? skidding - 1 : 0;
else if (speed >= 0.5f && on_ground) else if (speed >= 0.5f && on_ground)
rate = speed/m_kart->getKartProperties()->getEngineMaxSpeed(); rate = speed/m_kart->getKartProperties()->getEngineMaxSpeed();
else else

8
src/karts/kart_with_stats.cpp
View File

@ -61,11 +61,9 @@ void KartWithStats::reset()
void KartWithStats::update(float dt) void KartWithStats::update(float dt)
{ {
Kart::update(dt); Kart::update(dt);
if(getSpeed()>m_top_speed) m_top_speed = getSpeed(); if(getSpeed()>m_top_speed ) m_top_speed = getSpeed();
if(getControls().m_skid) if(getControls().getSkidControl()) m_skidding_time += dt;
m_skidding_time += dt; if(getControls().getBrake() ) m_brake_count ++;
if(getControls().m_brake)
m_brake_count ++;
LinearWorld *world = dynamic_cast<LinearWorld*>(World::getWorld()); LinearWorld *world = dynamic_cast<LinearWorld*>(World::getWorld());
if(world && !world->isOnRoad(getWorldKartId())) if(world && !world->isOnRoad(getWorldKartId()))
m_off_track_count ++; m_off_track_count ++;

2
src/karts/skidding.cpp
View File

@ -77,7 +77,7 @@ void Skidding::reset()
m_kart->getKartGFX()->setCreationRateAbsolute(KartGFX::KGFX_SKIDL, 0); m_kart->getKartGFX()->setCreationRateAbsolute(KartGFX::KGFX_SKIDL, 0);
m_kart->getKartGFX()->setCreationRateAbsolute(KartGFX::KGFX_SKIDR, 0); m_kart->getKartGFX()->setCreationRateAbsolute(KartGFX::KGFX_SKIDR, 0);
m_kart->getKartGFX()->updateSkidLight(0); m_kart->getKartGFX()->updateSkidLight(0);
m_kart->getControls().m_skid = KartControl::SC_NONE; m_kart->getControls().setSkidControl(KartControl::SC_NONE);
btVector3 rot(0, 0, 0); btVector3 rot(0, 0, 0);
// Only access the vehicle if the kart is not a ghost // Only access the vehicle if the kart is not a ghost

28
src/network/protocols/controller_events_protocol.cpp
View File

@ -72,12 +72,12 @@ bool ControllerEventsProtocol::notifyEventAsynchronous(Event* event)
Controller *controller = World::getWorld()->getKart(kart_id) Controller *controller = World::getWorld()->getKart(kart_id)
->getController(); ->getController();
KartControl *controls = controller->getControls(); KartControl *controls = controller->getControls();
controls->m_brake = (serialized_1 & 0x40)!=0; controls->setBrake( (serialized_1 & 0x40)!=0);
controls->m_nitro = (serialized_1 & 0x20)!=0; controls->setNitro( (serialized_1 & 0x20)!=0);
controls->m_rescue = (serialized_1 & 0x10)!=0; controls->setRescue( (serialized_1 & 0x10)!=0);
controls->m_fire = (serialized_1 & 0x08)!=0; controls->setFire( (serialized_1 & 0x08)!=0);
controls->m_look_back = (serialized_1 & 0x04)!=0; controls->setLookBack((serialized_1 & 0x04)!=0);
controls->m_skid = KartControl::SkidControl(serialized_1 & 0x03); controls->setSkidControl(KartControl::SkidControl(serialized_1 & 0x03));
controller->action(action, action_value); controller->action(action, action_value);
} }
@ -110,19 +110,19 @@ void ControllerEventsProtocol::controllerAction(Controller* controller,
KartControl* controls = controller->getControls(); KartControl* controls = controller->getControls();
uint8_t serialized_1 = 0; uint8_t serialized_1 = 0;
serialized_1 |= (controls->m_brake==true); serialized_1 |= (controls->getBrake()==true);
serialized_1 <<= 1; serialized_1 <<= 1;
serialized_1 |= (controls->m_nitro==true); serialized_1 |= (controls->getNitro()==true);
serialized_1 <<= 1; serialized_1 <<= 1;
serialized_1 |= (controls->m_rescue==true); serialized_1 |= (controls->getRescue()==true);
serialized_1 <<= 1; serialized_1 <<= 1;
serialized_1 |= (controls->m_fire==true); serialized_1 |= (controls->getFire()==true);
serialized_1 <<= 1; serialized_1 <<= 1;
serialized_1 |= (controls->m_look_back==true); serialized_1 |= (controls->getLookBack()==true);
serialized_1 <<= 2; serialized_1 <<= 2;
serialized_1 += controls->m_skid; serialized_1 += controls->getSkidControl();
uint8_t serialized_2 = (uint8_t)(controls->m_accel*255.0); uint8_t serialized_2 = (uint8_t)(controls->getAccel()*255.0);
uint8_t serialized_3 = (uint8_t)(controls->m_steer*127.0); uint8_t serialized_3 = (uint8_t)(controls->getSteer()*127.0);
NetworkString *ns = getNetworkString(13); NetworkString *ns = getNetworkString(13);
ns->addFloat(World::getWorld()->getTime()); ns->addFloat(World::getWorld()->getTime());

12
src/race/history.cpp
View File

@ -208,8 +208,8 @@ void History::Save()
for(int k=0; k<num_karts; k++) for(int k=0; k<num_karts; k++)
{ {
fprintf(fd, "%f %f %d %f %f %f %f %f %f %f\n", fprintf(fd, "%f %f %d %f %f %f %f %f %f %f\n",
m_all_controls[index+k].m_steer, m_all_controls[index+k].getSteer(),
m_all_controls[index+k].m_accel, m_all_controls[index+k].getAccel(),
m_all_controls[index+k].getButtonsCompressed(), m_all_controls[index+k].getButtonsCompressed(),
m_all_xyz[index+k].getX(), m_all_xyz[index+k].getY(), m_all_xyz[index+k].getX(), m_all_xyz[index+k].getY(),
m_all_xyz[index+k].getZ(), m_all_xyz[index+k].getZ(),
@ -321,14 +321,14 @@ void History::Load()
unsigned int index = num_karts * i+k; unsigned int index = num_karts * i+k;
fgets(s, 1023, fd); fgets(s, 1023, fd);
int buttonsCompressed; int buttonsCompressed;
float x,y,z,rx,ry,rz,rw; float x,y,z,rx,ry,rz,rw, steer, accel;
sscanf(s, "%f %f %d %f %f %f %f %f %f %f\n", sscanf(s, "%f %f %d %f %f %f %f %f %f %f\n",
&m_all_controls[index].m_steer, &steer, &accel, &buttonsCompressed,
&m_all_controls[index].m_accel,
&buttonsCompressed,
&x, &y, &z, &x, &y, &z,
&rx, &ry, &rz, &rw &rx, &ry, &rz, &rw
); );
m_all_controls[index].setSteer(steer);
m_all_controls[index].setAccel(accel);
m_all_xyz[index] = Vec3(x,y,z); m_all_xyz[index] = Vec3(x,y,z);
m_all_rotations[index] = btQuaternion(rx,ry,rz,rw); m_all_rotations[index] = btQuaternion(rx,ry,rz,rw);
m_all_controls[index].setButtonsCompressed(char(buttonsCompressed)); m_all_controls[index].setButtonsCompressed(char(buttonsCompressed));

2
src/states_screens/race_gui.cpp
View File

@ -602,7 +602,7 @@ void RaceGUI::drawEnergyMeter(int x, int y, const AbstractKart *kart,
video::SMaterial m; video::SMaterial m;
if(kart->getControls().m_nitro || kart->isOnMinNitroTime()) if(kart->getControls().getNitro() || kart->isOnMinNitroTime())
m.setTexture(0, m_gauge_full_bright); m.setTexture(0, m_gauge_full_bright);
else else
m.setTexture(0, m_gauge_full); m.setTexture(0, m_gauge_full);