ballController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2010 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: .h,v $ $Revision: 1.2 $ $State: Exp $
*******************************************************************************/

#ifndef BallController_H_
#define BallController_H_

#include "ballData.h"
#include "regionData.h"
#include "textData.h"

#include <string>
#include <list>

// Generic class that updates owned balls and processes updates on
// other balls
class BallController
{
public:

   BallController(BallMap* data, DdmRegionMap* regionData);
   virtual ~BallController();

   // Creates (if not already created) and joins the given federation.
   // Returns success indicator.
   virtual bool createAndJoinFederation(const std::wstring& federation,
      const std::wstring& federateType,
      const std::wstring& federateName = std::wstring(),
      bool includeInterExt = false) = 0;

   // Resigns from and attempts to destroy the current federation.
   // Returns success indicator.
   virtual bool resignAndDestroyFederation() = 0;

   // Subscribes to the ball class and all its attributes. Must already have
   // created and joined the federation. Returns success indicator.
   virtual bool subscribe() = 0;

   // Unsubscribes to the ball class and all its attributes. Must already have
   // created and joined the federation. Returns success indicator.
   virtual bool unsubscribe() = 0;

   // Move owned balls and receive updates on others
   virtual void update();

   // Adds a new ball that is owned by this federate at the
   // given location
   virtual void addBall(int x, int y);

   // Deletes the owned ball with the given ID
   virtual void deleteBall(const std::wstring id) = 0;

   // Attempts to acquire the ball with the given ID
   virtual void acquireBall(const std::wstring id) = 0;

   // Attempts to divest the owned ball with the given ID
   virtual void divestBall(const std::wstring id) = 0;

   // Adds a new DDM subscription region
   virtual bool subscribeWithRegion(int xLowerBound, int yLowerBound,
      int xUpperBound, int yUpperBound) = 0;

   // Unsubscribes from the current DDM regions. If resubscribeWithoutRegion is
   // set, automatically resubscribes without regions.
   virtual bool unsubscribeWithRegions(bool resubscribeWithoutRegion) = 0;

   // Sets the field dimensions
   virtual void setDimensions(int minX, int minY, int maxX, int maxY);

   // Sets the current ball color for this federate
   virtual void setBallColor(BallColor);

   // Returns the federate ID (based on the federate handle)
   virtual const std::wstring& federateId() const = 0;

   // Returns the federate type
   virtual const std::wstring& federateType() const = 0;

   // Returns the federate name
   virtual const std::wstring& federateName() const = 0;

   // Returns the federation name
   virtual const std::wstring& federationName() const = 0;

   // Returns true if the federate name field is supported
   virtual bool isFederateNameSupported() const = 0;

   // Returns true if the optional interaction module extension is supported
   virtual bool isInteractionExtensionSupported() const = 0;

   // Returns true if DDM is enabled
   virtual bool isDdmEnabled() const;

   // Returns true if ownership transfer is enabled
   virtual bool isOwnershipTransferEnabled() const;

   // Returns true if the federate is currently connected
   virtual bool isConnected() const;

   // Returns true if the federate is currently joined to the federation
   virtual bool isJoined() const;

   // Returns true if the federate is currently subscribed
   virtual bool isSubscribed() const;

   // Returns a list of pending text events
   virtual void getPendingTextEvents(std::list<TextEvent>& textEvents);

   // Access the notification log
   virtual const std::wstring& getLog() const;
   virtual void clearLog();

protected:

   // Calculates the new locations for all owned balls 
   virtual void moveBalls();

   // Calculates the new location for the ball
   virtual void calculateNewLoc(double x, double y, double distance,
      double direction, double& newX, double& newY) const;

   // Calculate if a collision occurred with a vertical wall, and, if so,
   // determine new location and direction of the ball
   virtual bool calculateVertWallCollision(double x, double y,
      double distance, double direction, double newX, double newY,
      double radius, double& finalDirection, double& distAfterColl,
      double& collX, double& collY, double& finalX, double& finalY) const;

   // Calculate if a collision occurred with a horizontal wall, and, if so,
   // determine new location and direction of the ball
   virtual bool calculateHorizWallCollision(double x, double y,
      double distance, double direction, double newX, double newY,
      double radius, double& finalDirection, double& distAfterColl,
      double& collX, double& collY, double& finalX, double& finalY) const;

   // Sends updates on all owned balls to other federates in the federation
   virtual void sendUpdates() = 0;

   // Receives updates on balls from other federates in the federation
   virtual void receiveUpdates() = 0;

   // Request the RTI to create the a new ball
   virtual void requestNewBall(Ball* ball, const std::wstring name) = 0;

private:

   // No default constructor
   BallController();

protected:

   BallMap* myBallData;
   DdmRegionMap* myRegionData;

   std::list<TextEvent> myPendingTextEvents;

   bool myIsConnected;
   bool myDdmEnabled;
   bool myOwnershipTransferEnabled;
   bool myIsJoined;
   bool myIsSubscribed;

   int myMinX;
   int myMinY;
   int myMaxX;
   int myMaxY;

   unsigned int myNextBallNumber;
   BallColor myBallColor;

   std::wstring myLog;

   // Math constants
   static const double pi;
   static const double maxRadians;
   static const double maxDegrees;
   static const double degreesToRadians;
};

#endif