base_interface.cpp File Reference

#include "config.h"
#include <Python.h>
#include "base.h"
#include "gldrv/winsys.h"
#include "vsfilesystem.h"
#include "lin_time.h"
#include "audiolib.h"
#include "gfx/camera.h"
#include "gfx/cockpit_generic.h"
#include "python/init.h"
#include "python/python_compile.h"
#include "planet_generic.h"
#include <algorithm>
#include "base_util.h"
#include "config_xml.h"
#include "save_util.h"
#include "unit_util.h"
#include "networking/netclient.h"
#include "gfx/cockpit.h"
#include "gfx/ani_texture.h"
#include "music.h"
#include "load_mission.h"
#include "universe_util.h"
#include "gui/guidefs.h"
#include "main_loop.h"
#include "in_mouse.h"
#include "in_kb.h"
#include "audio/SceneManager.h"
#include "basecomputer.h"
#include "../gui/eventmanager.h"
#include "ai/communication.h"

Go to the source code of this file.

Classes
struct	BaseColor

Macros
#define	NEW_GUI
#define	mymin(a, b)   ( ( (a) < (b) ) ? (a) : (b) )

Functions
static unsigned int &	getMouseButtonMask ()
static void	biModifyMouseSensitivity (int &x, int &y, bool invert)
void	ModifyMouseSensitivity (int &x, int &y)
static void	CalculateRealXAndY (int xbeforecalc, int ybeforecalc, float *x, float *y)
static void	SetupViewport ()
static FILTER	BlurBases ()
void	RunPython (const char *filnam)
bool	RefreshGUI (void)
void	base_main_loop ()
int	shiftup (int)
static void	base_keyboard_cb (unsigned int ch, unsigned int mod, bool release, int x, int y)
double	compute_light_dot (Unit *base, Unit *un)
const char *	compute_time_of_day (Unit *base, Unit *un)
void	ExecuteDirector ()
void	InitCallbacks (void)
void	TerminateCurrentBase (void)
void	CurrentBaseUnitSet (Unit *un)
void	abletodock (int dock)
float	aynrand (float min, float max)
QVector	randyVector (float min, float max)
static void	AnimationDraw ()

Variables
static bool	createdbase = false
static int	createdmusic = -1
const char *	mission_key
std::vector< unsigned int >	base_keyboard_queue
static std::vector < BaseInterface::Room::BaseTalk * >	active_talks

Macro Definition Documentation

#define mymin	(		a,
			b
	)		( ( (a) < (b) ) ? (a) : (b) )

Definition at line 100 of file base_interface.cpp.

Referenced by Beam::Collide(), Unit::DamageRandSys(), DrawShield(), Orders::AutoLongHaul::Execute(), HaloAccelSmooth(), Unit::LightShields(), SetupViewport(), and trackPrice().

#define NEW_GUI

Definition at line 88 of file base_interface.cpp.

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;
        }
    }
}

static void AnimationDraw ( )

static

Definition at line 1397 of file base_interface.cpp.

References CULLFACE, GFXBegin(), GFXDisable(), GFXEnable(), GFXEnd(), GFXQUAD, GFXREPLACETEXTURE, GFXTexCoord2f(), GFXTextureEnv(), GFXVertex3f(), i, j, StreamTexture::MakeActive(), StreamTexture::Map(), NEAREST, TEXTURE0, TEXTURE1, and StreamTexture::UnMap().

Referenced by BaseInterface::Draw().

