#include <assert.h>
#include "star_system_generic.h"
#include "gfx/vec.h"
#include "cmd/planet_generic.h"
#include "cmd/unit_generic.h"
#include "cmd/unit_collide.h"
#include "cmd/collection.h"
#include "gfx/cockpit_generic.h"
#include "audiolib.h"
#include "lin_time.h"
#include "cmd/beam.h"
#include "cmd/bolt.h"
#include <expat.h>
#include "cmd/music.h"
#include "configxml.h"
#include "vs_globals.h"
#include "vegastrike.h"
#include "universe_generic.h"
#include "cmd/nebula_generic.h"
#include "galaxy_gen.h"
#include "cmd/script/mission.h"
#include "in_kb.h"
#include "cmd/script/flightgroup.h"
#include "load_mission.h"
#include "cmd/unit_util.h"
#include "cmd/unit_factory.h"
#include "vs_random.h"
#include "savegame.h"
#include "networking/netclient.h"
#include "in_kb_data.h"
#include "universe_util.h"
#include <boost/version.hpp>
#include "cs_boostpython.h"

Functions
void	TentativeJumpTo (StarSystem ss, Unit un, Unit *jumppoint, const std::string &system)

float	ScaleJumpRadius (float radius)

void	ClientServerSetLightContext (int lightcontext)

void	setStaticFlightgroup (vector< Flightgroup * > &fg, const std::string &nam, int faction)

Flightgroup *	getStaticBaseFlightgroup (int faction)

Flightgroup *	getStaticStarFlightgroup (int faction)

Flightgroup *	getStaticNebulaFlightgroup (int faction)

Flightgroup *	getStaticAsteroidFlightgroup (int faction)

Flightgroup *	getStaticUnknownFlightgroup (int faction)

string	RemoveDotSystem (const char *input)

Unit *	getTopLevelOwner ()

void	CarSimUpdate (Unit *un, float height)

void	TerrainCollide ()

void	UpdateAnimatedTexture ()

void	UpdateCameraSnds ()

float	getTimeCompression ()

void	ExecuteDirector ()

StarSystem *	GetLoadedStarSystem (const char *system)

bool	PendingJumpsEmpty ()

void	SetShieldZero (Unit *)

double	calc_blend_factor (double frac, int priority, unsigned int when_it_will_be_simulated, int cur_simulation_frame)

void	ActivateAnimation (Unit *jumppoint)

static bool	isJumping (const vector< unorigdest * > &pending, Unit *un)

QVector	SystemLocation (std::string system)

double	howFarToJump ()

QVector	ComputeJumpPointArrival (QVector pos, std::string origin, std::string destination)

Variables
vector< Vector >	perplines

std::vector< unorigdest * >	pendingjump

unsigned int	physicsframecounter = 1

unsigned int	theunitcounter = 0

unsigned int	totalprocessed = 0

unsigned int	movingavgarray [128] = {0}

unsigned int	movingtotal = 0

double	aggfire = 0

int	numprocessed = 0

double	targetpick = 0

Hashtable< std::string, StarSystem, 127 >	star_system_table

Function Documentation

void ActivateAnimation ( Unit * jumppoint)

Definition at line 893 of file star_system_generic.cpp.

References ActivateAnimation(), Unit::graphic_options::Animating, Unit::getSubUnits(), Unit::graphicOptions, and i.

Referenced by ActivateAnimation(), StarSystem::JumpTo(), and GameUnit< UnitType >::TransferUnitToSystem().

 {
     jumppoint->graphicOptions.Animating = 1;
     Unit *un;
     for (un_iter i = jumppoint->getSubUnits(); NULL != (un = *i); ++i)
         ActivateAnimation( un );
 }

double calc_blend_factor	(	double	frac,
		int	priority,
		unsigned int	when_it_will_be_simulated,
		int	cur_simulation_frame
	)

Definition at line 880 of file star_system_generic.cpp.

References SIM_QUEUE_SIZE.

 {
     if (when_it_will_be_simulated == SIM_QUEUE_SIZE) {
         return 1;
     } else {
         int relwas = when_it_will_be_simulated-priority;
         if (relwas < 0) relwas += SIM_QUEUE_SIZE;
         int relcur = cur_simulation_frame-relwas-1;
         if (relcur < 0) relcur += SIM_QUEUE_SIZE;
         return (relcur+frac)/(double) priority;
     }
 }

