ZRCamera.cpp

Go to the documentation of this file.

#include <string.h>
#include <math.h>
#include "ZRGame.h"
#include "ZRGameInternal.h"

/*#ifdef ZRSIMULATION
#include "mex.h"
#define GAME_TRACE(arg) DEBUG(arg)
#else
#define GAME_TRACE(arg)
#endif*/

void ZeroRoboticsGameImpl::initCamera()
{
  challInfo.camera.memoryFilled = 0;
  challInfo.camera.memorySize = CAMERA_DEFAULT_MEMORY;
  challInfo.camera.cameraOn = true;
  challInfo.camera.cameraBlocked = false;
}

void ZeroRoboticsGameImpl::disableCamera()
{
  challInfo.camera.cameraOffTime = apiImpl.api->getTime();
  challInfo.camera.cameraOn = false;
  GAME_TRACE(("[%d] camera OFF | ", apiImpl.api->getTime()));
}

void ZeroRoboticsGameImpl::activateCamera()
{
  challInfo.camera.cameraOn = true;
  GAME_TRACE(("[%d] camera ON | ", apiImpl.api->getTime()));
}


void ZeroRoboticsGameImpl::memoryLoss()
{
  memset(challInfo.camera.memory,0,CAMERA_MAX_MEMORY*sizeof(Picture));  // erase memory
  challInfo.camera.memoryFilled = 0;                                    // reset counter
  GAME_TRACE(("[%d] memory CLEARED | ", apiImpl.api->getTime()));
}

/********************camera functions************************/
int ZeroRoboticsGame::getMemoryFilled() const
{
  return pimpl.challInfo.camera.memoryFilled;
}

int ZeroRoboticsGame::getMemorySize()
{
  return pimpl.challInfo.camera.memorySize;
}

float ZeroRoboticsGame::takePic()
{
  if(!pimpl.challInfo.camera.cameraOn) {
    return 0;
  }
  return pimpl.takePicImpl();
}

float ZeroRoboticsGame::getPicPoints()
{
  if(!pimpl.challInfo.camera.cameraOn) {
        return 0;
    }

  if (!pimpl.tryToUseEnergy(ENERGY_COST_GET_PIC_POINTS)) {
    return 0;
  }

  return pimpl.picPointsImpl();
}

bool ZeroRoboticsGame::isCameraOn()
{
  return pimpl.challInfo.camera.cameraOn;
}

float ZeroRoboticsGameImpl::picPointsImpl()
{
  // check if other in light or grey zone, camera is on, the spheres are facing
  bool isCameraOn = challInfo.camera.cameraOn;
  bool isFacingOtherResult = isFacingOther();
  bool isOppNotInDarkZone = !sphereInDark(challInfo.other.zrState);
  bool myMirror = challInfo.me.mirrorTime != 0 && challInfo.me.mirrorTime + ITEM_MIRROR_DURATION > challInfo.currentTime;
  bool otherMirror = challInfo.other.mirrorTime != 0 && challInfo.other.mirrorTime + ITEM_MIRROR_DURATION > challInfo.currentTime;
  float picturePointValue = 0;
  if (isCameraOn && isFacingOtherResult && isOppNotInDarkZone && !myMirror)
  {
    float bet[3], distance;
    mathVecSubtract(bet, challInfo.me.zrState, challInfo.other.zrState, 3);
    distance = mathVecMagnitude(bet, 3);

    if (distance < PHOTO_MIN_DISTANCE) {
      GAME_TRACE(("Not a good shot: too close to the other satellite | "));
      return 0.0;
    }
    picturePointValue = 2.0 + 0.1/(distance - PHOTO_MIN_DISTANCE + 0.1);
    if(otherMirror){
      #ifdef ZR2D
      picturePointValue = 0;
      #else
      picturePointValue = -1*picturePointValue;
      #endif
      GAME_TRACE(("Not a good shot: Opposing mirror active %f|", picturePointValue));
    }

  }
  else if(!isCameraOn){
    GAME_TRACE(("Not a good shot: camera off |"));
  }
  else if(myMirror){
    GAME_TRACE(("Not a good shot: my mirror's in the way |"));
  }
  else if(!isFacingOtherResult) {
        GAME_TRACE(("Not a good shot: not facing the other satellite | "));
    }
  else if(!isOppNotInDarkZone){
    GAME_TRACE(("Not a good shot: opponent in dark zone |"));
  }
  return picturePointValue;
}

