---

world.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 "world.h"
#include "client.h"
#include "log.h"
#include "cylinder.h"
#include "agent.h"
#include "collision.h"
#include "commcenter.h"

/// The gravity constant of this world 
double World::gravity=-0.0005;//-0.5;
/// Linear drag coefficient
double World::linearDragCoefficient=0.20;
/// Angular drag coefficient
double World::angularDragCoefficient=0.20;
/// Ground restitution coefficient
double World::groundRestitutionCoefficient=0.02;
/// Ground friction coefficient
double World::groundFrictionCoefficient=0.09;
/// Spring coefficient (glue)
double World::springCoefficient=10;
/// Damper coefficient (resistance to union/separation in glue)
double World::damperCoefficient=2;


/**
 * creates a world that comprehen this bounding box
 */
World::World(CommCenter *_commCenter, BoundingBox _bbox){
  commCenter=_commCenter;

  bbox=_bbox;
  log <<"New World. "<<bbox.toString()<<endl;

  quit=false;
}

/**
 * Is simply adds the agent to the list of agents
 */
void World::newAgent(Agent *agent){
  log <<"Create new agent"<<endl;
  agents.push_back(agent);
}

/**
 * It searchs for a suitable client and creates the agent for that
 * client
 */
void World::newAgent(Cylinder *cyl, const char *creationMessage, unsigned long int messageSize){
  log <<"Create NEW Agent!"<<endl;

  Agent *ag=cyl->getAgent();
  if (NULL==ag)
    return;
  Client *cl=ag->getClient();
  if (NULL==cl)
    return;
  string clientName=cl->getName();

  Client *newClient=commCenter->getClientForMigration(clientName);
  if (NULL==newClient){
    log <<"Can not find a suitable client for migration, agent not created; cylinder droped to the world"<<endl;
    cyl->setNewAgent(NULL);
    return;
  }
  Agent *newAgent=new Agent(newClient, cyl, creationMessage, messageSize);

  agents.push_back(newAgent);
}


/**
 * When a client go out it's agents are deleted. 
 *
 * They should be drop to the world. FIXME
 */
void World::clientOut(Client *client){
  unsigned int i;
  for (i=agents.size();i--;)
    if (agents[i]->getClient()==client){  /// FIXME! Agents should not be deleted, but let them without an agent.
      delete agents[i];
      agents.erase(&agents[i]);
    }
}

/**
 * Gets and agents given a agentId. If none is found returns a NULL
 * pointer.
 */

Agent *World::getAgent(unsigned long int agentId){
  unsigned int i;
  for (i=agents.size();i--;)
    if (agents[i]->getId()==agentId){
      return agents[i];
    }
  return NULL;
}

/**
 * Get a vector of agents that it's center is into the bounding box
 */
vector<Agent*> World::getAgents(BoundingBox box){
  vector<Agent*> agentList;
  unsigned int i;

  for (i=agents.size();i--;){
    if (agents[i]->into(box))
      agentList.push_back(agents[i]);
  }

  return agentList;
}


/**
 * Prints several stats about the world. Each one is a variable with
 * an equal (=) between the variable and the value. Semicolon (;) is
 * used as separator.
 */
string World::getStats(){
  string a; char s[256];

  sprintf(s,"numAgents=%d;",agents.size()); a+=s;
  sprintf(s,"numCylinders=%d;",cylinders.size()); a+=s;
  sprintf(s,"time=%ld;",sTime()); a+=s;

  return a;
}

/**
 * Runs a time step; first tell all cylinders to acomplish intentions,
 * and later move according to forces, velocities and collisions.
 */
void World::step(){
  unsigned int i;

  /// First signal that we begin a new cycle, so they can reset forces
  /// and moments. It also adds some forces as gravity and drags.
  /*
  /// We HAVE TO make it in this order to correctly apply spring forces
  unsigned int j=cylinders.size();
  for (i=0;i<j;i++)
    cylinders[i]->newCycle();
  */
  for (i=cylinders.size();i--;){
    //log <<"-----+ "<<i<<endl;
    cylinders[i]->newCycle();
  }


  /// Then we perform actions
  for (i=agents.size();i--;){
    vector<Cylinder *> newCyls;
    newCyls=agents[i]->performActions();
  }

  step(0,1); // one time unit step

  messages.clear();
}

/**
 * Runs a collision detection/reponse step of upper-lower time
 * units. This is so to detect correctly all collisions.
 */
void World::step(double lowerLimit, double upperLimit){
  //log <<"step"<<lowerLimit<<" to "<<upperLimit<<endl;
  unsigned int i;

  /// Now apply forces
  for (i=cylinders.size();i--;){
    //log <<"------ "<<i<<endl;
    cylinders[i]->applyVelocity(upperLimit-lowerLimit);
  }

  // The last oportunity cames when you've checked too many times
  bool lastOportunity=(upperLimit-lowerLimit)<COLLISION_TIME_EPSILUM;

  /// Now check collisions
  vector<Collision *> coll;
  vector<Collision *> contacts;
  bool penetrate=false;
  for (i=cylinders.size();(i--)&&(!penetrate);){
    coll=cylinders[i]->checkCollisions(); /// Returns all collisions of all it's cylinders
    unsigned int j;
    for (j=coll.size();j--;){  /// For each, 
      contacts.push_back(coll[j]); // add to contacts vector
      if ((coll[j]->getType()==penetrating)&&(!lastOportunity)) // Check if penetrating
        penetrate=true;
    }
  }

  // If there is penetration (and I wanna check more times)
  if (penetrate&&(!lastOportunity)){ 
    for (i=cylinders.size();i--;){ // undo the velocity
      cylinders[i]->undoVelocity();
    }
    step(lowerLimit, (lowerLimit+upperLimit)/2); // repeat in the lower part
    step((lowerLimit+upperLimit)/2, upperLimit); // and upper
  }
  else{ // Only contact, or nothing, or lastOportunity
    //    log <<lowerLimit<<" "<<upperLimit<<endl;
    for (i=contacts.size();i--;)
      contacts[i]->resolve();
  }
  
  for (i=contacts.size();i--;){
    delete contacts[i];
  }
}

/**
 * Add a new cylinder. All cylinders are in this vector, and are
 * here until they finally dissapear.
 */
void World::addCylinder(Cylinder *c){
  cylinders.push_back(c);
}

/**
 * Add a new cylinder. All cylinders are in this vector, and are
 * here until they finally dissapear.
 */
void World::delCylinder(Cylinder *c){
  unsigned int i;
  for (i=cylinders.size();i--;)
    if (c==cylinders[i])
      cylinders.erase(&cylinders[i]);
}

---