//-----------------------------------------------------------------------------
void ArenaAI::handleArenaUTurn(const float dt)
{
const float turn_side = (m_adjusting_side ? 1.0f : -1.0f);
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;
else
m_controls->m_accel = -5.0f;
if (m_time_since_uturn >=
(m_cur_difficulty == RaceManager::DIFFICULTY_EASY ? 2.0f : 1.5f))
setSteering(-(turn_side), dt); // Preventing keep going around circle
else
setSteering(turn_side, dt);
m_time_since_uturn += dt;
checkPosition(m_target_point, &m_cur_kart_pos_data);
if (!m_cur_kart_pos_data.behind || m_time_since_uturn >
(m_cur_difficulty == RaceManager::DIFFICULTY_EASY ? 3.5f : 3.0f))
{
m_is_uturn = false;
m_time_since_uturn = 0.0f;
}
else
m_is_uturn = true;
} // handleArenaUTurn
/** This function sets the steering.
* \param dt Time step size.
*/
void ArenaAI::handleArenaSteering(const float dt)
{
const int current_node = getCurrentNode();
if (current_node == BattleGraph::UNKNOWN_POLY ||
m_target_node == BattleGraph::UNKNOWN_POLY) return;
if (m_target_node == current_node)
{
// Very close to the item, steer directly
checkPosition(m_target_point, &m_cur_kart_pos_data);
#ifdef AI_DEBUG
m_debug_sphere->setPosition(m_target_point.toIrrVector());
#endif
if (m_cur_kart_pos_data.behind)
{
m_adjusting_side = m_cur_kart_pos_data.on_side;
m_is_uturn = true;
}
else
{
float target_angle = steerToPoint(m_target_point);
setSteering(target_angle, dt);
}
return;
}
else if (m_target_node != current_node)
{
findPortals(current_node, m_target_node);
stringPull(m_kart->getXYZ(), m_target_point);
if (m_path_corners.size() > 0)
m_target_point = m_path_corners[0];
checkPosition(m_target_point, &m_cur_kart_pos_data);
#ifdef AI_DEBUG
m_debug_sphere->setPosition(m_target_point.toIrrVector());
#endif
if (m_cur_kart_pos_data.behind)
{
m_adjusting_side = m_cur_kart_pos_data.on_side;
m_is_uturn = true;
}
else
{
float target_angle = steerToPoint(m_target_point);
setSteering(target_angle, dt);
}
return;
}
else
{
// Do nothing (go straight) if no targets found
setSteering(0.0f, dt);
return;
}
} // handleSteering
int main(int argc, char** argv) {
initTruck();
int start_time = timeInSecs();
long double start_lat = getLatitude();
long double start_lon = getLongitude();
int start_heading = getHeading();
int phase = 0;
setSteering(0);
setThrottle(50);
while(TRUE){
int target_heading;
if(phase == 0){
if(distance(start_lat, getLatitude(), start_lon, getLongitude())>5){
setThrottle(30);
setSteering(60);
phase = 1;
target_heading = newHeading(90);
}
}
else if (phase == 1){
if(getHeading()==target_heading){
setSteering(-60);
target_heading=start_heading;
phase = 2;
}
}
else if (phase == 2){
if(getHeading()==target_heading){
setSteering(0);
setThrottle(0);
while(TRUE);
}
}
background();
}
return (EXIT_SUCCESS);
}
void Vehicle::setInput(const VehicleInput & input)
{
setSteering(input.controls[VehicleInput::STEER]);
setThrottle(input.controls[VehicleInput::THROTTLE]);
setBrake(input.controls[VehicleInput::BRAKE]);
setHandBrake(input.controls[VehicleInput::HBRAKE]);
setClutch(1 - input.controls[VehicleInput::CLUTCH]);
setNOS(input.controls[VehicleInput::NOS]);
setGear(transmission.getGear() + input.shiftgear);
autoshift = (input.logic & VehicleInput::AUTOSHIFT);
autoclutch = (input.logic & VehicleInput::AUTOCLUTCH);
setABS(input.logic & VehicleInput::ABS);
setTCS(input.logic & VehicleInput::TCS);
if (input.logic & VehicleInput::STARTENG)
startEngine();
if (input.logic & VehicleInput::RECOVER)
rolloverRecover();
}
/** Function to let AI get unstuck.
* \param dt Time step size.
* \return True if getting stuck is needed to be done.
*/
bool ArenaAI::gettingUnstuck(const float dt)
{
if (!m_is_stuck || m_is_uturn) return false;
resetAfterStop();
setSteering(0.0f, dt);
m_controls->setBrake(true);
m_time_since_reversing += dt;
if (m_time_since_reversing >= 1.0f)
{
m_is_stuck = false;
m_time_since_reversing = 0.0f;
}
AIBaseController::update(dt);
return true;
} // gettingUnstuck
/** Make AI reverse so that it faces in front of the last target point.
*/
void ArenaAI::doUTurn(const float dt)
{
float turn_angle = atan2f(m_target_point_lc.x(),
fabsf(m_target_point_lc.z()));
m_controls->setBrake(true);
setSteering(turn_angle > 0.0f ? -1.0f : 1.0f, dt);
m_time_since_uturn += dt;
if ((m_target_point_lc.z() > 0 && fabsf(turn_angle) < 0.2f) ||
m_time_since_uturn > 1.5f)
{
// End U-turn until target point is in front of this AI
m_is_uturn = false;
m_time_since_uturn = 0.0f;
m_time_since_driving = 0.0f;
m_reverse_point = Vec3(0, 0, 0);
}
else
m_is_uturn = true;
} // doUTurn
void initTruck(){
//Setup Debugging Connection
initUART1();
//Check for any errors
checkErrorCodes();
//Setup GPS
initGPS();
initTimer4();
//Setup Input and Output
initPWM(0b11,0b11);
PWMOutputCalibration(1,HUNTER_TRUCK_STEERING_SCALE_FACTOR, HUNTER_TRUCK_STEERING_OFFSET);
PWMOutputCalibration(2,HUNTER_TRUCK_THROTTLE_SCALE_FACTOR, HUNTER_TRUCK_THROTTLE_OFFSET);
setThrottle(0);
setSteering(0);
//Setup Datalink
// initDataLink();
}
bool GameDriver::prerenderUpdate(float frameTime)
{
auto car = mWorld.getCar();
if(!mBrake)
car->setThrottle(mThrottle);
if(!mThrottle)
car->setBrake(mBrake);
if((mSteeringVelocity > 0.0f && mSteering < 0.0f) ||
(mSteeringVelocity < 0.0f && mSteering > 0.0f))
mSteering = 0.0f;
if(mSteeringVelocity) {
mSteering += mSteeringVelocity * frameTime;
mSteering = Common::clamp(-1.0f, mSteering, 1.0f);
}
if(!mSteeringWithMouse && mSteeringVelocity == 0.0f && mSteering != 0.0f) {
if(fabs(mSteering) < 4.0f * frameTime)
mSteering = 0.0f;
else if(mSteering < 0.0f)
mSteering += 4.0f * frameTime;
else if(mSteering > 0.0f)
mSteering -= 4.0f * frameTime;
}
car->setSteering(mSteering);
mWorld.updatePhysics(frameTime);
mZoom += mZoomSpeed * frameTime;
mZoom = mRenderer.setZoom(mZoom);
mRenderer.setSteering(mThrottle, mBrake, mSteering);
if(mDebugDisplay.check(frameTime)) {
mRenderer.updateDebug(&mWorld);
}
return false;
}
//-----------------------------------------------------------------------------
bool ArenaAI::handleArenaUnstuck(const float dt)
{
if (!m_is_stuck || m_is_uturn) return false;
setSteering(0.0f, dt);
if (fabsf(m_kart->getSpeed()) >
(m_kart->getKartProperties()->getEngineMaxSpeed() / 5)
&& m_kart->getSpeed() < 0)
m_controls->m_accel = -0.06f;
else
m_controls->m_accel = -4.0f;
m_time_since_reversing += dt;
if (m_time_since_reversing >= 1.0f)
{
m_is_stuck = false;
m_time_since_reversing = 0.0f;
}
AIBaseController::update(dt);
return true;
} // handleArenaUnstuck
/** This is the main entry point for the AI.
* It is called once per frame for each AI and determines the behaviour of
* the AI, e.g. steering, accelerating/braking, firing.
* \param dt Time step size.
*/
void ArenaAI::update(float dt)
{
// This is used to enable firing an item backwards.
m_controls->setLookBack(false);
m_controls->setNitro(false);
// Let the function below to reset it later
m_controls->setAccel(0.0f);
m_controls->setBrake(false);
m_mini_skid = false;
// Don't do anything if there is currently a kart animations shown.
if (m_kart->getKartAnimation())
{
resetAfterStop();
return;
}
if (!isKartOnRoad() && m_kart->isOnGround())
{
m_time_since_off_road += dt;
}
else if (m_time_since_off_road != 0.0f)
{
m_time_since_off_road = 0.0f;
}
// If the kart needs to be rescued, do it now (and nothing else)
if (m_time_since_off_road > 5.0f && m_kart->isOnGround())
{
m_time_since_off_road = 0.0f;
new RescueAnimation(m_kart);
AIBaseController::update(dt);
return;
}
if (isWaiting())
{
AIBaseController::update(dt);
return;
}
checkIfStuck(dt);
if (gettingUnstuck(dt))
return;
findTarget();
// After found target, convert it to local coordinate, used for skidding or
// u-turn
if (!m_is_uturn)
{
m_target_point_lc = m_kart->getTrans().inverse()(m_target_point);
doSkiddingTest();
configSteering();
}
else
{
m_target_point_lc = m_kart->getTrans().inverse()(m_reverse_point);
}
useItems(dt);
if (m_kart->getSpeed() > 15.0f && !m_is_uturn && m_turn_radius > 30.0f &&
!ignorePathFinding())
{
// Only use nitro when turn angle is big (180 - angle)
m_controls->setNitro(true);
}
if (m_is_uturn)
{
resetAfterStop();
doUTurn(dt);
}
else
{
configSpeed();
setSteering(m_steering_angle, dt);
}
AIBaseController::update(dt);
} // update