void CarSimUpdate	(	Unit *	un,
		float	height
	)

Definition at line 325 of file star_system_generic.cpp.

References Unit::curr_physical_state, Unit::GetVelocity(), Transformation::position, QVector, Unit::SetVelocity(), and Vector.

 {
     un->SetVelocity( Vector( un->GetVelocity().i, 0, un->GetVelocity().k ) );
     un->curr_physical_state.position = QVector( un->curr_physical_state.position.i,
                                                 height,
                                                 un->curr_physical_state.position.k );
 }

void ClientServerSetLightContext ( int lightcontext)

Definition at line 41 of file universe_util.cpp.

References GFXSetLightContext().

Referenced by StarSystem::~StarSystem().

 {
     GFXSetLightContext( lightcontext );
 }

QVector ComputeJumpPointArrival	(	QVector	pos,
		std::string	origin,
		std::string	destination
	)

Definition at line 911 of file star_system_generic.cpp.

References howFarToJump(), QVector, start, and SystemLocation().

Referenced by StarSystem::JumpTo().

 {
     QVector finish = SystemLocation( destination );
     QVector start  = SystemLocation( origin );
     QVector dir    = finish-start;
     if ( dir.MagnitudeSquared() ) {
         dir.Normalize();
         dir = -dir;
         pos = -pos;
         pos.Normalize();
         if ( pos.MagnitudeSquared() ) pos.Normalize();
         return (dir*.5+pos*.125)*howFarToJump();
     }
     return QVector( 0, 0, 0 );
 }

void ExecuteDirector ( )

Definition at line 617 of file star_system_generic.cpp.

References _Universe, Universe::AccessCockpit(), active_missions, Cockpit::activeStarSystem, Universe::CurrentCockpit(), i, mission, Universe::popActiveStarSystem(), processDelayedMissions(), Universe::pushActiveStarSystem(), and Universe::SetActiveCockpit().

Referenced by BaseInterface::BaseInterface(), Unit::ForceDock(), NetServer::start(), and StarSystem::Update().

 {
     unsigned int curcockpit = _Universe->CurrentCockpit();
     {
         for (unsigned int i = 0; i < active_missions.size(); ++i)
             if (active_missions[i]) {
                 _Universe->SetActiveCockpit( active_missions[i]->player_num );
                 StarSystem *ss = _Universe->AccessCockpit()->activeStarSystem;
                 if (ss) _Universe->pushActiveStarSystem( ss );
                 mission = active_missions[i];
                 active_missions[i]->DirectorLoop();
                 if (ss) _Universe->popActiveStarSystem();
             }
     }
     _Universe->SetActiveCockpit( curcockpit );
     mission = active_missions[0];
     processDelayedMissions();
     {
         for (unsigned int i = 1; i < active_missions.size();) {
             if (active_missions[i]) {
                 if (active_missions[i]->runtime.pymissions) {
                     ++i;
                 } else {
                     unsigned int w = active_missions.size();
                     active_missions[i]->terminateMission();
                     if ( w == active_missions.size() ) {
                         printf( "MISSION NOT ERASED\n" );
                         break;
                     }
                 }
             } else {
                 active_missions.Get()->erase( active_missions.Get()->begin()+i );
             }
         }
     }
 }

StarSystem* GetLoadedStarSystem ( const char * system)

Definition at line 786 of file star_system_generic.cpp.

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

Referenced by ZoneMgr::addZone(), GameUniverse::GenerateStarSystem(), and Universe::GenerateStarSystem().

 {
     StarSystem *ss = star_system_table.Get( string( system ) );
     std::string ssys( string( system )+string( ".system" ) );
     if (!ss)
         ss = star_system_table.Get( ssys );
     return ss;
 }

Flightgroup* getStaticAsteroidFlightgroup ( int faction)

Definition at line 195 of file star_system_generic.cpp.

References StarSystemGent::faction, and setStaticFlightgroup().

 {
     static vector< Flightgroup* >fg;
     setStaticFlightgroup( fg, "Asteroid", faction );
     return fg[faction];
 }

