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;
// if the kart is looking backwards, release from the back
if( kart->getControls().m_look_back )
if( kart->getControls().getLookBack())
{
y_offset = -y_offset;
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);
// 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;
Vec3 direction;
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;
// 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
const AbstractKart *closest_kart=0;

2
src/items/powerup.cpp
View File

@ -272,7 +272,7 @@ void Powerup::use()
case PowerupManager::POWERUP_BUBBLEGUM:
// 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 normal;

2
src/karts/abstract_kart.hpp
View File

@ -109,7 +109,7 @@ public:
// Functions related to controlling the 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. */
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();
if(!canSkid(steer_fraction))
m_controls->m_skid = KartControl::SC_NONE;
m_controls->setSkidControl(KartControl::SC_NONE);
else
m_controls->m_skid = steer_fraction > 0 ? KartControl::SC_RIGHT
: KartControl::SC_LEFT;
float old_steer = m_controls->m_steer;
m_controls->setSkidControl(steer_fraction > 0 ? KartControl::SC_RIGHT
: KartControl::SC_LEFT );
float old_steer = m_controls->getSteer();
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;
if(old_steer < steer_fraction)
{
m_controls->m_steer = (old_steer+max_steer_change > steer_fraction)
? steer_fraction : old_steer+max_steer_change;
m_controls->setSteer(( old_steer+max_steer_change > steer_fraction)
? steer_fraction : old_steer+max_steer_change);
}
else
{
m_controls->m_steer = (old_steer-max_steer_change < steer_fraction)
? steer_fraction : old_steer-max_steer_change;
m_controls->setSteer( (old_steer-max_steer_change < steer_fraction)
? steer_fraction : old_steer-max_steer_change );
}
} // setSteering

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

