void goToTarget(float target[]){
api.getMyZRState(me);
switch (state){
case 0: //initializing
if(pathToTarget(target,waypoint)){
float temp[3];
while(pathToTarget(waypoint, temp)){
for(int i = 0; i < 3; i++){
waypoint[i] = waypoint[i] + 0.05;
}
}
mathVecSubtract(originalVecBetween, waypoint, me, 3);
state = 1;
}
else{
state = 2;
}
break;
case 1:
mathVecSubtract(vecBetween, waypoint, me, 3);
float temp[3];
if(pathToTarget(target,temp)){
api.setVelocityTarget(originalVecBetween);
//magnitude stays the same as beginning magnitude
DEBUG(("Going to waypoint"));
DEBUG(("%f",mathVecMagnitude(originalVecBetween,3)));
}
else{
DEBUG(("going to target"));
api.setPositionTarget(target);
state = 2;
}
break;
case 2:
if(distance(me,target)>0.08){
haulAssTowardTarget(target,2);
DEBUG(("Going to Target haulAss"));
}
else{
api.setPositionTarget(target);
}
break;
}
}
bool goToWaypoint(float target[],float waypoint[],float tempTarget[], float originalVecBetween[]){
mathVecSubtract(vecBetween, waypoint, myState, 3);
float temp[3];
if(angleBetween(myState,target) > 150 *PI / 180){
dilateValue(waypoint,tempTarget, -1.12,tempTarget);
}
else{
dilateValue(waypoint,tempTarget, -1.02,tempTarget);
}
if(pathToTarget(myState,tempTarget,temp)){
api.setVelocityTarget(originalVecBetween);
//magnitude stays the same as beginning magnitude
return true; //going to waypoint still
}
else{
return false; //not going to waypoint anymore
}
}
void setWaypoint(float waypoint[],float originalVecBetween[]){
float temp[3];
while(pathToTarget(myState,waypoint, temp)){
for(int i = 0; i < 3; i++){
if(waypoint[i] >= 0){
waypoint[i] += 0.01;
}
else{
waypoint[i] -= 0.01;
}
}
}
for(int i = 0; i < 3; i++){
if(waypoint[i] >= 0){
waypoint[i] += 0.05;
}
else{
waypoint[i] -= 0.05;
}
}
mathVecSubtract(originalVecBetween, waypoint, myState, 3);
}
void loop() {
api.getMyZRState(myState);
time = api.getTime();
picNum = game.getMemoryFilled();
DEBUG(("%d picture(s) have been taken\n", picNum));
DEBUG(("STATE = %d\n",state));
DEBUG(("ARRAY = %d,%d,%d\n",goodPOI[0],goodPOI[1],goodPOI[2]));
DEBUG(("TARGET = %f,%f,%f\n",target[0],target[1],target[2]));
if(takePic > -1){ //takePic is used to make sure you take an accurate picture.
takePic--;
}
if(time%60 == 0){
for(int i = 0; i < 3; i++){
goodPOI[i] = 1;
}
state = ST_GET_POI;
}
if((time > solarFlareBegin - 25)&&(time < solarFlareBegin)){
if((state < ST_SHADOW)||(state > ST_SHADOW + 9)){
state = ST_SHADOW; //if not in shadow state go there.
}
}
else if(time == solarFlareBegin + 3){
state = ST_GET_POI + 1;
}
else if (game.getNextFlare() != -1) {
solarFlareBegin = api.getTime() + game.getNextFlare();
DEBUG(("Next solar flare will occur at %ds.\n", solarFlareBegin));
}
switch(state){
case ST_GET_POI: //POI selection
closestPOI(goodPOI,POI,23);
getPOILoc(POIproj, POIID, 23);
takePic = 23; //25 probably needs to be changed. only good for the first cycle.
DEBUG(("POI Coors = %f,%f,%f\n",POI[0],POI[1],POI[2]));
state = ST_OUTER;
break;
case ST_GET_POI + 1: //if coming from shadow zone
closestPOI(goodPOI,POI,30);
getPOILoc(POIproj, POIID, 30);
takePic = 30; //25 probably needs to be changed. only good for the first cycle.
DEBUG(("POI Coors = %f,%f,%f\n",POI[0],POI[1],POI[2]));
state = ST_OUTER;
break;
case ST_OUTER: //outer picture
wp = false;
//find closest place to take picture
memcpy(target, POIproj, 3*sizeof(float)); //copy the projected POI location to target
for(int i = 0; i < 3; i++){
target[i] *= 0.465/mathVecMagnitude(POI,3); //dilate target to outer zone
}
mathVecSubtract(facing,origin,target,3);
mathVecNormalize(facing,3);
api.setAttitudeTarget(facing);
if(pathToTarget(myState,target,waypoint)){
setWaypoint(waypoint,originalVecBetween);
state = ST_OUTER + 1;
for (int i = 0; i < 3; i++) tempTarget[i] = target[i];
}
else{
state = ST_OUTER + 2;
}
break;
case ST_OUTER + 1: //something is in the way so go to waypoint
wp = true;
mathVecSubtract(facing,POIproj,target,3);
mathVecNormalize(facing,3);
api.setAttitudeTarget(facing);
if(goToWaypoint(target,waypoint,tempTarget,originalVecBetween)){
goToWaypoint(target,waypoint,tempTarget,originalVecBetween);
}
else{
state = ST_OUTER + 2;
}
break;
case ST_OUTER + 2://go to target
mathVecSubtract(facing,origin,myState,3);
mathVecNormalize(facing,3);
api.setAttitudeTarget(facing);
toTarget();
if(takePic == 0){
game.takePic(POIID);
}
if(game.getMemoryFilled() > checkNum){
checkNum++;
getPOILoc(POIproj, POIID, 5);
state = ST_INNER;
}
break;
case ST_INNER: //inner picture
wp = false;
memcpy(target, POIproj, 3*sizeof(float));
for(int i = 0; i < 3; i++){
target[i] *= 0.34/mathVecMagnitude(POI,3);
}
mathVecSubtract(facing,POIproj,target,3);
mathVecNormalize(facing,3);
api.setAttitudeTarget(facing);
haulAssTowardTarget(target,8);
state = ST_INNER + 1;
break;
case ST_INNER + 1: //after outer picture is taken, rush to inner zone.
mathVecSubtract(facing,POIproj,myState,3);
mathVecNormalize(facing,3);
api.setAttitudeTarget(facing);
if(distance(myState,target)<0.02){
haulAssTowardTarget(target,10);
}
else{
haulAssTowardTarget(target,2);
}
if(game.alignLine(POIID)){
game.takePic(POIID);
}
if(game.getMemoryFilled() > checkNum){
checkNum++;
state = ST_UPLOAD;
}
break;
case ST_SHADOW: //shadow zone
wp = false;
target[0] = 0.39; //arbitrary point in the shadow zone
target[1] = 0.00;
target[2] = 0.00;
if(pathToTarget(myState,target,waypoint)){
setWaypoint(waypoint,originalVecBetween);
goToWaypoint(target,waypoint,tempTarget,originalVecBetween);
state = 31;
}
else{
state = 32;
}
break;
case ST_SHADOW + 1:
wp = true;
if(goToWaypoint(target,waypoint,tempTarget,originalVecBetween)){
goToWaypoint(target,waypoint,tempTarget,originalVecBetween);
}
else{
toTarget();
state = 32;
}
break;
case ST_SHADOW + 2:
mathVecSubtract(facing,earth,myState,3);
mathVecNormalize(facing,3);
api.setAttitudeTarget(facing);
toTarget();
game.uploadPic();
break;
case ST_UPLOAD: //upload, needs to be fixed
for(int i = 0; i < 3; i++){
uploadPos[i] = myState[i] / mathVecMagnitude(myState, 3) * 0.65;
}
mathVecSubtract(facing,earth,uploadPos,3);
mathVecNormalize(facing,3);
api.setAttitudeTarget(facing);
haulAssTowardTarget(uploadPos,1.8);
state = ST_UPLOAD + 1;
break;
case ST_UPLOAD + 1:
//get to the closest place, keep trying to upload
api.setAttitudeTarget(facing);
if(distance(myState,origin)>0.54){
api.setPositionTarget(myState);
game.uploadPic();
}
else{
if(distance(myState,origin)>0.51){
api.setPositionTarget(uploadPos);
}
else{
haulAssTowardTarget(uploadPos,1.8);
}
}
if(picNum == 0){
DEBUG(("LOOKING FOR POI"));
state = ST_GET_POI;
}
break;
}
}
void Enemy::update() {
float old_x = x;
float old_y = y;
int searchPlayerCountdown = 400 - searchPlayerClock.getElapsedTime().asMilliseconds();
if(searchPlayerCountdown<=0){
if(abs(state->player->sprite.getPosition().x-x)<100 && abs(state->player->sprite.getPosition().y-y)<100)
path = pathToTarget();
//printf("%d\n",(int)path.size());
searchPlayerClock.restart();
}
if((int)path.size()>0){
//printf("%d\n",(int)path.size());
if((int)path.size()<50 && state->player->isSatisfying){
game->currentState = new GameOverState(game, 0, state->currentLevel);
state->player->satisfactionSound.stop();
}
if(followPlayer){
x = path[(int)path.size()-1].x;
y = path[(int)path.size()-1].y;
speedX = x-old_x;
speedY = y-old_y;
path.erase(path.end()-1);
if(abs(speedX)>abs(speedY)){
if(speedX>0){
spriteSource.y = 2;
}
else{
spriteSource.y = 3;
}
}
else{
if(speedY>0){
spriteSource.y = 0;
}
else{
spriteSource.y = 1;
}
}
spriteSource.x += 0.2;
if(spriteSource.x*spriteSize.x>=64){
spriteSource.x = 0;
}
sprite.setTextureRect(sf::IntRect((int)floor(spriteSource.x)*spriteSize.x,spriteSource.y*spriteSize.y,spriteSize.x,spriteSize.y));
sprite.setPosition(x, y);
return;
}
}
int randomMoveCountdown = 5000 - randomMoveClock.getElapsedTime().asMilliseconds();
if(randomMoveCountdown<=0){
do{
speedX = (rand() % 3000 - 1500)/(float)1000;
speedY = (rand() % 3000 - 1500)/(float)1000;
} while(speedY==0 && speedX==0);
randomMoveClock.restart();
}
x += speedX;
y += speedY;
if(abs(speedX)>abs(speedY)){
if(speedX>0){
spriteSource.y = 2;
}
else{
spriteSource.y = 3;
}
}
else{
if(speedY>0){
spriteSource.y = 0;
}
else{
spriteSource.y = 1;
}
}
spriteSource.x += 0.2;
if(spriteSource.x*spriteSize.x>=64){
spriteSource.x = 0;
}
sprite.setTextureRect(sf::IntRect((int)floor(spriteSource.x)*spriteSize.x,spriteSource.y*spriteSize.y,spriteSize.x,spriteSize.y));
/*if((int)path.size()==0)
return;
x = path[(int)path.size()-1].x;
y = path[(int)path.size()-1].y;
path.erase(path.end()-1);*/
wallCollision(old_x,old_y);
sprite.setPosition(x, y);
}
