#include <star_system_generic.h>

Inheritance diagram for StarSystem:

Classes
struct	StarXML
	Starsystem XML Struct For use with XML loading. More...

struct	Statistics

Public Member Functions
	StarSystem ()

	StarSystem (const char *filename, const Vector &centroid=Vector(0, 0, 0), const float timeofyear=0)

virtual	~StarSystem ()

void	SetZone (unsigned int zonenum)

unsigned int	GetZone ()

virtual void	AddMissileToQueue (class MissileEffect *)

virtual void	UpdateMissiles ()

void	UpdateUnitPhysics (bool firstframe)

void	RequestPhysics (Unit *un, unsigned int queue)
	Requeues the unit so that it is simulated ASAP. More...

virtual void	activateLightMap (int stage=1)

virtual Texture *	getLightMap ()

virtual unsigned int	numTerrain ()
	activates the light map texture More...

virtual unsigned int	numContTerrain ()

virtual void	Draw (bool DrawCockpit=true)
	Draws a frame of action, interpolating between physics frames. More...

void	Update (float priority, bool executeDirector)
	update a simulation atom ExecuteDirector must be false if star system is just loaded before mission is loaded More...

void	Update (float priority)

virtual void	SwapIn ()
	re-enables the included lights and terrains More...

virtual void	SwapOut ()
	Disables included lights and terrains. More...

virtual Terrain *	getTerrain (unsigned int which)

virtual ContinuousTerrain *	getContTerrain (unsigned int which)

virtual Background *	getBackground ()

virtual ClickList *	getClickList ()

unsigned int	getCurrentSimFrame () const
	Gets the current simulation frame. More...

void	ExecuteUnitAI ()

std::string	getFileName () const

std::string	getName ()

UnitCollection &	getUnitList ()
	Loads the star system from an XML file. More...

UnitCollection &	gravitationalUnits ()

Unit *	nextSignificantUnit ()

void	AddUnit (Unit *unit)

bool	RemoveUnit (Unit *unit)
	Removes from draw list. More...

bool	JumpTo (Unit unit, Unit jumppoint, const std::string &system, bool force=false, bool save_coordinates=false)

virtual void	VolitalizeJumpAnimation (const int ani)

virtual void	DoJumpingComeSightAndSound (Unit *un)

virtual int	DoJumpingLeaveSightAndSound (Unit *un)

virtual void	createBackground (StarSystem::StarXML *xml)

Static Public Member Functions
static void	beginElement (void userData, const XML_Char name, const XML_Char **atts)

static void	endElement (void userData, const XML_Char name)

static void	ProcessPendingJumps ()

Public Attributes
struct StarSystem::Statistics	stats

std::multimap< Unit , Unit >	last_collisions

class CollideTable *	collidetable

CollideMap *	collidemap [2]

class bolt_draw *	bolts

Protected Types
enum	PHYSICS_STAGE { MISSION_SIMULATION, PROCESS_UNIT, PHY_NUM }
	Physics is divided into 3 stages spread over 3 frames. More...

Protected Member Functions
void	LoadXML (const char *, const Vector &centroid, const float timeofyear)

void	beginElement (const std::string &name, const AttributeList &attributes)

void	endElement (const std::string &name)

void	AddStarsystemToUniverse (const std::string &filename)
	The Light Map corresponding for the BP for spheremapping. More...

void	RemoveStarsystemFromUniverse ()

Protected Attributes
struct StarSystem::StarXML *	xml

enum StarSystem::PHYSICS_STAGE	current_stage

std::vector< Terrain * >	terrains
	Stars, planets, etc. Orbital mechanics precalculated. More...

std::vector< ContinuousTerrain * >	contterrains

UnitCollection	drawList
	Everything to be drawn. Folded missiles in here oneday. More...

UnitCollection	GravitationalUnits

UnitCollection	physics_buffer [SIM_QUEUE_SIZE+1]

unsigned int	current_sim_location

unsigned char	no_collision_time
	Objects subject to global gravitron physics (disabled) More...

char *	name
	system name More...

std::string	filename

un_iter	sigIter

double	time
	to track the next given physics frame More...

Stars *	stars
	The background associated with this system. More...

int	lightcontext

std::vector< class MissileEffect * >	dischargedMissiles

unsigned int	zone

Friends
class	Universe

Detailed Description

Definition at line 53 of file star_system_generic.h.

Member Enumeration Documentation

enum StarSystem::PHYSICS_STAGE

protected

Physics is divided into 3 stages spread over 3 frames.

Enumerator
MISSION_SIMULATION
PROCESS_UNIT
PHY_NUM

Definition at line 113 of file star_system_generic.h.

113 {MISSION_SIMULATION, PROCESS_UNIT, PHY_NUM}

Constructor & Destructor Documentation

StarSystem::StarSystem ( )

adds to jumping table;

Definition at line 73 of file star_system_generic.cpp.

References bolts, collidemap, collidetable, UnitCollection::createIterator(), current_sim_location, current_stage, drawList, MISSION_SIMULATION, name, no_collision_time, sigIter, stars, time, Unit::UNIT_BOLT, Unit::UNIT_ONLY, and zone.

Referenced by Universe::GenerateStarSystem().

 {
     stars = NULL;
     bolts = NULL;
     collidetable = NULL;
     collidemap[Unit::UNIT_ONLY] = new CollideMap( Unit::UNIT_ONLY );
     collidemap[Unit::UNIT_BOLT] = new CollideMap( Unit::UNIT_BOLT );
 
     no_collision_time = 0;               //(int)(1+2.000/SIMULATION_ATOM);
     name = NULL;
     current_stage = MISSION_SIMULATION;
     time    = 0;
     zone    = 0;
     sigIter = drawList.createIterator();
     this->current_sim_location = 0;
 }

StarSystem::StarSystem	(	const char *	filename,
		const Vector &	centroid = `Vector( 0, 0, 0 )`,
		const float	timeofyear = `0`
	)

adds to jumping table;

Definition at line 91 of file star_system_generic.cpp.