{
#ifdef RENDER_FROM_TEXTURE
    static StreamTexture T( 512, 256, NEAREST, NULL );
    BaseColor( *data )[512] = reinterpret_cast< BaseColor(*)[512] > ( T.Map() );
    bool counter = false;
    srand( time( NULL ) );
    for (int i = 0; i < 256; ++i)
        for (int j = 0; j < 512; ++j) {
            data[i][j].r = rand()&0xff;
            data[i][j].g = rand()&0xff;
            data[i][j].b = rand()&0xff;
            data[i][j].a = rand()&0xff;
        }
    T.UnMap();
    T.MakeActive();
    GFXTextureEnv( 0, GFXREPLACETEXTURE );
    GFXEnable( TEXTURE0 );
    GFXDisable( TEXTURE1 );
    GFXDisable( CULLFACE );
    GFXBegin( GFXQUAD );
    GFXTexCoord2f( 0, 0 );
    GFXVertex3f( -1.0, -1.0, 0.0 );
    GFXTexCoord2f( 1, 0 );
    GFXVertex3f( 1.0, -1.0, 0.0 );
    GFXTexCoord2f( 1, 1 );
    GFXVertex3f( 1.0, 1.0, 0.0 );
    GFXTexCoord2f( 0, 1 );
    GFXVertex3f( -1.0, 1.0, 0.0 );
    GFXEnd();
#endif
}

float aynrand ( float  min, float  max  )

inline

Definition at line 1242 of file base_interface.cpp.

References min().

Referenced by randyVector().

{
    return ( (float) ( rand() )/RAND_MAX )*(max-min)+min;
}

static void base_keyboard_cb ( unsigned int  ch, unsigned int  mod, bool  release, int  x, int  y  )

static

Definition at line 970 of file base_interface.cpp.

References base_keyboard_queue, BaseInterface::CallComp, BaseInterface::CurrentBase, KB_MOD_ALT, KB_MOD_CTRL, KB_MOD_SHIFT, BaseInterface::Key(), BaseInterface::ProcessKeyboardBuffer(), setActiveModifiers(), shiftup(), WSK_MOD_LALT, WSK_MOD_LCTRL, WSK_MOD_LSHIFT, WSK_MOD_RALT, WSK_MOD_RCTRL, and WSK_MOD_RSHIFT.

Referenced by BaseInterface::InitCallbacks().

{
    //Set modifiers
    unsigned int amods = 0;
    amods |= ( mod&(WSK_MOD_LSHIFT|WSK_MOD_RSHIFT) ) ? KB_MOD_SHIFT : 0;
    amods |= ( mod&(WSK_MOD_LCTRL|WSK_MOD_RCTRL) ) ? KB_MOD_CTRL : 0;
    amods |= ( mod&(WSK_MOD_LALT|WSK_MOD_RALT) ) ? KB_MOD_ALT : 0;
    setActiveModifiers( amods );
    unsigned int shiftedch =
        ( ( WSK_MOD_LSHIFT == (mod&WSK_MOD_LSHIFT) ) || ( WSK_MOD_RSHIFT == (mod&WSK_MOD_RSHIFT) ) ) ? shiftup( ch ) : ch;
    if (BaseInterface::CurrentBase && !BaseInterface::CurrentBase->CallComp) {
        //Flush buffer
        if ( base_keyboard_queue.size() )
            BaseInterface::ProcessKeyboardBuffer();
        //Send directly to base interface handlers
        BaseInterface::CurrentBase->Key( shiftedch, amods, release, x, y );
    } else
    //Queue keystroke
    if (!release) {
        base_keyboard_queue.push_back( shiftedch );
    }
}

void base_main_loop

(

)

Definition at line 649 of file base_interface.cpp.

References _Universe, AUDStopAllSounds(), createdbase, createdmusic, BaseComputer::dirty, GFXBeginScene(), GFXEndScene(), micro_sleep, Music::MuzakCycle(), Network, Universe::numPlayers(), RefreshGUI(), restore_main_loop(), and UpdateTime().

Referenced by BaseInterface::InitCallbacks().

{
    UpdateTime();
    Music::MuzakCycle();
    if (Network != NULL)
        for (size_t jj = 0; jj < _Universe->numPlayers(); jj++)
            Network[jj].checkMsg( NULL );
    GFXBeginScene();
    if (createdbase) {
        createdbase = false;
        AUDStopAllSounds( createdmusic );
    }
    if ( !RefreshGUI() ) {
        restore_main_loop();
    } else {
        GFXEndScene();
        micro_sleep( 1000 );
    }
    BaseComputer::dirty = false;
}

