ZRGameInternal.h

Go to the documentation of this file.

#ifndef _ZR_GAME_INTERNAL_H_
#define _ZR_GAME_INTERNAL_H_
#pragma once

#include "Constants.h"
#include "ZeroRoboticsGameBaseImpl.hpp"
#include "comm.h"

//typedef unsigned long int u4;
//typedef struct ranctx {u4 a;u4 b;u4 c;u4 d; } ranctx;
//#define rot(x,k) (((x)<<(k))|((x)>>(32-(k))))


///Forward declaration of ZR Game
class ZeroRoboticsGame;


/**
 * This class defines the hidden game implementation. Any internal
 * utility functions or game ru//les functsions hould be put here.  You may also
 * override any of the standard GSP functions by implementing
 * them here.  The functions init(), update(), and sendDebug() are required.
 */

class ZeroRoboticsGameImpl : public ZeroRoboticsGameBaseImpl<ZeroRoboticsGameImpl>
{
public:
  /**
   * (Required) Runs initialization fo the ZR game at the start of a test. Use this function
   * to reset all member variables.
   */

  struct PlayerInfo
  {
    float           zrState[12];
    state_vector    sphState;
    float     fuelUsed;
    float   energy;       // The amount of energy
    bool    collisionActive;    // true if collision avoidance is activated
    bool    FlareisActive;      // true if solar flare is active
    float     userForces[6];    // stores userForces for download
    float     initQuat[4];       // initial quaternion when picking up items
    float     score;      // current total score in the game
    short     message;  // message to send to other satellite
    bool    acquiringMP[NUM_ITEMS]; // true when rotating within item to pick it up (but not picked up yet)
    unsigned short  mpTime[NUM_ITEMS];  // time when an item is picked up
    short mirrorTime;
    int mirrors;
    float lastAttTarget[4];
    float lastPosTarget[4];
  };

  struct OtherInfo
  {
    float           zrState[12];
    state_vector    sphState;
    unsigned short  mpTime[NUM_ITEMS];    // time when other player picks up items
    float score;          // latest known score of other player
    short message;          // message from other player
    float energy;         
    short mirrorTime;
  };

  struct Light
  {
    float center;    // center of the grey zone in 2D/3D. In Alliance, it is the center of the grey zone that has a higher Y-position than the dark zone and a lower Y-position than the light zone.
    float greyWidth;    // the greyWidth of the grey zone (distance between light and dark)
    float lightWidth;  // how wide the light zone is
    int direction; // the direction of the light side.
    int nextSwitchTime; // Timestap at which light should be switched
  };

  struct Picture
  {
    bool  picStored;          // true when a picture is stored here
    float value;            // points value associated with the picture
    int   round;            // In what minute of the game the picture was taken
  };

  struct Camera
  {
    unsigned int  memoryFilled;           // amount of memory currently in use
    unsigned int   memorySize;              // total amount of memory available
    bool     cameraOn;      // true if camera is enabled; its disabled for 3 seconds after each picture is taken
    unsigned short  cameraOffTime;        // time when camera was turned off (picture was taken)
    bool            cameraBlocked;    // true if the other player's SPHERE is in the way of the camera
    Picture         memory[CAMERA_MAX_MEMORY];    // stores pictures taken by the camera
    bool            tookPicture;    // true if the player took a picture this turn
    bool            uploadedPictures;   // true if the player uploaded pictures this turn
  };

  struct ChallengeInfo
  {
    int currentTime;
    int random;
    float mpLoc[NUM_ITEMS][3];
    PlayerInfo me;
    OtherInfo other;
    Light light;
    Camera camera;
    int currentPicID;
    unsigned int round;               // round of lights switched
  };

  ChallengeInfo challInfo;