References _Universe, AddStarsystemToUniverse(), bolts, collidemap, collidetable, UnitCollection::createIterator(), current_sim_location, current_stage, drawList, filename, LoadXML(), MISSION_SIMULATION, name, no_collision_time, Universe::popActiveStarSystem(), Universe::pushActiveStarSystem(), sigIter, time, Unit::UNIT_BOLT, Unit::UNIT_ONLY, and zone.

 {
     no_collision_time = 0;               //(int)(1+2.000/SIMULATION_ATOM);
     collidemap[Unit::UNIT_ONLY] = new CollideMap( Unit::UNIT_ONLY );
     collidemap[Unit::UNIT_BOLT] = new CollideMap( Unit::UNIT_BOLT );
 
     this->current_sim_location  = 0;
     name  = NULL;
     zone  = 0;
     _Universe->pushActiveStarSystem( this );
     bolts = new bolt_draw;
     collidetable   = new CollideTable( this );
     current_stage  = MISSION_SIMULATION;
     this->filename = filename;
     LoadXML( filename, centr, timeofyear );
     if (!name)
         name = strdup( filename );
     sigIter = drawList.createIterator();
     AddStarsystemToUniverse( filename );
 
     time = 0;
     _Universe->popActiveStarSystem();
 }

StarSystem::~StarSystem ( )

virtual

Definition at line 117 of file star_system_generic.cpp.

References _Universe, Universe::activeStarSystem(), ClientServerSetLightContext(), collidemap, collidetable, UnitCollection::createIterator(), drawList, fprintf, getFileName(), Universe::getNumActiveStarSystem(), Unit::Kill(), lightcontext, name, Universe::popActiveStarSystem(), Universe::pushActiveStarSystem(), RemoveStarsystemFromUniverse(), SwapIn(), SwapOut(), Unit::UNIT_BOLT, and Unit::UNIT_ONLY.

 {
     if ( _Universe->getNumActiveStarSystem() )
         _Universe->activeStarSystem()->SwapOut();
     _Universe->pushActiveStarSystem( this );
     ClientServerSetLightContext( lightcontext );
     delete[] name;
     Unit *unit;
     for (un_iter iter = drawList.createIterator(); (unit = *iter); ++iter)
         unit->Kill( false );
     //if the next line goes ANYWHERE else Vega Strike will CRASH!!!!!
     //DO NOT MOVE THIS LINE! IT MUST STAY
     if (collidetable) delete collidetable;
     _Universe->popActiveStarSystem();
     vector< StarSystem* >activ;
     while ( _Universe->getNumActiveStarSystem() ) {
         if (_Universe->activeStarSystem() != this)
             activ.push_back( _Universe->activeStarSystem() );
         else
             fprintf( stderr, "Avoided fatal error in deleting star system %s\n", getFileName().c_str() );
         _Universe->popActiveStarSystem();
     }
     while ( activ.size() ) {
         _Universe->pushActiveStarSystem( activ.back() );
         activ.pop_back();
     }
     if ( _Universe->getNumActiveStarSystem() )
         _Universe->activeStarSystem()->SwapIn();
     RemoveStarsystemFromUniverse();
     delete collidemap[Unit::UNIT_ONLY];
     delete collidemap[Unit::UNIT_BOLT];
 }

Member Function Documentation

virtual void StarSystem::activateLightMap ( int stage = 1)

inlinevirtual

Reimplemented in GameStarSystem.

Definition at line 163 of file star_system_generic.h.

Referenced by GameUniverse::activateLightMap(), and RestoreFirstPassState().

163 {}

void StarSystem::AddMissileToQueue ( class MissileEffect * me)

virtual

Definition at line 67 of file missile_generic.cpp.

References dischargedMissiles.

Referenced by Missile::Discharge(), and GameUnit< UnitType >::Explode().

 {
     dischargedMissiles.push_back( me );
 }

void StarSystem::AddStarsystemToUniverse ( const std::string & filename)

protected

The Light Map corresponding for the BP for spheremapping.

Definition at line 775 of file star_system_generic.cpp.

References Hashtable< KEY, VALUE, SIZ >::Put().

Referenced by GameStarSystem::GameStarSystem(), and StarSystem().

 {
     star_system_table.Put( mname, this );
 }

void StarSystem::AddUnit ( Unit * unit)

returns xy sorted bounding spheres of all units in current view Adds to draw list

Definition at line 230 of file star_system_generic.cpp.

References Unit::activeStarSystem, StarSystem::Statistics::AddUnit(), ASTEROIDPTR, UnitFactory::broadcastUnit(), StarSystem::Statistics::CheckVitals(), UnitCollection::createIterator(), current_sim_location, drawList, VSRandom::genrand_int32(), FactionUtil::GetNeutralFaction(), UnitUtil::getPhysicsPriority(), GetZone(), gravitationalUnits(), i, int, Unit::isJumppoint(), Unit::isPlanet(), Unit::isUnit(), physics_buffer, UnitCollection::prepend(), SIM_QUEUE_SIZE, Unit::specInterdiction, stats, StarSystem::Statistics::system_faction, and vsrandom.

Referenced by ZoneMgr::addClient(), NetClient::AddClientObject(), AddUnitToSystem(), buyShip(), Mission::call_unit_launch(), StarSystem::Statistics::CheckVitals(), createObjects(), Unit::EjectCargo(), LoadMission(), LoadXML(), Mount::PhysicsAlignedFire(), NetClient::Respawn(), Unit::TransferUnitToSystem(), and Cockpit::Update().

 {
     if ( stats.system_faction == FactionUtil::GetNeutralFaction() )
         stats.CheckVitals( this );
     if (unit->specInterdiction > 0 || unit->isPlanet() || unit->isJumppoint() || unit->isUnit() == ASTEROIDPTR) {
         Unit *un;
         bool  found = false;
         for (un_iter i = gravitationalUnits().createIterator();
              (un = *i) != NULL;
              ++i)
             if (un == unit) {
                 found = true;
                 break;
             }
         if (!found)
             gravitationalUnits().prepend( unit );
     }
     drawList.prepend( unit );
     unit->activeStarSystem = this;     //otherwise set at next physics frame...
     UnitFactory::broadcastUnit( unit, GetZone() );
     unsigned int priority = UnitUtil::getPhysicsPriority( unit );
     //Do we need the +1 here or not - need to look at when current_sim_location is changed relative to this function
     //and relative to this function, when the bucket is processed...
     unsigned int tmp = 1+( (unsigned int) vsrandom.genrand_int32() )%priority;
     this->physics_buffer[(this->current_sim_location+tmp)%SIM_QUEUE_SIZE].prepend( unit );
     stats.AddUnit( unit );
 }

