planet.cpp File Reference

#include <math.h>
#include "vegastrike.h"
#include "unit_factory.h"
#include "planet.h"
#include "gfxlib.h"
#include "gfx/sphere.h"
#include "collection.h"
#include "ai/order.h"
#include "gfxlib_struct.h"
#include "vs_globals.h"
#include "config_xml.h"
#include <assert.h>
#include "cont_terrain.h"
#include "atmosphere.h"
#include "collide2/CSopcodecollider.h"
#include "images.h"
#include "gfx/halo.h"
#include "gfx/animation.h"
#include "cmd/script/flightgroup.h"
#include "gfx/ring.h"
#include "alphacurve.h"
#include "gfx/vsimage.h"
#include "vsfilesystem.h"
#include "gfx/camera.h"

Go to the source code of this file.

Classes
class	AtmosphereHalo

Functions
static void	SetFogMaterialColor (Mesh *thus, const GFXColor &color, const GFXColor &dcolor)
Mesh *	MakeFogMesh (const AtmosphericFogMesh &f, float radius)
const vector< string > &	ParseDestinations (const string &value)
bool	CrashForceDock (Unit *thus, Unit *dockingUn, bool force)
void	abletodock (int dock)

Variables
vector< UnitContainer * >	PlanetTerrainDrawQueue

Function Documentation

void abletodock

(

int

dock)

Definition at line 1247 of file firekeyboard.cpp.

{
    static bool play_anim = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "docking_comm_anim", "false" ) );
    switch (dock)
    {
    case 5:
        {
            static soundContainer reqsound;
            if (reqsound.sound == -2) {
                static string str = vs_config->getVariable( "cockpitaudio", "undocking_complete", "undocking_complete" );
                reqsound.loadsound( str );
            }
            reqsound.playsound();
            break;
        }
    case 4:
        {
            static soundContainer reqsound;
            if (reqsound.sound == -2) {
                static string str = vs_config->getVariable( "cockpitaudio", "undocking_failed", "undocking_failed" );
                reqsound.loadsound( str );
            }
            reqsound.playsound();
            break;
        }
    case 3:
        {
            static soundContainer reqsound;
            static string otherstr = vs_config->getVariable( "audio", "automatic_docking_zone", "automatic_landing_zone.wav" );
            if (otherstr != "" && rand() < RAND_MAX/2) {
                static int s = AUDCreateSoundWAV( otherstr, false );
                AUDPlay( s, QVector( 0, 0, 0 ), Vector( 0, 0, 0 ), 1 );
            } else {
                if (reqsound.sound == -2) {
                    static string str = vs_config->getVariable( "cockpitaudio", "docking_complete", "docking_complete" );
                    reqsound.loadsound( str );
                }
                reqsound.playsound();
            }
            break;
        }
    case 2:
        {
            static soundContainer reqsound;
            if (reqsound.sound == -2) {
                static string str = vs_config->getVariable( "cockpitaudio", "docking_failed", "docking_failed" );
                reqsound.loadsound( str );
            }
            reqsound.playsound();
            break;
        }
    case 1:
        {
            static soundContainer reqsound;
            if (reqsound.sound == -2) {
                static string str = vs_config->getVariable( "cockpitaudio", "docking_granted", "request_granted" );
                reqsound.loadsound( str );
            }
            reqsound.playsound();
            break;
        }
    case 0:
        {
            static soundContainer reqsound;
            if (reqsound.sound == -2) {
                static string str = vs_config->getVariable( "cockpitaudio", "docking_denied", "request_denied" );
                reqsound.loadsound( str );
            }
            reqsound.playsound();
            break;
        }
    }
}

bool CrashForceDock	(	Unit *	thus,
		Unit *	dockingUn,
		bool	force
	)

Definition at line 365 of file unit_generic.cpp.

References _Universe, abletodock(), Unit::CanDockWithMe(), NetClient::dockRequest(), Unit::ForceDock(), Unit::GetSerial(), Network, Unit::Position(), QVector, Unit::rSize(), UniverseUtil::SafeEntrancePoint(), Unit::SetPosAndCumPos(), Unit::UpgradeInterface(), and Universe::whichPlayerStarship().

Referenced by GamePlanet::reactToCollision(), and Unit::reactToCollision().

{
    Unit *un = dockingUn;
    int   whichdockport = thus->CanDockWithMe( un, force );
    if (whichdockport != -1) {
        if (Network == NULL) {
            QVector place = UniverseUtil::SafeEntrancePoint( un->Position(), un->rSize()*1.5 );
            un->SetPosAndCumPos( place );
            if (un->ForceDock( thus, whichdockport ) > 0) {
                abletodock( 3 );
                un->UpgradeInterface( thus );
                return true;
            }
        } else {
            int playernum = _Universe->whichPlayerStarship( dockingUn );
            if (playernum >= 0)
                Network[playernum].dockRequest( thus->GetSerial() );
            return false;
        }
    }
    return false;
}

Mesh* MakeFogMesh	(	const AtmosphericFogMesh &	f,
		float	radius
	)

