universe_util.h

Go to the documentation of this file.

#ifndef _UNIVERSE_UTILGENERIC_H__
#define _UNIVERSE_UTILGENERIC_H__
#include "cmd/collection.h"
#include "gfx/vec.h"
#include "networking/const.h"
#include "cmd/unit_util.h"

#include <string>
#include <vector>

class Unit;
class StarSystem;
class Cargo;

namespace UniverseUtil
{
class PythonUnitIter : public un_iter
{
public: PythonUnitIter() : UnitIterator() {}
//PythonUnitIterator (UnitListNode * start):UnitIterator(start){}
    PythonUnitIter( const UnitCollection::UnitIterator &t ) : UnitIterator( t ) {}
    ~PythonUnitIter() {}
    Unit * current();
    inline void advance()
    {
        UnitIterator::advance();
    }
    void advanceSignificant();
    void advanceInsignificant();
    void advancePlanet();
    void advanceJumppoint();
    void advanceN( int );
    void advanceNSignificant( int n );
    void advanceNInsignificant( int n );
    void advanceNPlanet( int n );
    void advanceNJumppoint( int n );
    inline void preinsert( Unit *unit )
    {
        UnitIterator::preinsert( unit );
    }
    inline bool isDone()
    {
        return UnitIterator::isDone();
    }
    inline bool notDone()
    {
        return UnitIterator::notDone();
    }
    inline void remove()
    {
        UnitIterator::remove();
    }
    inline class Unit * next()
    {
        advance();
        return current();
    }
};

std::string LookupUnitStat( const std::string &unitname, const std::string &faction, const std::string &statname );

Unit * GetUnitFromSerial( ObjSerial serial );

Unit * GetMasterPartList();


void pushSystem( std::string name );
bool systemInMemory( std::string name );

void popSystem();

std::string getSystemFile();

std::string getSystemName();

PythonUnitIter getUnitList();


Unit * getUnit( int index );

Unit * getUnitByName( std::string name );

Unit * getUnitByPtr( void *ptr, Unit *finder = 0, bool allowslowness = true );
Unit * getScratchUnit();
void setScratchUnit( Unit* );

void precacheUnit( std::string name, std::string faction );
QVector getScratchVector();
void setScratchVector( QVector );
int getNumUnits();
void cacheAnimation( std::string anim );

Unit * launchJumppoint( std::string name_string,
                        std::string faction_string,
                        std::string type_string,
                        std::string unittype_string,
                        std::string ai_string,
                        int nr_of_ships,
                        int nr_of_waves,
                        QVector pos,
                        std::string squadlogo,
                        std::string destinations );
std::string vsConfig( std::string category, std::string option, std::string def );

Unit * launch( std::string name_string,
               std::string type_string,
               std::string faction_string,
               std::string unittype,
               std::string ai_string,
               int nr_of_ships,
               int nr_of_waves,
               QVector pos,
               std::string sqadlogo );

Cargo getRandCargo( int quantity, std::string category );

std::string GetAdjacentSystem( std::string str, int which );

std::string GetGalaxyProperty( std::string sys, std::string prop );

std::vector< std::string > GetJumpPath( std::string from, std::string to );

std::string GetGalaxyPropertyDefault( std::string sys, std::string prop, std::string def );

std::string GetGalaxyFaction( std::string sys );
void SetGalaxyFaction( std::string sys, std::string fac );

int GetNumAdjacentSystems( std::string sysname );

float GetGameTime();

float getStarTime();

string getStarDate();

void SetTimeCompression();

int musicAddList( std::string str );

void musicSetSoftVolume( float vol, float latency_override );

void musicSetHardVolume( float vol );

void musicLayerPlaySong( std::string str, int layer );

void musicLayerPlayList( int which, int layer );

void musicLayerLoopList( int numloops, int layer );

void musicLayerSkip( int layer );

void musicLayerStop( int layer );

void musicLayerSetSoftVolume( float vol, float latency_override, int layer );

void musicLayerSetHardVolume( float vol, int layer );

void musicMute( bool stopSound );

inline void musicPlaySong( std::string str )
{
    musicLayerPlaySong( str, -1 );
}

inline void musicPlayList( int which )
{
    musicLayerPlayList( which, -1 );
}

inline void musicLoopList( int numloops )
{
    musicLayerLoopList( numloops, -1 );
}

inline void musicSkip()
{
    musicLayerSkip( -1 );
}

inline void musicStop()
{
    musicLayerStop( -1 );
}

float GetDifficulty();

void SetDifficulty( float diff );

void playSound( std::string soundName, QVector loc, Vector speed );

void playSoundCockpit( std::string soundName );

void playAnimation( std::string aniName, QVector loc, float size );
void playAnimationGrow( std::string aniName, QVector loc, float size, float growpercent );

void TargetEachOther( std::string fgname, std::string faction, std::string enfgname, std::string enfaction );

void StopTargettingEachOther( std::string fgname, std::string faction, std::string enfgname, std::string enfaction );

void terminateMission( bool term );

Unit * getPlayer();

Unit * getPlayerX( int which );
unsigned int getCurrentPlayer();

int getNumPlayers();

//Clears all objectives (used for server-side when it's easy to get inconsistent.
void setTargetLabel( std::string label );
std::string getTargetLabel();

float getRelationModifierInt( int which_cp, int faction );
float getRelationModifier( int which_cp, string faction );
float getFGRelationModifier( int which_cp, string fg );
void adjustRelationModifierInt( int which_cp, int faction, float delta );
void adjustRelationModifier( int which_cp, string faction, float delta );
void adjustFGRelationModifier( int which_cp, string fg, float delta );

void AdjustRelation( std::string myfaction, std::string theirfaction, float factor, float rank );
float GetRelation( std::string myfaction, std::string theirfaction );

void clearObjectives();
//Erases an objective.
void eraseObjective( int which );

int addObjective( std::string objective );

void setObjective( int which, std::string newobjective );

void setCompleteness( int which, float completeNess );

float getCompleteness( int which );

void setOwnerII( int which, Unit *owner );

Unit * getOwner( int which );
//gets the owner of this mission
int getMissionOwner();
//sets the owner of this mission to be a particular cockpit
void setMissionOwner( int );

int numActiveMissions();

void IOmessage( int delay, std::string from, std::string to, std::string message );

Unit * GetMasterPartList();

Unit * GetContrabandList( std::string faction );

void SetAutoStatus( int global_auto, int player_auto );
void LoadMission( std::string missionname );
void LoadMissionScript( std::string scriptcontents );
void LoadNamedMissionScript( std::string missiontitle, std::string scriptcontents );
QVector SafeEntrancePoint( QVector, float radial_size = -1 );
QVector SafeStarSystemEntrancePoint( StarSystem*sts, QVector, float radial_size = -1 );
float getPlanetRadiusPercent();

void cacheAnimation( std::string anim );

Unit * launchJumppoint( std::string name_string,
                        std::string faction_string,
                        std::string type_string,
                        std::string unittype_string,
                        std::string ai_string,
                        int nr_of_ships,
                        int nr_of_waves,
                        QVector pos,
                        std::string squadlogo,
                        std::string destinations );

Unit * launch( std::string name_string,
               std::string type_string,
               std::string faction_string,
               std::string unittype,
               std::string ai_string,
               int nr_of_ships,
               int nr_of_waves,
               QVector pos,
               std::string sqadlogo );

Cargo getRandCargo( int quantity, std::string category );

//float GetGameTime();

//float getStarTime();

void SetTimeCompression();

int musicAddList( std::string str );

void musicPlaySong( std::string str );

void musicPlayList( int which );

void musicLoopList( int numloops );

void playSound( std::string soundName, QVector loc, Vector speed );

void playAnimation( std::string aniName, QVector loc, float size );
void playAnimationGrow( std::string aniName, QVector loc, float size, float growpercent );

Unit * getPlayer();

Unit * getPlayerX( int which );
void StopAllSounds( void );
unsigned int getCurrentPlayer();

int getNumPlayers();
unsigned int maxMissions();
bool networked();
bool isserver();
//Forwards this request onto the server if this is a client, or send back to client.
void sendCustom( int cp, string cmd, string args, string id );
//Executes a python script
void receivedCustom( int cp, bool trusted, string cmd, string args, string id );

std::string getVariable( std::string section, std::string name, std::string def );
std::string getSubVariable( std::string section, std::string subsection, std::string name, std::string def );
double timeofday();
double sqrt( double );
double log( double );
double exp( double );
double cos( double );
double sin( double );
double acos( double );
double asin( double );
double atan( double );
double tan( double );
void micro_sleep( int n );
void addParticle( QVector loc, Vector velocity, Vector color, float size );

void ComputeGalaxySerials( std::vector< std::string > &stak );
void ComputeSystemSerials( std::string &systempath );

std::string getSaveDir();
std::string getSaveInfo( const std::string &filename, bool formatForTextbox );
std::string getCurrentSaveGame();
std::string setCurrentSaveGame( const std::string &newsave );
std::string getNewGameSaveName();
void loadGame( const std::string &savename );
void saveGame( const std::string &savename );

//Splash stuff
void showSplashScreen( const std::string &filename );
void showSplashMessage( const std::string &text );
void showSplashProgress( float progress );
void hideSplashScreen();
bool isSplashScreenShowing();

//Defined in gamemenu.cpp for vegastrike, universe_util_server.cpp for vegaserver.
void startMenuInterface( bool firsttime, string alert = string() );         //If game fails, bring it back to a common starting point.
}

#undef activeSys
#endif