#include <base.h>

Classes
class	Room

Public Member Functions
void	Terminate ()

void	GotoLink (int linknum)

void	InitCallbacks ()

void	CallCommonLinks (const std::string &name, const std::string &value)

void	Load (const char filename, const char time_of_day, const char *faction)

void	Click (int x, int y, int button, int state)

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

void	MouseOver (int x, int y)

	BaseInterface (const char basefile, Unit base, Unit *un)

	~BaseInterface ()

void	Draw ()

void	setDJEnabled (bool enabled)

bool	isDJEnabled () const

Static Public Member Functions
static void	ClickWin (int x, int y, int button, int state)

static void	PassiveMouseOverWin (int x, int y)

static void	ActiveMouseOverWin (int x, int y)

static void	ProcessKeyboardBuffer ()

Public Attributes
int	curroom

std::vector< Room * >	rooms

TextPlane	othtext

bool	CallComp

UnitContainer	caller

UnitContainer	baseun

std::string	python_kbhandler

Static Public Attributes
static BaseInterface *	CurrentBase = NULL

Friends
class	Room

class	Room::BaseTalk

Detailed Description

Definition at line 21 of file base.h.

Constructor & Destructor Documentation

BaseInterface::BaseInterface	(	const char *	basefile,
		Unit *	base,
		Unit *	un
	)

Definition at line 1084 of file base_interface.cpp.

References AUDHighestSoundPlaying(), BASE_EXTENSION, baseun, CallComp, caller, BaseUtil::Comp(), compute_time_of_day(), createdbase, createdmusic, CurrentBase, curroom, ExecuteDirector(), Unit::faction, TextPlane::GetCharSize(), FactionUtil::GetFaction(), UniverseUtil::GetGalaxyFaction(), UnitUtil::getUnitSystemFile(), GotoLink(), i, UnitUtil::isPlayerStarship(), BaseUtil::Launch(), Load(), mission_key, Unit::name, othtext, QVector, Room, rooms, saveStringList(), TextPlane::SetCharSize(), TextPlane::SetSize(), VSFileSystem::vs_fprintf(), x, and y.

                                                                          :
     curtext( getConfigColor( "Base_Text_Color_Foreground",
                             GFXColor( 0, 1, 0, 1 ) ), getConfigColor( "Base_Text_Color_Background", GFXColor( 0, 0, 0, 1 ) ) )
     , othtext( getConfigColor( "Fixer_Text_Color_Foreground",
                               GFXColor( 1, 1, .5, 1 ) ), getConfigColor( "FixerTextColor_Background", GFXColor( 0, 0, 0, 1 ) ) )
 {
     CurrentBase    = this;
     CallComp       = false;
     lastmouseindex = 0;
     enabledj       = true;
     createdbase    = true;
     midloop        = false;
     terminate_scheduled = false;
     createdmusic   = -1;
     caller = un;
     curroom = 0;
     curlinkindex   = 0;
     this->baseun   = base;
     float x, y;
     curtext.GetCharSize( x, y );
     curtext.SetCharSize( x*2, y*2 );
     curtext.SetSize( 1-.01, -2 );
     othtext.GetCharSize( x, y );
     othtext.SetCharSize( x*2, y*2 );
     othtext.SetSize( 1-.01, -.75 );
 
     std::string fac = base ? FactionUtil::GetFaction( base->faction ) : "neutral";
     if (base && fac == "neutral")
         fac = UniverseUtil::GetGalaxyFaction( UnitUtil::getUnitSystemFile( base ) );
     Load( basefile, compute_time_of_day( base, un ), fac.c_str() );
     createdmusic = AUDHighestSoundPlaying();
     if (base && un) {
         vector< string >vec;
         vec.push_back( base->name );
         int cpt = UnitUtil::isPlayerStarship( un );
         if (cpt >= 0)
             saveStringList( cpt, mission_key, vec );
     }
     if ( !rooms.size() ) {
         VSFileSystem::vs_fprintf( stderr,
                                   "ERROR: there are no rooms in basefile \"%s%s%s\" ...\n",
                                   basefile,
                                   compute_time_of_day( base, un ),
                                   BASE_EXTENSION );
         rooms.push_back( new Room() );
         rooms.back()->deftext = "ERROR: No rooms specified...";
 #ifndef BASE_MAKER
         rooms.back()->objs.push_back( new Room::BaseShip( -1, 0, 0, 0, 0, -1, 0, 1, 0, QVector( 0, 0, 2 ), "default room" ) );
         BaseUtil::Launch( 0, "default room", -1, -1, 1, 2, "ERROR: No rooms specified... - Launch" );
         BaseUtil::Comp( 0, "default room", 0, -1, 1, 2, "ERROR: No rooms specified... - Computer",
                         "Cargo Upgrade Info ShipDealer News Missions" );
 #endif
     }
     GotoLink( 0 );
     {
         for (unsigned int i = 0; i < 16; ++i)
             ExecuteDirector();
     }
 }

