tweaked console

client status with timer and fps
core connect/disconnect

5 files changed, 91 insertions, 48 deletions

diff --git a/src/core/applicationinterface.cc b/src/core/applicationinterface.cc
index d195881..63e1dea 100644
--- a/src/core/applicationinterface.cc
+++ b/src/core/applicationinterface.cc
@@ -17,8 +17,9 @@ namespace core {
 // --------------- function repository ------------------------------
 extern "C" void func_print(std::stringstream &args) {
 	char text[MAXCMDSIZE];
+	// FIXME leading space
 	if(args.getline(text, MAXCMDSIZE))
-		con_print << args << std::endl;
+		con_print << text << std::endl;
 }
 
 extern "C" void func_help(std::stringstream &args) {
@@ -26,8 +27,20 @@ extern "C" void func_help(std::stringstream &args) {
 }
 
 extern "C" void func_quit(std::stringstream &args) {
-	ApplicationInterface::instance()->shutdown();
-				ApplicationInterface::instance()->quit(0);
+	if(ApplicationInterface::instance()) {
+		ApplicationInterface::instance()->shutdown();
+		ApplicationInterface::instance()->quit(0);
+	}
+}
+
+extern "C" void func_connect(std::stringstream &args) {
+	if(ApplicationInterface::instance())
+		ApplicationInterface::instance()->connect();
+}
+
+extern "C" void func_disconnect(std::stringstream &args) {
+	if(ApplicationInterface::instance())
+		ApplicationInterface::instance()->disconnect();
 }
 
 // --------------- signal_handler -----------------------------------
@@ -83,21 +96,25 @@ ApplicationInterface *ApplicationInterface::instance()
 
 void ApplicationInterface::init() 
 {
-        filesystem::init();
-
 	con_print << "Initializing core..." << std::endl;
 	con_debug << "Debug messages enabled" << std::endl;
 
+	// initialize core subsystems
+	filesystem::init();
+
 	// register our functions
 	func_register("print", func_print);
 	func_register("help", func_help);
 	func_register("quit", func_quit);
 
+	func_register("connect", func_connect);
+	func_register("disconnect", func_disconnect);
+
         if (game())
-                game()->init();
+                game()->connected = false;
         else
                 con_warn << "No game module loaded!" << std::endl;
-
+	current_time = 0;
 }
 
 void ApplicationInterface::shutdown()
@@ -105,7 +122,8 @@ void ApplicationInterface::shutdown()
 	con_print << "Shutting down core..." << std::endl;
 
 	if (game())
-		game()->shutdown();
+		if (game()->connected)
+			disconnect();
 	else
 		con_warn << "No game module loaded!" << std::endl;
 
@@ -117,9 +135,51 @@ void ApplicationInterface::quit(int status)
 	sys::quit(status);
 } 
 
+void ApplicationInterface::connect()
+{
+	if (!game()) {
+		con_warn << "No game module loaded!" << std::endl;
+		return;
+	}
+	
+	if (game()->connected) {
+		con_warn << "Connected. Disconnect first." << std::endl;
+	}
+
+	game()->current_time = 0;
+	if (game()->connected = game()->init()) {
+		con_print << "Connected." << std::endl;
+	} else {
+		con_warn << "Connect failed." << std::endl;
+	}
+}
+
+void ApplicationInterface::disconnect()
+{
+	if (!game()) {
+		con_warn << "No game module loaded!" << std::endl;
+		return;
+	}
+
+	if (!game()->connected) {
+		con_warn << "Not connected." << std::endl;
+		return;
+	}
+
+	game()->shutdown();
+
+	game()->connected = false;
+	game()->current_time = 0;
+
+	con_print << "Disconnected." << std::endl;
+}
+
 void ApplicationInterface::frame(float seconds)
 {
-	if (game()) {
+	current_time += seconds;
+
+	if (game() && game()->connected) {
+		game()->current_time += seconds;
 		game()->frame(seconds);
 	}
 
diff --git a/src/core/applicationinterface.h b/src/core/applicationinterface.h
index ef02d8f..76dfe01 100644
--- a/src/core/applicationinterface.h
+++ b/src/core/applicationinterface.h
@@ -33,6 +33,14 @@ public:
 	/// quit the application
 	virtual void quit(int status);
 
+	/// connect to the game module
+	void connect();
+
+	/// disconnect from the game module
+	void disconnect();
+
+	/// time the core has been running, in seconds
+	float current_time;
 private:
 	/// console singleton
 	static ApplicationInterface *applicationinterface_instance;
diff --git a/src/core/core.h b/src/core/core.h
index 64eadb1..eb8e067 100644
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -10,8 +10,6 @@
 #include "core/gameinterface.h"
 #include "core/applicationinterface.h"
 
-#define MAXCMDSIZE 1024
-
 /// core contains the basic functionality of the engine
 namespace core
 {
@@ -20,6 +18,12 @@ namespace core
 
 	/// pointer to the current ApplicationInterface
 	inline ApplicationInterface *application() { return ApplicationInterface::instance(); }
+
+	/// true if the core is connected to a game module
+	inline bool connected() { return (GameInterface::instance() && GameInterface::instance()->connected); }
+
+	/// return the time the core has been running, in seconds
+	inline float time() { return ApplicationInterface::instance()->current_time; }
 };
 
 #include "core/commandbuffer.h"
diff --git a/src/core/gameinterface.cc b/src/core/gameinterface.cc
index ac5209b..86e8556 100644
--- a/src/core/gameinterface.cc
+++ b/src/core/gameinterface.cc
@@ -21,7 +21,7 @@ GameInterface::GameInterface()
 		exit(2);
 	}
 	gameinterface_instance = this;
-	game_ready = false;
+	connected = false;
 }
 
 GameInterface::~GameInterface()
@@ -34,29 +34,4 @@ GameInterface *GameInterface::instance()
 	return gameinterface_instance;
 }
 
-void GameInterface::init()
-{
-	game_ready = true;
-}
-
-void GameInterface::shutdown()
-{
-	game_ready = false;
-}
-
-bool GameInterface::ready() const
-{
-	return game_ready;
-}
-
-float GameInterface::time() const
-{
-	return current_time;
-}
-
-void GameInterface::frame (float seconds)
-{
-	current_time += seconds;
-}
-
 }
diff --git a/src/core/gameinterface.h b/src/core/gameinterface.h
index 1986939..dde7f12 100644
--- a/src/core/gameinterface.h
+++ b/src/core/gameinterface.h
@@ -21,31 +21,27 @@ public:
 	virtual ~GameInterface();
 
 	/// initialize the game
-	virtual void init();
+	virtual bool init() = 0;
 
 	/// shutdown the game
-	virtual void shutdown();
+	virtual void shutdown() = 0;
 
 	/// run one frame of the game
 	/** @param sec time since the previous frame, in seconds
 	 */
-	virtual void frame (float seconds);
+	virtual void frame (float seconds) = 0;
 
 	/// a pointer to the current game instance
 	static GameInterface * instance();
 
-	/// return true if the game is ready and running
-	bool ready() const;
+	/// true if the game is ready and running
+	bool connected;
 
-	/// return the current game time, in seconds
-	float time() const;
+	/// time the game has been running, in seconds
+	float current_time;
 
 private:
 	static GameInterface *gameinterface_instance;
-	
-	bool game_ready;
-
-	float current_time;
 };
 
 }