physics.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008 Jakub Filak <xfilak01@stud.fit.vutbr.cz>
 *
 * This file is part of rob08
 *
 * rob08 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * rob08 is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with rob08.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __PHYSICS_H__
#define __PHYSICS_H__

#include "config.h"
#include "geometry.h"
#include "DateTime.h"

#include <vector>
#include <iostream>

class IObject
{
  public:
    struct Position Position()
    {
      DateTime now( DateTime::Now() );
      return ImplPosition(now);
    }

    struct Position Position( const DateTime& at ) 
    { return ImplPosition( at ); }

    double Size() 
    { 
      DateTime now( DateTime::Now() );
      return ImplSize(now); 
    }

    double Size( const DateTime& at ) 
    { return ImplSize( at ); }

    virtual ~IObject() {}

    IObject& Serialize( std::ostream& output ) {
      ImplSerialize( output );
      return *this;
    }

    IObject& Deserialize( std::istream& input ) {
      ImplDeserialize( input );
      return *this;
    }

  protected:
    IObject() {}

    virtual struct Position ImplPosition( const DateTime& ) =0;
    virtual double ImplSize( const DateTime& ) =0;

    virtual void ImplSerialize( std::ostream& )=0;
    virtual void ImplDeserialize( std::istream& )=0;

  private:
    IObject( const IObject& );
    IObject& operator=( const IObject& );
};

typedef IObject* IObjectPtr;
typedef IObject*const IObjectConstPtr;
typedef STD_VECTOR(IObjectPtr) IObjectContainer;
typedef STD_VECTOR(IObjectPtr) IObjectConstContainer;

class IMovingObject : public virtual IObject
{
  public: 
    double Speed()
    {
      DateTime now( DateTime::Now());
      return ImplSpeed(now);
    }

    double Speed( const DateTime& at ) 
    { return ImplSpeed( at ); }

    double Radius() 
    { 
      DateTime now( DateTime::Now() );
      return ImplRadius( now );
    }

    double Radius(const DateTime& at) 
    { return ImplRadius(at); }

    virtual ~IMovingObject() {}

  protected:
    IMovingObject() {}

    virtual double ImplSpeed(const DateTime&)  =0;
    virtual double ImplRadius(const DateTime&)  =0;

  private:
    IMovingObject( const IMovingObject& );
    IMovingObject& operator=( const IMovingObject& );
};

class BaseObject : public virtual IObject
{
  public:
    BaseObject( double size=.0,
          double x=.0,
          double y=.0,
          double angle=.0 );

    BaseObject( double size, const struct Point& point, double angle );
    BaseObject( double size, const struct Position& position );

    virtual ~BaseObject();

  protected:
    struct Position ImplPosition(const DateTime&);
    double ImplSize(const DateTime&);

    void SetPosition( double x, double y, double angle );
    void SetPosition( const struct Point& point, double angle );
    void SetPosition( const struct Position& position );

    void SetSize( double size );

    virtual void ImplSerialize( std::ostream& );
    virtual void ImplDeserialize( std::istream& );

  private:
    BaseObject( const BaseObject& rhs );
    BaseObject& operator=( const BaseObject& rhs );

    struct Members;
    Members* pimpl;
};

class BaseMovingObject : public virtual IMovingObject, public virtual BaseObject
{
  public:
    BaseMovingObject( double speed=.0,
          double turn=.0,
          double size=.0,
          double x=.0,
          double y=.0,
          double angle=.0 );

    BaseMovingObject( double speed, double turn, double size, const struct Point& point, double angle );
    BaseMovingObject( double speed, double turn, double size, const struct Position& position );

    virtual ~BaseMovingObject();

  protected:
    
    double ImplSpeed(const DateTime&) ;
    double ImplRadius(const DateTime&) ;

    void SetSpeed( double );
    void SetRadius( double );

    virtual void ImplSerialize( std::ostream& );
    virtual void ImplDeserialize( std::istream& );

  private:
    BaseMovingObject( const BaseMovingObject& rhs );
    BaseMovingObject& operator=( const BaseMovingObject& rhs );

    struct Members;
    Members* pimpl;
};

class IEnviroment
{
  public:
    typedef std::vector<struct Vector> BorderVector;

    struct Point RightTop() const {
      return ImplRightTop();
    }
    
    const IObjectConstContainer& Objects() const {
      return ImplObjects();
    }

    const BorderVector& Borders() const {
      return ImplBorders();
    }

    virtual ~IEnviroment() {}

  protected:
    virtual struct Point ImplRightTop() const =0;
    virtual const IObjectConstContainer& ImplObjects() const =0;
    virtual const BorderVector& ImplBorders() const =0;
};

class PhysicsEngine
{
  public:
    double TimeToCollision( IMovingObject& mobj, IObject& sobj ) const {
      return ImplTimeToCollision(mobj,sobj);
    }

    PointsVector CollisionPoints(  IMovingObject& mobj,  IObject& sobj ) const {
      return ImplCollisionPoints(mobj,sobj);
    }

    Position PositionAfterTime(  IMovingObject& mobj, double time ) const {
      return ImplPositionAfterTime( mobj, time );
    }

    Point PositionAtTime(  IMovingObject& mobj, const DateTime& time ) const {
      return ImplPositionAtTime( mobj, time );
    }

    double DistanceAfterTime(  IMovingObject& mobj, double time ) const {
      return ImplDistanceAfterTime( mobj, time );
    }

    double DistanceAtTime(  IMovingObject& mobj, const DateTime& time ) const {
      return ImplDistanceAtTime( mobj, time );
    }
    
    double TimeToDistance(  IMovingObject& mobj, double distance ) const {
      return ImplTimeToDistance( mobj, distance );
    }

    DateTime TimeAfterDistance(  IMovingObject& mobj, double distance, const DateTime& now ) const {
      return ImplTimeAfterDistance( mobj, distance, now );
    }

    double TimeToPoint( IMovingObject& mobj, struct Point point ) const {
      return ImplTimeToPoint( mobj, point );
    }

    double GetCollisionTime( IMovingObject& obj, IMovingObject& reference, Point& collPoint ) const {
      return ImplGetCollTime( obj, reference, collPoint );
    }

    virtual ~PhysicsEngine() {};

  protected:
    virtual double ImplTimeToCollision( IMovingObject& mobj, IObject& sobj ) const =0;
    virtual PointsVector ImplCollisionPoints(  IMovingObject& mobj,  IObject& sobj ) const =0;
    virtual Position ImplPositionAfterTime(  IMovingObject& mobj, double time ) const =0;
    virtual Point ImplPositionAtTime(  IMovingObject& mobj, const DateTime& time ) const =0;
    virtual double ImplDistanceAfterTime(  IMovingObject& mobj, double time ) const =0;
    virtual double ImplDistanceAtTime(  IMovingObject& mobj, const DateTime& time ) const =0;
    virtual double ImplTimeToDistance(  IMovingObject& mobj, double distance ) const =0;
    virtual DateTime ImplTimeAfterDistance(  IMovingObject& mobj, double distance, const DateTime& now ) const =0;
    virtual double ImplTimeToPoint( IMovingObject& mobj, struct Point point ) const =0;
    virtual double ImplGetCollTime( IMovingObject& obj, IMovingObject& reference, Point& collPoint ) const =0;
};

#endif

---