BaseInterface::~BaseInterface ( )

Definition at line 952 of file base_interface.cpp.

References BASE_EXTENSION, CurrentBase, i, restore_main_loop(), rooms, VSFileSystem::vs_close(), and VSFileSystem::vs_open().

 {
 #ifdef BASE_MAKER
     FILE *fp = VSFileSystem::vs_open( "bases/NEW_BASE" BASE_EXTENSION, "wt" );
     if (fp) {
         EndXML( fp );
         VSFileSystem::vs_close( fp );
     }
 #endif
     CurrentBase = 0;
     restore_main_loop();
     for (size_t i = 0; i < rooms.size(); i++)
         delete rooms[i];
 }

Member Function Documentation

void BaseInterface::ActiveMouseOverWin	(	int	x,
		int	y
	)

static

Definition at line 892 of file base_interface.cpp.

References CallComp, CurrentBase, ModifyMouseSensitivity(), NavigationSystem::mouseDrag(), MouseOver(), and SetSoftwareMousePosition().

Referenced by InitCallbacks(), and GameCockpit::NavScreen().

 {
     ModifyMouseSensitivity( x, y );
     SetSoftwareMousePosition( x, y );
     if (CurrentBase) {
         if (CurrentBase->CallComp) {
 #ifdef NEW_GUI
             EventManager::
 #else
             UpgradingInfo::
 #endif
             ProcessMouseActive( x, y );
         } else {
             CurrentBase->MouseOver( x, y );
         }
     } else {
         NavigationSystem::mouseDrag( x, y );
     }
 }

void BaseInterface::CallCommonLinks	(	const std::string &	name,
		const std::string &	value
	)

void BaseInterface::Click	(	int	x,
		int	y,
		int	button,
		int	state
	)

Definition at line 841 of file base_interface.cpp.

References CalculateRealXAndY(), curroom, rooms, x, and y.

Referenced by ClickWin().

 {
     float x, y;
     CalculateRealXAndY( xint, yint, &x, &y );
     rooms[curroom]->Click( this, x, y, button, state );
 }

void BaseInterface::ClickWin	(	int	x,
		int	y,
		int	button,
		int	state
	)

static

Definition at line 848 of file base_interface.cpp.

References CallComp, Click(), CurrentBase, getMouseButtonMask(), ModifyMouseSensitivity(), NavigationSystem::mouseClick(), WS_MOUSE_DOWN, and WS_MOUSE_UP.

Referenced by InitCallbacks(), and GameCockpit::NavScreen().

 {
     ModifyMouseSensitivity( x, y );
     if (state == WS_MOUSE_DOWN)
         getMouseButtonMask() |= ( 1<<(button-1) );
 
     else if (state == WS_MOUSE_UP)
         getMouseButtonMask() &= ~( 1<<(button-1) );
     if (CurrentBase) {
         if (CurrentBase->CallComp) {
 #ifdef NEW_GUI
             EventManager::
 #else
             UpgradingInfo::
 #endif
             ProcessMouseClick( button, state, x, y );
         } else {
             CurrentBase->Click( x, y, button, state );
         }
     } else {
         NavigationSystem::mouseClick( button, state, x, y );
     }
 }

void BaseInterface::Draw ( )