static void biModifyMouseSensitivity ( int &  x, int &  y, bool  invert  )

static

Definition at line 42 of file base_interface.cpp.

References g_game, VegaConfig::getVariable(), int, XMLSupport::parse_float(), XMLSupport::parse_int(), vs_config, game_data_t::x_resolution, and game_data_t::y_resolution.

Referenced by BaseInterface::Room::Click(), and ModifyMouseSensitivity().

{
    int xrez = g_game.x_resolution;
    static int   whentodouble = XMLSupport::parse_int( vs_config->getVariable( "joystick", "double_mouse_position", "1280" ) );
    static float factor = XMLSupport::parse_float( vs_config->getVariable( "joystick", "double_mouse_factor", "2" ) );
    if (xrez >= whentodouble) {
        x -= g_game.x_resolution/2;
        y -= g_game.y_resolution/2;
        if (invert) {
            x = int(x/factor);
            y = int(y/factor);
        } else {
            x = int(x*factor);
            y = int(y*factor);
        }
        x += g_game.x_resolution/2;
        y += g_game.y_resolution/2;
        if (x > g_game.x_resolution)
            x = g_game.x_resolution;
        if (y > g_game.y_resolution)
            y = g_game.y_resolution;
        if (x < 0) x = 0;
        if (y < 0) y = 0;
    }
}

static FILTER BlurBases ( )

static

Definition at line 135 of file base_interface.cpp.

References BILINEAR, VegaConfig::getVariable(), NEAREST, XMLSupport::parse_bool(), and vs_config.

Referenced by BaseInterface::Room::BaseVSSprite::SetSprite().

{
    static bool blur_bases = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "blur_bases", "true" ) );
    return blur_bases ? BILINEAR : NEAREST;
}

static void CalculateRealXAndY ( int  xbeforecalc, int  ybeforecalc, float *  x, float *  y  )

static

Definition at line 95 of file base_interface.cpp.

References float, g_game, game_data_t::x_resolution, and game_data_t::y_resolution.

Referenced by BaseInterface::Click(), and BaseInterface::MouseOver().

{
    (*x) = ( ( (float) (xbeforecalc*2) )/g_game.x_resolution )-1;
    (*y) = -( ( (float) (ybeforecalc*2) )/g_game.y_resolution )+1;
}

double compute_light_dot	(	Unit *	base,
		Unit *	un
	)

Definition at line 1034 of file base_interface.cpp.

References _Universe, UnitCollection::createIterator(), Unit::getStarSystem(), StarSystem::getUnitList(), Unit::isPlanet(), Unit::isUnit(), PLANETPTR, Universe::popActiveStarSystem(), Unit::Position(), Universe::pushActiveStarSystem(), QVector, and VSFileSystem::vs_fprintf().

Referenced by compute_time_of_day().

{
    StarSystem *ss    = base->getStarSystem();
    double ret        = -1;
    Unit  *st;
    Unit  *base_owner = NULL;
    if (ss) {
        _Universe->pushActiveStarSystem( ss );
        un_iter ui = ss->getUnitList().createIterator();
        for (; (st = *ui); ++ui)
            if ( st->isPlanet() ) {
                if ( ( (Planet*) st )->hasLights() ) {
                    QVector v1  = ( un->Position()-base->Position() ).Normalize();
                    QVector v2  = ( st->Position()-base->Position() ).Normalize();
#ifdef VS_DEBUG
                    double  dot = v1.Dot( v2 );
                    if (dot > ret) {
                        VSFileSystem::vs_fprintf( stderr, "dot %lf", dot );
                        ret = dot;
                    }
#endif
                } else {
                    un_iter ui   = ( (Planet*) st )->satellites.createIterator();
                    Unit   *ownz = NULL;
                    for (; (ownz = *ui); ++ui)
                        if (ownz == base)
                            base_owner = st;
                }
            }
        _Universe->popActiveStarSystem();
    } else {return 1; } if (base_owner == NULL || base->isUnit() == PLANETPTR)
        return ret;
    else
        return compute_light_dot( base_owner, un );
}