void StarSystem::beginElement	(	const std::string &	name,
		const AttributeList &	attributes
	)

protected

Referenced by LoadXML().

void StarSystem::beginElement	(	void *	userData,
		const XML_Char *	name,
		const XML_Char **	atts
	)

static

Definition at line 209 of file star_system_generic.cpp.

 {
     ( (StarSystem*) userData )->beginElement( name, AttributeList( atts ) );
 }

virtual void StarSystem::createBackground ( StarSystem::StarXML * xml)

inlinevirtual

Reimplemented in GameStarSystem.

Definition at line 242 of file star_system_generic.h.

Referenced by LoadXML().

242 {}

virtual void StarSystem::DoJumpingComeSightAndSound ( Unit * un)

inlinevirtual

Reimplemented in GameStarSystem.

Definition at line 236 of file star_system_generic.h.

Referenced by ProcessPendingJumps().

236 {}

virtual int StarSystem::DoJumpingLeaveSightAndSound ( Unit * un)

inlinevirtual

Reimplemented in GameStarSystem.

Definition at line 237 of file star_system_generic.h.

Referenced by JumpTo().

     {
         return -1;
     }

virtual void StarSystem::Draw ( bool DrawCockpit = true)

inlinevirtual

Draws a frame of action, interpolating between physics frames.

Reimplemented in GameStarSystem.

Definition at line 178 of file star_system_generic.h.

Referenced by GameUniverse::StartDraw().

178 {}

void StarSystem::endElement ( const std::string & name)

protected

Referenced by LoadXML().

void StarSystem::endElement	(	void *	userData,
		const XML_Char *	name
	)

static

Definition at line 214 of file star_system_generic.cpp.

 {
     ( (StarSystem*) userData )->endElement( name );
 }

void StarSystem::ExecuteUnitAI ( )

Definition at line 300 of file star_system_generic.cpp.

References Unit::ExecuteAI(), getUnitList(), and Unit::ResetThreatLevel().

 {
     try {
         Unit *unit = NULL;
         for (un_iter iter = getUnitList().createIterator(); (unit = *iter); ++iter) {
             unit->ExecuteAI();
             unit->ResetThreatLevel();
         }
     }
     catch (const boost::python::error_already_set) {
         if ( PyErr_Occurred() ) {
             PyErr_Print();
             PyErr_Clear();
             fflush( stderr );
             fflush( stdout );
         } throw;
     }
 }

virtual Background* StarSystem::getBackground ( )

inlinevirtual

Reimplemented in GameStarSystem.

Definition at line 195 of file star_system_generic.h.

Referenced by CockpitKeys::Inside(), NetClient::Respawn(), and Cockpit::Update().

     {
         return NULL;
     }

virtual ClickList* StarSystem::getClickList ( )

inlinevirtual

Reimplemented in GameStarSystem.

Definition at line 199 of file star_system_generic.h.

Referenced by createObjects().

     {
         return NULL;
     }

virtual ContinuousTerrain* StarSystem::getContTerrain ( unsigned int which)

inlinevirtual

Reimplemented in GameStarSystem.

Definition at line 191 of file star_system_generic.h.

Referenced by createObjects().

     {
         return NULL;
     }

unsigned int StarSystem::getCurrentSimFrame ( ) const

inline

Gets the current simulation frame.

Definition at line 204 of file star_system_generic.h.

References current_sim_location.

Referenced by GameStarSystem::Draw(), GameUnit< UnitType >::Draw(), UnitDrawer::draw(), Unit::UpdatePhysics(), and Unit::UpdateSubunitPhysics().

     {
         return current_sim_location;
     }

string StarSystem::getFileName ( ) const

Definition at line 220 of file star_system_generic.cpp.

References filename, getStarSystemName(), getStarSystemSector(), and RemoveDotSystem().

Referenced by StarSystem::Statistics::CheckVitals(), ChooseNavPoint(), CompareDest(), CreateCargoForOwnerStarship(), ZoneInfo::display(), GameCockpit::Draw(), NavigationSystem::DrawSystem(), Universe::Generate2(), NavigationSystem::getCurrentSystem(), NavigationSystem::getDestinationSystem(), NavigationSystem::getFocusedSystem(), SaveNetUtil::GetSaveStrings(), NavigationSystem::getSelectedSystem(), UnitUtil::getUnitSystemFile(), JumpTo(), sellShip(), NetServer::sendJump(), NetServer::sendNewUnitQueue(), NavigationSystem::Setup(), SwapInNewShipName(), Unit::Target(), Unit::TransferUnitToSystem(), Cockpit::Update(), Unit::UpdatePhysics(), WarpPursuit(), GameUniverse::WriteSaveGame(), WriteSaveGame(), and ~StarSystem().

 {
     return getStarSystemSector( filename )+string( "/" )+RemoveDotSystem( getStarSystemName( filename ).c_str() );
 }

virtual Texture* StarSystem::getLightMap ( )

inlinevirtual

Reimplemented in GameStarSystem.

Definition at line 164 of file star_system_generic.h.

Referenced by GameUniverse::getLightMap().

     {
         return NULL;
     }

string StarSystem::getName ( )

Definition at line 225 of file star_system_generic.cpp.

References name.

Referenced by ZoneMgr::displayStats(), NavigationSystem::DrawSystem(), and Universe::getStarSystem().

 {
     return string( name );
 }

virtual Terrain* StarSystem::getTerrain ( unsigned int which)

inlinevirtual

Reimplemented in GameStarSystem.

Definition at line 187 of file star_system_generic.h.

