universe_generic.h

Go to the documentation of this file.

/*
 * Vega Strike
 * Copyright (C) 2001-2002 Daniel Horn
 *
 * http://vegastrike.sourceforge.net/
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#ifndef _GENERICUNIVERSE_H
#define _GENERICUNIVERSE_H

#define NUM_LIGHT 8
#define NUM_FORCES 64

#include <memory>
#include "star_system_generic.h"
#include "faction_generic.h"
#include "stardate.h"

class Cockpit;
class Camera;
class Unit;
class Texture;

namespace GalaxyXML
{
class Galaxy;
}
class Universe
{
protected:
    std::auto_ptr<GalaxyXML::Galaxy> galaxy;
    unsigned int current_cockpit;
    std::vector< Cockpit* >cockpit;
//Camera hud_camera;
//void StartGL();
    std::vector< StarSystem* >active_star_system;

//the system currently used by the scripting
    StarSystem *script_system;
    bool is_server;
    bool network_lock;

private:
    friend class Faction;
//friend void bootstrap_main_loop();//so it can get all cockpits

public:
    void netLock( bool enable );
    bool netLocked();

    StarDate current_stardate;
    bool isServer()
    {
        return is_server;
    }
    Cockpit * isPlayerStarship( const Unit *fighter );
    Cockpit * isPlayerStarshipVoid( const void *pointercompare )
    {
//void *newp = const_cast<void *>(pointercompare);
//return this->isPlayerStarship(reinterpret_cast<Unit*>(newp));
        return isPlayerStarship( (const Unit*) pointercompare );
    }
    int whichPlayerStarship( const Unit *fighter );
    Cockpit * AccessCockpit()
    {
        return cockpit[current_cockpit];
    }
    Cockpit * AccessCockpit( int i )
    {
        return cockpit[i];
    }
    unsigned int CurrentCockpit()
    {
        return current_cockpit;
    }
    virtual Camera * AccessCamera( int num )
    {
        return NULL;
    }
    virtual Camera * AccessCamera()
    {
        return NULL;
    }
    virtual Camera * AccessHudCamera()
    {
        return NULL;
    }
    virtual void SetViewport() {}
    void SetActiveCockpit( int whichcockpit );
    void SetActiveCockpit( Cockpit *which );
    virtual void WriteSaveGame( bool auto_save ) {}
    virtual void SetupCockpits( std::vector< std::string >players );
    virtual void activateLightMap( int stage = 1 ) {}
    virtual Texture * getLightMap()
    {
        return NULL;
    }
    virtual void SelectCamera( int cam ) {}
//virtual unsigned int CurrentCockpit(){return 0;}
    Cockpit * createCockpit( std::string player );

    void getJumpPath( const std::string &from, const std::string &to, std::vector< std::string > &path ) const;
    const std::vector< std::string >& getAdjacentStarSystems( const std::string &ss ) const;
    std::string getGalaxyProperty( const std::string &sys, const std::string &prop );
    std::string getGalaxyPropertyDefault( const std::string &sys, const std::string &prop, const std::string def = "" );
    GalaxyXML::Galaxy * getGalaxy()
    {
        return galaxy.get();
    }
    bool StillExists( StarSystem *ss );
    void setActiveStarSystem( StarSystem *ss )
    {
        if ( active_star_system.empty() )
            pushActiveStarSystem( ss );
        else
            active_star_system.back() = ss;
    }
    void pushActiveStarSystem( StarSystem *ss )
    {
        active_star_system.push_back( ss );
    }
    void popActiveStarSystem()
    {
        if ( !active_star_system.empty() )
            active_star_system.pop_back();
    }
    void clearAllSystems();
//void SetActiveCockpit (int whichcockpit);
//void SetActiveCockpit (Cockpit * which);
    StarSystem * getActiveStarSystem( unsigned int size )
    {
        return size >= active_star_system.size() ? NULL : active_star_system[size];
    }
    unsigned int getNumActiveStarSystem()
    {
        return active_star_system.size();
    }
    void LoadStarSystem( StarSystem *ss );
    void UnloadStarSystem( StarSystem *ss );
    void Generate1( const char *file, const char *jumpback );
    void Generate2( StarSystem *ss );
    virtual StarSystem * GenerateStarSystem( const char *file, const char *jumpback, Vector origin );
    void LoadFactionXML( const char *factfile )
    {
        Faction::LoadXML( factfile );
    }
//void SetupCockpits (std::vector <std::string> players);
//void WriteSaveGame(bool auto_save);
//void activateLightMap();
    Universe();
    Universe( int argc, char **argv, const char *galaxy, bool server = false );
    void Init( const char *gal );
    virtual ~Universe();
//void StartGFX();
    virtual class StarSystem * Init( string systemfile, const Vector &centroid = Vector( 0,
                                                                                         0,
                                                                                         0 ), const string planetname = string() );
    virtual void StartDraw() {}
//Update starsystems (for server side)
    void Update();
    virtual void Loop( void f() ) {}
    StarSystem * activeStarSystem()
    {
        return active_star_system.empty() ? NULL
               : active_star_system.back();
    }
/*
 *  void SelectCamera(int cam) {
 *  AccessCockpit()->SelectCamera(cam);
 *  }
 */
//unsigned int CurrentCockpit(){return current_cockpit;}
//Cockpit *AccessCockpit() {return cockpit[current_cockpit];}
    unsigned int numPlayers()
    {
        return cockpit.size();
    }
//Cockpit *AccessCockpit (int i) {return cockpit[i];}
/*
 *  Camera *AccessCamera(int num) {
 *  return AccessCockpit()->AccessCamera(num);
 *  }
 */
/*
 *  Camera *AccessCamera() {
 *  return AccessCockpit()->AccessCamera();
 *  }
 */
//Camera *AccessHudCamera() { return &hud_camera; }
/*
 *  void SetViewport() {
 *  AccessCockpit()->SetViewport();
 *  }
 */

    StarSystem * getStarSystem( string name );
    StarSystem * scriptStarSystem()
    {
        if (script_system != NULL) return script_system;

        else return activeStarSystem();
        ;
    }
    bool setScriptSystem( string name )
    {
        if (name == "-active-") {
            script_system = NULL;
            return true;
        }
        StarSystem *ss = getStarSystem( name );
        if (script_system != NULL) {
            script_system = ss;
            return true;
        }
        return false;
    }
public:
    std::vector< StarSystem* >star_system;
    int StarSystemIndex( StarSystem *ss );
};

#endif