const char* compute_time_of_day	(	Unit *	base,
		Unit *	un
	)

Definition at line 1070 of file base_interface.cpp.

References compute_light_dot().

Referenced by BaseInterface::BaseInterface().

{
    if (!base || !un)
        return "day";
    float rez = compute_light_dot( base, un );
    if (rez > .2)
        return "day";
    if (rez < -.1)
        return "night";
    return "sunset";
}

void CurrentBaseUnitSet

(

Unit *

un)

Definition at line 1159 of file base_interface.cpp.

References BaseInterface::caller, BaseInterface::CurrentBase, and UnitContainer::SetUnit().

Referenced by buyShip().

{
    if (BaseInterface::CurrentBase)
        BaseInterface::CurrentBase->caller.SetUnit( un );
}

void ExecuteDirector

(

)

Definition at line 617 of file star_system_generic.cpp.

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 );
            }
        }
    }
}

static unsigned int& getMouseButtonMask ( )

static

Definition at line 36 of file base_interface.cpp.

Referenced by BaseInterface::Room::Link::Click(), BaseInterface::ClickWin(), and BaseInterface::MouseOver().

{
    static unsigned int mask = 0;
    return mask;
}

void InitCallbacks

(

void

)

Definition at line 1145 of file base_interface.cpp.

References BaseInterface::CurrentBase, and BaseInterface::InitCallbacks().

Referenced by EventManager::checkForShutDownEventManager().

{
    if (BaseInterface::CurrentBase)
        BaseInterface::CurrentBase->InitCallbacks();
}

void ModifyMouseSensitivity	(	int &	x,
		int &	y
	)

Definition at line 71 of file base_interface.cpp.

References biModifyMouseSensitivity().

Referenced by BaseInterface::ActiveMouseOverWin(), BaseInterface::ClickWin(), BaseInterface::PassiveMouseOverWin(), EventManager::ProcessMouseActive(), EventManager::ProcessMouseClick(), and EventManager::ProcessMousePassive().

{
    biModifyMouseSensitivity( x, y, false );
}

QVector randyVector ( float  min, float  max  )

inline

Definition at line 1247 of file base_interface.cpp.

References aynrand(), and QVector.

Referenced by BaseInterface::Room::Eject::Click().

{
    return QVector( aynrand( min, max ),
                   aynrand( min, max ),
                   aynrand( min, max ) );
}

bool RefreshGUI

(

void

)

Definition at line 625 of file base_interface.cpp.

References _Universe, Universe::AccessCockpit(), BaseInterface::CallComp, BaseInterface::caller, BaseInterface::CurrentBase, WindowManager::draw(), BaseInterface::Draw(), Cockpit::GetParent(), UnitContainer::GetUnit(), and globalWindowManager().

Referenced by base_main_loop(), and GameUniverse::StartDraw().

{
    bool retval = false;
    if ( _Universe->AccessCockpit() ) {
        if (BaseInterface::CurrentBase) {
            if ( _Universe->AccessCockpit()->GetParent() == BaseInterface::CurrentBase->caller.GetUnit() ) {
                if (BaseInterface::CurrentBase->CallComp) {
#ifdef NEW_GUI
                    globalWindowManager().draw();
                    return true;

#else
                    return RefreshInterface();
#endif
                } else {
                    BaseInterface::CurrentBase->Draw();
                }
                retval = true;
            }
        }
    }
    return retval;
}

void RunPython

(

const char *

filnam)

Definition at line 546 of file base_interface.cpp.

