//------------------------------------------------------------------------------
// processBackgroundTasks() -- Process the background models and interfaces
//------------------------------------------------------------------------------
void Station::processBackgroundTasks(const LCreal dt)
{
// Note: interoperability networks are handled by
// processNetworkInputTasks() and processNetworkOutputTasks()
// The I/O handers
if (ioHandlers != 0) {
Basic::List::Item* item = ioHandlers ->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::IoHandler* p = (Basic::IoHandler*)( pair->object() );
p->updateData(dt);
item = item->getNext();
}
}
// Our simulation model
if (sim != 0) sim->updateData(dt);
// The OTW interfaces
if (otw != 0) {
Basic::List::Item* item = otw ->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Otw* p = (Otw*)( pair->object() );
p->updateData(dt);
item = item->getNext();
}
}
}
bool Arbiter::setSlotBehaviors(Basic::PairStream* const x)
{
bool ok = true;
// First, make sure they are all behaviors
{
Basic::List::Item* item = x->getFirstItem();
while (item != nullptr && ok) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
item = item->getNext();
Behavior* b = dynamic_cast<Behavior*>( pair->object() );
if (b == nullptr) {
// Item is NOT a behavior
std::cerr << "setSlotBehaviors: slot: " << *pair->slot() << " is NOT of a Behavior type!" << std::endl;
ok = false;
}
}
}
// next, add behaviors to our list
if (ok) {
Basic::List::Item* item = x->getFirstItem();
while (item != nullptr) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
item = item->getNext();
Behavior* b = static_cast<Behavior*>(pair->object());
addBehavior(b);
}
}
return ok;
}
//------------------------------------------------------------------------------
// setSlotNetworks() -- Set our list of networks
//------------------------------------------------------------------------------
bool Station::setSlotNetworks(Basic::PairStream* const a)
{
bool ok = true;
// Remove the old networks list
if (networks != 0) {
// we are no longer the container for these networks
for (Basic::List::Item* item = networks->getFirstItem(); item != 0; item = item->getNext()) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
NetIO* p = (NetIO*)( pair->object() );
p->container(0);
}
}
// Set our network list pointer
networks = a;
// Make sure the new network list is setup correctly
if (networks != 0) {
for (Basic::List::Item* item = networks->getFirstItem(); item != 0; item = item->getNext()) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
NetIO* p = dynamic_cast<NetIO*>( pair->object() );
if (p != 0) {
// We are this network's container
p->container(this);
}
else {
// Not of the proper type
std::cerr << "Player::setSlotNetworks: network at slot \"" << pair->slot() << "\" is not of class type NetIO" << std::endl;
ok = false;
}
}
}
return ok;
}
//------------------------------------------------------------------------------
// getSteerpoints() -- Get the route we're flying to (starting at 'to')
//------------------------------------------------------------------------------
unsigned int Route::getSteerpoints(Basic::safe_ptr<Steerpoint>* const stptList, const unsigned int max)
{
unsigned int i = 0;
Basic::PairStream* steerpoints = getComponents();
if (stptList != nullptr && max > 0 && steerpoints != nullptr) {
// Find our 'to' steerpoint
bool found = false;
Basic::List::Item* item = steerpoints->getFirstItem();
while (item != nullptr && !found) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
found = (pair == to);
if (!found) {
item = item->getNext();
}
}
// Get the route we're flying 'to'
while (item != nullptr && i < max) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
Steerpoint* p = dynamic_cast<Steerpoint*>(pair->object());
if (p != nullptr) {
stptList[i++] = p;
}
item = item->getNext();
}
}
if (steerpoints != nullptr) {
steerpoints->unref();
steerpoints = nullptr;
}
return i;
}
//------------------------------------------------------------------------------
// shutdownNotification() -- We're shutting down
//------------------------------------------------------------------------------
bool Station::shutdownNotification()
{
// Tell the interoperability networks that we're shutting down
if (networks != 0) {
Basic::List::Item* item = networks->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::Component* p = dynamic_cast<Basic::Component*>(pair->object());
p->event(SHUTDOWN_EVENT);
item = item->getNext();
}
}
setSlotNetworks(0);
// Tell the I/O devices that we're shutting down
if (ioHandlers != 0) {
Basic::List::Item* item = ioHandlers->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::Component* p = dynamic_cast<Basic::Component*>(pair->object());
p->event(SHUTDOWN_EVENT);
item = item->getNext();
}
}
setSlotIoHandler((Basic::PairStream*)0);
// Tell our simulation to shut down
Simulation* s = getSimulation();
if (s != 0) {
s->event(SHUTDOWN_EVENT);
}
setOwnshipPlayer(0);
// Inform our OTW interfaces
if (otw != 0) {
Basic::List::Item* item = otw ->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::Component* p = dynamic_cast<Basic::Component*>(pair->object());
p->event(SHUTDOWN_EVENT);
item = item->getNext();
}
}
setSlotOutTheWindow((Basic::PairStream*)0);
// Zero (unref) our thread objects (of any). The thread's functions have ref()'d
// these objects, so they won't be deleted until the threads terminate, which they
// will based on our BaseClass::isShutdown() function. But at least we won't
// mistakenly think that they're still around.
tcThread = 0;
netThread = 0;
bgThread = 0;
// remove the reset timer
setSlotStartupResetTime(0);
return BaseClass::shutdownNotification();
}
//------------------------------------------------------------------------------
// reset() -- Reset the station
//------------------------------------------------------------------------------
void Station::reset()
{
if (isMessageEnabled(MSG_INFO)) {
std::cout << "Station::reset()" << std::endl;
}
// Reset our major subsystems
if (sim != 0) sim->event(RESET_EVENT);
// ---
// Reset the ownship pointer
// ---
if (ownshipName != 0) {
setOwnshipByName( *ownshipName );
if (ownship == 0) {
// Ok, we had a list of players and an ownship player name, but still
// don't have an ownship pointer -- print an error message.
std::cerr << "Station::reset(): ownship not found: " << *ownshipName << std::endl;
}
}
// Reset the I/O Handlers
if (ioHandlers != 0) {
Basic::List::Item* item = ioHandlers ->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::IoHandler* p = (Basic::IoHandler*)( pair->object() );
p->event(RESET_EVENT);
item = item->getNext();
}
}
// Reset the OTW subsystems
if (otw != 0) {
Basic::List::Item* item = otw ->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Otw* p = (Otw*)( pair->object() );
p->event(RESET_EVENT);
item = item->getNext();
}
}
// Reset the networks
if (networks != 0) {
Basic::List::Item* item = networks ->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
NetIO* p = (NetIO*)( pair->object() );
p->event(RESET_EVENT);
item = item->getNext();
}
}
BaseClass::reset();
}
// Get the next free missile of type 'missileType'
Missile* SimpleStoresMgr::getSpecificMissile(const Basic::String* const missileType)
{
Missile* msl = 0;
if (missileType != 0) {
Basic::PairStream* list = getWeapons();
if (list != 0) {
// Find the first free (inactive) missile of type weaponType
Basic::List::Item* item = list->getFirstItem();
while (item != 0 && msl == 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Missile* p = dynamic_cast<Missile*>( pair->object() );
if (p != 0 && p->isInactive()) {
// Ok, we have a missile, but is it the type we want?
if (*p->getType() == *missileType) {
p->ref();
msl = p;
}
}
item = item->getNext();
}
list->unref();
}
}
return msl;
}
//-----------------------------------------------------------------------------
// reshape it function, for reshaping our subdisplays
//-----------------------------------------------------------------------------
void GlutDisplay::reshapeIt(int w, int h)
{
//std::cout << "reshapeIt() winID = " << winId;
//std::cout << "; size(" << w << ", " << h << ")";
//std::cout << std::endl;
// make sure we have a min height and width or our displays will get destroyed
if (w > 10 && h > 10) {
BaseClass::reshapeIt(w, h);
if (subDisplays() != nullptr && okToResize) {
// go through and put our new numbers in
Basic::List::Item* item = subDisplays()->getFirstItem();
while (item != nullptr) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
if (pair != nullptr) {
GlutDisplay* gd = dynamic_cast<GlutDisplay*>(pair->object());
if (gd != nullptr) gd->reshapeSubWindow();
}
item = item->getNext();
}
// Restore our window ID
glutSetWindow(this->getWindowId());
}
}
}
// Default external equipment jettison event handler
bool Stores::onJettisonEvent(ExternalStore* const sys)
{
bool ok = false;
if (sys != 0) {
Basic::PairStream* list = getStores();
if (list != 0) {
// First, make sure it's one of ours!
bool found = false;
Basic::List::Item* item = list->getFirstItem();
while (item != 0 && !found) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
found = (sys == pair->object()); // is it a match?
item = item->getNext();
}
if (found) {
// Send a jettison event to the system
ok = sys->event(JETTISON_EVENT);
}
list->unref();
list = 0;
}
}
return ok;
}
//-----------------------------------------------------------------------------
// createWindow() -- create the main window
//-----------------------------------------------------------------------------
int GlutDisplay::createWindow()
{
winId = -1;
#ifdef __FREEGLUT_EXT_H__ /* freeglut only */
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS);
#endif
unsigned int wmode = GLUT_DOUBLE | GLUT_RGB | GLUT_ALPHA;
if (getClearDepth() >= 0.0f) { wmode = wmode | GLUT_DEPTH; }
if (accumBuff) { wmode = wmode | GLUT_ACCUM; }
if (stencilBuff) { wmode = wmode | GLUT_STENCIL; }
glutInitDisplayMode( wmode );
GLint vpX(0), vpY(0); // our initial viewport position
GLsizei vpWidth(0), vpHeight(0); // our initial viewport size
getViewport(&vpX, &vpY, &vpWidth, &vpHeight);
glutInitWindowPosition(vpX, vpY);
glutInitWindowSize(vpWidth, vpHeight);
winId = glutCreateWindow(getName());
if (winId > 0) {
if (isMessageEnabled(MSG_INFO)) {
std::cout << "GlutDisplay::createWindow() name = " << getName() << ", winId = " << winId << std::endl;
}
// Configure the new window
if (fullScreenFlg) glutFullScreen();
glutDisplayFunc(drawFuncCB);
glutReshapeFunc(reshapeItCB);
glutIdleFunc(idleCB);
glutPassiveMotionFunc(passiveMotionFuncCB);
glutMotionFunc(motionFuncCB);
glutKeyboardFunc(keyboardFuncCB);
glutSpecialFunc(specialFuncCB);
glutMouseFunc(mouseFuncCB);
glutEntryFunc(entryFuncCB);
registerGlutDisplay(winId, this);
glutSetWindow(winId);
configure();
loadTextures();
// Create sub windows (if any)
if (subDisplays() != nullptr) {
Basic::List::Item* item = subDisplays()->getFirstItem();
while (item != nullptr) {
Basic::Pair* pair = dynamic_cast<Basic::Pair*>(item->getValue());
if (pair != nullptr) {
GlutDisplay* dobj = dynamic_cast<GlutDisplay*>( pair->object() );
if (dobj != nullptr) dobj->createSubWindow(winId);
}
item = item->getNext();
}
}
// Select this window
select();
}
return winId;
}
// Get the next free weapon of this 'type'
Weapon* SimpleStoresMgr::getSpecificWeapon(const std::type_info& type)
{
Weapon* wpn = 0;
if (&type != 0) {
Basic::PairStream* list = getWeapons();
if (list != 0) {
// Find the first free (inactive) bomb
Basic::List::Item* item = list->getFirstItem();
while (item != 0 && wpn == 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Weapon* p = dynamic_cast<Weapon*>( pair->object() );
if (p != 0 && p->isInactive() && p->isClassType(type)) {
p->ref();
wpn = p;
}
item = item->getNext();
}
list->unref();
}
}
return wpn;
}
// Puts a state on to the 'open' list
void Puzzle::putOpen(State* const s)
{
if (openStates == nullptr) {
// create the list (as needed)
openStates = new Basic::List();
}
if (s != nullptr) {
// Create a new list item for this state and get the state's f() value
Basic::List::Item* newItem = new Basic::List::Item();
newItem->value = s;
s->ref();
int f = s->f();
// Find where in the list to insert this new state (based on their f() values)
Basic::List::Item* item = openStates->getFirstItem();
Basic::List::Item* refItem = nullptr;
while (item != nullptr && refItem == nullptr) {
const State* p = static_cast<const State*>( item->getValue() );
if (f < p->f()) {
refItem = item;
}
item = item->getNext();
}
// Insert our new state
openStates->insert(newItem, refItem);
}
}
//------------------------------------------------------------------------------
// updateData()
//------------------------------------------------------------------------------
void Instrument::updateData(const LCreal dt)
{
// update our base class
BaseClass::updateData(dt);
// check for a color rotary, just in case we need one
BasicGL::ColorRotary* cr = dynamic_cast<BasicGL::ColorRotary*>(getColor());
if (cr != 0) cr->determineColor(preScaleInstVal);
// only tell the rest of our instruments our value if we want them to know it
if (allowPassing) {
// sort out the instruments from our components
Basic::PairStream* ps = getComponents();
if (ps != 0) {
Basic::List::Item* item = ps->getFirstItem();
while(item != 0) {
Basic::Pair* pair = (Basic::Pair*) item->getValue();
if (pair != 0) {
// send the value down to all of our instrument components
Instrument* myInst = dynamic_cast<Instrument*>(pair->object());
Basic::Number n = preScaleInstVal;
if (myInst != 0) myInst->event(UPDATE_INSTRUMENTS, &n);
}
item = item->getNext();
}
ps->unref();
ps = 0;
}
}
}
// Get the next free bomb of type 'bombType'
Bomb* SimpleStoresMgr::getSpecificBomb(const Basic::String* const bombType)
{
Bomb* bomb = 0;
if (bombType != 0) {
Basic::PairStream* list = getWeapons();
if (list != 0) {
// Find the first free (inactive) bomb
Basic::List::Item* item = list->getFirstItem();
while (item != 0 && bomb == 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Bomb* p = dynamic_cast<Bomb*>( pair->object() );
if (p != 0 && p->isInactive()) {
// Ok, we have a bomb, but is it the type we want?
if (*p->getType() == *bombType) {
p->ref();
bomb = p;
}
}
item = item->getNext();
}
list->unref();
}
}
return bomb;
}
//------------------------------------------------------------------------------
// Set slot functions
//------------------------------------------------------------------------------
bool StoresMgr::setSlotStores(const Basic::PairStream* const msg)
{
// First let our base class do everything that it needs to.
BaseClass::setSlotStores(msg);
// ---
// Clear all previous stores and assigned weapons
// ---
weaponsList = 0;
externalList = 0;
fuelList = 0;
gunPtr = 0;
// ---
// Use the stores list that the Stores class just processed.
Basic::PairStream* stores = getStores();
if (stores != 0){
// Create the new weapons list that contains all weapons
{
Basic::PairStream* newWeapons = new Basic::PairStream();
searchAndAdd(stores, typeid(Weapon), newWeapons);
if (newWeapons->entries() > 0) weaponsList = newWeapons;
newWeapons->unref();
}
// Create the new external stores list that contains all
// non-weapon, external stores (e.g., fuel tanks, pods, guns)
{
Basic::PairStream* newExternal = new Basic::PairStream();
searchAndAdd(stores, typeid(ExternalStore), newExternal);
if (newExternal->entries() > 0) externalList = newExternal;
newExternal->unref();
}
// Create the new fuel tank list that contains all fuel tanks
{
Basic::PairStream* newFuel = new Basic::PairStream();
searchAndAdd(stores, typeid(FuelTank), newFuel);
if (newFuel->entries() > 0) fuelList = newFuel;
newFuel->unref();
}
// Find the primary gun; i.e., the first gun found on our stores
Basic::List::Item* item = stores->getFirstItem();
while (item != 0 && gunPtr == 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Gun* p = dynamic_cast<Gun*>( pair->object() );
if (p != 0) gunPtr = p;
item = item->getNext();
}
stores->unref();
stores = 0;
}
return true;
}
//------------------------------------------------------------------------------
// Compute nav steering data for each steerpoint.
//------------------------------------------------------------------------------
void Route::computeSteerpointData(const LCreal, const Navigation* const nav)
{
if (nav != nullptr) {
Basic::PairStream* steerpoints = getComponents();
if (steerpoints != nullptr) {
// Until we pass the 'to' steerpoint, the 'from' pointer will be
// null(0) and the steerpoint's compute() function will compute
// direct-to the steerpoint. After the 'to' steerpoint, the 'from'
// pointer will help compute each from-to leg of the route.
Steerpoint* from = nullptr;
Basic::List::Item* item = steerpoints->getFirstItem();
while (item != nullptr) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
Steerpoint* stpt = static_cast<Steerpoint*>(pair->object());
stpt->compute(nav,from);
if (pair == to || from != nullptr) from = stpt;
item = item->getNext();
}
steerpoints->unref();
steerpoints = nullptr;
}
}
}
// Default weapon jettison event handler
bool Stores::onJettisonEvent(Weapon* const wpn)
{
bool ok = false;
if (wpn != nullptr) {
Basic::PairStream* list = getStores();
if (list != nullptr) {
// First, make sure it's one of ours!
bool found = false;
Basic::List::Item* item = list->getFirstItem();
while (item != nullptr && !found) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
found = (wpn == pair->object()); // is it a match?
item = item->getNext();
}
if (found) {
// Send a jettison event to the weapon
ok = wpn->event(JETTISON_EVENT);
}
list->unref();
list = nullptr;
}
}
return ok;
}
//------------------------------------------------------------------------------
// mapPlayers2ElevTable() - Map the player list to the model table
//------------------------------------------------------------------------------
void Otw::mapPlayers2ElevTable()
{
// Set all entries as unciecked
for (unsigned int i = 0; i < getElevationTableSize(); i++) {
hotTbl[i]->setCheckedFlag(false);
}
// When we have a player list ...
if (playerList != 0) {
// ---
// Find players that are alive and require terrain elevation from the visual system ...
// ---
Basic::List::Item* item = playerList->getFirstItem();
while (item != 0) {
// Get a pointer to the player, 'p'
Basic::Pair* pair = dynamic_cast<Basic::Pair*>(item->getValue());
Player* p = (Player*) pair->object();
// Check if this player is alive and within range.
if ( p->isActive() && p->isTerrainElevationRequired() ) {
// Check if in-range
bool inRange = computeRangeToPlayer(p) <= maxRange;
if (inRange) {
// Find the player's model entry (if any)
OtwModel* model = findModel(p, HOT_TABLE);
if (model != 0) {
// The player has a valid entry.
model->incReqCount();
}
else {
// Player doesn't have an entry, so create one.
model = newElevEntry(p);
}
if (model != 0) model->setCheckedFlag(true);
}
}
//completed = p->isNetworkedPlayer();
item = item->getNext(); // Next player
}
}
// ---
// Remove unmatched model entries; their players are inactive or no longer
// require terrain elevation
// ---
for (int i = getElevationTableSize(); i > 0; --i) {
if ( hotTbl[i-1]->isNotChecked() ) {
// Deleting this entry
removeModelFromList( (i-1), HOT_TABLE);
}
}
}
//------------------------------------------------------------------------------
// stepOwnshipPlayer() -- Step to the next local player
//------------------------------------------------------------------------------
void SimStation::stepOwnshipPlayer()
{
Basic::PairStream* pl = getSimulation()->getPlayers();
if (pl != nullptr) {
Simulation::Player* f = nullptr;
Simulation::Player* n = nullptr;
bool found = false;
// Find the next player
Basic::List::Item* item = pl->getFirstItem();
while (item != nullptr) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
if (pair != nullptr) {
Simulation::Player* ip = static_cast<Simulation::Player*>(pair->object());
if ( ip->isMode(Simulation::Player::ACTIVE) &&
ip->isLocalPlayer() &&
ip->isClassType(typeid(Simulation::AirVehicle))
) {
if (f == nullptr) { f = ip; } // Remember the first
if (found) { n = ip; ; break; }
if (ip == getOwnship()) found = true;
}
}
item = item->getNext();
}
if (found && n == nullptr) n = f;
if (n != nullptr) setOwnshipPlayer(n);
pl->unref();
}
}
bool Station::setSlotOutTheWindow(Basic::PairStream* const list)
{
Basic::PairStream* newList = 0;
// Make sure the new list only has OTW type objects
if (list != 0) {
for (Basic::List::Item* item = list->getFirstItem(); item != 0; item = item->getNext()) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Otw* p = dynamic_cast<Otw*>( pair->object() );
if (p != 0) {
if (newList == 0) {
newList = new Basic::PairStream();
}
newList->put(pair); // Add this OTW to our new OTW list
p->container(this);
}
else if (isMessageEnabled(MSG_WARNING)) {
// Not of the proper type
std::cerr << "Player::setOutTheWindow: OTW at slot \"" << pair->slot() << "\" is not of type Otw" << std::endl;
}
}
}
// Remove the old OTW interfaces
if (otw != 0) {
SPtr<Basic::PairStream> oldList( otw );
otw = 0;
// we are no longer the container for these old OTW interfaces
for (Basic::List::Item* item = oldList->getFirstItem(); item != 0; item = item->getNext()) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Component* p = (Component*)( pair->object() );
p->container(0);
}
}
// Set the pointer to the list of OTW interfaces
otw = newList;
return true;
}
//------------------------------------------------------------------------------
// outputDevices() -- Process station hardware outputs
//------------------------------------------------------------------------------
void Station::outputDevices(const LCreal dt)
{
if (ioHandlers != 0) {
Basic::List::Item* item = ioHandlers ->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::IoHandler* p = (Basic::IoHandler*)( pair->object() );
p->outputDevices(dt);
item = item->getNext();
}
}
}
//------------------------------------------------------------------------------
// resetStores() -- Reset all stores
//------------------------------------------------------------------------------
void Stores::resetStores(Basic::PairStream* const list)
{
// Reset the external stores
if (list != 0) {
Basic::List::Item* item = list->getFirstItem();
while (item != 0) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
Basic::Component* p = static_cast<Basic::Component*>( pair->object() );
p->event(RESET_EVENT);
item = item->getNext();
}
}
}
//------------------------------------------------------------------------------
// setOwnshipPlayer() -- set this player as our ownship
//------------------------------------------------------------------------------
bool Station::setOwnshipPlayer(Player* const newOS)
{
// Is it already own ownship? Yes, then nothing else to do.
if (newOS == ownship) return true;
// When we're just setting a null(0) ownship ...
if (newOS == 0) {
// Unref the old player
if (ownshipName != 0) { ownshipName->unref(); ownshipName = 0; }
if (ownship != 0) {
ownship->event(ON_OWNSHIP_DISCONNECT);
ownship->unref();
ownship = 0;
}
return true;
}
// Look for this ownship in our list of players
bool set = false;
Basic::PairStream* pl = sim->getPlayers();
if (pl != 0) {
Basic::List::Item* item = pl->getFirstItem();
while (item != 0 && !set) {
Basic::Pair* pair = dynamic_cast<Basic::Pair*>(item->getValue());
if (pair != 0) {
Player* ip = dynamic_cast<Player*>( pair->object() );
if (ip == newOS && ip->isLocalPlayer()) {
// Unref the old stuff
if (ownshipName != 0) { ownshipName->unref(); ownshipName = 0; }
if (ownship != 0) {
ownship->event(ON_OWNSHIP_DISCONNECT);
ownship->unref();
ownship = 0;
}
// Ok, we found the player -- make it our ownship
ownship = newOS;
ownship->ref();
ownshipName = pair->slot();
ownshipName->ref();
ownship->event(ON_OWNSHIP_CONNECT);
set = true;
}
}
item = item->getNext();
}
pl->unref();
pl = 0;
}
return set;
}
//------------------------------------------------------------------------------
// reset() -- Reset parameters
//------------------------------------------------------------------------------
void Page::reset()
{
BaseClass::reset();
if (subpages != 0) {
// Reset all of our sub-pages
Basic::List::Item* item = subpages->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Component* obj = (Component*)( pair->object() );
if (obj != 0) obj->reset();
item = item->getNext();
}
}
}
//------------------------------------------------------------------------------
// processNetworkOutputTasks() -- Process network output tasks
//------------------------------------------------------------------------------
void Station::processNetworkOutputTasks(const LCreal dt)
{
Basic::Object::SPtr<Basic::PairStream> networks( getNetworks() );
if (networks != 0) {
Basic::List::Item* item = networks->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
NetIO* p = (NetIO*)( pair->object() );
p->outputFrame( dt );
item = item->getNext();
}
}
}
bool Station::setSlotIoHandler(Basic::PairStream* const list)
{
bool ok = true;
// Remove the old list
if (ioHandlers != 0) {
// we are no longer the container for these handlers
for (Basic::List::Item* item = ioHandlers->getFirstItem(); item != 0; item = item->getNext()) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::Component* p = (Basic::Component*)( pair->object() );
p->container(0);
}
ioHandlers = 0;
}
// Set our list pointer
ioHandlers = list;
// Make sure the new list is setup correctly
if (ioHandlers != 0) {
for (Basic::List::Item* item = ioHandlers->getFirstItem(); item != 0; item = item->getNext()) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::IoHandler* p = dynamic_cast<Basic::IoHandler*>( pair->object() );
if (p != 0) {
// We are its container
p->container(this);
}
else {
// Not of the proper type
std::cerr << "Player::setSlotIoHandler: Slot \"" << pair->slot() << "\" is not of type Basic::IoHandler" << std::endl;
ok = false;
}
}
}
return ok;
}
//------------------------------------------------------------------------------
// Default function to jettison all jettisonable stores
//------------------------------------------------------------------------------
bool Stores::jettisonAll()
{
// Notify the external stores that we're shutting down
Basic::PairStream* list = getStores();
if (list != 0) {
Basic::List::Item* item = list->getFirstItem();
while (item != 0) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
Basic::Component* p = static_cast<Basic::Component*>( pair->object() );
p->event(JETTISON_EVENT);
item = item->getNext();
}
list->unref();
list = 0;
}
return true;
}
//------------------------------------------------------------------------------
// updateData() -- update non-time critical stuff here
//------------------------------------------------------------------------------
void Stores::updateData(const LCreal dt)
{
// Update our non-weapon, external stores, which need to act as
// active systems attached to our ownship player.
{
Basic::PairStream* list = getStores();
if (list != 0) {
Basic::List::Item* item = list->getFirstItem();
while (item != 0) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
ExternalStore* p = dynamic_cast<ExternalStore*>( pair->object() );
if (p != 0) p->updateData(dt);
item = item->getNext();
}
list->unref();
list = 0;
}
}
BaseClass::updateData(dt);
}
//------------------------------------------------------------------------------
// shutdownNotification() -- We're shutting down
//------------------------------------------------------------------------------
bool StoresMgr::shutdownNotification()
{
// Notify the external stores that we're shutting down
Basic::PairStream* list = getStores();
if (list != 0) {
Basic::List::Item* item = list->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::Component* p = (Basic::Component*)( pair->object() );
p->event(SHUTDOWN_EVENT);
item = item->getNext();
}
list->unref();
list = 0;
}
// Clear our stores
setSlotStores(0);
return BaseClass::shutdownNotification();
}
bool Table::setSlotColumns(Basic::PairStream* const msg)
{
if (columns != 0) { columns->unref(); columns = 0; }
if (msg != 0) {
// Make a copy of the list and Make sure we have only Field objexts
Basic::PairStream* newColumns = new Basic::PairStream();
Basic::List::Item* item = msg->getFirstItem();
while (item != 0) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
BasicGL::Field* g = dynamic_cast<BasicGL::Field*>(pair->object());
if (g != 0) {
// We have a Field object, so add it to the new columns list
newColumns->put(pair);
}
item = item->getNext();
}
columns = newColumns;
}
build();
return true;
}