@ -86,8 +86,8 @@ void ArenaAI::reset()
void ArenaAI::update(float dt)
{
// This is used to enable firing an item backwards.
m_controls->m_look_back = false;
m_controls->m_nitro = false;
m_controls->setLookBack(false);
m_controls->setNitro(false);
m_avoiding_banana = false;
// 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)
{
// Only use nitro when turn angle is big (180 - angle)
m_controls->m_nitro = true;
m_controls->setNitro(true);
}
if (m_is_uturn)
@ -298,15 +298,15 @@ void ArenaAI::checkIfStuck(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;
}
const float handicap =
(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
@ -318,9 +318,9 @@ void ArenaAI::handleArenaUTurn(const float dt)
if (fabsf(m_kart->getSpeed()) >
(m_kart->getKartProperties()->getEngineMaxSpeed() / 5)
&& m_kart->getSpeed() < 0) // Try to emulate reverse like human players
m_controls->m_accel = -0.06f;
m_controls->setAccel(-0.06f);
else
m_controls->m_accel = -5.0f;
m_controls->setAccel(-5.0f);
if (m_time_since_uturn >=
(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()) >
(m_kart->getKartProperties()->getEngineMaxSpeed() / 5)
&& m_kart->getSpeed() < 0)
m_controls->m_accel = -0.06f;
m_controls->setAccel(-0.06f);
else
m_controls->m_accel = -4.0f;
m_controls->setAccel(-4.0f);
m_time_since_reversing += dt;
@ -423,11 +423,11 @@ void ArenaAI::handleArenaBraking()
if (forceBraking() && m_kart->getSpeed() > MIN_SPEED)
{
// Brake now
m_controls->m_brake = true;
m_controls->setBrake(true);
return;
}
m_controls->m_brake = false;
m_controls->setBrake(false);
if (getCurrentNode() == BattleGraph::UNKNOWN_POLY ||
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);
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_controls->m_brake = true;
m_controls->setBrake(true);
}
} // handleArenaBraking
@ -502,7 +502,7 @@ float ArenaAI::findAngleFrom3Edges(float a, float b, float c)
//-----------------------------------------------------------------------------
void ArenaAI::handleArenaItems(const float dt)
{
m_controls->m_fire = false;
m_controls->setFire(false);
if (m_kart->getKartAnimation() ||
m_kart->getPowerup()->getType() == PowerupManager::POWERUP_NOTHING)
return;
@ -544,8 +544,8 @@ void ArenaAI::handleArenaItems(const float dt)
)
)
{
m_controls->m_fire = true;
m_controls->m_look_back = false;
m_controls->setFire(true);
m_controls->setLookBack(false);
break;
}
@ -558,8 +558,8 @@ void ArenaAI::handleArenaItems(const float dt)
m_closest_kart_pos_data.distance > 3.0f) ||
m_time_since_last_shot > 15.0f)
{
m_controls->m_fire = true;
m_controls->m_look_back = true;
m_controls->setFire(true);
m_controls->setLookBack(true);
break;
}
@ -577,8 +577,8 @@ void ArenaAI::handleArenaItems(const float dt)
if (m_closest_kart_pos_data.distance < 25.0f &&
!m_closest_kart->isInvulnerable())
{
m_controls->m_fire = true;
m_controls->m_look_back = fire_behind;
m_controls->setFire(true);
m_controls->setLookBack(fire_behind);
break;
}
@ -598,8 +598,8 @@ void ArenaAI::handleArenaItems(const float dt)
(difficulty || perfect_aim) &&
!m_closest_kart->isInvulnerable())
{
m_controls->m_fire = true;
m_controls->m_look_back = fire_behind;
m_controls->setFire(true);
m_controls->setLookBack(fire_behind);
break;
}
@ -618,8 +618,8 @@ void ArenaAI::handleArenaItems(const float dt)
m_closest_kart_pos_data.distance < d2 &&
m_closest_kart->getSpeed() < m_kart->getSpeed())
{
m_controls->m_fire = true;
m_controls->m_look_back = false;
m_controls->setFire(true);
m_controls->setLookBack(false);
break;
}
break;
@ -633,7 +633,7 @@ void ArenaAI::handleArenaItems(const float dt)
break; // POWERUP_PLUNGER
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
case PowerupManager::POWERUP_PARACHUTE:
@ -651,7 +651,7 @@ void ArenaAI::handleArenaItems(const float dt)
m_kart->getPowerup()->getType());
assert(false);
}
if (m_controls->m_fire)
if (m_controls->getFire())
m_time_since_last_shot = 0.0f;
} // 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)
{
// This is used to enable firing an item backwards.
m_controls->m_look_back = false;
m_controls->m_nitro = false;
m_controls->m_brake = false;
m_controls->m_accel = 1.0f;
m_controls->setLookBack(false);
m_controls->setNitro(false);
m_controls->setBrake(false);
m_controls->setAccel(1.0f);
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_EASTER_EGG)
{
m_controls->m_accel = 0.0f;
m_controls->setAccel(0.0f);
// Brake while we are still driving forwards (if we keep
// on braking, the kart will reverse otherwise)
m_controls->m_brake = m_kart->getSpeed()>0;
m_controls->setBrake(m_kart->getSpeed()>0);
return;
}
/*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->getType() != Camera::CM_TYPE_END)
{
if (m_controls->m_look_back)
if (m_controls->getLookBack())
{
camera->setMode(Camera::CM_REVERSE);
}
@ -85,5 +85,5 @@ void GhostController::action(PlayerAction action, int value)
{
// Watching replay use only
if (action == PA_LOOK_BACK)
m_controls->m_look_back = (value!=0);
m_controls->setLookBack(value!=0);
} // action

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

@ -29,6 +29,12 @@
class KartControl
{
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]. */
float m_steer;
/** Acceleration, in [0, 1]. */
@ -37,17 +43,15 @@ public:
bool m_brake;
/** True if the kart activates nitro. */
bool m_nitro;
/** 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}
m_skid;
/** Skidding control state. */
SkidControl m_skid;
/** True if rescue is selected. */
bool m_rescue;
/** True if fire is selected. */
bool m_fire;
/** True if the kart looks (and shoots) backwards. */
bool m_look_back;
public:
KartControl()
{
@ -126,6 +130,58 @@ public:
m_look_back = (c & 16) != 0;
m_skid = (SkidControl)((c & 96) >> 5);
} // 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

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)
{
Log::debug("LocalPlayerController", " set to: %f\n", m_controls->m_steer);
Log::debug("LocalPlayerController", " set to: %f\n",
m_controls->getSteer());
}
} // steer
@ -170,7 +171,7 @@ void LocalPlayerController::update(float dt)
Camera *camera = Camera::getCamera(m_camera_index);
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))
{
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)
{
m_steer_val = value;
if(m_controls->m_skid==KartControl::SC_NO_DIRECTION)
m_controls->m_skid = KartControl::SC_LEFT;
if(m_controls->getSkidControl()==KartControl::SC_NO_DIRECTION)
m_controls->setSkidControl(KartControl::SC_LEFT);
}
else
m_steer_val = m_steer_val_r;
@ -115,8 +115,8 @@ void PlayerController::action(PlayerAction action, int value)
if (value)
{
m_steer_val = -value;
if(m_controls->m_skid==KartControl::SC_NO_DIRECTION)
m_controls->m_skid = KartControl::SC_RIGHT;
if(m_controls->getSkidControl()==KartControl::SC_NO_DIRECTION)
m_controls->setSkidControl(KartControl::SC_RIGHT);
}
else
m_steer_val = m_steer_val_l;
@ -126,15 +126,15 @@ void PlayerController::action(PlayerAction action, int value)
m_prev_accel = value;
if (value && !(m_penalty_time > 0.0f))
{
m_controls->m_accel = value/32768.0f;
m_controls->m_brake = false;
m_controls->m_nitro = m_prev_nitro;
m_controls->setAccel(value/32768.0f);
m_controls->setBrake(false);
m_controls->setNitro(m_prev_nitro);
}
else
{
m_controls->m_accel = 0.0f;
m_controls->m_brake = m_prev_brake;
m_controls->m_nitro = false;
m_controls->setAccel(0.0f);
m_controls->setBrake(m_prev_brake);
m_controls->setNitro(false);
}
break;
case PA_BRAKE:
@ -142,44 +142,44 @@ void PlayerController::action(PlayerAction action, int value)
// let's consider below that to be a deadzone
if(value > 32768/2)
{
m_controls->m_brake = true;
m_controls->m_accel = 0.0f;
m_controls->m_nitro = false;
m_controls->setBrake(true);
m_controls->setAccel(0.0f);
m_controls->setNitro(false);
}
else
{
m_controls->m_brake = false;
m_controls->m_accel = m_prev_accel/32768.0f;
m_controls->setBrake(false);
m_controls->setAccel(m_prev_accel/32768.0f);
// 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;
case PA_NITRO:
// This basically keeps track whether the button still is being pressed
m_prev_nitro = (value != 0);
// 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;
case PA_RESCUE:
m_controls->m_rescue = (value!=0);
m_controls->setRescue(value!=0);
break;
case PA_FIRE:
m_controls->m_fire = (value!=0);
m_controls->setFire(value!=0);
break;
case PA_LOOK_BACK:
m_controls->m_look_back = (value!=0);
m_controls->setLookBack(value!=0);
break;
case PA_DRIFT:
if(value==0)
m_controls->m_skid = KartControl::SC_NONE;
m_controls->setSkidControl(KartControl::SC_NONE);
else
{
if(m_steer_val==0)
m_controls->m_skid = KartControl::SC_NO_DIRECTION;
m_controls->setSkidControl(KartControl::SC_NO_DIRECTION);
else
m_controls->m_skid = m_steer_val<0
? KartControl::SC_RIGHT
: KartControl::SC_LEFT;
m_controls->setSkidControl(m_steer_val<0
? KartControl::SC_RIGHT
: KartControl::SC_LEFT );
}
break;
case PA_PAUSE_RACE:
@ -196,52 +196,54 @@ void PlayerController::action(PlayerAction action, int value)
*/
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 &&
m_controls->m_skid==KartControl::SC_NONE &&
m_controls->getSkidControl()==KartControl::SC_NONE &&
m_kart->getSkidding()->getVisualSkidRotation()!=0)
{
m_controls->m_steer = 0;
steer = 0;
}
// Amount the steering is changed for digital devices.
// If the steering is 'back to straight', a different steering
// change speed is used.
const float STEER_CHANGE = ( (steer_val<=0 && m_controls->m_steer<0) ||
(steer_val>=0 && m_controls->m_steer>0) )
const float STEER_CHANGE = ( (steer_val<=0 && steer<0) ||
(steer_val>=0 && steer>0) )
? 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 we got analog values do not cumulate.
if (steer_val > -32767)
m_controls->m_steer = -steer_val/32767.0f;
steer = -steer_val/32767.0f;
else
m_controls->m_steer += STEER_CHANGE;
steer += STEER_CHANGE;
}
else if(steer_val > 0)
{
// If we got analog values do not cumulate.
if (steer_val < 32767)
m_controls->m_steer = -steer_val/32767.0f;
steer = -steer_val/32767.0f;
else
m_controls->m_steer -= STEER_CHANGE;
steer -= STEER_CHANGE;
}
else
{ // no key is pressed
if(m_controls->m_steer>0.0f)
if(steer>0.0f)
{
m_controls->m_steer -= STEER_CHANGE;
if(m_controls->m_steer<0.0f) m_controls->m_steer=0.0f;
steer -= STEER_CHANGE;
if(steer<0.0f) steer=0.0f;
}
else
{ // m_controls->m_steer<=0.0f;
m_controls->m_steer += STEER_CHANGE;
if(m_controls->m_steer>0.0f) m_controls->m_steer=0.0f;
} // if m_controls->m_steer<=0.0f
{ // steer<=0.0f;
steer += STEER_CHANGE;
if(steer>0.0f) steer=0.0f;
} // if steer<=0.0f
} // 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
@ -251,7 +253,7 @@ void PlayerController::steer(float dt, int steer_val)
*/
void PlayerController::skidBonusTriggered()
{
m_controls->m_steer = 0;
m_controls->setSteer(0);
} // skidBonusTriggered
//-----------------------------------------------------------------------------
@ -267,15 +269,15 @@ void PlayerController::update(float dt)
if (World::getWorld()->getPhase() == World::GOAL_PHASE)
{
m_controls->m_brake = false;
m_controls->m_accel = 0.0f;
m_controls->setBrake(false);
m_controls->setAccel(0.0f);
return;
}
if (World::getWorld()->isStartPhase())
{
if (m_controls->m_accel || m_controls->m_brake ||
m_controls->m_fire || m_controls->m_nitro)
if (m_controls->getAccel() || m_controls->getBrake()||
m_controls->getFire() || m_controls->getNitro())
{
// Only give penalty time in SET_PHASE.
// 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;
} // if penalty_time = 0
m_controls->m_brake = false;
m_controls->m_accel = 0.0f;
m_controls->setBrake(false);
m_controls->setAccel(0.0f);
} // if key pressed
return;
@ -303,10 +305,10 @@ void PlayerController::update(float dt)
// 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
// starting any other animation).
if ( m_controls->m_rescue && !m_kart->getKartAnimation() )
if ( m_controls->getRescue() && !m_kart->getKartAnimation() )
{
new RescueAnimation(m_kart);
m_controls->m_rescue=false;
m_controls->setRescue(false);
}
} // 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)
{
// This is used to enable firing an item backwards.
m_controls->m_look_back = false;
m_controls->m_nitro = false;
m_controls->setLookBack(false);
m_controls->setNitro(false);
// Don't do anything if there is currently a kart animations shown.
if(m_kart->getKartAnimation())
@ -323,8 +323,8 @@ void SkiddingAI::update(float dt)
m_kart_ahead )
{
// Use nitro if the kart is far ahead, or faster than this kart
m_controls->m_nitro = m_distance_ahead>10.0f ||
m_kart_ahead->getSpeed() > m_kart->getSpeed();
m_controls->setNitro(m_distance_ahead>10.0f ||
m_kart_ahead->getSpeed() > m_kart->getSpeed());
// If we are close enough, try to hit this kart
if(m_distance_ahead<=10)
{
@ -354,12 +354,12 @@ void SkiddingAI::update(float dt)
handleRescue(dt);
handleBraking();
// If a bomb is attached, nitro might already be set.
if(!m_controls->m_nitro)
if(!m_controls->getNitro())
handleNitroAndZipper();
}
// If we are supposed to use nitro, but have a zipper,
// 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->getSpeed()>1.0f &&
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 ||
(m_world->getTime()<3.0f && rand()%50==1) )
{
m_controls->m_nitro = false;
m_controls->m_fire = true;
m_controls->setNitro(false);
m_controls->setFire(true);
}
}
@ -390,7 +390,7 @@ void SkiddingAI::update(float dt)
*/
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
// the leader (and not the leader, i.e. don't have initial position 1)
if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_FOLLOW_LEADER &&
@ -403,7 +403,7 @@ void SkiddingAI::handleBraking()
m_kart->getIdent().c_str());
#endif
m_controls->m_brake = true;
m_controls->setBrake(true);
return;
}
@ -423,7 +423,7 @@ void SkiddingAI::handleBraking()
"%s not aligned with track.",
m_kart->getIdent().c_str());
#endif
m_controls->m_brake = true;
m_controls->setBrake(true);
return;
}
if(m_current_track_direction==GraphNode::DIR_LEFT ||
@ -434,9 +434,9 @@ void SkiddingAI::handleBraking()
if(m_kart->getSpeed() > 1.5f*max_turn_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
if(m_ai_debug)
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)
{
m_controls->m_fire = false;
m_controls->setFire(false);
if(m_kart->getKartAnimation() ||
m_kart->getPowerup()->getType() == PowerupManager::POWERUP_NOTHING )
return;
@ -1150,12 +1150,12 @@ void SkiddingAI::handleItems(const float dt)
if (m_superpower == RaceManager::SUPERPOWER_NOLOK_BOSS)
{
m_controls->m_look_back = (m_kart->getPowerup()->getType() ==
PowerupManager::POWERUP_BOWLING );
m_controls->setLookBack(m_kart->getPowerup()->getType() ==
PowerupManager::POWERUP_BOWLING );
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)
m_time_since_last_shot = 3.0f;
else
@ -1166,7 +1166,7 @@ void SkiddingAI::handleItems(const float dt)
}
else
{
m_controls->m_fire = false;
m_controls->setFire(false);
}
return;
}
@ -1177,7 +1177,7 @@ void SkiddingAI::handleItems(const float dt)
{
if( m_time_since_last_shot > 10.0f )
{
m_controls->m_fire = true;
m_controls->setFire(true);
m_time_since_last_shot = 0.0f;
}
return;
@ -1202,8 +1202,8 @@ void SkiddingAI::handleItems(const float dt)
projectile_manager->projectileIsClose(m_kart,
m_ai_properties->m_shield_incoming_radius) )
{
m_controls->m_fire = true;
m_controls->m_look_back = false;
m_controls->setFire(true);
m_controls->setLookBack(false);
break;
}
@ -1218,8 +1218,8 @@ void SkiddingAI::handleItems(const float dt)
// overtaken kart to overtake us again.
if(m_distance_behind < 15.0f && m_distance_behind > 3.0f )
{
m_controls->m_fire = true;
m_controls->m_look_back = true;
m_controls->setFire(true);
m_controls->setLookBack(true);
break;
}
@ -1231,8 +1231,8 @@ void SkiddingAI::handleItems(const float dt)
lin_world->getKartLaps(m_kart->getWorldKartId())
== race_manager->getNumLaps()-1)
{
m_controls->m_fire = true;
m_controls->m_look_back = true;
m_controls->setFire(true);
m_controls->setLookBack(true);
break;
}
break; // POWERUP_BUBBLEGUM
@ -1278,10 +1278,10 @@ void SkiddingAI::handleItems(const float dt)
: m_distance_ahead;
// 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
m_controls->m_fire = (fire_backwards && distance < 25.0f) ||
(!fire_backwards && distance < 20.0f);
if(m_controls->m_fire)
m_controls->m_look_back = fire_backwards;
m_controls->setFire( (fire_backwards && distance < 25.0f) ||
(!fire_backwards && distance < 20.0f) );
if(m_controls->getFire())
m_controls->setLookBack(fire_backwards);
break;
} // POWERUP_CAKE
@ -1324,12 +1324,12 @@ void SkiddingAI::handleItems(const float dt)
float distance = fire_backwards ? m_distance_behind
: 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) ) &&
m_time_since_last_shot > 3.0f &&
(straight_behind || straight_ahead);
if(m_controls->m_fire)
m_controls->m_look_back = fire_backwards;
(straight_behind || straight_ahead) );
if(m_controls->getFire())
m_controls->setLookBack(fire_backwards);
break;
} // POWERUP_BOWLING
@ -1355,10 +1355,10 @@ void SkiddingAI::handleItems(const float dt)
!m_kart_ahead;
float distance = fire_backwards ? m_distance_behind
: m_distance_ahead;
m_controls->m_fire = distance < 30.0f ||
m_time_since_last_shot > 10.0f;
if(m_controls->m_fire)
m_controls->m_look_back = fire_backwards;
m_controls->setFire(distance < 30.0f ||
m_time_since_last_shot > 10.0f );
if(m_controls->getFire())
m_controls->setLookBack(fire_backwards);
break;
} // POWERUP_PLUNGER
@ -1368,13 +1368,13 @@ void SkiddingAI::handleItems(const float dt)
// after a waiting an appropriate time
if(m_kart->getPosition()>1 &&
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
case PowerupManager::POWERUP_PARACHUTE:
// Wait one second more than a previous parachute
if(m_time_since_last_shot > m_kart->getKartProperties()->getParachuteDurationOther() + 1.0f)
m_controls->m_fire = true;
m_controls->setFire(true);
break; // POWERUP_PARACHUTE
case PowerupManager::POWERUP_ANVIL:
@ -1383,13 +1383,13 @@ void SkiddingAI::handleItems(const float dt)
if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER)
{
m_controls->m_fire = m_world->getTime()<1.0f &&
m_kart->getPosition()>2;
m_controls->setFire(m_world->getTime()<1.0f &&
m_kart->getPosition()>2 );
}
else
{
m_controls->m_fire = m_time_since_last_shot > 3.0f &&
m_kart->getPosition()>1;
m_controls->setFire(m_time_since_last_shot > 3.0f &&
m_kart->getPosition()>1 );
}
break; // POWERUP_ANVIL
@ -1410,7 +1410,7 @@ void SkiddingAI::handleItems(const float dt)
m_kart_ahead->getSpeed() < m_kart->getSpeed() ) ||
( m_kart_behind && !m_kart_behind->isSquashed() &&
(m_kart_behind->getXYZ()-m_kart->getXYZ()).length2()<d2) )
m_controls->m_fire = true;
m_controls->setFire(true);
break;
}
case PowerupManager::POWERUP_RUBBERBALL:
@ -1420,7 +1420,7 @@ void SkiddingAI::handleItems(const float dt)
// Perhaps some more sophisticated algorithm might be useful.
// For now: fire if there is a kart ahead (which means that
// this kart is certainly not the first kart)
m_controls->m_fire = m_kart_ahead != NULL;
m_controls->setFire(m_kart_ahead != NULL);
break;
default:
Log::error(getControllerName().c_str(),
@ -1428,7 +1428,7 @@ void SkiddingAI::handleItems(const float dt)
m_kart->getPowerup()->getType());
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
//-----------------------------------------------------------------------------
@ -1504,26 +1504,26 @@ void SkiddingAI::handleAcceleration( const float dt)
if( m_start_delay > 0.0f )
{
m_start_delay -= dt;
m_controls->m_accel = 0.0f;
m_controls->setAccel(0.0f);
return;
}
if( m_controls->m_brake )
if( m_controls->getBrake())
{
m_controls->m_accel = 0.0f;
m_controls->setAccel(0.0f);
return;
}
if(m_kart->getBlockedByPlungerTime()>0)
{
if(m_kart->getSpeed() < m_kart->getCurrentMaxSpeed() / 2)
m_controls->m_accel = 0.05f;
m_controls->setAccel(0.05f);
else
m_controls->m_accel = 0.0f;
m_controls->setAccel(0.0f);
return;
}
m_controls->m_accel = stk_config->m_ai_acceleration;
m_controls->setAccel(stk_config->m_ai_acceleration);
} // handleAcceleration
@ -1580,7 +1580,7 @@ void SkiddingAI::handleRescue(const float dt)
*/
void SkiddingAI::handleNitroAndZipper()
{
m_controls->m_nitro = false;
m_controls->setNitro(false);
// If we are already very fast, save nitro.
if(m_kart->getSpeed() > 0.95f*m_kart->getCurrentMaxSpeed())
return;
@ -1588,7 +1588,7 @@ void SkiddingAI::handleNitroAndZipper()
if(m_kart->getBlockedByPlungerTime()>0) return;
// 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
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(m_kart->getSpeed()<5)
{
m_controls->m_nitro = true;
m_controls->setNitro(true);
return;
}
@ -1629,7 +1629,7 @@ void SkiddingAI::handleNitroAndZipper()
if(m_kart->getPosition()== (int)num_karts &&
num_karts>1 && m_kart->getEnergy()>2.0f)
{
m_controls->m_nitro = true;
m_controls->setNitro(true);
return;
}
@ -1645,7 +1645,7 @@ void SkiddingAI::handleNitroAndZipper()
m_world->getEstimatedFinishTime(m_kart->getWorldKartId());
if( 1.5f*m_kart->getEnergy() >= finish - m_world->getTime() )
{
m_controls->m_nitro = true;
m_controls->setNitro(true);
return;
}
}
@ -1661,7 +1661,7 @@ void SkiddingAI::handleNitroAndZipper()
m_distance_ahead < overtake_distance &&
m_kart_ahead->getSpeed()+5.0f > m_kart->getSpeed() )
{
m_controls->m_nitro = true;
m_controls->setNitro(true);
return;
}
@ -1670,8 +1670,8 @@ void SkiddingAI::handleNitroAndZipper()
m_kart_behind->getSpeed() > m_kart->getSpeed() )
{
// Only prevent overtaking on highest level
m_controls->m_nitro = m_ai_properties->m_nitro_usage
== AIProperties::NITRO_ALL;
m_controls->setNitro(m_ai_properties->m_nitro_usage
== AIProperties::NITRO_ALL);
return;
}
@ -1689,7 +1689,7 @@ void SkiddingAI::handleNitroAndZipper()
- QuadGraph::get()->getDistanceFromStart(m_track_node);
if(diff<0) diff+=World::getWorld()->getTrack()->getTrackLength();
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
// a good time to release the skid button, since this will turn the
// kart more sharply:
if(m_controls->m_skid)
if(m_controls->getSkidControl())
{
#ifdef DEBUG
if(m_ai_debug)
@ -2247,7 +2247,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_current_track_direction==GraphNode::DIR_UNDEFINED )
{
#ifdef DEBUG
if(m_controls->m_skid && m_ai_debug)
if(m_controls->getSkidControl() && m_ai_debug)
{
Log::debug(getControllerName().c_str(),
"%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
// 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)
Log::debug(getControllerName().c_str(),
@ -2301,7 +2301,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_current_track_direction==GraphNode::DIR_RIGHT) )
{
#ifdef DEBUG
if(m_controls->m_skid && m_ai_debug)
if(m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(),
"%s skidding against track direction.",
m_kart->getIdent().c_str());
@ -2313,7 +2313,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_kart->getKartProperties()->getSkidTimeTillBonus()[0] < duration)
{
#ifdef DEBUG
if(!m_controls->m_skid && m_ai_debug)
if(!m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(),
"%s start skid, duration %f.",
m_kart->getIdent().c_str(), duration);
@ -2323,7 +2323,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
} // if curve long enough for skidding
#ifdef DEBUG
if(m_controls->m_skid && m_ai_debug)
if(m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(),
"%s has no reasons to skid anymore.",
m_kart->getIdent().c_str());
@ -2354,7 +2354,7 @@ void SkiddingAI::setSteering(float angle, float dt)
if(!canSkid(steer_fraction))
{
m_skid_probability_state = SKID_PROBAB_NOT_YET;
m_controls->m_skid = KartControl::SC_NONE;
m_controls->setSkidControl(KartControl::SC_NONE);
}
else
{
@ -2377,8 +2377,8 @@ void SkiddingAI::setSteering(float angle, float dt)
sc= ? "no" : sc==KartControl::SC_LEFT ? "left" : "right");
#endif
}
m_controls->m_skid = m_skid_probability_state == SKID_PROBAB_SKID
? sc : KartControl::SC_NONE;
m_controls->setSkidControl(m_skid_probability_state == SKID_PROBAB_SKID
? sc : KartControl::SC_NONE );
}
// 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 ) ||
(ss==Skidding::SKID_ACCUMULATE_RIGHT && steer_fraction<-0.2f) )
{
m_controls->m_skid = KartControl::SC_NONE;
m_controls->setSkidControl(KartControl::SC_NONE);
#ifdef DEBUG
if(m_ai_debug)
Log::info(getControllerName().c_str(),
@ -2411,7 +2411,7 @@ void SkiddingAI::setSteering(float angle, float dt)
#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_RIGHT ) )
{
@ -2425,7 +2425,7 @@ void SkiddingAI::setSteering(float angle, float dt)
"%s steering too much (%f).",
m_kart->getIdent().c_str(), steer_fraction);
#endif
m_controls->m_skid = KartControl::SC_NONE;
m_controls->setSkidControl(KartControl::SC_NONE);
}
if(steer_fraction<-1.0f)
steer_fraction = -1.0f;
@ -2433,19 +2433,19 @@ void SkiddingAI::setSteering(float angle, float dt)
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
float max_steer_change = dt/m_ai_properties->m_time_full_steer;
if(old_steer < steer_fraction)
{
m_controls->m_steer = (old_steer+max_steer_change > steer_fraction)
? steer_fraction : old_steer+max_steer_change;
m_controls->setSteer( (old_steer+max_steer_change > steer_fraction)
? steer_fraction : old_steer+max_steer_change );
}
else
{
m_controls->m_steer = (old_steer-max_steer_change < steer_fraction)
? steer_fraction : old_steer-max_steer_change;
m_controls->setSteer( (old_steer-max_steer_change < steer_fraction)
? 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)
{
resetAfterStop();
m_controls->m_brake = false;
m_controls->m_accel = 0.0f;
m_controls->setBrake(false);
m_controls->setAccel(0.0f);
AIBaseController::update(dt);
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)
{
// This is used to enable firing an item backwards.
m_controls->m_look_back = false;
m_controls->m_nitro = false;
m_controls->setLookBack(false);
m_controls->setNitro(false);
// Don't do anything if there is currently a kart animations shown.
if(m_kart->getKartAnimation())
@ -329,8 +329,8 @@ void SkiddingAI::update(float dt)
m_kart_ahead )
{
// Use nitro if the kart is far ahead, or faster than this kart
m_controls->m_nitro = m_distance_ahead>10.0f ||
m_kart_ahead->getSpeed() > m_kart->getSpeed();
m_controls->setNitro(m_distance_ahead>10.0f ||
m_kart_ahead->getSpeed() > m_kart->getSpeed());
// If we are close enough, try to hit this kart
if(m_distance_ahead<=10)
{
@ -360,12 +360,12 @@ void SkiddingAI::update(float dt)
handleRescue(dt);
handleBraking();
// If a bomb is attached, nitro might already be set.
if(!m_controls->m_nitro)
if(!m_controls->getNitro())
handleNitroAndZipper();
}
// If we are supposed to use nitro, but have a zipper,
// 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->getSpeed()>1.0f &&
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 ||
(m_world->getTime()<3.0f && rand()%50==1) )
{
m_controls->m_nitro = false;
m_controls->m_fire = true;
m_controls->setNitro(false);
m_controls->setFire(true);
}
}
@ -396,7 +396,7 @@ void SkiddingAI::update(float dt)
*/
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
// the leader (and not the leader, i.e. don't have initial position 1)
if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_FOLLOW_LEADER &&
@ -409,7 +409,7 @@ void SkiddingAI::handleBraking()
m_kart->getIdent().c_str());
#endif
m_controls->m_brake = true;
m_controls->setBrake(true);
return;
}
@ -429,7 +429,7 @@ void SkiddingAI::handleBraking()
"%s not aligned with track.",
m_kart->getIdent().c_str());
#endif
m_controls->m_brake = true;
m_controls->setBrake(true);
return;
}
if(m_current_track_direction==GraphNode::DIR_LEFT ||
@ -440,9 +440,9 @@ void SkiddingAI::handleBraking()
if(m_kart->getSpeed() > 1.5f*max_turn_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
if(m_ai_debug)
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)
{
m_controls->m_fire = false;
m_controls->setFire(false);
if(m_kart->getKartAnimation() ||
m_kart->getPowerup()->getType() == PowerupManager::POWERUP_NOTHING )
return;
@ -1156,12 +1156,12 @@ void SkiddingAI::handleItems(const float dt)
if (m_superpower == RaceManager::SUPERPOWER_NOLOK_BOSS)
{
m_controls->m_look_back = (m_kart->getPowerup()->getType() ==
PowerupManager::POWERUP_BOWLING );
m_controls->setLookBack(m_kart->getPowerup()->getType() ==
PowerupManager::POWERUP_BOWLING );
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)
m_time_since_last_shot = 3.0f;
else
@ -1172,7 +1172,7 @@ void SkiddingAI::handleItems(const float dt)
}
else
{
m_controls->m_fire = false;
m_controls->setFire(false);
}
return;
}
@ -1183,7 +1183,7 @@ void SkiddingAI::handleItems(const float dt)
{
if( m_time_since_last_shot > 10.0f )
{
m_controls->m_fire = true;
m_controls->setFire(true);
m_time_since_last_shot = 0.0f;
}
return;
@ -1208,8 +1208,8 @@ void SkiddingAI::handleItems(const float dt)
projectile_manager->projectileIsClose(m_kart,
m_ai_properties->m_shield_incoming_radius) )
{
m_controls->m_fire = true;
m_controls->m_look_back = false;
m_controls->setFire(true);
m_controls->setLookBack(false);
break;
}
@ -1224,8 +1224,8 @@ void SkiddingAI::handleItems(const float dt)
// overtaken kart to overtake us again.
if(m_distance_behind < 15.0f && m_distance_behind > 3.0f )
{
m_controls->m_fire = true;
m_controls->m_look_back = true;
m_controls->setFire(true);
m_controls->setLookBack(true);
break;
}
@ -1237,8 +1237,8 @@ void SkiddingAI::handleItems(const float dt)
lin_world->getKartLaps(m_kart->getWorldKartId())
== race_manager->getNumLaps()-1)
{
m_controls->m_fire = true;
m_controls->m_look_back = true;
m_controls->setFire(true);
m_controls->setLookBack(true);
break;
}
break; // POWERUP_BUBBLEGUM
@ -1284,10 +1284,10 @@ void SkiddingAI::handleItems(const float dt)
: m_distance_ahead;
// 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
m_controls->m_fire = (fire_backwards && distance < 25.0f) ||
(!fire_backwards && distance < 20.0f);
if(m_controls->m_fire)
m_controls->m_look_back = fire_backwards;
m_controls->setFire( (fire_backwards && distance < 25.0f) ||
(!fire_backwards && distance < 20.0f) );
if(m_controls->getFire())
m_controls->setLookBack(fire_backwards);
break;
} // POWERUP_CAKE
@ -1330,12 +1330,12 @@ void SkiddingAI::handleItems(const float dt)
float distance = fire_backwards ? m_distance_behind
: 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) ) &&
m_time_since_last_shot > 3.0f &&
(straight_behind || straight_ahead);
if(m_controls->m_fire)
m_controls->m_look_back = fire_backwards;
(straight_behind || straight_ahead) );
if(m_controls->getFire())
m_controls->setLookBack(fire_backwards);
break;
} // POWERUP_BOWLING
@ -1361,10 +1361,10 @@ void SkiddingAI::handleItems(const float dt)
!m_kart_ahead;
float distance = fire_backwards ? m_distance_behind
: m_distance_ahead;
m_controls->m_fire = distance < 30.0f ||
m_time_since_last_shot > 10.0f;
if(m_controls->m_fire)
m_controls->m_look_back = fire_backwards;
m_controls->setFire(distance < 30.0f ||
m_time_since_last_shot > 10.0f );
if(m_controls->getFire())
m_controls->setLookBack(fire_backwards);
break;
} // POWERUP_PLUNGER
@ -1374,13 +1374,13 @@ void SkiddingAI::handleItems(const float dt)
// after a waiting an appropriate time
if(m_kart->getPosition()>1 &&
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
case PowerupManager::POWERUP_PARACHUTE:
// Wait one second more than a previous parachute
if(m_time_since_last_shot > m_kart->getKartProperties()->getParachuteDurationOther() + 1.0f)
m_controls->m_fire = true;
m_controls->setFire(true);
break; // POWERUP_PARACHUTE
case PowerupManager::POWERUP_ANVIL:
@ -1389,13 +1389,13 @@ void SkiddingAI::handleItems(const float dt)
if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER)
{
m_controls->m_fire = m_world->getTime()<1.0f &&
m_kart->getPosition()>2;
m_controls->setFire(m_world->getTime()<1.0f &&
m_kart->getPosition()>2 );
}
else
{
m_controls->m_fire = m_time_since_last_shot > 3.0f &&
m_kart->getPosition()>1;
m_controls->setFire(m_time_since_last_shot > 3.0f &&
m_kart->getPosition()>1 );
}
break; // POWERUP_ANVIL
@ -1416,7 +1416,7 @@ void SkiddingAI::handleItems(const float dt)
m_kart_ahead->getSpeed() < m_kart->getSpeed() ) ||
( m_kart_behind && !m_kart_behind->isSquashed() &&
(m_kart_behind->getXYZ()-m_kart->getXYZ()).length2()<d2) )
m_controls->m_fire = true;
m_controls->setFire(true);
break;
}
case PowerupManager::POWERUP_RUBBERBALL:
@ -1426,7 +1426,7 @@ void SkiddingAI::handleItems(const float dt)
// Perhaps some more sophisticated algorithm might be useful.
// For now: fire if there is a kart ahead (which means that
// this kart is certainly not the first kart)
m_controls->m_fire = m_kart_ahead != NULL;
m_controls->setFire(m_kart_ahead != NULL);
break;
default:
Log::error(getControllerName().c_str(),
@ -1434,7 +1434,7 @@ void SkiddingAI::handleItems(const float dt)
m_kart->getPowerup()->getType());
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
//-----------------------------------------------------------------------------
@ -1510,7 +1510,7 @@ void SkiddingAI::handleAcceleration( const float dt)
if( m_start_delay > 0.0f )
{
m_start_delay -= dt;
m_controls->m_accel = 0.0f;
m_controls->setAccel(0.0f);
return;
}
@ -1518,22 +1518,22 @@ void SkiddingAI::handleAcceleration( const float dt)
// m_brake has not been reset from the previous frame, which can
// cause too long slow downs. On the other hand removing it appears
// 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;
}
if(m_kart->getBlockedByPlungerTime()>0)
{
if(m_kart->getSpeed() < m_kart->getCurrentMaxSpeed() / 2)
m_controls->m_accel = 0.05f;
m_controls->setAccel(0.05f);
else
m_controls->m_accel = 0.0f;
m_controls->setAccel(0.0f);
return;
}
m_controls->m_accel = stk_config->m_ai_acceleration;
m_controls->setAccel(stk_config->m_ai_acceleration);
} // handleAcceleration
@ -1590,7 +1590,7 @@ void SkiddingAI::handleRescue(const float dt)
*/
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
// is already fast.
@ -1599,14 +1599,14 @@ void SkiddingAI::handleNitroAndZipper()
if(m_kart->getSpeed() > 0.95f*m_kart->getCurrentMaxSpeed())
return;
// 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
// sandtrack), but worse in others (zen, xr591). The good result
// 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
// 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
// (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
// 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
@ -1637,7 +1637,7 @@ void SkiddingAI::handleNitroAndZipper()
if(m_kart->getBlockedByPlungerTime()>0) return;
// 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
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(m_kart->getSpeed()<5)
{
m_controls->m_nitro = true;
m_controls->setNitro(true);
return;
}
@ -1678,7 +1678,7 @@ void SkiddingAI::handleNitroAndZipper()
if(m_kart->getPosition()== (int)num_karts &&
num_karts>1 && m_kart->getEnergy()>2.0f)
{
m_controls->m_nitro = true;
m_controls->setNitro(true);
return;
}
@ -1694,7 +1694,7 @@ void SkiddingAI::handleNitroAndZipper()
m_world->getEstimatedFinishTime(m_kart->getWorldKartId());
if( 1.5f*m_kart->getEnergy() >= finish - m_world->getTime() )
{
m_controls->m_nitro = true;
m_controls->setNitro(true);
return;
}
}
@ -1710,7 +1710,7 @@ void SkiddingAI::handleNitroAndZipper()
m_distance_ahead < overtake_distance &&
m_kart_ahead->getSpeed()+5.0f > m_kart->getSpeed() )
{
m_controls->m_nitro = true;
m_controls->setNitro(true);
return;
}
@ -1719,8 +1719,8 @@ void SkiddingAI::handleNitroAndZipper()
m_kart_behind->getSpeed() > m_kart->getSpeed() )
{
// Only prevent overtaking on highest level
m_controls->m_nitro = m_ai_properties->m_nitro_usage
== AIProperties::NITRO_ALL;
m_controls->setNitro(m_ai_properties->m_nitro_usage
== AIProperties::NITRO_ALL );
return;
}
@ -1738,7 +1738,7 @@ void SkiddingAI::handleNitroAndZipper()
- QuadGraph::get()->getDistanceFromStart(m_track_node);
if(diff<0) diff+=World::getWorld()->getTrack()->getTrackLength();
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
// a good time to release the skid button, since this will turn the
// kart more sharply:
if(m_controls->m_skid)
if(m_controls->getSkidControl())
{
#ifdef DEBUG
if(m_ai_debug)
@ -2296,7 +2296,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_current_track_direction==GraphNode::DIR_UNDEFINED )
{
#ifdef DEBUG
if(m_controls->m_skid && m_ai_debug)
if(m_controls->getSkidControl() && m_ai_debug)
{
Log::debug(getControllerName().c_str(),
"%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
// 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)
Log::debug(getControllerName().c_str(),
@ -2350,7 +2350,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_current_track_direction==GraphNode::DIR_RIGHT) )
{
#ifdef DEBUG
if(m_controls->m_skid && m_ai_debug)
if(m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(),
"%s skidding against track direction.",
m_kart->getIdent().c_str());
@ -2362,7 +2362,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
m_kart->getKartProperties()->getSkidTimeTillBonus()[0] < duration)
{
#ifdef DEBUG
if(!m_controls->m_skid && m_ai_debug)
if(!m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(),
"%s start skid, duration %f.",
m_kart->getIdent().c_str(), duration);
@ -2372,7 +2372,7 @@ bool SkiddingAI::canSkid(float steer_fraction)
} // if curve long enough for skidding
#ifdef DEBUG
if(m_controls->m_skid && m_ai_debug)
if(m_controls->getSkidControl() && m_ai_debug)
Log::debug(getControllerName().c_str(),
"%s has no reasons to skid anymore.",
m_kart->getIdent().c_str());
@ -2403,7 +2403,7 @@ void SkiddingAI::setSteering(float angle, float dt)
if(!canSkid(steer_fraction))
{
m_skid_probability_state = SKID_PROBAB_NOT_YET;
m_controls->m_skid = KartControl::SC_NONE;
m_controls->setSkidControl(KartControl::SC_NONE);
}
else
{
@ -2426,8 +2426,8 @@ void SkiddingAI::setSteering(float angle, float dt)
sc= ? "no" : sc==KartControl::SC_LEFT ? "left" : "right");
#endif
}
m_controls->m_skid = m_skid_probability_state == SKID_PROBAB_SKID
? sc : KartControl::SC_NONE;
m_controls->setSkidControl(m_skid_probability_state == SKID_PROBAB_SKID
? sc : KartControl::SC_NONE );
}
// 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 ) ||
(ss==Skidding::SKID_ACCUMULATE_RIGHT && steer_fraction<-0.2f) )
{
m_controls->m_skid = KartControl::SC_NONE;
m_controls->setSkidControl(KartControl::SC_NONE);
#ifdef DEBUG
if(m_ai_debug)
Log::info(getControllerName().c_str(),
@ -2460,7 +2460,7 @@ void SkiddingAI::setSteering(float angle, float dt)
#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_RIGHT ) )
{
@ -2474,7 +2474,7 @@ void SkiddingAI::setSteering(float angle, float dt)
"%s steering too much (%f).",
m_kart->getIdent().c_str(), steer_fraction);
#endif
m_controls->m_skid = KartControl::SC_NONE;
m_controls->setSkidControl(KartControl::SC_NONE);
}
if(steer_fraction<-1.0f)
steer_fraction = -1.0f;
@ -2482,19 +2482,19 @@ void SkiddingAI::setSteering(float angle, float dt)
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
float max_steer_change = dt/m_ai_properties->m_time_full_steer;
if(old_steer < steer_fraction)
{
m_controls->m_steer = (old_steer+max_steer_change > steer_fraction)
? steer_fraction : old_steer+max_steer_change;
m_controls->setSteer( (old_steer+max_steer_change > steer_fraction)
? steer_fraction : old_steer+max_steer_change );
}
else
{
m_controls->m_steer = (old_steer-max_steer_change < steer_fraction)
? steer_fraction : old_steer-max_steer_change;
m_controls->setSteer( (old_steer-max_steer_change < steer_fraction)
? 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);
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
// 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();
}
// 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,
max_speed_increase, speed_gain,
@ -1807,7 +1807,7 @@ void Kart::handleZipper(const Material *material, bool play_sound)
*/
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();
}
@ -1817,11 +1817,11 @@ void Kart::updateNitro(float dt)
// when pressing the key, don't allow the min time to go under zero.
// 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;
}
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(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
// is done in getStartupBoost - it returns 0 if the start was actually
// 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;
float f = getStartupBoost();
@ -2155,8 +2155,8 @@ void Kart::updatePhysics(float dt)
if (m_flying)
updateFlying();
m_skidding->update(dt, isOnGround(), m_controls.m_steer,
m_controls.m_skid);
m_skidding->update(dt, isOnGround(), m_controls.getSteer(),
m_controls.getSkidControl());
m_vehicle->setVisualRotation(m_skidding->getVisualSkidRotation());
if(( m_skidding->getSkidState() == Skidding::SKID_ACCUMULATE_LEFT ||
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));
}
if(m_controls.m_accel) // accelerating
if(m_controls.getAccel()) // accelerating
{
// For a short time after a collision disable the engine,
// 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;
// Lose some traction when skidding, to balance the advantage
if (m_controls.m_skid &&
if (m_controls.getSkidControl() &&
m_kart_properties->getSkidVisualTime() == 0)
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
// resetting all brakes most of the time.
@ -2324,7 +2324,7 @@ void Kart::updateEnginePowerAndBrakes(float dt)
}
else
{ // not accelerating
if(m_controls.m_brake)
if(m_controls.getBrake())
{ // check if the player is currently only slowing down
// or moving backwards
if(m_speed > 0.0f)
@ -2360,9 +2360,9 @@ void Kart::updateEnginePowerAndBrakes(float dt)
{
m_brake_time = 0;
// 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));
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
// 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);
if (m_controls.m_accel)
if (m_controls.getAccel())
{
btVector3 velocity = m_body->getLinearVelocity();
if (velocity.length() < 25)
@ -2441,7 +2441,7 @@ void Kart::updateFlying()
100.0f*cos(orientation)));
}
}
else if (m_controls.m_brake)
else if (m_controls.getBrake())
{
btVector3 velocity = m_body->getLinearVelocity();
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
@ -2690,7 +2690,7 @@ void Kart::updateGraphics(float dt, const Vec3& offset_xyz,
// depending on speed)
// --------------------------------------------------------
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 )
{
// 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() &&
m_kart->getSkidding()->getGraphicalJumpOffset()==0;
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)
rate = speed/m_kart->getKartProperties()->getEngineMaxSpeed();
else

8
src/karts/kart_with_stats.cpp
View File

@ -61,11 +61,9 @@ void KartWithStats::reset()
void KartWithStats::update(float dt)
{
Kart::update(dt);
if(getSpeed()>m_top_speed) m_top_speed = getSpeed();
if(getControls().m_skid)
m_skidding_time += dt;
if(getControls().m_brake)
m_brake_count ++;
if(getSpeed()>m_top_speed ) m_top_speed = getSpeed();
if(getControls().getSkidControl()) m_skidding_time += dt;
if(getControls().getBrake() ) m_brake_count ++;
LinearWorld *world = dynamic_cast<LinearWorld*>(World::getWorld());
if(world && !world->isOnRoad(getWorldKartId()))
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_SKIDR, 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);
// 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)
->getController();
KartControl *controls = controller->getControls();
controls->m_brake = (serialized_1 & 0x40)!=0;
controls->m_nitro = (serialized_1 & 0x20)!=0;
controls->m_rescue = (serialized_1 & 0x10)!=0;
controls->m_fire = (serialized_1 & 0x08)!=0;
controls->m_look_back = (serialized_1 & 0x04)!=0;
controls->m_skid = KartControl::SkidControl(serialized_1 & 0x03);
controls->setBrake( (serialized_1 & 0x40)!=0);
controls->setNitro( (serialized_1 & 0x20)!=0);
controls->setRescue( (serialized_1 & 0x10)!=0);
controls->setFire( (serialized_1 & 0x08)!=0);
controls->setLookBack((serialized_1 & 0x04)!=0);
controls->setSkidControl(KartControl::SkidControl(serialized_1 & 0x03));
controller->action(action, action_value);
}
@ -110,19 +110,19 @@ void ControllerEventsProtocol::controllerAction(Controller* controller,
KartControl* controls = controller->getControls();
uint8_t serialized_1 = 0;
serialized_1 |= (controls->m_brake==true);
serialized_1 |= (controls->getBrake()==true);
serialized_1 <<= 1;
serialized_1 |= (controls->m_nitro==true);
serialized_1 |= (controls->getNitro()==true);
serialized_1 <<= 1;
serialized_1 |= (controls->m_rescue==true);
serialized_1 |= (controls->getRescue()==true);
serialized_1 <<= 1;
serialized_1 |= (controls->m_fire==true);
serialized_1 |= (controls->getFire()==true);
serialized_1 <<= 1;
serialized_1 |= (controls->m_look_back==true);
serialized_1 |= (controls->getLookBack()==true);
serialized_1 <<= 2;
serialized_1 += controls->m_skid;
uint8_t serialized_2 = (uint8_t)(controls->m_accel*255.0);
uint8_t serialized_3 = (uint8_t)(controls->m_steer*127.0);
serialized_1 += controls->getSkidControl();
uint8_t serialized_2 = (uint8_t)(controls->getAccel()*255.0);
uint8_t serialized_3 = (uint8_t)(controls->getSteer()*127.0);
NetworkString *ns = getNetworkString(13);
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++)
{
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].m_accel,
m_all_controls[index+k].getSteer(),
m_all_controls[index+k].getAccel(),
m_all_controls[index+k].getButtonsCompressed(),
m_all_xyz[index+k].getX(), m_all_xyz[index+k].getY(),
m_all_xyz[index+k].getZ(),
@ -321,14 +321,14 @@ void History::Load()
unsigned int index = num_karts * i+k;
fgets(s, 1023, fd);
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",
&m_all_controls[index].m_steer,
&m_all_controls[index].m_accel,
&buttonsCompressed,
&steer, &accel, &buttonsCompressed,
&x, &y, &z,
&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_rotations[index] = btQuaternion(rx,ry,rz,rw);
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;
if(kart->getControls().m_nitro || kart->isOnMinNitroTime())
if(kart->getControls().getNitro() || kart->isOnMinNitroTime())
m.setTexture(0, m_gauge_full_bright);
else
m.setTexture(0, m_gauge_full);