Referenced by createObjects().

     {
         return NULL;
     }

UnitCollection& StarSystem::getUnitList ( )

inline

Loads the star system from an XML file.

Definition at line 219 of file star_system_generic.h.

References drawList.

Referenced by AllUnitsCloseAndEngage(), Arrested(), Unit::AutoPilotToErrorMessage(), ZoneMgr::broadcastDamage(), ZoneMgr::broadcastSnapshots(), StarSystem::Statistics::CheckVitals(), ChooseNearNavPoint(), ChooseTargets(), Terrain::Collide(), compute_light_dot(), ZoneInfo::display(), DockToSavedBases(), DoDockingOps(), FireKeyboard::Execute(), ExecuteUnitAI(), findUnitInStarsystem(), getAtmospheric(), getNearestTarget(), getNearestTargetUnit(), GetThreat(), ZoneMgr::getUnit(), ZoneMgr::getZoneBuffer(), HelpOut(), KillDuplicateUnits(), Unit::ReTargetFg(), UniverseUtil::SafeStarSystemEntrancePoint(), Orders::FormUpToOwner::SetParent(), UniverseUtil::StopTargettingEachOther(), Unit::Target(), UniverseUtil::TargetEachOther(), GameUnit< UnitType >::TransferUnitToSystem(), UnDockNow(), Atmosphere::Update(), Cockpit::Update(), Cockpit::updateAttackers(), UpdateMissiles(), and UpdateUnitPhysics().

     {
         return drawList;
     }

unsigned int StarSystem::GetZone ( )

inline

Definition at line 153 of file star_system_generic.h.

References zone.

Referenced by ZoneMgr::addClient(), AddUnit(), ZoneMgr::broadcast(), NetServer::sendMessage(), and NetServer::sendNewUnitQueue().

     {
         //short fix
         return this->zone;
     }

UnitCollection& StarSystem::gravitationalUnits ( )

inline

Definition at line 223 of file star_system_generic.h.

References GravitationalUnits.

Referenced by AddUnit(), CalculateNearestWarpUnit(), createObjects(), Radar::Sensor::FindTracksInRange(), RemoveUnit(), Unit::UpAndDownGrade(), and UpdateUnitPhysics().

     {
         return GravitationalUnits;
     }

bool StarSystem::JumpTo	(	Unit *	unit,
		Unit *	jumppoint,
		const std::string &	system,
		bool	force = `false`,
		bool	save_coordinates = `false`
	)

Definition at line 927 of file star_system_generic.cpp.

References _Universe, Universe::AccessCockpit(), ActivateAnimation(), Universe::activeStarSystem(), ComputeJumpPointArrival(), Unit::UnitJump::delay, Unit::DockedOrDocking(), DoJumpingLeaveSightAndSound(), Unit::UnitJump::drive, filename, Universe::GenerateStarSystem(), Hashtable< KEY, VALUE, SIZ >::Get(), Universe::getActiveStarSystem(), getFileName(), Unit::GetJumpStatus(), Unit::GetSerial(), isJumping(), Universe::isPlayerStarship(), Unit::jump, NetClient::jumpRequest(), Network, Cockpit::OnJumpBegin(), pendingjump, Unit::Position(), QVector, Vector, and VSFileSystem::vs_fprintf().

Referenced by Unit::jumpReactToCollision(), UnitUtil::JumpTo(), TentativeJumpTo(), Unit::UpdatePhysics(), and WarpPursuit().

 {
     if ( ( un->DockedOrDocking()&(~Unit::DOCKING_UNITS) ) != 0 )
         return false;
     if (Network == NULL || force) {
         if (un->jump.drive >= 0)
             un->jump.drive = -1;
 #ifdef JUMP_DEBUG
         VSFileSystem::vs_fprintf( stderr, "jumping to %s.  ", system.c_str() );
 #endif
         StarSystem *ss = star_system_table.Get( system );
         std::string ssys( system+".system" );
         if (!ss)
             ss = star_system_table.Get( ssys );
         bool justloaded = false;
         if (!ss) {
             justloaded = true;
             ss = _Universe->GenerateStarSystem( ssys.c_str(), filename.c_str(), Vector( 0, 0, 0 ) );
             //NETFIXME: Do we want to generate the system if an AI unit jumps?
         }
         if ( ss && !isJumping( pendingjump, un ) ) {
 #ifdef JUMP_DEBUG
             VSFileSystem::vs_fprintf( stderr, "Pushing back to pending queue!\n" );
 #endif
             bool dosightandsound = ( ( this == _Universe->getActiveStarSystem( 0 ) ) || _Universe->isPlayerStarship( un ) );
             int  ani = -1;
             if (dosightandsound)
                 ani = _Universe->activeStarSystem()->DoJumpingLeaveSightAndSound( un );
         _Universe->AccessCockpit()->OnJumpBegin(un);
             pendingjump.push_back( new unorigdest( un, jumppoint, this, ss, un->GetJumpStatus().delay, ani, justloaded,
                                                   save_coordinates ? ComputeJumpPointArrival( un->Position(), this->getFileName(),
                                                                                               system ) : QVector( 0, 0, 0 ) ) );
         } else {
 #ifdef JUMP_DEBUG
             VSFileSystem::vs_fprintf( stderr, "Failed to retrieve!\n" );
 #endif
             return false;
         }
         if (jumppoint)
             ActivateAnimation( jumppoint );
     } else
     //Networking mode
     if (jumppoint) {
         Network->jumpRequest( system, jumppoint->GetSerial() );
     }
     return true;
 }

void StarSystem::LoadXML	(	const char *	filename,
		const Vector &	centroid,
		const float	timeofyear
	)

protected

Definition at line 1498 of file star_system_xml.cpp.