Definition at line 1429 of file base_interface.cpp.

References GFXColor::a, MessageCenter::add(), AnimationDraw(), baseun, TextPlane::bgcol, caller, curroom, UnitImages< BOGUS >::dockedunits, TextPlane::Draw(), EndGUIFrame(), Unit::FreeDockingPort(), g_game, GetElapsedTime(), Singleton< SceneManager >::getSingleton(), TextPlane::GetText(), UnitContainer::GetUnit(), VegaConfig::getVariable(), GFXTRUE, BaseInterface::Room::BaseTalk::hastalked, i, mission, Mission::msgcenter, othtext, XMLSupport::parse_float(), Unit::pImage, rooms, TextPlane::SetPos(), SetupViewport(), game_data_t::sound_enabled, StartGUIFrame(), Terminate(), AnimatedTexture::UpdateAllFrame(), vs_config, VSFileSystem::vs_fprintf(), x, game_data_t::x_resolution, y, and game_data_t::y_resolution.

Referenced by RefreshGUI().

 {
     // Some operations cannot be performed in the middle of a Draw() loop
     midloop = true;
     
     GFXColor( 0, 0, 0, 0 );
     SetupViewport();
     StartGUIFrame( GFXTRUE );
     if (GetElapsedTime() < 1) {
         AnimatedTexture::UpdateAllFrame();
     }
     Room::BaseTalk::hastalked = false;
     rooms[curroom]->Draw( this );
     AnimationDraw();
 
     float x, y;
     glViewport( 0, 0, g_game.x_resolution, g_game.y_resolution );
     static float base_text_background_alpha =
         XMLSupport::parse_float( vs_config->getVariable( "graphics", "base_text_background_alpha", "0.0625" ) );
 
     curtext.GetCharSize( x, y );
     curtext.SetPos( -.99, -1+(y*1.5) );
 
     if (curtext.GetText().find( "XXX" ) != 0) {
         GFXColor tmpbg     = curtext.bgcol;
         bool     automatte = (0 == tmpbg.a);
         if (automatte) curtext.bgcol = GFXColor( 0, 0, 0, base_text_background_alpha );
         curtext.Draw( curtext.GetText(), 0, true, false, automatte );
         curtext.bgcol = tmpbg;
     }
     othtext.SetPos( -.99, 1 );
 
     if (othtext.GetText().length() != 0) {
         GFXColor tmpbg     = othtext.bgcol;
         bool     automatte = (0 == tmpbg.a);
         if (automatte) othtext.bgcol = GFXColor( 0, 0, 0, base_text_background_alpha );
         othtext.Draw( othtext.GetText(), 0, true, false, automatte );
         othtext.bgcol = tmpbg;
     }
     SetupViewport();
     EndGUIFrame( mousePointerStyle );
     glViewport( 0, 0, g_game.x_resolution, g_game.y_resolution );
     Unit *un   = caller.GetUnit();
     Unit *base = baseun.GetUnit();
     if ( un && (!base) ) {
         VSFileSystem::vs_fprintf( stderr, "Error: Base NULL" );
         mission->msgcenter->add( "game", "all", "[Computer] Docking unit destroyed. Emergency launch initiated." );
         for (size_t i = 0; i < un->pImage->dockedunits.size(); i++)
             if (un->pImage->dockedunits[i]->uc.GetUnit() == base)
                 un->FreeDockingPort( i );
         Terminate();
     }
     
     //Commit audio scene status to renderer
     if (g_game.sound_enabled)
         Audio::SceneManager::getSingleton()->commit();
     
     // Some operations cannot be performed in the middle of a Draw() loop
     // If any of them are scheduled for deferred execution, do so now
     midloop = false;
     if (terminate_scheduled)
         Terminate();
 }

void BaseInterface::GotoLink ( int linknum)

Definition at line 928 of file base_interface.cpp.

References curroom, BaseInterface::Room::deftext, MOUSE_POINTER_NORMAL, othtext, BaseInterface::Room::Room(), rooms, TextPlane::SetText(), and VSFileSystem::vs_fprintf().