References CompileRunPython().

Referenced by BaseInterface::Room::Link::Click(), BaseInterface::Room::BasePython::Draw(), BaseInterface::Room::BaseVSMovie::Draw(), BaseInterface::Key(), BaseInterface::Room::Link::MouseEnter(), BaseInterface::Room::Link::MouseLeave(), BaseInterface::Room::Link::MouseMove(), and BaseUtil::VideoAudioStreamListener::onEndOfStream().

{
#ifdef DEBUG_RUN_PYTHON
    printf( "Run python:\n%s\n", filnam );
#endif
    if (filnam[0]) {
        if (filnam[0] == '#' && filnam[1] != '\0') {
            ::Python::reseterrors();
            PyRun_SimpleString( const_cast< char* > (filnam) );
            ::Python::reseterrors();
        } else {
            CompileRunPython( filnam );
        }
    }
}

static void SetupViewport ( )

static

Definition at line 101 of file base_interface.cpp.

References g_game, VegaConfig::getVariable(), mymin, XMLSupport::parse_int(), vs_config, game_data_t::x_resolution, and game_data_t::y_resolution.

Referenced by BaseInterface::Room::BaseShip::Draw(), and BaseInterface::Draw().

{
    static int base_max_width  = XMLSupport::parse_int( vs_config->getVariable( "graphics", "base_max_width", "0" ) );
    static int base_max_height = XMLSupport::parse_int( vs_config->getVariable( "graphics", "base_max_height", "0" ) );
    if (base_max_width && base_max_height) {
        int xrez    = mymin( g_game.x_resolution, base_max_width );
        int yrez    = mymin( g_game.y_resolution, base_max_height );
        int offsetx = (g_game.x_resolution-xrez)/2;
        int offsety = (g_game.y_resolution-yrez)/2;
        glViewport( offsetx, offsety, xrez, yrez );
    }
}

int shiftup

(

int

)

Definition at line 72 of file in_kb.cpp.

Referenced by base_keyboard_cb(), gamemenu_keyboard_handler(), glut_keyboard_cb(), nav_keyboard_cb(), and CockpitKeys::TextMessageCallback().

{
    if ( ch == (ch&0xFF) ) {
        const char *c = strchr( _lomap, ch );
        if (c)
            return _himap[c-_lomap];

        else
            return toupper( ch );
    } else {return ch; }}

void TerminateCurrentBase

(

void

)

Definition at line 1151 of file base_interface.cpp.

References BaseInterface::CurrentBase, and BaseInterface::Terminate().

Referenced by BaseComputer::actionConfirmedLoadGame(), BaseComputer::draw(), NetActionConfirm::finalizeJoinGame(), UniverseUtil::loadGame(), and GameMenu::processSinglePlayerButton().

{
    if (BaseInterface::CurrentBase) {
        BaseInterface::CurrentBase->Terminate();
        BaseInterface::CurrentBase = NULL;
    }
}

Variable Documentation

std::vector< BaseInterface::Room::BaseTalk* > active_talks

static

Definition at line 496 of file base_interface.cpp.

Referenced by BaseInterface::Room::BaseTalk::BaseTalk(), and BaseInterface::Room::BaseTalk::Draw().

std::vector< unsigned int > base_keyboard_queue

Definition at line 94 of file base_interface.cpp.

Referenced by base_keyboard_cb(), BaseComputer::constructControls(), and BaseInterface::ProcessKeyboardBuffer().

bool createdbase = false

static

Definition at line 68 of file base_interface.cpp.

Referenced by base_main_loop(), and BaseInterface::BaseInterface().

int createdmusic = -1

static

Definition at line 69 of file base_interface.cpp.

Referenced by base_main_loop(), and BaseInterface::BaseInterface().

const char* mission_key

Definition at line 22 of file vs_globals.cpp.

Referenced by BaseInterface::BaseInterface(), DockToSavedBases(), and BaseInterface::Terminate().