//------------------------------------------------------------------------------
// playerState2Nib() -- Sets this NIB's player data
//------------------------------------------------------------------------------
void Nib::playerState2Nib()
{
const models::Player* player = getPlayer();
if (player != nullptr) {
// Player name
const char* cname = nullptr;
const base::String* sname = player->getName();
if (sname != nullptr) cname = *sname;
if (cname != nullptr) setPlayerName(cname);
else setPlayerName("OPENEAAGLES");
freeze( player->isFrozen() );
if (!isMode(models::Player::DELETE_REQUEST)) setMode( player->getMode() );
setDamage( player->getDamage() );
setSmoke( player->getSmoke() );
setFlames( player->getFlames() );
setCamouflageType( player->getCamouflageType() );
setSide( player->getSide() );
// Reset our dead reckoning with the current state data from the player
//resetDeadReckoning(
// RVW_DRM,
// player->getGeocPosition(),
// player->getGeocVelocity(),
// player->getGeocAcceleration(),
// player->getGeocEulerAngles(),
// player->getGeocAngularVelocities()
//);
resetDeadReckoning(
RVW_DRM,
player->getSynchronizedState().getGeocPosition(),
player->getSynchronizedState().getGeocVelocity(),
player->getSynchronizedState().getGeocAcceleration(),
player->getSynchronizedState().getGeocEulerAngles(),
player->getSynchronizedState().getAngularVelocities()
);
// mark the current times
//Simulation* sim = getNetIO()->getSimulation();
//setTimeExec( static_cast<double>(sim->getExecTimeSec()) );
setTimeExec( static_cast<double>(player->getSynchronizedState().getTimeExec()) );
//setTimeUtc( static_cast<double>(sim->getSysTimeOfDay()) );
setTimeUtc( static_cast<double>(player->getSynchronizedState().getTimeUtc()) );
{
//base::Vec3d pos = player->getGeocPosition();
//base::Vec3d vec = player->getGeocVelocity();
//std::cout << "playerState2Nib(): geoc pos: (";
//std::cout << pos[0] << ", ";
//std::cout << pos[1] << ", ";
//std::cout << pos[2] << ") ";
//std::cout << "geoc vel: (";
//std::cout << vec[0] << ", ";
//std::cout << vec[1] << ", ";
//std::cout << vec[2] << ") ";
//std::cout << std::endl;
}
}
}
//------------------------------------------------------------------------------
// entityState2Nib() -- (Input support)
// Transfers data from the incoming entity attributes to the basic
// NIB class variables.
//------------------------------------------------------------------------------
void Nib::entityState2Nib()
{
if (isAttributeUpdateRequired(NetIO::ENTITY_IDENTIFIER_AI)) {
setPlayerID(baseEntity->entityIdentifier.entityNumber);
setSiteID(baseEntity->entityIdentifier.federateIdentifier.siteID);
setApplicationID(baseEntity->entityIdentifier.federateIdentifier.applicationID);
setAttributeUpdateRequiredFlag(NetIO::ENTITY_IDENTIFIER_AI, false);
haveEntityIdFlg = true;
}
if (isAttributeUpdateRequired(NetIO::ENTITY_TYPE_AI)) {
setEntityType(
baseEntity->entityType.entityKind,
baseEntity->entityType.domain,
baseEntity->entityType.countryCode,
baseEntity->entityType.category,
baseEntity->entityType.subcategory,
baseEntity->entityType.specific,
baseEntity->entityType.extra
);
setAttributeUpdateRequiredFlag(NetIO::ENTITY_TYPE_AI, false);
haveEntityTypeFlg = true;
}
if (isAttributeUpdateRequired(NetIO::SPATIAL_AI)) {
// NIB's base entity structures
//SpatialStruct* spatial = &(baseEntity->spatial);
SpatialRVStruct* spatialRvw = &(baseEntity->spatialRvw);
// Set the freeze flag
freeze(spatialRvw->isFrozen != 0);
// Get the geocentric position, velocity and acceleration
osg::Vec3d geocPos;
geocPos[base::Nav::IX] = spatialRvw->worldLocation.x;
geocPos[base::Nav::IY] = spatialRvw->worldLocation.y;
geocPos[base::Nav::IZ] = spatialRvw->worldLocation.z;
osg::Vec3d geocVel;
geocVel[base::Nav::IX] = spatialRvw->velocityVector.xVelocity;
geocVel[base::Nav::IY] = spatialRvw->velocityVector.yVelocity;
geocVel[base::Nav::IZ] = spatialRvw->velocityVector.zVelocity;
osg::Vec3d geocAcc;
geocAcc[base::Nav::IX] = spatialRvw->accelerationVector.xAcceleration;
geocAcc[base::Nav::IY] = spatialRvw->accelerationVector.yAcceleration;
geocAcc[base::Nav::IZ] = spatialRvw->accelerationVector.zAcceleration;
// Get orientation orientation and rates
osg::Vec3d geocAngles;
geocAngles[base::Nav::IPHI] = spatialRvw->orientation.phi;
geocAngles[base::Nav::ITHETA] = spatialRvw->orientation.theta;
geocAngles[base::Nav::IPSI] = spatialRvw->orientation.psi;
osg::Vec3d arates(0.0, 0.0, 0.0);
// (re)initialize the dead reckoning function
double diffTime(0.0);
resetDeadReckoning(
RVW_DRM,
geocPos,
geocVel,
geocAcc,
geocAngles,
arates,
diffTime);
haveWorldLocationFlg = true;
haveOrientationFlg = true;
setAttributeUpdateRequiredFlag(NetIO::SPATIAL_AI, false);
}
// PhysicalEntity pointer
PhysicalEntity* physicalEntity = dynamic_cast<PhysicalEntity*>(baseEntity);
if (physicalEntity != nullptr) {
if (isAttributeUpdateRequired(NetIO::FORCE_IDENTIFIER_AI)) {
// Side: When mapping Force ID to Player Side ...
if (physicalEntity->forceIdentifier == FRIENDLY) {
// Friendly's are blue, ...
setSide(simulation::Player::BLUE);
}
else if (physicalEntity->forceIdentifier == OPPOSING) {
// opposing side is red, ...
setSide(simulation::Player::RED);
}
else if (physicalEntity->forceIdentifier == NEUTRAL) {
// Neutrals are white, ...
setSide(simulation::Player::WHITE);
}
else {
// and everyone else is gray.
setSide(simulation::Player::GRAY);
}
setAttributeUpdateRequiredFlag(NetIO::FORCE_IDENTIFIER_AI, false);
}
}
setMode(simulation::Player::ACTIVE);
setTimeExec( (double) getNetIO()->getCurrentTime() );
}