Referenced by BaseInterface(), BaseInterface::Room::Goto::Click(), and BaseUtil::SetCurRoom().

 {
     othtext.SetText( "" );
     if (static_cast<int>(rooms.size()) > linknum && linknum >= 0) {
         curlinkindex   = 0;
         curroom = linknum;
         curtext.SetText( rooms[curroom]->deftext );
         mousePointerStyle = MOUSE_POINTER_NORMAL;
     } else {
 #ifndef BASE_MAKER
         VSFileSystem::vs_fprintf( stderr, "\nWARNING: base room #%d tried to go to an invalid index: #%d", curroom, linknum );
         assert( 0 );
 #else
         while (rooms.size() <= linknum) {
             rooms.push_back( new Room() );
             char roomnum[50];
             sprintf( roomnum, "Room #%d", linknum );
             rooms.back()->deftext = roomnum;
         }
         GotoLink( linknum );
 #endif
     }
 }

void BaseInterface::InitCallbacks ( )

Definition at line 993 of file base_interface.cpp.

References _Universe, ActiveMouseOverWin(), base_keyboard_cb(), base_main_loop(), CallComp, ClickWin(), CurrentBase, VegaConfig::getVariable(), GFXLoop(), Universe::numPlayers(), XMLSupport::parse_bool(), PassiveMouseOverWin(), vs_config, winsys_set_keyboard_func(), winsys_set_motion_func(), winsys_set_mouse_func(), and winsys_set_passive_motion_func().

Referenced by InitCallbacks(), and BaseUtil::LoadBaseInterfaceAtDock().

 {
     winsys_set_keyboard_func( base_keyboard_cb );
     winsys_set_mouse_func( ClickWin );
     winsys_set_motion_func( ActiveMouseOverWin );
     winsys_set_passive_motion_func( PassiveMouseOverWin );
     CurrentBase = this;
     CallComp    = false;
     static bool simulate_while_at_base =
         XMLSupport::parse_bool( vs_config->getVariable( "physics", "simulate_while_docked", "false" ) );
     if ( !(simulate_while_at_base || _Universe->numPlayers() > 1) )
         GFXLoop( base_main_loop );
 }

bool BaseInterface::isDJEnabled ( ) const

inline

Definition at line 352 of file base.h.

352 { return enabledj; }

void BaseInterface::Key	(	unsigned int	ch,
		unsigned int	mod,
		bool	release,
		int	x,
		int	y
	)

Definition at line 912 of file base_interface.cpp.

References python_kbhandler, RunPython(), and BaseUtil::SetKeyEventData().

Referenced by base_keyboard_cb(), and ProcessKeyboardBuffer().

 {
     if ( !python_kbhandler.empty() ) {
         const std::string *evtype;
         if (release) {
             static const std::string release_evtype( "keyup" );
             evtype = &release_evtype;
         } else {
             static const std::string press_evtype( "keydown" );
             evtype = &press_evtype;
         }
         BaseUtil::SetKeyEventData( *evtype, ch );
         RunPython( python_kbhandler.c_str() );
     }
 }

void BaseInterface::Load	(	const char *	filename,
		const char *	time_of_day,
		const char *	faction
	)

Definition at line 34 of file base_xml.cpp.

References BASE_EXTENSION, baseun, getFullFile(), Unit::isUnit(), PLANETPTR, VSFileSystem::vs_close(), and VSFileSystem::vs_open().