Flightgroup* getStaticBaseFlightgroup ( int faction)

Definition at line 172 of file star_system_generic.cpp.

References StarSystemGent::faction, and setStaticFlightgroup().

Referenced by Planet::beginElement().

 {
     //warning mem leak...not big O(num factions)
     static vector< Flightgroup* >fg;
     setStaticFlightgroup( fg, "Base", faction );
     return fg[faction];
 }

Flightgroup* getStaticNebulaFlightgroup ( int faction)

Definition at line 188 of file star_system_generic.cpp.

References StarSystemGent::faction, and setStaticFlightgroup().

 {
     static vector< Flightgroup* >fg;
     setStaticFlightgroup( fg, "Nebula", faction );
     return fg[faction];
 }

Flightgroup* getStaticStarFlightgroup ( int faction)

Definition at line 180 of file star_system_generic.cpp.

References StarSystemGent::faction, and setStaticFlightgroup().

 {
     //warning mem leak...not big O(num factions)
     static vector< Flightgroup* >fg;
     setStaticFlightgroup( fg, "Base", faction );
     return fg[faction];
 }

Flightgroup* getStaticUnknownFlightgroup ( int faction)

Definition at line 202 of file star_system_generic.cpp.

References StarSystemGent::faction, and setStaticFlightgroup().

 {
     static vector< Flightgroup* >fg;
     setStaticFlightgroup( fg, "Unknown", faction );
     return fg[faction];
 }

float getTimeCompression ( )

Definition at line 102 of file lin_time.cpp.

References timecompression.

Referenced by Cockpit::Autopilot(), Mission::DirectorLoop(), BaseInterface::Room::BasePython::Draw(), GameCockpit::Draw(), BaseInterface::Room::BaseTalk::Draw(), Orders::AggressiveAI::Execute(), FlyByWire::Right(), FlyByWire::RollRight(), FlyByWire::Up(), PhysicsSystem::Update(), StarSystem::Update(), CockpitKeys::ZoomIn(), and CockpitKeys::ZoomOut().

 {
     return timecompression;
 }

Unit* getTopLevelOwner ( )

Definition at line 320 of file star_system_generic.cpp.

Referenced by Radar::CollectRadarTracks::acquire(), FireKeyboard::Execute(), UnitUtil::getPhysicsPriority(), UnitUtil::orbit(), and TargUn().

 {
     return (Unit*) 0x31337; //FIXME How about telling us a little story behind this function? --chuck_starchaser
 }

double howFarToJump ( )

Definition at line 2129 of file unit_generic.cpp.

References VegaConfig::getVariable(), XMLSupport::parse_float(), and vs_config.

Referenced by ComputeJumpPointArrival(), GameCockpit::Draw(), and Unit::UpdatePhysics().

 {
     static float tmp = XMLSupport::parse_float( vs_config->getVariable( "physics", "distance_to_warp", "1000000000000.0" ) );
     return tmp;
 }

static bool isJumping	(	const vector< unorigdest * > &	pending,
		Unit *	un
	)

static

Definition at line 901 of file star_system_generic.cpp.

References i.

Referenced by StarSystem::JumpTo().

 {
     for (size_t i = 0; i < pending.size(); ++i)
         if (pending[i]->un == un)
             return true;
     return false;
 }

bool PendingJumpsEmpty ( )

Definition at line 797 of file star_system_generic.cpp.

References pendingjump.

Referenced by GameUniverse::StartDraw().

 {
     return pendingjump.empty();
 }

string RemoveDotSystem ( const char * input)

Definition at line 27 of file galaxy.cpp.

 {
     int   sl  = strlen( input );
     if (sl == 0)
         return string( "" );
     char *tmp = strdup( input );
     char *ptr = tmp+sl-1;
     while (ptr > tmp) {
         if (*ptr == '.') {
             if ( 0 == strcmp( ptr, ".system" ) ) {
                 *ptr = '\0';
 
                 char *ttmp = tmp;
                 tmp  = strdup( RemoveDotSystem( tmp ).c_str() );
                 ptr  = ( tmp+(ptr-ttmp) );
                 free( ttmp );
 
                 break;
             } else {
                 break;
             }
         }
         ptr--;
     }
     string retval( tmp );
     free( tmp );
     return retval;
 }