Referenced by GameStarSystem::GameStarSystem(), and StarSystem().

 {
     using namespace StarXML;
     bool   autogenerated = false;
     this->filename = filename;
     string file = VSFileSystem::GetCorrectStarSysPath( filename, autogenerated );
     if ( file.empty() )
         file = filename;
     if (game_options.game_speed_affects_autogen_systems)
         autogenerated = false;
     VSFile  f;
     VSError err;
     //if (file.length()) {
     err = f.OpenReadOnly( file, SystemFile );
     if (err > Ok) {
         printf( "StarSystem: file not found %s\n", file.c_str() );
         return;
     }
     xml = new StarXML;
     xml->scale = 1;
     xml->fade  = autogenerated;
     xml->scale *= game_options.star_system_scale;
     xml->parentterrain = NULL;
     xml->ct     = NULL;
     xml->systemcentroid = centroid;
     xml->timeofyear     = timeofyear;
     xml->starsp = GetStarSpreadScale();
     xml->numnearstars   = GetNumNearStarsScale();
     xml->numstars = GetNumStarsScale();
     xml->backgroundname = string( "cube" );
     xml->backgroundColor = GFXColor(1.0,1.0,1.0,1.0);
     xml->backgroundDegamma = false;
     xml->reflectivity   = game_options.reflectivity;
     xml->unitlevel = 0;
     XML_Parser parser = XML_ParserCreate( NULL );
     XML_SetUserData( parser, this );
     XML_SetElementHandler( parser, &StarSystem::beginElement, &StarSystem::endElement );
     {
         string fcontents = f.ReadFull();
         VSFileSystem::vs_dprintf( 2, "Contents of star system:\n%s\n", fcontents.c_str() );
         XML_Parse( parser, (fcontents).c_str(), f.Size(), 1 );
     }
     f.Close();
     XML_ParserFree( parser );
     unsigned int i;
     for (i = 0; i < xml->moons.size(); ++i) {
         if (xml->moons[i]->isUnit() == PLANETPTR) {
             Unit *un = NULL;
             for ( Planet::PlanetIterator iter( (Planet*) xml->moons[i] ); (un = *iter); iter.advance() )
                 AddUnit( un );
         } else {
             AddUnit( xml->moons[i] );
         }
     }
     createBackground( xml );
     delete xml;
 }

Unit * StarSystem::nextSignificantUnit ( )

Definition at line 654 of file star_system_generic.cpp.

References sigIter.

 {
     return(*sigIter);
 }

virtual unsigned int StarSystem::numContTerrain ( )

inlinevirtual

Reimplemented in GameStarSystem.

Definition at line 173 of file star_system_generic.h.

Referenced by createObjects().

     {
         return 0;
     }

virtual unsigned int StarSystem::numTerrain ( )

inlinevirtual

activates the light map texture

Reimplemented in GameStarSystem.

Definition at line 169 of file star_system_generic.h.

Referenced by createObjects().

     {
         return 0;
     }

void StarSystem::ProcessPendingJumps ( )

static

Definition at line 804 of file star_system_generic.cpp.

References _Universe, Universe::AccessCockpit(), Universe::activeStarSystem(), Unit::activeStarSystem, Unit::DecreaseWarpEnergy(), DoJumpingComeSightAndSound(), NetClient::downloadZoneInfo(), GetElapsedTime(), VegaConfig::getVariable(), NetClient::inGame(), Universe::isPlayerStarship(), Unit::LocalPosition(), Network, Cockpit::OnJumpEnd(), XMLSupport::parse_bool(), pendingjump, QVector, Universe::setActiveStarSystem(), Unit::SetCurPosition(), SetShieldZero(), Unit::SetVelocity(), SIMULATION_ATOM, speed, Universe::StillExists(), time, Unit::TransferUnitToSystem(), NetClient::unreadyToJump(), Vector, VolitalizeJumpAnimation(), vs_config, VSFileSystem::vs_fprintf(), and Universe::whichPlayerStarship().

Referenced by NetServer::start(), and GameUniverse::StartDraw().

 {
     for (unsigned int kk = 0; kk < pendingjump.size(); ++kk) {
         Unit *un = pendingjump[kk]->un.GetUnit();
         if (pendingjump[kk]->delay >= 0) {
             Unit *jp = pendingjump[kk]->jumppoint.GetUnit();
             if (un && jp) {
                 QVector delta = ( jp->LocalPosition()-un->LocalPosition() );
                 float   dist  = delta.Magnitude();
                 if (pendingjump[kk]->delay > 0) {
                     float speed  = dist/pendingjump[kk]->delay;
                     bool  player = (_Universe->isPlayerStarship( un ) != NULL);
                     if (dist > 10 && player) {
                         if (un->activeStarSystem == pendingjump[kk]->orig)
                             un->SetCurPosition( un->LocalPosition()+SIMULATION_ATOM*delta*(speed/dist) );
                     } else if (!player) {
                         un->SetVelocity( Vector( 0, 0, 0 ) );
                     }
                     static bool setshieldzero =
                         XMLSupport::parse_bool( vs_config->getVariable( "physics", "jump_disables_shields", "true" ) );
                     if (setshieldzero)
                         SetShieldZero( un );
                 }
             }
             double time = GetElapsedTime();
             if (time > 1)
                 time = 1;
             pendingjump[kk]->delay -= time;
             continue;
         } else {
 #ifdef JUMP_DEBUG
             VSFileSystem::vs_fprintf( stderr, "Volitalizing pending jump animation.\n" );
 #endif
             _Universe->activeStarSystem()->VolitalizeJumpAnimation( pendingjump[kk]->animation );
         }
         int playernum = _Universe->whichPlayerStarship( un );
         //In non-networking mode or in networking mode or a netplayer wants to jump and is ready or a non-player jump
         if ( Network == NULL || playernum < 0 || ( Network != NULL && playernum >= 0 && Network[playernum].readyToJump() ) ) {
             Unit *un = pendingjump[kk]->un.GetUnit();
             StarSystem *savedStarSystem = _Universe->activeStarSystem();
             //Download client descriptions of the new zone (has to be blocking)
             if (Network != NULL)
                 Network[playernum].downloadZoneInfo();
             if ( un == NULL || !_Universe->StillExists( pendingjump[kk]->dest )
                 || !_Universe->StillExists( pendingjump[kk]->orig ) ) {
 #ifdef JUMP_DEBUG
                 VSFileSystem::vs_fprintf( stderr, "Adez Mon! Unit destroyed during jump!\n" );
 #endif
                 delete pendingjump[kk];
                 pendingjump.erase( pendingjump.begin()+kk );
                 --kk;
                 continue;
             }
             bool dosightandsound = ( (pendingjump[kk]->dest == savedStarSystem) || _Universe->isPlayerStarship( un ) );
             _Universe->setActiveStarSystem( pendingjump[kk]->orig );
             if ( un->TransferUnitToSystem( kk, savedStarSystem, dosightandsound ) )
                 un->DecreaseWarpEnergy( false, 1.0f );
             if (dosightandsound)
                 _Universe->activeStarSystem()->DoJumpingComeSightAndSound( un );
         _Universe->AccessCockpit()->OnJumpEnd(un);
             delete pendingjump[kk];
             pendingjump.erase( pendingjump.begin()+kk );
             --kk;
             _Universe->setActiveStarSystem( savedStarSystem );
             //In networking mode we tell the server we want to go back in game
             if (Network != NULL) {
                 //Find the corresponding networked player
                 if (playernum >= 0) {
                     Network[playernum].inGame();
                     Network[playernum].unreadyToJump();
                 }
             }
         }
     }
 }