Referenced by BaseInterface().

 {
 #if 0
     std::string full_filename     = string( "bases/" )+filename;
     std::string daynight_filename = full_filename+"_"+string( time_of_day_hint );
     full_filename     += BASE_EXTENSION;
     daynight_filename += BASE_EXTENSION;
     std::string newfile = daynight_filename;
     cout<<"BaseInterface::LoadXML "<<full_filename<<endl;
     FILE *inFile = VSFileSystem::vs_open( daynight_filename.c_str(), "r" );
     if (!inFile) {
         newfile = full_filename;
         inFile  = VSFileSystem::vs_open( full_filename.c_str(), "r" );
     }
     if (!inFile) {
         Unit *baseun = this->baseun.GetUnit();
         if (baseun) {
             if (baseun->isUnit() == PLANETPTR) {
                 daynight_filename = string( "bases/planet_" )+time_of_day_hint+string( BASE_EXTENSION );
                 inFile  = VSFileSystem::vs_open( daynight_filename.c_str(), "r" );
                 newfile = daynight_filename;
                 if (!inFile) {
                     newfile = "bases/planet" BASE_EXTENSION;
                     inFile  = VSFileSystem::vs_open( newfile.c_str(), "r" );
                 }
             } else {
                 daynight_filename = string( "bases/unit_" )+time_of_day_hint+string( BASE_EXTENSION );
                 inFile  = VSFileSystem::vs_open( daynight_filename.c_str(), "r" );
                 newfile = daynight_filename;
                 if (!inFile) {
                     newfile = "bases/unit" BASE_EXTENSION;
                     inFile  = VSFileSystem::vs_open( newfile.c_str(), "r" );
                 }
             }
         }
         if (!inFile)
             return;
     }
 #else
     FILE *inFile = getFullFile( string( "bases/" )+filename, time_of_day_hint, faction );
     if (!inFile) {
         bool   planet = false;
         Unit  *baseun = this->baseun.GetUnit();
         if (baseun)
             planet = (baseun->isUnit() == PLANETPTR);
         string basestring( "bases/unit" );
         if (planet)
             basestring = "bases/planet";
         inFile = getFullFile( basestring, time_of_day_hint, faction );
         if (!inFile)
             return;
     }
 #endif
     //now that we have a FILE * named inFile and a std::string named newfile we can finally begin the python
     string compilefile = string( filename )+time_of_day_hint+string( faction )+BASE_EXTENSION;
     Python::reseterrors();
     PyRun_SimpleFile( inFile, compilefile.c_str() );
     Python::reseterrors();
     VSFileSystem::vs_close( inFile );
 }

void BaseInterface::MouseOver	(	int	x,
		int	y
	)

Definition at line 791 of file base_interface.cpp.

References CalculateRealXAndY(), curroom, BaseInterface::Room::deftext, getMouseButtonMask(), VegaConfig::getVariable(), i, BaseInterface::Room::links, MOUSE_POINTER_HOVER, MOUSE_POINTER_NORMAL, BaseInterface::Room::Link::MouseEnter(), BaseInterface::Room::Link::MouseLeave(), BaseInterface::Room::Link::MouseMove(), XMLSupport::parse_bool(), XMLSupport::parse_float(), BaseInterface::Room::Link::pythonfile, rooms, UniverseUtil::sqrt(), BaseInterface::Room::Link::text, vs_config, x, and y.

Referenced by ActiveMouseOverWin(), and PassiveMouseOverWin().

 {
     float x, y;
     CalculateRealXAndY( xbeforecalc, ybeforecalc, &x, &y );
     int   i = rooms[curroom]->MouseOver( this, x, y ); //FIXME Whatever this is, it shouldn't be named just "i"; & possibly should be size_t
     Room::Link *link    = 0;
     Room::Link *hotlink = 0;
     if (i >= 0)
         link = rooms[curroom]->links[i];
     if ( lastmouseindex >= 0 && lastmouseindex < static_cast<int>(rooms[curroom]->links.size()) )
         hotlink = rooms[curroom]->links[lastmouseindex];
     if ( hotlink && (lastmouseindex != i) )
         hotlink->MouseLeave( this, x, y, getMouseButtonMask() );
     if ( link && (lastmouseindex != i) )
         link->MouseEnter( this, x, y, getMouseButtonMask() );
     if (link)
         link->MouseMove( this, x, y, getMouseButtonMask() );
     lastmouseindex = i;
     static float overcolor[4]     = {1, .666666667, 0, 1};
     static float inactivecolor[4] = {0, 1, 0, 1};
     if (link)
         curtext.SetText( link->text );
     else
         curtext.SetText( rooms[curroom]->deftext );
     if (link && link->pythonfile != "#") {
         curtext.col    = GFXColor( overcolor[0], overcolor[1], overcolor[2], overcolor[3] );
         mousePointerStyle = MOUSE_POINTER_HOVER;
     } else {
         curtext.col    = GFXColor( inactivecolor[0], inactivecolor[1], inactivecolor[2], inactivecolor[3] );
         mousePointerStyle = MOUSE_POINTER_NORMAL;
     }
     static bool  draw_always =
         XMLSupport::parse_bool( vs_config->getVariable( "graphics", "base_locationmarker_drawalways", "false" ) );
     static float defined_distance =
         fabs( XMLSupport::parse_float( vs_config->getVariable( "graphics", "base_locationmarker_distance", "0.5" ) ) );
     if (!draw_always) {
         float cx, cy;
         float dist_cur2link;
         for (i = 0; i < static_cast<int>(rooms[curroom]->links.size()); i++) {
             cx = ( rooms[curroom]->links[i]->x+(rooms[curroom]->links[i]->wid/2) ); //get the x center of the location
             cy = ( rooms[curroom]->links[i]->y+(rooms[curroom]->links[i]->hei/2) ); //get the y center of the location
             dist_cur2link = sqrt( pow( (cx-x), 2 )+pow( (cy-y), 2 ) );
             if (dist_cur2link < defined_distance)
                 rooms[curroom]->links[i]->alpha = ( 1-(dist_cur2link/defined_distance) );
             else
                 rooms[curroom]->links[i]->alpha = 1;
         }
     }
 }