float ScaleJumpRadius ( float radius)

Definition at line 64 of file star_system_generic.cpp.

References VegaConfig::getVariable(), XMLSupport::parse_float(), and vs_config.

Referenced by Planet::beginElement().

 {
     static float jump_radius_scale = parse_float( vs_config->getVariable( "physics", "jump_radius_scale", "2" ) );
     static float game_speed = parse_float( vs_config->getVariable( "physics", "game_speed", "1" ) );
     //need this because sys scale doesn't affect j-point size
     radius *= jump_radius_scale*game_speed;
     return radius;
 }

void SetShieldZero ( Unit * )

Definition at line 78 of file unit_functions_generic.cpp.

References Shield::number, Unit::shield, Shield::shield2fb, Shield::shield4fbrl, and Shield::shield8.

Referenced by StarSystem::ProcessPendingJumps(), and Unit::UpdatePhysics().

 {
     switch (un->shield.number)
     {
     case 8:
 
         un->shield.shield8.frontlefttop =
             un->shield.shield8.frontrighttop   =
                 un->shield.shield8.backlefttop =
                     un->shield.shield8.backrighttop =
                         un->shield.shield8.frontleftbottom =
                             un->shield.shield8.frontrightbottom   =
                                 un->shield.shield8.backleftbottom =
                                     un->shield.shield8.backrightbottom = 0;
         break;
     case 4:
         un->shield.shield4fbrl.front        =
             un->shield.shield4fbrl.back     =
                 un->shield.shield4fbrl.left =
                     un->shield.shield4fbrl.right = 0;
         break;
     case 2:
         un->shield.shield2fb.front = un->shield.shield2fb.back = 0;
         break;
     }
 }

void setStaticFlightgroup	(	vector< Flightgroup * > &	fg,
		const std::string &	nam,
		int	faction
	)

Definition at line 151 of file star_system_generic.cpp.

References StarSystemGent::faction, and FactionUtil::GetFaction().

Referenced by getStaticAsteroidFlightgroup(), getStaticBaseFlightgroup(), getStaticNebulaFlightgroup(), getStaticStarFlightgroup(), and getStaticUnknownFlightgroup().

 {
     while ( faction >= (int) fg.size() ) {
         fg.push_back( new Flightgroup() );
         fg.back()->nr_ships = 0;
     }
     if (fg[faction]->nr_ships == 0) {
         fg[faction]->flightgroup_nr = faction;
         fg[faction]->pos.i    = fg[faction]->pos.j = fg[faction]->pos.k = 0;
         fg[faction]->nr_ships = 0;
         fg[faction]->ainame   = "default";
         fg[faction]->faction  = FactionUtil::GetFaction( faction );
         fg[faction]->type     = "Base";
         fg[faction]->nr_waves_left = 0;
         fg[faction]->nr_ships_left = 0;
         fg[faction]->name     = nam;
     }
     ++fg[faction]->nr_ships;
     ++fg[faction]->nr_ships_left;
 }

QVector SystemLocation ( std::string system)

Definition at line 2135 of file unit_generic.cpp.

References _Universe, Universe::getGalaxyProperty(), and QVector.

Referenced by ComputeJumpPointArrival(), GameCockpit::Draw(), NearestSystem(), and WarpPursuit().

 {
     string  xyz = _Universe->getGalaxyProperty( system, "xyz" );
     QVector pos;
     if ( xyz.size() && (sscanf( xyz.c_str(), "%lf %lf %lf", &pos.i, &pos.j, &pos.k ) >= 3) )
         return pos;
     else
         return QVector( 0, 0, 0 );
 }

void TentativeJumpTo	(	StarSystem *	ss,
		Unit *	un,
		Unit *	jumppoint,
		const std::string &	system
	)

Definition at line 56 of file star_system_generic.cpp.

References i, StarSystem::JumpTo(), and pendingjump.

 {
     for (unsigned int i = 0; i < pendingjump.size(); ++i)
         if (pendingjump[i]->un.GetUnit() == un)
             return;
     ss->JumpTo( un, jumppoint, system );
 }