void StarSystem::RemoveStarsystemFromUniverse ( )

protected

Definition at line 780 of file star_system_generic.cpp.

References Hashtable< KEY, VALUE, SIZ >::Delete(), filename, and Hashtable< KEY, VALUE, SIZ >::Get().

Referenced by GameStarSystem::~GameStarSystem(), and ~StarSystem().

 {
     if ( star_system_table.Get( filename ) )
         star_system_table.Delete( filename );
 }

bool StarSystem::RemoveUnit ( Unit * unit)

Removes from draw list.

Definition at line 258 of file star_system_generic.cpp.

References collidemap, UnitCollection::createIterator(), drawList, CollideArray::erase(), gravitationalUnits(), i, is_null(), Unit::location, Unit::NUM_COLLIDE_MAPS, physics_buffer, StarSystem::Statistics::RemoveUnit(), set_null(), SIM_QUEUE_SIZE, and stats.

Referenced by ZoneMgr::removeClient().

 {
     for (unsigned int locind = 0; locind < Unit::NUM_COLLIDE_MAPS; ++locind)
         if ( !is_null( un->location[locind] ) ) {
             collidemap[locind]->erase( un->location[locind] );
             set_null( un->location[locind] );
         }
     bool  removed2 = false;
     Unit *unit;
     for (un_iter iter = gravitationalUnits().createIterator(); (unit = *iter); ++iter)
         if (unit == un) {
             iter.remove();
             removed2 = true;
             break;                                       //Shouldn't be in there twice
         }
     //NOTE: not sure why if(1) was here, but safemode removed it
     bool removed = false;
     if (1) {
         for (un_iter iter = drawList.createIterator(); (unit = *iter); ++iter)
             if (unit == un) {
                 iter.remove();
                 removed = true;
                 break;
             }
     }
     if (removed) {
         for (unsigned int i = 0; i <= SIM_QUEUE_SIZE; ++i) {
             Unit *unit;
             for (un_iter iter = physics_buffer[i].createIterator(); (unit = *iter); ++iter)
                 if (unit == un) {
                     iter.remove();
                     removed = true;
                     //terminate outer loop
                     i = SIM_QUEUE_SIZE+1;
                     break;
                 }
         }
         stats.RemoveUnit( un );
     }
     return removed;
 }

void StarSystem::RequestPhysics	(	Unit *	un,
		unsigned int	queue
	)

Requeues the unit so that it is simulated ASAP.

Definition at line 484 of file star_system_generic.cpp.

References UnitCollection::createIterator(), current_sim_location, UnitCollection::UnitIterator::moveBefore(), physics_buffer, Unit::predicted_priority, and SIM_QUEUE_SIZE.

 {
     Unit   *unit = NULL;
     un_iter iter = this->physics_buffer[queue].createIterator();
     while ( (unit = *iter) && *iter != un )
         ++iter;
     if (unit == un) {
         un->predicted_priority = 0;
         unsigned int newloc = (current_sim_location+1)%SIM_QUEUE_SIZE;
         if (newloc != queue)
             iter.moveBefore( this->physics_buffer[newloc] );
     }
 }

void StarSystem::SetZone ( unsigned int zonenum)

inline

Definition at line 149 of file star_system_generic.h.

References zone.

Referenced by ZoneMgr::addZone().

     {
         this->zone = zonenum;
     }

virtual void StarSystem::SwapIn ( )

inlinevirtual

re-enables the included lights and terrains

Reimplemented in GameStarSystem.

Definition at line 184 of file star_system_generic.h.

Referenced by GameUniverse::StartDraw(), Cockpit::Update(), and ~StarSystem().

184 {}

virtual void StarSystem::SwapOut ( )

inlinevirtual

Disables included lights and terrains.

Reimplemented in GameStarSystem.

Definition at line 186 of file star_system_generic.h.

Referenced by Universe::Generate2(), GameUnit< UnitType >::TransferUnitToSystem(), Cockpit::Update(), and ~StarSystem().

186 {}

void StarSystem::Update	(	float	priority,
		bool	executeDirector
	)

update a simulation atom ExecuteDirector must be false if star system is just loaded before mission is loaded

this makes it so systems without players may be simulated less accurately

just be sure to restore this at the end

Definition at line 689 of file star_system_generic.cpp.

References _Universe, Universe::AccessCockpit(), active_missions, Cockpit::activeStarSystem, AUDRefreshSounds(), collidetable, UnitCollection::createIterator(), current_stage, Universe::CurrentCockpit(), drawList, ExecuteDirector(), Universe::getActiveStarSystem(), GetElapsedTime(), getTimeCompression(), i, UnitCollection::UnitIterator::isDone(), UnitUtil::isSignificant(), j, k, MISSION_SIMULATION, Universe::numPlayers(), PHY_NUM, Universe::popActiveStarSystem(), PROCESS_UNIT, Unit::ProcessDeleteQueue(), Universe::pushActiveStarSystem(), queryTime(), run_only_player_starsystem, Universe::SetActiveCockpit(), sigIter, SIMULATION_ATOM, TerrainCollide(), time, Cockpit::Update(), CollideTable::Update(), UpdateAnimatedTexture(), Cockpit::updateAttackers(), UpdateCameraSnds(), UpdateMissiles(), and UpdateUnitPhysics().