/**
* Returns the score value of the picture, or 0 if taking
* the picture failed
*/
float ZeroRoboticsGameImpl::takePicImpl()
{

  challInfo.me.score += 0.01f;
  GAME_TRACE(("[%d] attempting to take picture... ", challInfo.currentTime));

  bool enoughSpace = challInfo.camera.memoryFilled < challInfo.camera.memorySize;


  // uses the energy even if the picture can't be taken
  // (if not enough space or not facing other sphere)
  bool usedEnergy = tryToUseEnergy(ENERGY_COST_TAKE_PICTURE);

  float pictureValue = picPointsImpl();

  if(enoughSpace && usedEnergy && pictureValue != 0)     // check if it can take a picture
  {
    challInfo.camera.tookPicture = true;
    // apply score modifiers etc
    challInfo.me.score += 0.1f;         // Very small value. Subject to change.
    challInfo.camera.memory[challInfo.camera.memoryFilled].picStored = true;

    challInfo.camera.memory[challInfo.camera.memoryFilled].value = pictureValue;
    // End of scoring

    challInfo.camera.memory[challInfo.camera.memoryFilled].round = 1;


    challInfo.camera.memoryFilled++;


    GAME_TRACE(("[%d] took picture (round %d) valued %4.2f points | ", apiImpl.api->getTime(), challInfo.camera.memory[challInfo.camera.memoryFilled-1].round, challInfo.camera.memory[challInfo.camera.memoryFilled-1].value));

  }
   else if(!enoughSpace && pictureValue != 0 ){
    GAME_TRACE(("Failed to take a picture: memory filled up | "));
  }
   else if(!usedEnergy && pictureValue != 0 ){
    GAME_TRACE(("Failed to take a picture: not enough energy | "));
  }

  disableCamera();

  return pictureValue;
}

bool ZeroRoboticsGameImpl::isFacingPos(float position[]) {
  float relativePos[3];
  mathVecSubtract(relativePos, position, challInfo.me.zrState, 3);
  mathVecNormalize(relativePos, 3);
  //Check if generally pointing at the other satellite (dot product) and
  //if within a small margin of error (to account for noise)
  //after bugfix, increased allowed error to 0.25f from 0.0575f
  // MAX_FACING_ANGLE = 0.968912f is cosf(0.25f)
  bool facing = mathVecInner(&challInfo.me.zrState[ZR_ATT_X], relativePos, 3) > MAX_FACING_ANGLE;
  return facing;
}

bool ZeroRoboticsGameImpl::isFacingOther() {
  bool facing = isFacingPos(challInfo.other.zrState);
  //GAME_TRACE(("isFacingOther: facing = %d| ", facing));
  return facing;
}

bool ZeroRoboticsGame::isFacingOther(){
  return pimpl.isFacingOther();
}

bool ZeroRoboticsGameImpl::isFacingEarth() {
  float earth [3];
  memcpy(earth, EARTH, 3 * sizeof(float));
  return mathVecInner(&challInfo.me.zrState[ZR_ATT_X], earth, 3) > MAX_FACING_ANGLE;
}

float ZeroRoboticsGame::uploadPics(){
  float totalScore = 0.0;
  if(!pimpl.tryToUseEnergy(ENERGY_COST_UPLOAD_PICTURES)) return 0.0;

  GAME_TRACE(("[%d] trying to upload... ", apiImpl.api->getTime()));

  // Need to check that the SPHERE isn't going too fast to upload.
  float speed = mathVecMagnitude(&pimpl.challInfo.me.zrState[9],3);
  if (speed>UPLOAD_ANG_VEL)
  {
    GAME_TRACE(("Rotating too fast, Upload Failed. Speed=%2.4f",speed));
    return 0.0;
  }

// Need to check if the SPHERE is pointing towards earth before running the code to upload pictures.
#ifndef ZR2D
  if (!pimpl.isFacingEarth())
  {
  return totalScore;
  GAME_TRACE(("Not Facing Earth, Upload Failed. "));
  }
#endif
  pimpl.challInfo.camera.uploadedPictures = true;
  pimpl.disableCamera();            // For only three seconds.
  for (unsigned int i = 0; i < pimpl.challInfo.camera.memoryFilled; i++)
    {
  if (pimpl.challInfo.camera.memory[i].picStored == true)
  {
    pimpl.challInfo.camera.memory[i].picStored = false;
          pimpl.challInfo.me.score += pimpl.challInfo.camera.memory[i].value;
    totalScore  += pimpl.challInfo.camera.memory[i].value;
          GAME_TRACE(("uploaded picture for %4.2f points | ", pimpl.challInfo.camera.memory[i].value));
       }
    }
  pimpl.challInfo.camera.memoryFilled = 0;


  return totalScore;
}