Definition at line 60 of file planet.cpp.

References AtmosphericFogMesh::concavity, AtmosphericFogMesh::da, AtmosphericFogMesh::db, AtmosphericFogMesh::dg, AtmosphericFogMesh::dr, AtmosphericFogMesh::ea, AtmosphericFogMesh::eb, AtmosphericFogMesh::eg, AtmosphericFogMesh::er, AtmosphericFogMesh::focus, get_alpha(), VegaConfig::getVariable(), i, Mesh::LoadMesh(), AtmosphericFogMesh::max_alpha, AtmosphericFogMesh::meshname, AtmosphericFogMesh::min_alpha, override, XMLSupport::parse_int(), PngImage, AtmosphericFogMesh::scale, Mesh::setConvex(), SetFogMaterialColor(), AtmosphericFogMesh::tail_mode_end, AtmosphericFogMesh::tail_mode_start, VSFileSystem::TextureFile, XMLSupport::tostring(), Vector, and vs_config.

Referenced by GamePlanet::AddFog().

{
    static int count = 0;
    count++;
    string     nam   = f.meshname+XMLSupport::tostring( count )+".png";
    if (f.min_alpha != 0 || f.max_alpha != 255 || f.concavity != 0 || f.focus != .5 || f.tail_mode_start != -1
        || f.tail_mode_end != -1) {
        static int     rez = XMLSupport::parse_int( vs_config->getVariable( "graphics", "atmosphere_texture_resolution", "512" ) );
        unsigned char *tex = (unsigned char*) malloc( sizeof (char)*rez*4 );
        for (int i = 0; i < rez; ++i) {
            tex[i*4]   = 255;
            tex[i*4+1] = 255;
            tex[i*4+2] = 255;
            tex[i*4+3] = get_alpha( i, rez, f.min_alpha, f.max_alpha, f.focus, f.concavity, f.tail_mode_start, f.tail_mode_end );
        }
        //Writing in the homedir texture directory
        ::VSImage image;
        using VSFileSystem::TextureFile;
        image.WriteImage( (char*) nam.c_str(), &tex[0], PngImage, rez, 1, true, 8, TextureFile );
    }
    vector< string >override;
    override.push_back( nam );
    Mesh *ret = Mesh::LoadMesh( f.meshname.c_str(), Vector( f.scale*radius, f.scale*radius, f.scale*radius ), 0, NULL, override );
    ret->setConvex( true );
    SetFogMaterialColor( ret, GFXColor( f.er, f.eg, f.eb, f.ea ), GFXColor( f.dr, f.dg, f.db, f.da ) );
    return ret;
}

const vector< string >& ParseDestinations

(

const string &

value)

Definition at line 178 of file galaxy.cpp.

Referenced by Mission::call_unit_launch(), Universe::getAdjacentStarSystems(), MakeStarSystem(), and UniverseUtil::showSplashScreen().

{
    static vector< string >rv;
    rv.clear();
    string::size_type pos = 0, sep;
    while ( ( sep = value.find( ' ', pos ) ) != string::npos ) {
        rv.push_back( value.substr( pos, sep-pos ) );
        pos = sep+1;
    }
    if ( pos < value.length() )
        rv.push_back( value.substr( pos ) );
    return rv;
}

static void SetFogMaterialColor ( Mesh *  thus, const GFXColor &  color, const GFXColor &  dcolor  )

static

Definition at line 43 of file planet.cpp.

References GFXColor::a, GFXMaterial::aa, GFXMaterial::ab, GFXMaterial::ag, GFXMaterial::ar, GFXColor::b, GFXMaterial::da, GFXMaterial::db, GFXMaterial::dg, GFXMaterial::dr, GFXMaterial::ea, GFXMaterial::eb, GFXMaterial::eg, GFXMaterial::er, GFXColor::g, VegaConfig::getVariable(), XMLSupport::parse_float(), GFXMaterial::power, GFXColor::r, GFXMaterial::sa, GFXMaterial::sb, Mesh::SetMaterial(), GFXMaterial::sg, GFXMaterial::sr, and vs_config.

Referenced by MakeFogMesh().

{
    GFXMaterial  m;
    m.ar    = m.ag = m.ab = m.aa = m.sr = m.sg = m.sb = m.sa = 0;
    m.power = 0;
    static float emm  = XMLSupport::parse_float( vs_config->getVariable( "graphics", "atmosphere_emmissive", "1" ) );
    static float diff = XMLSupport::parse_float( vs_config->getVariable( "graphics", "atmosphere_diffuse", "1" ) );
    m.er    = emm*color.r;
    m.eg    = emm*color.g;
    m.eb    = emm*color.b;
    m.ea    = emm*color.a;
    m.dr    = diff*dcolor.r;
    m.dg    = diff*dcolor.g;
    m.db    = diff*dcolor.b;
    m.da    = diff*dcolor.a;
    thus->SetMaterial( m );
}

Variable Documentation

vector< UnitContainer* > PlanetTerrainDrawQueue

Definition at line 361 of file planet.cpp.