Referenced by Universe::Update().

 {
     bool   firstframe = true;
     double pythontime = 0;
     for (unsigned int k = 0; k < _Universe->numPlayers(); ++k)
         if (_Universe->AccessCockpit( k )->activeStarSystem == this)
             priority = 1;
     float normal_simulation_atom = SIMULATION_ATOM;
     SIMULATION_ATOM /= ( priority/getTimeCompression() );
     time += GetElapsedTime();
     _Universe->pushActiveStarSystem( this );
     //WARNING PERFORMANCE HACK!!!!!
     if (time > 2*SIMULATION_ATOM)
         time = 2*SIMULATION_ATOM;
     double bolttime = 0;
     if ( time/SIMULATION_ATOM >= (1./PHY_NUM) ) {
         //Chew up all SIMULATION_ATOMs that have elapsed since last update
         while ( time/SIMULATION_ATOM >= (1./PHY_NUM) ) {
             if (current_stage == MISSION_SIMULATION) {
                 TerrainCollide();
                 UpdateAnimatedTexture();
                 Unit::ProcessDeleteQueue();
                 double pythonidea = queryTime();
                 if ( (run_only_player_starsystem
                       && _Universe->getActiveStarSystem( 0 ) == this) || !run_only_player_starsystem )
                     if (executeDirector)
                         ExecuteDirector();
                 pythontime = queryTime()-pythonidea;
                 static int dothis = 0;
                 if ( this == _Universe->getActiveStarSystem( 0 ) )
                     if ( (++dothis)%2 == 0 )
                         AUDRefreshSounds();
                 for (unsigned int i = 0; i < active_missions.size(); ++i)
                     //waste of farkin time
                     active_missions[i]->BriefingUpdate();
                 current_stage = PROCESS_UNIT;
             } else if (current_stage == PROCESS_UNIT) {
                 UpdateUnitPhysics( firstframe );
                 UpdateMissiles(); //do explosions
                 collidetable->Update();
                 if ( this == _Universe->getActiveStarSystem( 0 ) )
                     UpdateCameraSnds();
                 bolttime      = queryTime();
                 bolttime      = queryTime()-bolttime;
                 current_stage = MISSION_SIMULATION;
                 firstframe    = false;
             }
             time -= (1./PHY_NUM)*SIMULATION_ATOM;
         }
         unsigned int i = _Universe->CurrentCockpit();
         for (unsigned int j = 0; j < _Universe->numPlayers(); ++j)
             if (_Universe->AccessCockpit( j )->activeStarSystem == this) {
                 _Universe->SetActiveCockpit( j );
                 _Universe->AccessCockpit( j )->updateAttackers();
                 if ( _Universe->AccessCockpit( j )->Update() ) {
                     SIMULATION_ATOM = normal_simulation_atom;
                     _Universe->SetActiveCockpit( i );
                     _Universe->popActiveStarSystem();
                     return;
                 }
             }
         _Universe->SetActiveCockpit( i );
     }
     if ( sigIter.isDone() )
         sigIter = drawList.createIterator();
     else
         ++sigIter;
     while ( !sigIter.isDone() && !UnitUtil::isSignificant( *sigIter) )
         ++sigIter;
     //If it is done, leave it NULL for this frame then.
     //WARNING cockpit does not get here...
     SIMULATION_ATOM = normal_simulation_atom;
     //WARNING cockpit does not get here...
     _Universe->popActiveStarSystem();
 }

void StarSystem::Update ( float priority)

Definition at line 659 of file star_system_generic.cpp.

References _Universe, collidetable, UnitCollection::createIterator(), current_stage, drawList, ExecuteDirector(), GetElapsedTime(), MISSION_SIMULATION, PHY_NUM, Universe::popActiveStarSystem(), Unit::ProcessDeleteQueue(), Universe::pushActiveStarSystem(), Unit::SetNebula(), SIMULATION_ATOM, TerrainCollide(), time, CollideTable::Update(), UpdateMissiles(), and UpdateUnitPhysics().

 {
     Unit *unit;
     bool  firstframe = true;
     //No time compression here
     float normal_simulation_atom = SIMULATION_ATOM;
     time += GetElapsedTime();
     _Universe->pushActiveStarSystem( this );
     if ( time/SIMULATION_ATOM >= (1./PHY_NUM) ) {
         while ( time/SIMULATION_ATOM >= (1.) ) {
             //Chew up all SIMULATION_ATOMs that have elapsed since last update
             ExecuteDirector();
             TerrainCollide();
             Unit::ProcessDeleteQueue();
             current_stage = MISSION_SIMULATION;
             collidetable->Update();
             for (un_iter iter = drawList.createIterator(); (unit = *iter); ++iter)
                 unit->SetNebula( NULL );
             UpdateMissiles();                    //do explosions
             UpdateUnitPhysics( firstframe );
 
             firstframe = false;
         }
         time -= SIMULATION_ATOM;
     }
     SIMULATION_ATOM = normal_simulation_atom;
     _Universe->popActiveStarSystem();
 }

void StarSystem::UpdateMissiles ( )

virtual

Definition at line 14 of file missile_generic.cpp.

References UnitCollection::createIterator(), dischargedMissiles, and getUnitList().

Referenced by Update().

 {
     //WARNING: This is a big performance problem...
     //...responsible for many hiccups.
     //TODO: Make it use the collidemap to only iterate through potential hits...
     //PROBLEM: The current collidemap does not allow this efficiently (no way of
     //taking the other unit's rSize() into account).
     if ( !dischargedMissiles.empty() ) {
         Unit *un;
         for (un_iter ui = getUnitList().createIterator();
              NULL != ( un = (*ui) );
              ++ui)
             dischargedMissiles.back()->ApplyDamage( un );
         delete dischargedMissiles.back();
         dischargedMissiles.pop_back();
     }
 }

