---

cylinder.h

Go to the documentation of this file.

/*
  svas_server -- virtual World Server of Svas
  Copyright (c) 2001, 2002 David Moreno Montero
 
 
  This program 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 2 of the License, or
  (at your option) any later version.
 
  This program 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 this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.  

*/

#ifndef __CYLINDER__
#define __CYLINDER__

#include "vector3d.h"
#include "matrix3x3.h"
#include "quaternion.h"
#include "action.h"
#include <vector>

class Agent;
class World;
class Collision;

/** 
 * This is the main physical body of the world. The cylinders. Each
 * agent is composed of one or more cylinders.
 *
 * @see Vector3d
 */
class Cylinder{
 protected:
  /**
   * @name Cylinder Physical Status
   * The physical status of the Cylinder
   * @{
   */
  /// Height of the cylinder (length)
  union{
    double height;
    double length;
  };
  /// Width of the cylinder (cincunference RADIUS) 
  union{
    double width;
    double radius;
  };
  /// Inertia tensor
  Matrix3x3 inertia;
  /// Inertia tensor inversed
  Matrix3x3 inertiaInverse;


  /// position of the cylinder respect to the parent cylinder, in
  /// world coordinates, if any, or (0,0,0) if none Indicate the
  /// position that the cylinder should have (and that the glue force
  /// sets)
  Point3d gluePosition;
  /// position of the cylinder with respect to the father, if any, in
  /// body coordinates in cylindrical "svas-coordinates": 
  /// (height, angle,0)
  Point3d gluePositionBody;
  

  /// position of the cylinder respect to the parent cylinder, in world coordinates, if any, or world if none
  Point3d position;
  /// Base for the orientation of the cylinder
  Quaternion orientationBase;
  /// Orientation of the cylinder, in world coordinates
  Vector3d orientationWorld;
  /// Velocity
  Vector3d velocity;
  /// Angular Velocity
  Vector3d angularVelocity;
  /// Force
  Vector3d force;
  /// Torque
  Vector3d moment;



  /// Energy of the cylinder
  double energy;
  /// Mass of the cylinder
  double mass;
  /** @} */

  /**
   * @name Old Physical properties (for undo)
   * @{
   */
  /// position of the cylinder in world coordinates
  Point3d oldPosition;
  /// Orientation base of the cylinder (maybe should be a quaternion?)
  Quaternion oldOrientationBase;
  /// Velocity
  Vector3d oldVelocity;
  /// Angular Velocity
  Vector3d oldAngularVelocity;
  /// Force
  Vector3d oldForce;
  /// Torque
  Vector3d oldMoment;
  /** @} */



  /** Pointers to sons */
  vector<Cylinder *> son;
  /** The father of the cylinder, if it's on the same agent (else NULL) */
  Cylinder *father;
  /** The agent to which this cylinder belongs */
  Agent *agent;
  /// The world from which the cylinder cames.
  World *world;

  /** The identifier of this cylinder, on this agent */
  unsigned char cylinderId;

  /** The action that the cylinder wants to perform in this cycle */
  Action desiredAction;

  /**
   * @name Change status
   * Methods to change the status of the cylinder. 
   *
   * All them returns the energy cylinders that is generated when
   * energy is consummed 
   * @{
   */
  Cylinder *grow(GrowType type, unsigned short int energy);
  Cylinder *move(MoveType type, unsigned short int energy);
  Cylinder *drop(unsigned char son, const char *creationMessage, unsigned long int messageSize);
  Cylinder *createCylinder(double angle, double height, unsigned short int energy);
  Cylinder *sendEnergyTo(unsigned char son, unsigned short int energy);
  Cylinder *sendMessage(unsigned long int agentId, const char *message, unsigned long int size);
  /** @} */

  /// Second part of operator()(unsigned short int);
  Cylinder *operator()(unsigned short int, unsigned short int &actual);

 public:
  Cylinder(World *_world, Cylinder *_father,
       double newEnergy, double newWidth, double newHeight, 
       Vector3d newGluePositionBody, bool onAgent);
  ~Cylinder();

  /** 
   * @name Get Properties
   * Methods to get several properties of the cylinder
   * @{
   */
  Point3d getPosition(bool relative=false);
  Point3d getGluePosition(bool relative=false);
  Point3d getCentreOfGravity(void);

  Vector3d getOrientation(){ return orientationWorld; };
  Cylinder *getFather(){ return father; };
  Agent *getAgent(){ return agent; };
  double  getHeight(){ return height; };
  double  getWidth(){ return width; };

  double getEnergy(){ return energy; };
  double getMass(bool pending=false);

  unsigned char getId(){ return cylinderId; };

  /// Search by id
  Cylinder *operator[](unsigned short int);
  /// Search by number
  Cylinder *operator()(unsigned short int n){ unsigned short int a=0; return (*this)(n,a); }
  unsigned short int getNumCylinders();
  /// Returns the logical distance between two cylinders (-1 if cyl is not a son)
  signed short int dist(Cylinder *cyl);
  World *getWorld();
  /// Updates the moment of inertia of the cylinder.
  void updateMomentOfInertia();
  /** @} */

  /// Changes parent agent of the cylinder (and it's sons)
  void setNewAgent(Agent *);

  /// Returns a energy cylinder of desired energy (that's energy+mass)
  Cylinder *dropEnergy(double energyMass);
  /// New intention of the cylinder for this turn
  void newIntention(const Action &a){ desiredAction=a; };
  /// A new cycle begins, we should reset forces and moments
  void newCycle();
  
  /// Really performs desired actions
  Cylinder *performAction();

  /**
   * @name Physics 
   * @{
   */
  /// Apply a force over the cylinder, from a world coordinate, it
  /// calculates the position of the body
  void applyForce(const Vector3d &force, const Point3d &where);
  /// Apply a force over the cylinder, on a given body position
  void applyForceOnBody(const Vector3d &force, const Point3d &where);
  /// Move the cylinders
  void applyVelocity(double dtime);
  /// Undo last velocity (only applicable once)
  void undoVelocity(void);
  /// sets the cylinder to the glue position
  void setToGluePosition(void);
  /// moves the position of the cylinder, but with care about father
  void movePosition(const Vector3d &ammount);
  /** @} */


  /**
   * @name Collission checkers
   *
   * Several checks about colissions
   * @{
   */
  /// Checks all collisions
  vector<Collision *> checkCollisions();
  /// Check collisions against ground
  Collision *checkGroundCollision(void);
  /// Check collisions against other cylinder
  Collision *checkCylinderCollision(Cylinder *other);
  /** @} */

  friend class Collision;

};

#endif

---