---

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

#ifndef M_PI
# define M_PI           3.14159265358979323846 
#endif

Client::~Client(){
  world->clientOut(this);
}

Client::Client(ost::TCPSocket &sock, World *w) : baseClient(sock,w){
  initialize();
}

void Client::Run(void){
  log <<"Run Agent Client"<<endl;
  
  try{
    while(1){
      Message msg(stream);    
      switch(msg.type){
      case messageNewCylinder:
    newCylinder(msg);
    break;
      case messageGrow:
    grow(msg);
    break;
      case messageSendEnergy:
    sendEnergy(msg);
    break;
      case messageMove:
    move(msg);
    break;
      case messageDrop:
    dropCylinder(msg);
    break;
      case messageSendMessage:
    sendMessage(msg);
    break;
      case messageLog:
    clientLog(msg);
    break;
      case messageEndOfTurn:
    endOfTurn(msg);
    break;
      default:
    log <<"Unknown message type "<<msg.type<<endl;
      }
    }
  }
  catch(...){      
    log <<"Exception caught! Exiting client!"<<endl;
    alive=false;
    return;          
  }

  alive=false;
  log <<"End of Agent Client"<<endl;
}

void Client::initialize(){
  /** Check client version */
  char version;
  version=stream->get();
  log<<"Client protocol version is "<<int(version)<<"."<<endl;
  if (version!=0x00){
    log <<"Invalid version!!!"<<endl;
    alive=false;
    return;
  }

  /** Get the name */
  char c;  name="";
  c=stream->get();
  while(c!=0){
    name+=c;
    *stream>>c;
  }
  log <<"Client name: "<<name<<endl;

  /** We Create an agent */

  Agent *ag=new Agent(this,Point3d(0,0,15),NULL,0);
  log <<"First agent of client in "<<(*ag)[0]->getPosition().toString()<<endl;
  world->newAgent(ag);
}

/**
 * Make a cylinder appear near any other cylinder
 */
void Client::newCylinder(Message &msg){
  if (msg.size!=4){
    log <<"Bad newCylinder message"<<endl;
    return;
  }
  unsigned char cyl=msg.umsg[0];
  double angle=(((unsigned char)msg.umsg[1])*2*M_PI)/256.0;
  double height=((unsigned char)msg.umsg[2])/255.0;
  unsigned short energy=msg.umsg[3];

  //  log <<"Create cylinder, father "<<long(cyl)<<" angle: "<<angle<<" height "<<height<<" energy: "<<energy<<endl;
  
  Agent *agent=world->getAgent(msg.organismId);
  Cylinder *cylinder=NULL;
  if (NULL!=agent)
    cylinder=(*agent)[cyl];
  if (cylinder==NULL){
    log <<"Cylinder or agent does not exist!"<<int(cyl)<<endl;
    msg.size=0;
  }
  else{
    if (cylinder->getEnergy()>=energy){
      
      //// This is the REAL call, all the rest are checks'n locks
      cylinder->newIntention(Action(angle, height, energy));
      ////
      
      msg.size=1;
      msg.msg[0]=agent->getCylinderCount();
    }
    else{ /// Cylinder can't create son
      msg.size=0;
    }
  }
  
  msg.petition=false;
  //log <<msg.toString()<<endl;
  msg.sendTo(stream);
  stream->sync();
}

/**
 * Make a cylinder get droped from agent, includes the creation
 * message of the new agent son
 */
void Client::dropCylinder(Message &msg){
  if (msg.size<1){
    log <<"Bad dropCylinder message"<<endl;
    return;
  }
  unsigned char cyl=msg.umsg[0];

  Agent *agent=world->getAgent(msg.organismId);
  Cylinder *cylinder=NULL;
  if (agent!=NULL)
    cylinder=(*agent)[cyl];

  if (cylinder==NULL){
    log <<"Cylinder or agent does not exist!"<<int(cyl)<<endl;
    msg.size=0;
  }
  else{
    cylinder=cylinder->getFather();
    if (cylinder==NULL){
      log <<"Can't drop 1st cylinder of agent"<<endl;
      msg.size=0;
    }
    else{
      cylinder->newIntention(Action(cyl, msg.msg+1, msg.size-1));
    }
  }

  msg.petition=false;
  msg.sendTo(stream);
  stream->sync();
}


/**
 * Send a message to another agent, and maybe some clients can get it
 * from the air. This message is sent by cylinder n. zero, always.
 */
void Client::sendMessage(Message &msg){
  if (msg.size<4){
    log <<"Bad sendMessage message"<<endl;
    return;
  }

  Agent *agent=world->getAgent(msg.organismId);

  long agentId=((msg.umsg[0]&0x0FF)<<24)+((msg.umsg[1]&0x0FF)<<16)+
               ((msg.umsg[2]&0x0FF)<<8 )+((msg.umsg[3]&0x0FF));
  char *message=&(msg.msg[4]);

  Cylinder *cyl=(*agent)[0];
  if (NULL==cyl)
    log <<"this agent cant' send messages"<<endl;
  else
    cyl->newIntention(Action(agentId, msg.size-4, message));

  msg.size=0;
  msg.petition=false;
  msg.sendTo(stream);
  stream->sync();
}