void BaseInterface::PassiveMouseOverWin	(	int	x,
		int	y
	)

static

Definition at line 872 of file base_interface.cpp.

References CallComp, CurrentBase, ModifyMouseSensitivity(), NavigationSystem::mouseMotion(), MouseOver(), and SetSoftwareMousePosition().

Referenced by BaseInterface::Room::Click(), InitCallbacks(), and GameCockpit::NavScreen().

 {
     ModifyMouseSensitivity( x, y );
     SetSoftwareMousePosition( x, y );
     if (CurrentBase) {
         if (CurrentBase->CallComp) {
 #ifdef NEW_GUI
             EventManager::
 #else
             UpgradingInfo::
 #endif
             ProcessMousePassive( x, y );
         } else {
             CurrentBase->MouseOver( x, y );
         }
     } else {
         NavigationSystem::mouseMotion( x, y );
     }
 }

void BaseInterface::ProcessKeyboardBuffer ( )

static

Definition at line 1493 of file base_interface.cpp.

References base_keyboard_queue, CallComp, CurrentBase, and Key().

Referenced by base_keyboard_cb().

 {
     if (CurrentBase) {
         if (!CurrentBase->CallComp) {
             for (std::vector< unsigned int >::iterator it = base_keyboard_queue.begin(); it != base_keyboard_queue.end();
                  ++it) {
                 CurrentBase->Key( *it, 0, false, 0, 0 );
                 CurrentBase->Key( *it, 0, true, 0, 0 );
             }
             base_keyboard_queue.clear();
         }
     }
 }

void BaseInterface::setDJEnabled ( bool enabled)

Definition at line 1507 of file base_interface.cpp.

Referenced by BaseUtil::SetDJEnabled().

 {
     enabledj = enabled;
 }

void BaseInterface::Terminate ( )

Definition at line 1185 of file base_interface.cpp.

References caller, CurrentBase, UnitContainer::GetUnit(), UnitUtil::isPlayerStarship(), mission_key, restore_main_loop(), and saveStringList().

Referenced by BaseInterface::Room::Launch::Click(), BaseInterface::Room::Eject::Click(), Draw(), BaseUtil::LoadBaseInterfaceAtDock(), and TerminateCurrentBase().

 {
     if (midloop) {
         terminate_scheduled = true;
     } else {
         Unit *un  = caller.GetUnit();
         int   cpt = UnitUtil::isPlayerStarship( un );
         if (un && cpt >= 0) {
             vector< string >vec;
             vec.push_back( string() );
             saveStringList( cpt, mission_key, vec );
         }
         BaseInterface::CurrentBase = NULL;
         restore_main_loop();
         delete this;
     }
 }