////////////////////////////////////////////////
// TEST: testReflectTSOWithInvalidAttribute() //
////////////////////////////////////////////////
void ReflectAttributesTest::testReflectTSOWithInvalidAttribute()
{
	RTI::AttributeHandleValuePairSet *set = defaultFederate->createAHVPS( 2 );
	set->add( aaHandle, "aa", 3 );
	set->add( 10000000, "na", 3 );
	
	try
	{
		RTIfedTime time = 10.0;
		defaultFederate->rtiamb->updateAttributeValues( theObject, *set, time, "NA" );
		delete set;
		failTestMissingException( "AttributeNotDefined",
		                          "updating attributes with invalid attribute" );
	}
	catch( RTI::AttributeNotDefined& attnd )
	{
		// success
		delete set;
	}
	catch( RTI::Exception& e )
	{
		delete set;
		failTestWrongException( "AttributeNotDefined", e,
		                        "updating attributes with invalid attribute" );
	}
}
/*
 * This method will update all the values of the given object instance. It will
 * set each of the values to be a string which is equal to the name of the
 * attribute plus the current time. eg "aa:10.0" if the time is 10.0.
 * <p/>
 * Note that we don't actually have to update all the attributes at once, we
 * could update them individually, in groups or not at all!
 */
void ExampleCPPFederate::updateAttributeValues( RTI::ObjectHandle objectHandle )
{
	///////////////////////////////////////////////
	// create the necessary container and values //
	///////////////////////////////////////////////
	// create the collection to store the values in, as you can see
	// this is quite a lot of work
	RTI::AttributeHandleValuePairSet *attributes = RTI::AttributeSetFactory::create( 3 );

	// generate the new values
	// we use EncodingHelpers to make things nice friendly for both Java and C++
	char aaValue[16], abValue[16], acValue[16];
	sprintf( aaValue, "aa:%f", getLbts() );
	sprintf( abValue, "ab:%f", getLbts() );
	sprintf( acValue, "ac:%f", getLbts() );
	attributes->add( aaHandle, aaValue, (RTI::ULong)strlen(aaValue)+1 );
	attributes->add( abHandle, abValue, (RTI::ULong)strlen(abValue)+1 );
	attributes->add( acHandle, acValue, (RTI::ULong)strlen(acValue)+1 );

	//////////////////////////
	// do the actual update //
	//////////////////////////
	rtiamb->updateAttributeValues( objectHandle, *attributes, "hi!" );

	// note that if you want to associate a particular timestamp with the
	// update. here we send another update, this time with a timestamp:
	RTIfedTime time = fedamb->federateTime + fedamb->federateLookahead;
	rtiamb->updateAttributeValues( objectHandle, *attributes, time, "hi!" );

	// clean up
	delete attributes;
}
Example #3
0
void Attribute<RTIObjectIdArrayStruct>::reflectAttribute(const RTI::AttributeHandleValuePairSet& theAttributes, int idx) throw (RTI::FederateInternalError)
{
    unsigned char *data = new unsigned char[theAttributes.getValueLength(idx)];
    copyData(theAttributes, idx, data, theAttributes.getValueLength(idx));
    unsigned int len = fromNet<unsigned short>(data+0);
    char* string = (char *)(data+2);
    unsigned int i = 0;
    while( *string && i<len )
    {
        value.push_back(std::string(string));
        while( *string && i<len )
        {
            string++;
            i++;
        }
        string++;
        i++;
    }
    delete [] data;
    std::cout << "Object IDs";
    for( i=0; i<value.size(); i++ )
    {
        std::cout << " " << value[i];
    }
    std::cout << std::endl;
}
Example #4
0
//-----------------------------------------------------------------
//
// METHOD:
//     RTI::AttributeHandleValuePairSet* Country::CreateNVPSet()
//
// PURPOSE:
//     Create a name value pair set (aka handle value pair) for
//     the changed attributes of this country object.
//
// RETURN VALUES:
//     RTI::AttributeHandleValuePairSet* containing the
//     attributes that have changed in the instance of Country. 
//
// HISTORY:
//     1) Created 11/6/96
//     2) Updated to RTI 1.3 3/26/98
//
//-----------------------------------------------------------------
RTI::AttributeHandleValuePairSet* Country::CreateNVPSet()
{
   RTI::AttributeHandleValuePairSet* pCountryAttributes = NULL;

   // Make sure the RTI Ambassador is set.
   if ( ms_rtiAmb )
   {
      //------------------------------------------------------
      // Set up the data structure required to push this
      // object's state to the RTI.
      //------------------------------------------------------
      pCountryAttributes = RTI::AttributeSetFactory::create( 2 );

      if ( hasNameChanged == RTI::RTI_TRUE )
      {
         // We don't do any encoding here since the name type
         // is a string.
         pCountryAttributes->add( this->GetNameRtiId(),
                                  (char*) this->GetName(),
                                  ((strlen(this->GetName())+1)*sizeof(char)) );
      }
      
      if ( hasPopulationChanged == RTI::RTI_TRUE )
      {
         // Here we are encoding the double so that it is in a
         // common format so that federates on other platforms
         // know how to read it.
#if defined(_X86_) || defined(i386)
         double tmp;
         *((long*)&tmp) = htonl(*(((long*)&this->GetPopulation()) + 1));
         *(((long*)&tmp) + 1) = htonl(*((long*)&this->GetPopulation()));
         pCountryAttributes->add( this->GetPopulationRtiId(),
                                  (char*)&tmp,
                                  sizeof(double) );
#elif defined(__alpha)
         double x;
         double pop = this->GetPopulation();
         cvt_ftof(&pop, CVT_BIG_ENDIAN_IEEE_T, &x, CVT_IEEE_T, 0);
         pCountryAttributes->add( this->GetPopulationRtiId(), 
                                  (char*)&x, sizeof(double));
#else
         pCountryAttributes->add( this->GetPopulationRtiId(),
                                  (char*) &this->GetPopulation(),
                                  sizeof(double) );
#endif
      }
   }

   // pCountryAttributes is allocated on the heap and must be
   // deallocated by the federate.
   return pCountryAttributes;
}
Example #5
0
//-----------------------------------------------------------------
//
// METHOD:
//     void Country::Update( const AttributeHandleValuePairSet& theAttributes )
//
// PURPOSE:
//     Update the new attribute values.  If this is being called
//     then this object is either a remote object that was
//     discovered or it has some attributes that are owned by
//     another federate.
//
//     Note: This version does not implement any ownership
//           transfer - the above was a generic statement.
//
// RETURN VALUES:
//     None. 
//
// HISTORY:
//     1) Created 11/6/96
//     2) Updated to RTI 1.3 3/26/98
//
//-----------------------------------------------------------------
void Country::Update( const RTI::AttributeHandleValuePairSet& theAttributes )
{
   RTI::AttributeHandle attrHandle;
   RTI::ULong           valueLength;

   // We need to iterate through the AttributeHandleValuePairSet
   // to extract each AttributeHandleValuePair.  Based on the type
   // specified ( the value returned by getHandle() ) we need to
   // extract the data from the buffer that is returned by 
   // getValue().
   for ( unsigned int i = 0; i < theAttributes.size(); i++ )
   {
      attrHandle = theAttributes.getHandle( i );

      if ( attrHandle == Country::GetPopulationRtiId() )
      {
         // When we run this over multiple platforms we will have
         // a problem with different endian-ness of platforms. Either
         // we need to encode the data using something like XDR or
         // provide another mechanism.
         double population;
         theAttributes.getValue( i, (char*)&population, valueLength );

#if defined(_X86_) || defined(i386)
         long x = ntohl(*(long*)&population);
         *(long*)&population = ntohl(* (((long*)&population) + 1));
         *(((long*)&population)+1) = x;
#elif defined(__alpha)
         double x;
         cvt_ftof(&population, CVT_IEEE_T, &x, CVT_BIG_ENDIAN_IEEE_T, 0);
         population = x;
#endif  // __alpha

         SetPopulation( (double)population );
      }
      else if ( attrHandle == Country::GetNameRtiId() )
      {
        // Same as above goes here...
         char name[ 1024 ];
         theAttributes.getValue( i, (char*)name, valueLength );
         SetName( (const char*)name );
      }
   }
}
///////////////////////////////////////////////
// TEST: testReflectROWithUnownedAttribute() //
///////////////////////////////////////////////
void ReflectAttributesTest::testReflectROWithUnownedAttribute()
{
	RTI::AttributeHandleValuePairSet *set = defaultFederate->createAHVPS( 1 );
	set->add( aaHandle, "aa", 3 );
	
	try
	{
		listenerFederate->rtiamb->updateAttributeValues( theObject, *set, "NA" );
		delete set;
		failTestMissingException( "AttributeNotOwned", "updating attributes not owned" );
	}
	catch( RTI::AttributeNotOwned& ano )
	{
		// success
		delete set;
	}
	catch( RTI::Exception& e )
	{
		delete set;
		failTestWrongException( "AttributeNotOwned", e, "updating attributes not owned" );
	}
}
Example #7
0
RTI::AttributeHandleValuePairSet* CFellow::CreateNVPSet()
{
    RTI::AttributeHandleValuePairSet *pCFellowAttrs = NULL;

    if (ms_rtiAmb)
    {
        pCFellowAttrs = RTI::AttributeSetFactory::create(3);

        if (m_bNameChanged)
        {
            pCFellowAttrs->add(this->GetFellowNameRtiId(),
                (char*)this->GetFellowName(),
                ((strlen(this->GetFellowName()) + 1) * sizeof(char)));
        }
        if (m_bColorChanged)
        {
            RTI::ULong tmp;
            *((long*)&tmp) = htonl(*(((long*)&this->GetFellowColor()) + 1));
            *(((long*)&tmp) + 1) = htonl(*((long*)&this->GetFellowColor()));
            pCFellowAttrs->add(this->GetFellowColorRtiId(),
                (char*)&tmp,
                sizeof(RTI::ULong));
        }
        if (m_bPortraitChanged)
        {
            RTI::ULong tmp;
            *((long*)&tmp) = htonl(*(((long*)&this->GetFellowPortrait()) + 1));
            *(((long*)&tmp) + 1) = htonl(*((long*)&this->GetFellowPortrait()));
            pCFellowAttrs->add(this->GetFellowPortraitRtiId(),
                (char*)&tmp,
                sizeof(RTI::ULong));
        }
    }

    return pCFellowAttrs;
}
Example #8
0
void CFellow::UpdateFellow(CFellow *pCFellow)
{
    char                                fellowName[256] = {'\0'};
    RTI::ULong                          fellowColor     = 0;
    RTI::ULong                          fellowPortrait  = 0;
    RTI::AttributeHandleValuePairSet    *theAttrs = NULL;

    try
    {
        theAttrs = RTI::AttributeSetFactory::create(3);
        if (pCFellow->GetFellowNameUpdate())
        {
            strcpy(fellowName, pCFellow->GetFellowName());
            theAttrs->add(pCFellow->GetFellowNameRtiId(), (char*)fellowName,
                sizeof(fellowName));
            pCFellow->SetFellowNameUpdate(RTI::RTI_FALSE);
        }
        if (pCFellow->GetFellowColorUpdate())
        {
            fellowColor = pCFellow->GetFellowColor();
            theAttrs->add(pCFellow->GetFellowColorRtiId(), (char*)&fellowColor,
                sizeof(fellowColor));
            pCFellow->SetFellowColorUpdate(RTI::RTI_FALSE);
        }
        if (pCFellow->GetFellowPortraitUpdate())
        {
            fellowPortrait = pCFellow->GetFellowPortrait();
            theAttrs->add(pCFellow->GetFellowPortraitRtiId(), (char*)&fellowPortrait,
                sizeof(fellowPortrait));
            pCFellow->SetFellowPortraitUpdate(RTI::RTI_FALSE);
        }
        if (theAttrs->size())
        {
            ms_rtiAmb->updateAttributeValues(pCFellow->GetInstanceId(),
                *theAttrs, "FellowUpdate");
            //ms_rtiAmb->tick(0.1, 2.0);
        }
        if (theAttrs)
        {
            theAttrs->empty();
            delete theAttrs;
        }
    }
    catch (RTI::Exception& e)
    {
        AfxMessageBox((CString)e._name);
    }
}
Example #9
0
//-----------------------------------------------------------------
//
// METHOD:
//     void Country::Update( RTIfedTime& newTime )
//
// PURPOSE:
//     Update the state of the Country's population based on
//     the new time value.  The deltaTime is calculated based
//     on the last time the Country object was updated and
//     the newTime passed in.  The deltaTime is multiplied by
//     the growth rate and current population to determine the
//     number of births in the deltaTime.  The population is
//     increased by the number of births.
//
// RETURN VALUES:
//     None. 
//
// HISTORY:
//     1) Created 11/6/96
//     2) Updated to RTI 1.3 3/26/98
//
//-----------------------------------------------------------------
void Country::Update( RTI::FedTime& newTime )
{
   //------------------------------------------------------
   // we have advanced in time so calculate my next state.
   //------------------------------------------------------

   RTI::FedTime *pTime = RTI::FedTimeFactory::makeZero();
   (*pTime) = newTime;
   (*pTime) -= this->GetLastTime();
   // Set last time to new time
   this->SetLastTime( newTime );

   if ( !(pTime->isZero()))
   {
      SetPopulation( GetPopulation() + 
                     (GetPopulation()*ms_growthRate) );
   }

   if ( ms_rtiAmb )
   {
      //------------------------------------------------------
      // Update state of country
      //------------------------------------------------------
      try
      {
         //------------------------------------------------------
         // In order to send the values of our attributes, we must
         // construct an AttributeHandleValuePairSet (AHVPS) which
         // is a set comprised of attribute handles, values, and
         // the size of the values. CreateNVPSet() is a method 
         // defined on the Country class - it is not part of the RTI.
         // Look inside the method to see how to construct an AHVPS
         //------------------------------------------------------
         RTI::AttributeHandleValuePairSet* pNvpSet = this->CreateNVPSet();
         
         //------------------------------------------------------
         // Send the AHVPS to the federation.
         //
         // this call returns an event retraction handle but we 
         // don't support event retraction so no need to store it.
         //------------------------------------------------------
         (void) ms_rtiAmb->updateAttributeValues( this->GetInstanceId(),
                                                  *pNvpSet,
                                                  this->GetLastTimePlusLookahead(), 
                                                  NULL );
         // Must free the memory
         pNvpSet->empty();
         delete pNvpSet;
      }
      catch ( RTI::Exception& e )
      {
         cerr << "FED_HW: Error:" << e << endl;
      }
      
      // Periodically send an interaction to tell everyone Hello
      static int periodicMessage = 0;

      if ( (periodicMessage++%100) == 0 )
      {
         RTI::ParameterHandleValuePairSet* pParams = NULL;

                 //------------------------------------------------------
                 // Periodically stimulate an update of the "Name" 
                 // attribute for the benefit of late-arriving federates.
                 // It would be more correct to use 
                 // "requestClassAttributeValueUpdate" and 
                 // "provideAttributeValueUpdate", but let's keep things
                 // simple.
                 //------------------------------------------------------
         hasNameChanged = RTI::RTI_TRUE;

         //------------------------------------------------------
         // Set up the data structure required to push this
         // objects's state to the RTI.  The
         // ParameterHandleValuePairSet is similar to the AHVPS
         // except it contains ParameterHandles instead of
         // AttributeHandles.
         //------------------------------------------------------
         pParams = RTI::ParameterSetFactory::create( 1 );

         char *pMessage = "Hello World!";
         
         pParams->add( this->GetMessageRtiId(),
                       (char*) pMessage,
                       ((strlen(pMessage)+1)*sizeof(char)) );
         try
         {
            //------------------------------------------------------
            // this call returns an event retraction handle but we 
            // don't support event retraction so no need to store it.
            //------------------------------------------------------
            (void) ms_rtiAmb->sendInteraction( GetCommRtiId(), *pParams,
                                               this->GetLastTimePlusLookahead(),
                                               NULL );
         }
         catch ( RTI::Exception& e )
         {
            cerr << "FED_HW: Error:" << e << endl;
         }

         //------------------------------------------------------
         // Must free the memory:
         //    ParameterSetFactory::create() allocates memory on
         //    the heap.
         //------------------------------------------------------
         delete pParams;
      }
   }
   delete pTime;
}
//------------------------------------------------------------------------------
// reflectAttributeValues() -- (Input support)
//  Called by our FederateAmbassador to update the attribute values for
//  this object instance.  (Also handles the network to host byte swapping)
//------------------------------------------------------------------------------
void Nib::reflectAttributeValues(const RTI::AttributeHandleValuePairSet& theAttrs)
{
   NetIO* netIO = static_cast<NetIO*>(getNetIO());
   if (netIO != nullptr && baseEntity != nullptr) {

      // PhysicalEntity pointer
      PhysicalEntity* physicalEntity = dynamic_cast<PhysicalEntity*>(baseEntity);

      RTI::ULong length;
      char netBuffer[1000];
      for (RTI::ULong j = 0; j < theAttrs.size(); j++ ) {

         // get the attribute's handle and data (network byte order)
         RTI::AttributeHandle theAttr = theAttrs.getHandle(j);
         theAttrs.getValue(j, netBuffer, length);

         // Process the attribute
         switch ( netIO->findAttributeIndex(theAttr) ) {

            // Update Federate ID
            case NetIO::ENTITY_IDENTIFIER_AI : {
               EntityIdentifierStruct* net = reinterpret_cast<EntityIdentifierStruct*>(&netBuffer);

               base::NetHandler::fromNetOrder(&baseEntity->entityIdentifier.federateIdentifier.applicationID, net->federateIdentifier.applicationID );
               base::NetHandler::fromNetOrder(&baseEntity->entityIdentifier.federateIdentifier.siteID, net->federateIdentifier.siteID );
               base::NetHandler::fromNetOrder(&baseEntity->entityIdentifier.entityNumber, net->entityNumber );

               setAttributeUpdateRequiredFlag(NetIO::ENTITY_IDENTIFIER_AI, true);
            }
            break;

            // Update Entity Type
            case NetIO::ENTITY_TYPE_AI : {
               EntityTypeStruct* net = reinterpret_cast<EntityTypeStruct*>(&netBuffer);

               // All bytes except for country
               baseEntity->entityType = *net;
               base::NetHandler::fromNetOrder(&baseEntity->entityType.countryCode, net->countryCode );

               setAttributeUpdateRequiredFlag(NetIO::ENTITY_TYPE_AI, true);
            }
            break;

            // Update Spatial
            case NetIO::SPATIAL_AI : {

               // NIB's base entity structure pointers
               SpatialStruct* spatial = &(baseEntity->spatial);
               SpatialRVStruct* spatialRvw = &(baseEntity->spatialRvw);
               WorldLocationStruct* worldLocation = &spatialRvw->worldLocation;
               OrientationStruct* orientation = &spatialRvw->orientation;
               VelocityVectorStruct* velocityVector = &spatialRvw->velocityVector;
               AccelerationVectorStruct* accelerationVector = &spatialRvw->accelerationVector;
               AngularVelocityVectorStruct* angularVelocity = &spatialRvw->angularVelocity;

               // Net buffer component pointers 
               SpatialStruct* netSpatial = reinterpret_cast<SpatialStruct*>(&netBuffer[0]);
               WorldLocationStruct* netWorldLocation = nullptr;
               OrientationStruct* netOrientation = nullptr;
               VelocityVectorStruct* netVelocityVector = nullptr;
               AccelerationVectorStruct* netAccelerationVector = nullptr;
               AngularVelocityVectorStruct* netAngularVelocity = nullptr;

               // Dead reckoning 
               spatial->deadReckoningAlgorithm = netSpatial->deadReckoningAlgorithm;

               // find network components based on dead reckoning algorithm
               // (and set the isFrozen flag)
               switch (spatial->deadReckoningAlgorithm) {

                  case DRM_STATIC : {
                     SpatialStaticStruct* netSpatialStatic = reinterpret_cast<SpatialStaticStruct*>(&netBuffer[sizeof(SpatialStruct)]);
                     spatialRvw->isFrozen = netSpatialStatic->isFrozen;
                     netWorldLocation = &netSpatialStatic->worldLocation;
                     netOrientation = &netSpatialStatic->orientation;
                  }
                  break;

                  case DRM_FPW : {
                     SpatialFPStruct* netSpatialFpw = reinterpret_cast<SpatialFPStruct*>(&netBuffer[sizeof(SpatialStruct)]);
                     spatialRvw->isFrozen = netSpatialFpw->isFrozen;
                     netWorldLocation = &netSpatialFpw->worldLocation;
                     netOrientation = &netSpatialFpw->orientation;
                     netVelocityVector = &netSpatialFpw->velocityVector;
                  }
                  break;

                  case DRM_RPW : {
                     SpatialRPStruct* netSpatialRpw = reinterpret_cast<SpatialRPStruct*>(&netBuffer[sizeof(SpatialStruct)]);
                     spatialRvw->isFrozen = netSpatialRpw->isFrozen;
                     netWorldLocation = &netSpatialRpw->worldLocation;
                     netOrientation = &netSpatialRpw->orientation;
                     netVelocityVector = &netSpatialRpw->velocityVector;
                     netAngularVelocity = &netSpatialRpw->angularVelocity;
                  }
                  break;

                  case DRM_RVW : {
                     SpatialRVStruct* netSpatialRvw = reinterpret_cast<SpatialRVStruct*>(&netBuffer[sizeof(SpatialStruct)]);
                     spatialRvw->isFrozen = netSpatialRvw->isFrozen;
                     netWorldLocation = &netSpatialRvw->worldLocation;
                     netOrientation = &netSpatialRvw->orientation;
                     netVelocityVector = &netSpatialRvw->velocityVector;
                     netAccelerationVector = &netSpatialRvw->accelerationVector;
                     netAngularVelocity = &netSpatialRvw->angularVelocity;
                  }
                  break;

                  case DRM_FVW : {
                     SpatialFVStruct* netSpatialFvw = reinterpret_cast<SpatialFVStruct*>(&netBuffer[sizeof(SpatialStruct)]);
                     spatialRvw->isFrozen = netSpatialFvw->isFrozen;
                     netWorldLocation = &netSpatialFvw->worldLocation;
                     netOrientation = &netSpatialFvw->orientation;
                     netVelocityVector = &netSpatialFvw->velocityVector;
                     netAccelerationVector = &netSpatialFvw->accelerationVector;
                  }
                  break;
               }  // end dead rec switch

               if (netWorldLocation != nullptr) {
                  base::NetHandler::fromNetOrder(&worldLocation->x, netWorldLocation->x);
                  base::NetHandler::fromNetOrder(&worldLocation->y, netWorldLocation->y);
                  base::NetHandler::fromNetOrder(&worldLocation->z, netWorldLocation->z);
               }
               else {
                  worldLocation->x = 0;
                  worldLocation->y = 0;
                  worldLocation->z = 0;
               }

               if (netOrientation != nullptr) {
                  base::NetHandler::fromNetOrder(&orientation->phi, netOrientation->phi);
                  base::NetHandler::fromNetOrder(&orientation->theta, netOrientation->theta);
                  base::NetHandler::fromNetOrder(&orientation->psi, netOrientation->psi);
               }
               else {
                  orientation->phi = 0;
                  orientation->theta = 0;
                  orientation->psi = 0;
               }

               if (netVelocityVector != nullptr) {
                  base::NetHandler::fromNetOrder(&velocityVector->xVelocity, netVelocityVector->xVelocity);
                  base::NetHandler::fromNetOrder(&velocityVector->yVelocity, netVelocityVector->yVelocity);
                  base::NetHandler::fromNetOrder(&velocityVector->zVelocity, netVelocityVector->zVelocity);
               }
               else {
                  velocityVector->xVelocity = 0;
                  velocityVector->yVelocity = 0;
                  velocityVector->zVelocity = 0;
               }

               if (netAccelerationVector != nullptr) {
                  base::NetHandler::fromNetOrder(&accelerationVector->xAcceleration, netAccelerationVector->xAcceleration);
                  base::NetHandler::fromNetOrder(&accelerationVector->yAcceleration, netAccelerationVector->yAcceleration);
                  base::NetHandler::fromNetOrder(&accelerationVector->zAcceleration, netAccelerationVector->zAcceleration);
               }
               else {
                  accelerationVector->xAcceleration = 0;
                  accelerationVector->yAcceleration = 0;
                  accelerationVector->zAcceleration = 0;
               }

               if (netAngularVelocity != nullptr) {
                  base::NetHandler::fromNetOrder(&angularVelocity->xAngularVelocity, netAngularVelocity->xAngularVelocity);
                  base::NetHandler::fromNetOrder(&angularVelocity->yAngularVelocity, netAngularVelocity->yAngularVelocity);
                  base::NetHandler::fromNetOrder(&angularVelocity->zAngularVelocity, netAngularVelocity->zAngularVelocity);
               }
               else {
                  angularVelocity->xAngularVelocity = 0;
                  angularVelocity->yAngularVelocity = 0;
                  angularVelocity->zAngularVelocity = 0;
               }

               setAttributeUpdateRequiredFlag(NetIO::SPATIAL_AI, true);
            }
            break;

            case NetIO::FORCE_IDENTIFIER_AI : {
               unsigned char* net = reinterpret_cast<unsigned char*>(&netBuffer);
               physicalEntity->forceIdentifier = ForceIdentifierEnum8( *net );
               //std::cout << "Recv force: " << physicalEntity->forceIdentifier << std::endl;;
               setAttributeUpdateRequiredFlag(NetIO::FORCE_IDENTIFIER_AI, true);
            }
            break;

         } // end -- process attribute switch
      } // end -- for each attribute pair

      // Update the basic NIB state data with this new data
      entityState2Nib();
   }
}