/**
 * Send some energy from a parent cylinder to one of his sons, or from
 * son to his father
 */
void Client::sendEnergy(Message &msg){
  if (msg.size!=3){
    log <<"Bad sendEnergy message"<<endl;
    return;
  }
  unsigned char cyl1=msg.umsg[0];
  unsigned char cyl2=msg.umsg[1];
  unsigned char energy=msg.umsg[2];

  //log <<"sendEnergy father: "<<long(cyl1)<<" son: "<<long(cyl2)<<" energy: "<<long(energy)<<endl;
  
  Agent *agent=world->getAgent(msg.organismId);
  Cylinder *cylinder1=NULL,*cylinder2=NULL;
  if (NULL!=agent){
    cylinder1=(*agent)[cyl1];
    cylinder2=(*agent)[cyl2];
  }
  if ((cylinder1==NULL)||(cylinder2==NULL)){
    log <<"Cylinder(s) or agent does not exist!"<<int(cyl1)<<" "<<int(cyl2)<<endl;
    msg.size=0;
  }
  else{
    if (cylinder1->dist(cylinder2)==1)   // cyl1 is the father
      if (cylinder1->getEnergy()>=energy)
    cylinder1->newIntention(Action(cyl2, energy));
      else
    msg.size=0;
    else if (cylinder2->dist(cylinder1)==1) // no, it's cyl2
      if (cylinder2->getEnergy()>=energy)
    cylinder2->newIntention(Action(cyl1, energy));
      else
    msg.size=0;
    else
      msg.size=0;
  }

  msg.petition=false;
  msg.sendTo(stream);
  stream->sync();
}

/** 
 * Make the client grow a little bit
 */
void Client::grow(Message &msg){
  if (msg.size!=2){
    log <<"Bad grow message"<<endl;
    return;
  }
  unsigned char cyl=msg.umsg[0];
  GrowType type=((msg.umsg[1]>>7)&1) ? growVertical : growHorizontal;
  unsigned short int energy=msg.umsg[1]&0x07F;
  
  // Use the same msg to response...
  msg.petition=false;
  
  Agent *agent=world->getAgent(msg.organismId);
  
  Cylinder *cylinder=NULL;
  if (NULL!=agent)
    cylinder=(*agent)[cyl];
  if (cylinder==NULL){
    log <<"Cylinder or agent does not exist!"<<int(cyl)<<endl;
    msg.size=0;
  }
  else{
    if (cylinder->getEnergy()>=energy){
      
      //// This is the REAL call, all the rest are checks'n locks
      cylinder->newIntention(Action(energy, type));
      ////
      
    }
    else{ /// Cylinder can't grow
      msg.size=0;
    }
  }
  
  msg.petition=false;
  msg.sendTo(stream);
  stream->sync();
}

/**
 * Moves a cylinder, around it's father
 */
void Client::move(Message &msg){
  if (msg.size!=3){
    log <<"Bad move message"<<endl;
    return;
  }
  unsigned char cyl=msg.umsg[0];
  MoveType type=moveUnknown;
  switch((msg.msg[1]>>6)&3){
  case 0:
    type=moveVerticalCW;
    break;
  case 1:
    type=moveVerticalCCW;
    break;
  case 2:
    type=moveHorizontalCW;
    break;
  case 3:
    type=moveHorizontalCCW;
    break;
  }
  unsigned short int energy=((msg.umsg[1]&0x03F)<<8)+msg.umsg[2];
  
  // Use the same msg to response...
  msg.petition=false;
  
  Agent *agent=world->getAgent(msg.organismId);
  
  Cylinder *cylinder=NULL;
  if (NULL!=agent)
    cylinder=(*agent)[cyl];
  if (cylinder==NULL){
    log <<"Cylinder or agent does not exist!"<<int(cyl)<<endl;
    msg.size=0;
  }
  else{
    if (cylinder->getEnergy()>=energy){
      //// This is the REAL call, all the rest are checks'n locks
      cylinder->newIntention(Action(energy, type));
      ////
      
    }
    else{ /// Cylinder can't grow
      msg.size=0;
    }
  }
  
  msg.petition=false;
  msg.sendTo(stream);
  stream->sync();
}


/**
 * Log a message
 */
void Client::clientLog(Message &msg){
  string str="";
  for (unsigned int i=0;i<msg.size;i++)
    str+=char(msg.msg[i]);
  log <<"Log: "<<str<<endl;
  
  // And we response
  msg.size=0;
  msg.petition=false;
  msg.sendTo(stream);
  stream->sync();
}


void Client::endOfTurn(Message &msg){
  msg.petition=false;
  msg.sendTo(stream);
  stream->sync();
  dontWalk();
}

---