---

cylinder_actions.cc

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.  

*/

#include <thread.h>
#include <math.h>
#include "cylinder.h"
#include "log.h"
#include "world.h"
#include "agent.h"

/** 
 * Make the cylinder grow. It wastes energy, in a proportion similar
 * to the new area, to make more mass.
 */
Cylinder *Cylinder::grow(GrowType type, unsigned short int usedEnergy){
  double grow=usedEnergy*0.95;


  if (type==growHorizontal)
    width=sqrt((mass+grow)/(2*M_PI*height));
  else{
    height=((mass+grow)/(2*M_PI*width*width));
  }

  mass=2*M_PI*width*width*height;
  energy-=grow;

  return dropEnergy(usedEnergy*0.05);
}

/**
 * Move the cylinder
 */
Cylinder *Cylinder::move(MoveType type, unsigned short int usedEnergy){
  if (father==NULL){
    log <<"Can't move cylinder without parent, energy not wasted"<<endl;
  }
  
  if (type==moveVerticalCW){
    //applyForceOnBody(Vector3d(0,usedEnergy,0), Vector3d(0,0,-length/2));
    //father->applyForceOnBody(Vector3d(0,-usedEnergy,0), gluePosition);
  }
  else if (type==moveVerticalCCW){
    //applyForceOnBody(Vector3d(0,-usedEnergy,0), Vector3d(0,0,-length/2));
    //father->applyForceOnBody(Vector3d(0,usedEnergy,0), gluePosition);
  }
  else if (type==moveHorizontalCW){
    //applyForceOnBody(Vector3d(usedEnergy,0,0), Vector3d(0,0,-length/2));
    //    father->applyForceOnBody(Vector3d(-usedEnergy,0,0), gluePosition);
  }
  else if (type==moveHorizontalCCW){
    //applyForceOnBody(Vector3d(-usedEnergy,0,0), Vector3d(0,0,-length/2));
    //father->applyForceOnBody(Vector3d(usedEnergy,0,0), gluePosition);
  }

  else{
    log <<"Wrong movement type ("<<int(type)<<")"<<endl;
  }


  double relation=energy/mass;
  double dropE=(log10(relation+1)/(relation*2))*log10(usedEnergy+1);
  energy-=(usedEnergy-dropE);
  return dropEnergy(dropE);
}

/**
 * Drop a cylinder
 */
Cylinder *Cylinder::drop(unsigned char sonId, const char *creationMessage, unsigned long messageSize){
  Cylinder *cyl=NULL;
  unsigned short int i;
  for (i=son.size();i--;)
    if (son[i]->cylinderId==sonId){
      cyl=son[i];
      break;
    }

  if (NULL==cyl){
    log <<"Can't drop NULL cylinder or it's not a direct son!"<<endl;
    return NULL;
  }
  // FIXME
  son.erase(&son[i]);

  World *world=getWorld();
  if (NULL==world){
    log <<"Can't drop if you are not in a world!!"<<endl;
    return NULL;
  }

  world->newAgent(cyl, creationMessage, messageSize);

  return NULL;
}

/**
 * A new cylinder is created in this agent with that position (angle
 * and height) on it's parent cylinder (this). Total energy of new
 * agent is parameter energy
 */

Cylinder *Cylinder::createCylinder(double angle, double atHeight, unsigned short int usedEnergy){
  energy-=usedEnergy;

  orientationBase.normalize();

  double h=7*usedEnergy/(16*M_PI*width*width);

  Cylinder *cyl=new Cylinder(world, this, usedEnergy/8, width,h,                
                 Vector3d(atHeight, angle, 0), true);

  son.push_back(cyl);

  return NULL;
}

/**
 * Traspases some of own energy to a son's cylinder energy
 */
Cylinder *Cylinder::sendEnergyTo(unsigned char son, unsigned short usedEnergy){
  Cylinder *cyl=(*this)[son];
  if (NULL==cyl)
    return NULL;

  energy-=usedEnergy;

  cyl->energy+=usedEnergy;

  return NULL;
}


/**
 * Creates an energy cylinder of desired energy+mass.
 *
 * It is created in pseudo-random position in the cylinder surface,
 * with a relation between the energy and mass of 7/8
 */
Cylinder *Cylinder::dropEnergy(double droppedEnergy){
  return NULL;
  energy-=droppedEnergy;

  double h=cbrt(droppedEnergy/(576*M_PI));

  /// We calculate the point at what the energy cyl appears.
  /*  Vector3d v=referenceAngle.rotate(orientation.getAxis(),energy);     // Rotate it the desired angle
  v*=width;                          // As it's normalized multipling
                      // it with radius give us a
                      // point in the circunference*/
  //  Vector3d newPos=getPosition()+(orientation.getAxis()*((cos(energy*mass)+1)*height/2))+v;

  return new Cylinder(world, this, droppedEnergy*7/8, h*6,h, 
              Vector3d(cos(energy*mass),energy,0), false);
}

Cylinder *Cylinder::sendMessage(unsigned long int _agentId, const char *message, unsigned long int size){
  if (agent==NULL)
    return NULL;

  unsigned long int agentId=agent->getId();


  /// FIXME!!! I must add noise to the message

  world->addMessage(message,size,agent);

  if (_agentId==agentId)
    return NULL;

  Agent *agent=world->getAgent(_agentId);
  if (NULL==agent)
    return NULL;
  agent->receiveMessage(agentId, message, size);

  return NULL;
}


/**
 * According to desiredAction it realizes an Action
 */
Cylinder *Cylinder::performAction(){
  Cylinder *ret=NULL;
  switch(desiredAction.action){
  case growTo:
    ret=grow(GrowType(desiredAction.growType), desiredAction.energy);
    break;
  case newCylinder:
    ret=createCylinder(desiredAction.angle, desiredAction.height, desiredAction.energy);
    break;
  case sendEnergy:
    ret=sendEnergyTo(desiredAction.cylinder, desiredAction.energy);
    break;
  case moveCylinder:
    ret=move(desiredAction.moveType, desiredAction.energy);
    break;
  case dropCylinder:
    ret=drop(desiredAction.cylinder, desiredAction.message, desiredAction.messageSize);
    break;
  case sendMessageAction:
    ret=sendMessage(desiredAction.agentId, desiredAction.message, desiredAction.messageSize);
    break;
  case none:
    break;
  default:
    log <<"desired Action "<<int(desiredAction.action)<<" not implemented yet"<<endl;
    break;
  }

  desiredAction=Action();
  return ret;
}

---