  void init(void);

/**
   * (Required) Runs an update of the game rules and calls the user function loop(). The return
   * value for this function indicates if the forceTorqueOut vector should be mixed into
   * thruster firings.  The function should return 0 if the user does not activate any
   * ZR API movement commands or implements their own thruster firing logic.
   *
   * Here we update player's scores
   *
   * /param forceTorqueOut forces and torques to be mixed into thruster firings
   * /return return 1 if forceTorqueOut should be mixed into thruster firings and 0 otherwise
   */

  bool update(float forceTorqueOut[6]);

  bool updateGameModeManeuver(float forceTorqueOut[6]);
  bool updateGameOverManeuver(float forceTorqueOut[6], unsigned char& finalScore);
  void updateStates();
  /**
   * (Required) Called on every gspControl control cycle.  It should be used to send debug
   * and telemetry information to the ground.
   */

  bool enforceBoundaries(float forceTorque[6]);

  /**
  * Limits the direction in which the programmed SPHERE can travel and slows down the velocity if
  * it travels in the direction of the limit
  */

  void limitDirection(state_vector ctrlState, float ctrlControl[6], unsigned int idx, float dir);

  /**
  * (Required) Called on every gspControl control cycle, It should be used to send debug
  * and telemetry information to the ground.
  */

  void sendDebug(void);

  /**
  * for Corona SPHERES: sends POI & Solar Flare info to Sat 2 at start of game
  */
  void sendInit(void);

  /**
   * (Required) Processes SPHERES telemetry data
   */

  void processRXData(default_rfm_packet packet);

  /**
   * (Required) Initial state where the satellite is initialized.
   */

  static const state_vector initState;

  //returns damage aquired every second if not in shadow zone and not turned off
  void  breakTie();

  void modify2DForceTorque(float forceTorque[6]);
  //void getFlareTimes(int Array[8]);

  /********************asteroid functions ************************/
  void resolveCollision(float zrState[12], float forceTorqueOut[6]); //Edits forceTorqueOut to resolve the SPHERE's movement
  float dist3d(float* pos1, float* pos2) const;
  /************************camera funtions****************/

  bool      photoBomb(float zrState[12], float poiLoc[3]);                //checks to see if the other sphere is in the view of the camera

  void    initItems();                          //Set up item positions;
  float     randomizeStartingLocs(int itemID, int coord);
  bool    itemPickUp(int objectNum);                  // True if memory pack was picked up.
  void    initCamera();
  void    disableCamera();
  void    activateCamera();
  void    memoryLoss();                       // Called by the system if the SPHERE is hit by a solar flare.
  bool    isFacingPos(float position[]);
  bool    isFacingOther();
  bool    isFacingEarth();
  float    takePicImpl();
  float picPointsImpl();
  void    resetPicsTaken();

  /*
  * LIGHT FUNCTIONS
  */

  // returns 1 if in light zone, 0 if in grey zone, and -1 if in dark zone
  int sphereInSwitchingArea(float position[]);
  int sphereInMovingArea(float position[]);

  bool sphereInLight(float position[]);
  bool sphereInDark(float position[]);
  void switchLightDirection();
  void initLight();
  void updateLight();

  /*
  * ENERGY FUNCTIONS
  */
  void initEnergy();
  void updateEnergy();
  bool tryToUseEnergy(float amount);

  /**
   * Retrieves singleton instance of the game implementation
   * \return The game implementation singleton
   */
  static ZeroRoboticsGameImpl &instance();

  /**
   * Constructor for binding an API implementation
   */
  ZeroRoboticsGameImpl(ZeroRoboticsAPIImpl &apiImpl);

  ///Reference to ZR API instance
  ZeroRoboticsAPIImpl &apiImpl;

  ///Back pointer to the game instance
  ZeroRoboticsGame *game;

};

ZeroRoboticsGameImpl *getGameImpl();


void overrideTarget2D(float target[13]);

// void overrideTarget(float target[13]);
void swingTwistDecomposition(float q[4], float q_sw[4], float q_tw[4], float sw_vec[3]);
void quatToPositive(float q[4]);

#endif