ZRGame.h

Go to the documentation of this file.

#ifndef _ZR_GAME_H_
#define _ZR_GAME_H_
#pragma once

extern "C" {
  #include "pads.h"
}

#include "Constants.h"
#include "spheres_constants.h"
#include "ZR_API.h"
#include "ZRGameInternal.h"



/** \file ZRGame.h
 * Contains documentation of functions specific to the player side of the game.
 * Use this documentation to learn about using the API functions available in the challenge.
 * General API operations for Zero Robotics are available under ZR_API.h.
 *
 * Access members of this file by using the syntax "game.functionname(inputs);"
 */

//Forward declaration of the game implementation (not visible)
class ZeroRoboticsGameImpl;

//Forward declaration of API implementation
class ZeroRoboticsAPIImpl;

/** \class ZeroRoboticsGame
 *
 * The class of the game object that you will use. Contains publicly available member functions.
 */
class ZeroRoboticsGame {

 public:

  /*!
   * Retrieves the singleton instance of the game API.  Users are not allowed to construct a game instance, so the
   * API must be retrieved through this interface.
   *
   * \return singleton of the game API
   */
  static ZeroRoboticsGame &instance();


  // DECLARATIONS FOR PUBLIC METHODS AND VARIALBES AVAILABLE TO USERS GO HERE

  /*!
   * Tells the player how much fuel remains.
   *
   * \return float indicating how many seconds of fuel remain.
   */
  float getFuelRemaining();
  
  /*!
   * Send a value from 0-255 to the other satellite.
   * 
   * \param inputMsg Unsigned Char to be sent to other satellite.
   */
  void sendMessage(unsigned char inputMsg);
  
  /*!
   * Recieve value from 0-255 from other satellite.
   *
   * \return An unsigned char containing a value from 0-255.
   */
  unsigned char receiveMessage();
  
  
  /**
   * Check if the camera is pointed towards the other satellite.
   * 
   * \return true if the camera is facing the other satellite, false otherwise.
   */
  bool isFacingOther();
  
  /**
   * Attempts to take a picture in the current position. 
   * The camera will be disabled for 3 seconds after an attempt, whether successful or not.
   * Costs 1.0 energy.
   *
   * \return The amount of points that the picture taken is worth.
   */
  float takePic();
  
  /**
   * Determines how many points a picture would give if taken immediately.
   * Does not actually take a picture. Costs 0.1 energy.
   * 
   * \return The amount of points that the picture is worth.
   */
  float getPicPoints();
  
  /**
   * Returns how many memory slots are currently in use.
   * 
   * \return The number of memory slots used.
   */
  int getMemoryFilled() const;
  
  /**
   * Returns the total number of memory slots available to the satellite.
   * This includes both used and unused slots.
   * 
   * \return Number of memory slots available.
   */
  int getMemorySize();
  
  /**
   * Attempts to upload pictures taken to Earth.
   * Will fail if not facing Earth (3D/Alliance).
   * Disables camera for three seconds upon sucessful upload.
   * Costs 1.0 energy.
   * 
   * \return The total score over the course of the game so far.
   */
  float uploadPics(void);
  
  /**
   * Makes sure the camera is on.
   * 
   * \return true if the camera is usable, false if not.
   */
  bool isCameraOn();

  /**
   * Tells how much energy the player has.
   * 
   * \return Amount of energy the player satellite currently has.
   */
  float getEnergy();
  
  /**
   * Tells how much energy the opponent has, at a cost of 0 energy.
   * 
   * \return Amount of energy the opponent satellite currently has.
   */
  float getOtherEnergy();
  
  
  /**
   * Returns true if the given coordinate is in the light zone.
   * 
   * \param pos An array of three floats in (x, y, z) order.
   * \return true if the coordinate is in light, false else.
   */

  bool posInLight(float pos[]);

  
  /**
   * Returns true if the given coordinate is in the dark zone.
   * 
   * \param pos An array of three floats in (x, y, z) order.
   * \return true if the coordinate is in dark, false else.
   */
  bool posInDark(float pos[]);

  /**
   * Returns true if the given coordinate is in a grey zone.
   * 
   * \param pos An array of three floats in (x, y, z) order.
   * \return true if the coordinate is in grey, false else.
   */

  bool posInGrey(float pos[]);

/**
   * Returns 1 if the given coordinate is in the light, -1 if in the dark, and 0 otherwise.
   * 
   * \param pos An array of three floats in (x, y, z) order.
   * \return 1 if the given coordinate is in the light, -1 if in the dark, and 0 else.
   */

  int posInArea(float pos[]);
  
  /**
   * Determines where the center of the grey zone at the tail end of the light zone is. The tail end is at the lower Y-coordinate of the light zone, disregarding any portion that has wrapped around.
   * 
   * \return The y-coordinate of the light interface plane.
   */
  float getLightInterfacePosition();
  
  /**
   * Determines where the boundary between the dark zone and the grey zone is.
   * 
   * \return The y-coordinate of the plane between the dark zone and the grey zone.
   */
  float getDarkGreyBoundary();
  
  /**
   * Determines where the boundary between the light zone and the grey zone is.
   * 
   * \return The y-coordinate of the plane between the light zone and the grey zone.
   */
  float getLightGreyBoundary();
  
  /**
   * Determines how long until the light and dark zones next switch (2D/3D).
   * 
   * \return Number of seconds until the light switches.
   */
  float getLightSwitchTime();
  
  
  /**
   * Returns the number of total items in play, whether they have been picked up yet or not.
   * 
   * \return Number of total items.
   */
  int getNumItem();

  /**
   * Uses a held mirror item.
   * 
   * \return true if the item existed and was used, false otherwise.
   */
  
  bool useMirror();

  /**
   * Returns the amount of time left on your current mirror.
   * 
   * \return remaining time with a mirror up, zero if no mirror is up.
   */

  int getMirrorTimeRemaining();

  /**
   * Returns the number of mirrors currently held and available for use.
   * 
   * \return number of mirrors held by the player.
   */

  int getNumMirrorsHeld();

  /**
   * Copies the location of a given item into the given array.
   * 
   * \param pos A pointer to an array of size 3 which will be overwritten by the item location.
   * \param itemID The integer identifier of a given item.
   */
  void getItemLoc(float pos[], int itemID);
  
  /**
   * Tells who has a given item.
   * 
   * \param itemID The integer identifier of a given item.
   * \return 0 if you have picked up the specified item, 1 if the other player has, or -1 if no one has.
   */
  int hasItem(int itemID);
  
  /**
   * Returns what the item does.
   * 
   * Possible Item Types:
   *  - ITEM_TYPE_ADD_SCORE
   *  - ITEM_TYPE_ADD_ENERGY
   *  - ITEM_TYPE_MIRROR
   * 
   * \param itemID The integer identifier of a given item.
   * \return The corresponding item type to the given identifier.
   */
  int getItemType(int itemID);
  
  /**
   * Returns the player's current score.
   * 
   * \return Player satellite score.
   */
  float getScore();     //returns me.score
  
  /**
   * Returns the opponent's current score.
   */
  float getOtherScore();    //returns other.score

   /**
   * Returns the time.
   */
  int getCurrentTime();

  //state_vector getOtherState();

  /// Constructor for the game.  The provided references should be singleton instances.
  ZeroRoboticsGame(ZeroRoboticsGameImpl &impl, ZeroRoboticsAPIImpl &apiImpl) ;

private:
  /// REQUIRED: reference to the game implementation, do not delete!
  ZeroRoboticsGameImpl &pimpl;
  ZeroRoboticsAPIImpl &apiImpl;
};


#endif