void StarSystem::UpdateUnitPhysics ( bool firstframe)

Definition at line 498 of file star_system_generic.cpp.

References aggfire, StarSystem::Statistics::CheckVitals(), Unit::CollideAll(), collidemap, UnitCollection::createIterator(), Unit::cumulative_transformation, Unit::curr_physical_state, current_sim_location, Unit::ExecuteAI(), CollideArray::flatten(), VSRandom::genrand_int32(), UnitUtil::getPhysicsPriority(), getUnitList(), gravitationalUnits(), identity_matrix(), identity_transformation(), int, last_collisions, Unit::NUM_COLLIDE_MAPS, numprocessed, physics_buffer, physicsframecounter, Unit::predicted_priority, queryTime(), Unit::ResetThreatLevel(), Unit::sim_atom_multiplier, SIM_QUEUE_SIZE, SIMULATION_ATOM, stats, targetpick, theunitcounter, totalprocessed, Unit::UNIT_BOLT, Unit::UNIT_ONLY, Bolt::UpdatePhysics(), Unit::UpdatePhysics(), Vector, and vsrandom.

Referenced by Universe::Generate2(), and Update().

 {
     static bool phytoggle  = true;
     static int  batchcount = SIM_QUEUE_SIZE-1;
     double aitime = 0;
     double phytime = 0;
     double collidetime     = 0;
     double flattentime     = 0;
     double bolttime = 0;
     targetpick   = 0;
     aggfire      = 0;
     numprocessed = 0;
     stats.CheckVitals( this );
     if (phytoggle) {
         for (++batchcount; batchcount > 0; --batchcount) {
             //BELOW COMMENTS ARE NO LONGER IN SYNCH
             //NOTE: Randomization is necessary to preserve scattering - otherwise, whenever a
             //unit goes from low-priority to high-priority and back to low-priority, they
             //get synchronized and start producing peaks.
             //NOTE2: But... randomization must come only on priority changes. Otherwise, it may
             //interfere with subunit scheduling. Luckily, all units that make use of subunit
             //scheduling also require a constant base priority, since otherwise priority changes
             //will wreak havoc with subunit interpolation. Luckily again, we only need
             //randomization on priority changes, so we're fine.
             try {
                 Unit *unit = NULL;
                 for (un_iter iter = physics_buffer[current_sim_location].createIterator(); (unit = *iter); ++iter) {
                     int priority  = UnitUtil::getPhysicsPriority( unit );
                     //Doing spreading here and only on priority changes, so as to make AI easier
                     int predprior = unit->predicted_priority;
                     //If the priority has really changed (not an initial scattering, because prediction doesn't match)
                     if (priority != predprior) {
                         if (predprior == 0)
                             //Validate snapshot of current interpolated state (this is a reschedule)
                             unit->curr_physical_state = unit->cumulative_transformation;
                         //Save priority value as prediction for next scheduling, but don't overwrite yet.
                         predprior = priority;
                         //Scatter, so as to achieve uniform distribution
                         priority  = 1+( ( (unsigned int) vsrandom.genrand_int32() )%priority );
                     }
                     float backup = SIMULATION_ATOM;
                     theunitcounter   = theunitcounter+1;
                     SIMULATION_ATOM *= priority;
                     unit->sim_atom_multiplier = priority;
                     double aa = queryTime();
                     unit->ExecuteAI();
                     double bb = queryTime();
                     unit->ResetThreatLevel();
                     //FIXME "firstframe"-- assume no more than 2 physics updates per frame.
                     unit->UpdatePhysics( identity_transformation, identity_matrix, Vector( 0,
                                                                                            0,
                                                                                            0 ), priority
                                          == 1 ? firstframe : true, &this->gravitationalUnits(), unit );
                     double cc = queryTime();
                     aitime  += bb-aa;
                     phytime += cc-bb;
                     SIMULATION_ATOM = backup;
                     unit->predicted_priority = predprior;
                 }
             }
             catch (const boost::python::error_already_set) {
                 if ( PyErr_Occurred() ) {
                     PyErr_Print();
                     PyErr_Clear();
                     fflush( stderr );
                     fflush( stdout );
                 } throw;
             }
             double c0  = queryTime();
             Bolt::UpdatePhysics( this );
             double cc  = queryTime();
             last_collisions.clear();
             double fl0 = queryTime();
             collidemap[Unit::UNIT_BOLT]->flatten();
             if (Unit::NUM_COLLIDE_MAPS > 1)
                 collidemap[Unit::UNIT_ONLY]->flatten( *collidemap[Unit::UNIT_BOLT] );
             flattentime = queryTime()-fl0;
             Unit *unit;
             for (un_iter iter = physics_buffer[current_sim_location].createIterator(); (unit = *iter);) {
                 int   priority = unit->sim_atom_multiplier;
                 float backup   = SIMULATION_ATOM;
                 SIMULATION_ATOM *= priority;
                 unsigned int newloc = (current_sim_location+priority)%SIM_QUEUE_SIZE;
                 unit->CollideAll();
                 SIMULATION_ATOM = backup;
                 if (newloc == current_sim_location)
                     ++iter;
                 else
                     iter.moveBefore( physics_buffer[newloc] );
             }
             double dd = queryTime();
             collidetime += dd-cc;
             bolttime    += cc-c0;
             current_sim_location = (current_sim_location+1)%SIM_QUEUE_SIZE;
             ++physicsframecounter;
             totalprocessed += theunitcounter;
             theunitcounter  = 0;
         }
     } else {
         Unit *unit = NULL;
         for (un_iter iter = getUnitList().createIterator(); (unit = *iter); ++iter) {
             unit->ExecuteAI();
             last_collisions.clear();
             unit->UpdatePhysics( identity_transformation, identity_matrix, Vector( 0,
                                                                                    0,
                                                                                    0 ), firstframe,
                                  &this->gravitationalUnits(), unit );
             unit->CollideAll();
         }
     }
 }