void perform(Robot *robot) override
{
Point rp = robot->getPosition();
double ori = Measurements::angleBetween(rp, gameModel->getBallPoint());
switch(state)
{
case pos_one:
setMovementTargets(A,ori,true,true);
if (Measurements::isClose(rp,A,DIST_TOLERANCE))
state = pos_two;
break;
case pos_two:
setMovementTargets(B,ori,true,true);
if (Measurements::isClose(rp,B,DIST_TOLERANCE))
state = pos_one;
}
GenericMovementBehavior::perform(robot, Move::MoveType::Default);
}
void perform(Robot * robot) override
{
Point target = Point(1500,0);
setMovementTargets(target,0, false, false);
std::cout << "Distance Error: " << Measurements::distance(robot->getPosition(),target) << std::endl;
std::cout << "Angle Error in Degrees: " << robot->getOrientation()*180/M_PI << std::endl;
GenericMovementBehavior::perform(robot,Move::MoveType::Default);
}
void DefendOneOnOne::perform(Robot *r)
{
GameModel * gm = GameModel::getModel();
setMovementTargets(gm->getPenaltyPoint(),
Measurments::angleBetween(gm->getPenaltyPoint(), gm->getOpponentGoal()));
GenericMovementBehavior::perform(r);
}
void DefendFarFromBall::perform(Robot *robot)
{
GameModel *gm = GameModel::getModel();
Point robPoint = robot->getRobotPosition();
Point ballPoint = gm->getBallPoint();
Point myGoal = gm->getMyGoal();
double direction = Measurments::angleBetween(myGoal, ballPoint);
Point defensiveWall(cos(direction)*DISTANCE + myGoal.x,
sin(direction)*DISTANCE + myGoal.y);
/* Check if there are any opp robots within 3000 distance of the ball
* This boolean is used to determine if the goalie should wait
* before kicking the ball to a teammate in case an opp robot intersepts
* the ball
*/
bool safeToKick = 1;
for(Robot* opRob:gm->getOponentTeam())
{
if (Measurments::distance(opRob->getRobotPosition(),ballPoint) < 3000)
safeToKick = 0;
}
bool isScoreHazard =
Measurments::distance(myGoal, ballPoint) < 1200
and not(Measurments::isClose(robPoint, ballPoint, 100))
and lastKickCounter <= 0
and safeToKick;
if(isScoreHazard or isKickingAwayBall) {
if(wasNotPreviousScoreHazard) {
KTPSkill = new Skill::KickToPoint(Point(0,0), 50*M_PI/180);
isKickingAwayBall = true;
wasNotPreviousScoreHazard = false;
}
if(KTPSkill->perform(robot) or
Measurments::distance(ballPoint, myGoal) > 1200){
lastKickCounter = 100;
wasNotPreviousScoreHazard = true;
isKickingAwayBall = false;
delete KTPSkill;
KTPSkill = nullptr;
}
} else {
if(lastKickCounter > 0)
--lastKickCounter;
Point defensiveWall(cos(direction)*DISTANCE + myGoal.x,
sin(direction)*DISTANCE + myGoal.y);
setMovementTargets(defensiveWall, direction, false, false);
GenericMovementBehavior::perform(robot, Movement::Type::facePoint);
}
}
void perform(Robot *robot) override {
setMovementTargets(gameModel->getBallPoint() + offset,
Measurements::angleBetween(robot->getPosition(),gameModel->getBallPoint()),
true, true);
GenericMovementBehavior::perform(robot);
}
void perform(Robot * robot) override
{
float ang = Measurements::angleBetween(robot, gameModel->getBallPoint());
setMovementTargets(robot->getPosition(), ang);
GenericMovementBehavior::perform(robot);
}
void KickToGoal::perform(Robot * r)
{
GameModel* gm = GameModel::getModel();
Point ball = gm->getBallPoint();
Point goal = gm->getOpponentGoal();
Point rob = r->getRobotPosition();
float robAng = r->getOrientation();
float goalToBall = Measurments::angleBetween(goal,ball);
float ballToGoal = Measurments::angleBetween(ball, goal);
Point behindBall(BEHIND_RADIUS*cos(goalToBall)+ball.x,
BEHIND_RADIUS*sin(goalToBall)+ball.y);
// Create a different skill depending on the state
switch (state) {
case goingBehind:
target = behindBall;
setMovementTargets(behindBall, ballToGoal, true);
GenericMovementBehavior::perform(r, Movement::Type::Default);
break;
case approaching:
setMovementTargets(ball, ballToGoal, false);
GenericMovementBehavior::perform(r, Movement::Type::SharpTurns);
break;
case kicking:
{
Skill::Kick k(0, 0);
k.perform(r);
}
break;
case stopping:
{
Skill::Stop stop;
stop.perform(r);
}
break;
}
// Evaluate possible transitions
switch (state){
case goingBehind:
cout << "going behind" << endl;
// cout << "1\t" << Measurments::distance(behindBall, rob) << endl;
// cout << "2\t" << abs(Measurments::angleDiff(robAng, ballToGoal))/M_PI*180 << endl;
if (Measurments::distance(behindBall, rob) < CLOSE_ENOUGH &&
Measurments::isClose(robAng, ballToGoal, ANGLE)) {
state = approaching;
target = ball;
}
else if (!Measurments::isClose(target, behindBall, CLOSE_ENOUGH))
{
state = goingBehind;
}
break;
case approaching:
cout << "approching" << endl;
// cout << "1\t" << Measurments::distance(ball, rob) << endl;
// cout << "2\t" << abs(Measurments::angleDiff(robAng, ballToGoal))/M_PI*180 << endl;
if (Measurments::distance(ball, rob) < CLOSE_ENOUGH &&
Measurments::isClose(robAng, ballToGoal, ANGLE))
state = kicking;
else if (!Measurments::isClose(target, ball, CLOSE_ENOUGH))
{
state = goingBehind;
}
// else if (Measurments::distance(ball, rob) > CLOSE_ENOUGH*2) {
// state = goingBehind;
// }
break;
case kicking:
cout << "kicking" << endl;
state = stopping;
break;
case stopping:
cout << "stopping" << endl;
break;
}
}
