19 files changed, 804 insertions, 642 deletions

diff --git a/src/core/application.cc b/src/core/application.cc
index ce7460f..5d313ad 100644
--- a/src/core/application.cc
+++ b/src/core/application.cc
@@ -11,25 +11,18 @@
 #include <vector>
 #include <sstream>
 
-#include "math/mathlib.h"
 #include "sys/sys.h"
+#include "math/mathlib.h"
 #include "filesystem/filesystem.h"
 #include "core/application.h"
-#include "core/core.h"
+#include "core/cvar.h"
 #include "core/entity.h"
 #include "core/func.h"
-#include "core/cvar.h"
 #include "core/netserver.h"
 
 namespace core
 {
 
-Cvar sv_dedicated;
-Cvar sv_private;
-
-Cvar net_host;
-Cvar net_port;
-
 // return the global application object
 Application *application()
 {
@@ -37,107 +30,88 @@ Application *application()
 }
 
 // --------------- engine functions  ------------------------------
-void func_print(std::stringstream &args)
+void func_print(std::string const &args)
 {
-	char text[MAXCMDSIZE];
-	if (args.getline(text, MAXCMDSIZE)) {
-		// remove the leading space
-		if (text[0] && text[1]) {
-			con_print << text+1 << std::endl;
-		}
-	}
+	con_print << args << "\n";
 }
 
-void func_help(std::stringstream &args)
+void func_help(std::string const &args)
 {
-	con_print << "This is the help function" << std::endl;
+	con_print << "This is the help function\n";
 }
 
-void func_quit(std::stringstream &args)
+void func_quit(std::string const  &args)
 {
-	if (Application::instance()) {
-		Application::instance()->shutdown();
-		Application::instance()->quit(0);
-	}
+	application()->shutdown();
+	application()->quit(0);
 }
 
-void func_connect(std::stringstream &args)
+void func_connect(std::string const &args)
 {
+	std::istringstream argstream(args);
 	std::string host;
-	if (!(args >> host))
+	if (!(argstream >> host))
 		host.clear();
 
-	if (Application::instance()) {
-		Application::instance()->connect(host);
-	}
-}
-
-void func_disconnect(std::stringstream &args)
-{
-	if (Application::instance()) 
-		Application::instance()->disconnect();
-}
-
-void func_list_func(std::stringstream &args)
-{
-	func::list();
-}
-
-void func_list_var(std::stringstream &args)
-{
-	cvar::list();
+	application()->connect(host);
 }
 
-void func_list_ent(std::stringstream &args)
+void func_disconnect(std::string const  &args)
 {
-	entity::list();
+	application()->disconnect();
 }
 
-void func_say(std::stringstream &args)
+// FIXME this is a game function
+void func_say(std::string const &args)
 {
 	if (application()->netserver) {
 		std::ostringstream osstream;
-		osstream << "msg public " << localplayer.name << " " << args.str() << "\n";
+		osstream << "msg public " << Player::local.name() << " " << args << "\n";
 		application()->netserver->broadcast(osstream.str());
-		con_print << localplayer.name << ": " << args.str() << std::endl;
+		con_print << Player::local.name() << ": " << args << "\n";
 	} else if (application()->netconnection.connected()) {
 		std::ostringstream osstream;
-		osstream << args.str() << std::endl;
-		application()->netconnection.send(osstream.str());
+		osstream << args << "\n";
+		application()->netconnection.send(args);
 	} else if (game() && game()->connected) {
-		con_print << args.str() << std::endl;
+		con_print << args << "\n";
 	} else
 		con_print << "Not connected.";
 }
 
-void func_name(std::stringstream &args) {
+void func_name(std::string const &args) {
+	std::istringstream argstream(args);
 	std::string name;
-	if (args >> name) {
+	if (argstream >> name) {
 		if (name.size() > 16) 
 			name = name.substr(0,16);
 	} else {
-		con_print << "name " << localplayer.name << std::endl;
+		con_print << "name " << Player::local.name() << "\n";
 		return;
 	}
 
-	if (name == localplayer.name) {
-		con_print << "name " << name << std::endl;
+	if (name == Player::local.name()) {
+		con_print << "name " << name << "\n";
 		return;
 	}
 
 	if (application()->netserver) {
 		std::ostringstream osstream;
-		osstream << "msg info " << localplayer.name << " renamed to " << name << "\n";
+		osstream << "msg info " << Player::local.name() << " renamed to " << name << "\n";
 		application()->netserver->broadcast(osstream.str());	
-		con_print << "msg info " << localplayer.name << " renamed to " << name << std::endl;
+
+		con_print << "msg info " << Player::local.name() << " renamed to " << name << "\n";
 	} else if (application()->netconnection.connected()) {
 		std::ostringstream osstream;
-		osstream << args.str() << std::endl;
+		osstream << "name " << name << "\n";
 		application()->netconnection.send(osstream.str());
+
+		con_print << "name " << name << "\n";
 	} else {
-		con_print << "name " << name << std::endl;
+		con_print << "name " << name << "\n";
 	}
-	localplayer.name = name;
+
+	Player::local.player_name = name;
 }
 
 // --------------- signal_handler -----------------------------------
@@ -150,17 +124,17 @@ extern "C" void signal_handler(int signum)
 		case SIGQUIT:
 		case SIGTERM:
 			if (Application::instance()) {
-				con_warn << "Received signal " << signum << ", shutting down..." << std::endl;
-				Application::instance()->shutdown();
-				Application::instance()->quit(0);
+				con_warn << "Received signal " << signum << ", shutting down...\n";
+				application()->shutdown();
+				application()->quit(0);
 			} else {
-				std::cerr << "Received signal " << signum << ", terminated..." << std::endl;
-				sys::quit(1);
+				std::cerr << "Received signal " << signum << ", terminated...\n";
+				application()->quit(1);
 			}
 			break;
 		default:
-			std::cerr << "Received signal " << signum << ", terminated..." << std::endl;
-			sys::quit(1);
+			std::cerr << "Received signal " << signum << ", terminated...\n";
+			application()->quit(1);
 			break;
 	}
 }
@@ -172,7 +146,7 @@ Application *Application::application_instance = 0;
 Application::Application()
 {
 	if (application_instance) {
-		std::cerr << "multiple core::Application instances!" << std::endl;
+		std::cerr << "multiple core::Application instances!\n";
 		sys::quit(2);
 	}
 
@@ -209,60 +183,66 @@ bool Application::connected() const
 
 void Application::init()
 {
-	con_debug << "Debug messages enabled" << std::endl;
-	con_print << "Initializing core..." << std::endl;
+	con_debug << "Debug messages enabled\n";
+	con_print << "Initializing core...\n";
 	
 	filesystem::init();
 
+	CommandBuffer::init();
+
 	gameinterface_preload = core::GameInterface::gameinterface_instance;
 	core::GameInterface::gameinterface_instance = 0;
 	if (gameinterface_preload) {
-		con_print << "  preloaded game found: " << gameinterface_preload->name() << std::endl;
+		con_print << "  preloaded game found: " << gameinterface_preload->name() << "\n";
 	}
 	game_time = 0;
 
-	// dedicated server, client should have set this to 0
-	core::sv_dedicated = core::cvar::get("sv_dedicated", "1", core::cvar::ReadOnly);
+	// dedicated server should set this to 1
+	Cvar::sv_dedicated = Cvar::get("sv_dedicated", "0", Cvar::ReadOnly);
 
-	// private server for the client, server should have set this to 0
-	core::sv_private = core::cvar::get("sv_private", "0");
+	// client can set this to 1
+	Cvar::sv_private = Cvar::get("sv_private", "0");
 
-	if (sv_dedicated->value())
-		localplayer.name = "Console";
+	if (Cvar::sv_dedicated->value())
+		Player::local.player_name = "Console";
 	else
-		localplayer.name = "Player0";
+		Player::local.player_name = "Player0";
 
 	// network settings
-	core::net_host = core::cvar::get("net_host", "0.0.0.0");
-	core::net_port = core::cvar::get("net_port", "8042");
+	Cvar::net_host = Cvar::get("net_host", "0.0.0.0");
+	Cvar::net_port = Cvar::get("net_port", "8042");
 	
-	// register our functions
-	func::add("print", func_print);
-	func::add("help", func_help);
-	func::add("quit", func_quit);
+	// register our engine functions
+	Func::add("print", func_print);
+	Func::add("help", func_help);
+	Func::add("quit", func_quit);
 	
-	func::add("connect", func_connect);
-	func::add("disconnect", func_disconnect);
+	Func::add("connect", func_connect);
+	Func::add("disconnect", func_disconnect);
 	
-	func::add("list_var", func_list_var);
-	func::add("list_func", func_list_func);
-	func::add("list_ent", func_list_ent);
-
-	func::add("say", func_say);
-	func::add("name", func_name);
+	Func::add("say", func_say);
+	Func::add("name", func_name);
 }
 
 void Application::shutdown()
 {
-	con_print << "Shutting down core..." << std::endl;
-	
-	if (game() && game()->connected)
+	con_print << "Shutting down core...\n";
+
+	if (connected())
 		disconnect();
 
-	if (netserver) {
-		delete netserver;
-		netserver = 0;
-	}
+	// remove our engine functions
+	Func::remove("print");
+	Func::remove("help");
+	Func::remove("quit");
+	
+	Func::remove("connect");
+	Func::remove("disconnect");
+	
+	Func::remove("say");
+	Func::remove("name");
+
+	CommandBuffer::shutdown();
 
 	filesystem::shutdown();
 }
@@ -272,10 +252,36 @@ void Application::quit(int status)
 	sys::quit(status);
 }
 
+// clear all game realted objects
+void Application::clear()
+{
+	// remove all entities
+	for (std::map<unsigned int, Entity*>::iterator it = Entity::registry.begin(); it != Entity::registry.end(); it++) {
+		delete (*it).second;
+	}
+	Entity::registry.clear();
+
+	// remove all game functions
+	for (std::map<std::string, Func*>::iterator it = Func::registry.begin(); it != Func::registry.end(); it++) {
+		if ( ((*it).second->flags() & Func::Game) == Func::Game) {
+			delete (*it).second;
+			Func::registry.erase(it);
+		}
+	}
+
+	// remove all game cvars
+	for (std::map<std::string, Cvar*>::iterator it = Cvar::registry.begin(); it != Cvar::registry.end(); it++) {
+		if ( ((*it).second->flags() & Cvar::Game) == Cvar::Game) {
+			delete (*it).second;
+			Cvar::registry.erase(it);
+		}
+	}
+}
+
 void Application::connect(std::string const &host)
 {
 	if (game() && game()->connected || netconnection.connected()) {
-		con_warn << "Connected. Disconnect first." << std::endl;
+		con_warn << "Connected. Disconnect first.\n";
 		return;
 	}
 	
@@ -285,6 +291,8 @@ void Application::connect(std::string const &host)
 			delete core::GameInterface::gameinterface_instance;
 	}
 
+	clear();
+
 	if (host.size()) {
 		// connect to remote core
 		core::GameInterface::gameinterface_instance = 0;
@@ -296,38 +304,37 @@ void Application::connect(std::string const &host)
 			if (str >> port) {
 				remotehost.erase(found, std::string::npos);
 			} else {
-				con_print << "Invalid hostname '" << remotehost << "'" << std::endl;
+				con_print << "Invalid hostname '" << remotehost << "'\n";
 				return;
 			}
 		}
 		netconnection.connect(remotehost, port);
 
 		if (netconnection.connected()) {
-			con_print << "Connected." << std::endl;
+			con_print << "Connected.\n";
 		} else {
 			netconnection.disconnect();
-			con_warn << "Could not connect to '" << host << "'" << std::endl;
+			con_warn << "Could not connect to '" << host << "'\n";
 		}
 	} else {
 		// use preloaded game
 		core::GameInterface::gameinterface_instance = gameinterface_preload;
 
 		// reset everything
-		entity::clear();
 		game_time = 0;
 	
 		if (game()->connected = game()->init()) {
-			con_print << "Connected." << std::endl;
+			con_print << "Connected.\n";
 		} else {
-			con_warn << "Could not connect." << std::endl;
+			con_warn << "Could not connect.\n";
 			return;
 		}
 
-		if (!netserver && (core::sv_dedicated->value() || core::sv_private->value())) {
-			netserver = new NetServer(net_host->text(), (unsigned int)net_port->value());
+		if (!netserver && (Cvar::sv_dedicated->value() || Cvar::sv_private->value())) {
+			netserver = new NetServer(Cvar::net_host->str(), (unsigned int)Cvar::net_port->value());
 			if (!netserver->valid()) {
 				delete netserver;
-				if (core::sv_dedicated->value())
+				if (Cvar::sv_dedicated->value())
 					shutdown();
 			}
 		}
@@ -343,13 +350,13 @@ void Application::disconnect()
 
 	if (netconnection.connected()) {
 		netconnection.disconnect();
-		con_print << "Disconnected." << std::endl;
+		con_print << "Disconnected.\n";
 		return;
 	}
 
 	if (game()) {
 		if (!game()->connected) {
-			con_warn << "Not connected." << std::endl;
+			con_warn << "Not connected.\n";
 			return;
 		}
 		
@@ -357,26 +364,9 @@ void Application::disconnect()
 		game()->connected = false;
 		game_time = 0;	
 	
-		// remove all entities
-		entity::clear();
-
-		// remove all game functions
-		for (std::map<std::string, Func>::iterator it = func::registry.begin(); it != func::registry.end(); it++) {
-			if ( ((*it).second->flags() & func::Game) == func::Game) {
-				delete (*it).second;
-				func::registry.erase(it);
-			}
-		}
-	
-		// remove all game cvars
-		for (std::map<std::string, Cvar>::iterator it = cvar::registry.begin(); it != cvar::registry.end(); it++) {
-			if ( ((*it).second->flags() & cvar::Game) == cvar::Game) {
-				delete (*it).second;
-				cvar::registry.erase(it);
-			}
-		}
+		clear();
 		
-		con_print << "Disconnected." << std::endl;
+		con_print << "Disconnected.\n";
 	}
 }
 
@@ -384,7 +374,22 @@ void Application::frame(float seconds)
 {
 	if (seconds == 0.0f)
 		return;
-	
+
+	// execute commands in the buffer
+	CommandBuffer::exec();
+
+	// update entities
+	if (connected()) {
+		std::map<unsigned int, Entity *>::iterator it;
+		for (it=Entity::registry.begin(); it != Entity::registry.end(); it++) {
+			Entity *entity = (*it).second;
+			if ((entity->type() == Entity::Controlable) || (entity->type() == Entity::Dynamic)) {
+				entity->frame(seconds);
+			}
+		}
+	}
+
+	// netstuff 
 	if (netconnection.connected()) {
 		netconnection.frame(seconds);
 		// TODO this should come from server
@@ -396,15 +401,11 @@ void Application::frame(float seconds)
 		}
 
 		if (game() && game()->connected) {
-			entity::frame(seconds);
 			game_time += seconds;	
 			
 			game()->frame(seconds);
 		}
 	}	
-	
-	// execute commands in the buffer
-	commandbuffer::execute();
 }
 
 }
diff --git a/src/core/application.h b/src/core/application.h
index 81e6a64..0f4c5fa 100644
--- a/src/core/application.h
+++ b/src/core/application.h
@@ -7,7 +7,7 @@
 #ifndef __INCLUDED_CORE_APPLICATION_H__
 #define __INCLUDED_CORE_APPLICATION_H__
 
-#include "core/cvar.h"
+#include "core/commandbuffer.h"
 #include "core/netserver.h"
 #include "core/netconnection.h"
 #include "core/gameinterface.h"
@@ -15,15 +15,6 @@
 namespace core
 {
 
-/// cvar to indicate dedicated server status
-extern Cvar sv_dedicated;
-
-/// cvar to indicate private server status
-/**
- * A private server is a client with server cababilities.
- */
-extern Cvar sv_private;
-
 /// core interface for the client and server Application classes
 class Application
 {
@@ -40,21 +31,9 @@ public:
 	/// shutdown the application
 	virtual void shutdown();
 	
-	/// run a core frame
-	virtual void frame(float seconds);
-	
 	/// a pointer to the current application instance
 	static Application *instance();
 	
-	/// quit the application
-	virtual void quit(int status);
-	
-	/// start the server or connect to remote host
-	void connect(std::string const &host);
-	
-	/// disconnect from the game module
-	void disconnect();
-	
 	/// time the has been connected, in seconds
 	float time() const;
 	
@@ -73,10 +52,25 @@ public:
 	/// global application object
 	static Application *application_instance;
 
+	/// quit the application without proper shutdown
+	virtual void quit(int status);
+
+	/// start the server or connect to remote host
+	void connect(std::string const &host);
+	
+	/// disconnect from the game module
+	void disconnect();
+
+protected:
+	/// clear all game related objects
+	void clear();
+
+	/// run a core frame
+	virtual void frame(float seconds);
+
 private:
 	/// time the core has been running
-	float 		game_time;
-
+	float 			game_time;
 };
 
 /// pointer to the current ApplicationInterface
diff --git a/src/core/commandbuffer.cc b/src/core/commandbuffer.cc
index a15708c..8f02f71 100644
--- a/src/core/commandbuffer.cc
+++ b/src/core/commandbuffer.cc
@@ -4,88 +4,123 @@
    the terms of the GNU General Public License version 2
 */
 
-#include "core/commandbuffer.h"
-#include "sys/sys.h"
-
-// C++ headers
 #include <string>
 #include <sstream>
 #include <list>
 
+#include "sys/sys.h"
+#include "core/commandbuffer.h"
+#include "core/func.h"
+#include "core/cvar.h"
+#include "core/gameinterface.h"
+
 namespace core
 {
 
-std::stringstream cmd(std::stringstream::in | std::stringstream::out);
+void func_list_func(std::istringstream const &args)
+{
+	Func::list();
+}
+
+void func_list_var(std::istringstream const &args)
+{
+	Cvar::list();
+}
+
+void func_list_ent(std::istringstream const &args)
+{
+	Entity::list();
+}
+
+std::stringstream CommandBuffer::cmdbuf(std::stringstream::in | std::stringstream::out);
+
+void CommandBuffer::init()
+{
+	con_debug << "Initializing command buffer...\n";
+
+	Func::add("list_var", (FuncPtr)func_list_var);
+	Func::add("list_func", (FuncPtr)func_list_func);
+	Func::add("list_ent", (FuncPtr)func_list_ent);
+}
 
-namespace commandbuffer
+void CommandBuffer::shutdown()
 {
+	con_debug << "Shutting down command buffer...\n";
 
-void exec(const char *text)
+	Func::remove("list_var");
+	Func::remove("list_func");
+	Func::remove("list_ent");
+}
+
+void  CommandBuffer::exec(std::string const &cmdline)
 {
-	std::stringstream cmdstream(text);
+	if (!cmdline.size())
+		return;
+
+	std::istringstream cmdstream(cmdline);
 	std::string command;
 	
 	if (!(cmdstream >> command))
 		return;
 		
+	con_debug << "Executing '" << cmdline << "'\n";
+
 	// is it a function
-	Func f = func::find(command);
+	Func *f = Func::find(command);
 	if (f) {
-		// function exists, execute it
-		if (f->flags() && func::Game) {
-			// it's a game function
+		std::string args;
+		char c;
+		if (cmdstream >> args) {
+			while (cmdstream >> c)
+				args += c;
+		}
+		if ((f->flags() & Func::Game)) {
 			if (game() && game()->connected) {
-				GameFuncPtr function = (GameFuncPtr) f->ptr;
-				function(localplayer, cmdstream);
+				f->exec(&Player::local, args);
 			} 
 		} else {
-			// it's a normal function
-			FuncPtr function = (FuncPtr) f->ptr;
-			function(cmdstream);
+			f->exec(args);
 		}
 		return;
 	}
 	
 	// is it a cvar
-	Cvar cv = cvar::find(command);
-	if (cv) {
+	Cvar *cvar = Cvar::find(command);
+	if (cvar) {
 		// cvar exists
-		std::string args;
-		if (((cv->flags() & cvar::ReadOnly) == 0) &&  (cmdstream >> args)) {
+		std::string value;
+		if (((cvar->flags() & Cvar::ReadOnly) == 0) &&  (cmdstream >> value)) {
 			// we're setting a new value
 			char c;
 			while (cmdstream >> c)
-				args += c;
-			(*cv) = args;
+				value += c;
+			(*cvar) = value;
 		}
 		
-		con_print << command << " " << cv->text() << std::endl;
+		con_print << command << " " << cvar->str() << "\n";
 		return;
 	}
 	
-	con_print << "Unknown command '" << command << "'" << std::endl;
+	// TODO this must get forwarded to the server
+
+	con_print << "Unknown command '" << command << "'\n";
 }
 
-void execute()
+void CommandBuffer::exec()
 {
-	if (core::cmd.eof())
+	if (cmdbuf.eof())
 		return;
 		
 	char line[MAXCMDSIZE];
-	while (core::cmd.getline(line, MAXCMDSIZE-1)) {
-		exec(line);
+
+	while (core::cmd().getline(line, MAXCMDSIZE-1)) {
+		exec(std::string(line));
 	}
 	
-	cmd.clear();
+	cmdbuf.clear();
 }
 
-void clear()
-{
-	char line[MAXCMDSIZE];
-	while (core::cmd.getline(line, MAXCMDSIZE-1));
-}
-
-void complete(std::string &input, size_t &pos)
+void CommandBuffer::complete(std::string &input, size_t &pos)
 {
 	std::list<std::string> match;
 	
@@ -94,20 +129,20 @@ void complete(std::string &input, size_t &pos)
 		return;
 		
 	// search function registry for matches
-	std::map<std::string, Func>::iterator f;
-	for (f = func::registry.begin(); f != func::registry.end(); f++) {
+	std::map<std::string, Func *>::iterator f;
+	for (f = Func::registry.begin(); f != Func::registry.end(); f++) {
 		if (partial == (*f).first.substr(0, partial.size())) {
 			match.push_back((*f).first);
-			//con_print << "  " << (*f).first << std::endl;
+			//con_print << "  " << (*f).first << "\n";
 		}
 	}
 	
 	// search cvar registry for matches
-	std::map<std::string, Cvar>::iterator c;
-	for (c = cvar::registry.begin(); c != cvar::registry.end(); c++) {
+	std::map<std::string, Cvar *>::iterator c;
+	for (c = Cvar::registry.begin(); c != Cvar::registry.end(); c++) {
 		if (partial == (*c).first.substr(0, partial.size())) {
 			match.push_back((*c).first);
-			//con_print << "  " << (*c).first << std::endl;
+			//con_print << "  " << (*c).first << "\n";
 		}
 	}
 	
@@ -127,9 +162,9 @@ void complete(std::string &input, size_t &pos)
 				if (i < maxmatch.size())
 					maxmatch.erase(i);
 			}
-			con_print << "  " << (*l) << std::endl;
+			con_print << "  " << (*l) << "\n";
 		}
-		con_print << match.size() << " matches" << std::endl;
+		con_print << match.size() << " matches\n";
 		
 	}
 	
@@ -141,7 +176,5 @@ void complete(std::string &input, size_t &pos)
 	
 }
 
-} // namespace commandbuffer
-
-} // namespace core
+}
 
diff --git a/src/core/commandbuffer.h b/src/core/commandbuffer.h
index 22f53d2..8970d89 100644
--- a/src/core/commandbuffer.h
+++ b/src/core/commandbuffer.h
@@ -4,35 +4,46 @@
    the terms of the GNU General Public License version 2
 */
 
-#ifndef __INCLUDED_COMMANDBUFFER_H__
-#define __INCLUDED_COMMANDBUFFER_H__
+#ifndef __INCLUDED_CORE_COMMANDBUFFER_H__
+#define __INCLUDED_CORE_COMMANDBUFFER_H__
 
-// project headers
-#include "core/core.h"
-
-// C++ headers
+#include <string>
 #include <sstream>
 
 namespace core
 {
 
-/// global buffer to hold the command stream
-extern std::stringstream cmd;
-
-namespace commandbuffer
+class CommandBuffer
 {
+public:
+	/// register command buffer functions
+	static void init();
 
-/// execute the commands in the buffer
-void execute();
+	/// remove command buffer functions
+	static void shutdown();
 
-/// flush the command buffer
-void clear();
+	/// execute the commands in the buffer
+	static void exec();
 
-/// tab completion
-void complete(std::string &input, size_t &pos);
+	/// clear the command buffer
+	static void clear();
 
-}
+	/// global buffer to hold the command stream
+	static std::stringstream cmd;
+
+	/// input command completion
+	static void complete(std::string &input, size_t &pos);
+
+	/// the global command buffer
+	static std::stringstream cmdbuf;
+
+private:
+	static void exec(std::string const & cmdline);
+};
+
+/// the global command buffer
+inline std::stringstream & cmd() { return CommandBuffer::cmdbuf; }
 
 }
 
-#endif // COMMANDBUFFER
+#endif // __INCLUDED_CORE_COMMANDBUFFER_H__
diff --git a/src/core/cvar.cc b/src/core/cvar.cc
index 531e0ad..dbe1d30 100644
--- a/src/core/cvar.cc
+++ b/src/core/cvar.cc
@@ -17,159 +17,154 @@
 namespace core
 {
 
-Cvar_t::Cvar_t(unsigned int cvarflags)
+Cvar				*Cvar::sv_dedicated = 0;
+Cvar				*Cvar::sv_private = 0;
+Cvar				*Cvar::net_host = 0;
+Cvar				*Cvar::net_port = 0;
+
+std::map<std::string, Cvar*> 	Cvar::registry;
+
+Cvar::Cvar(const char *name, unsigned int flags)
 {
-	cvar_flags = cvarflags;
+	cvar_flags = flags;
+	if (name)
+		cvar_name.assign(name);
 }
 
-Cvar_t & Cvar_t::operator=(const std::string &other)
+Cvar & Cvar::operator=(const std::string &other)
 {
-	cvar_text = other;
-	std::stringstream s(cvar_text);
+	cvar_str = other;
+	std::stringstream s(cvar_str);
 	if (!(s >> cvar_value))
-		cvar_value = cvar_text.size();
+		cvar_value = cvar_str.size();
 	return (*this);
 }
 
-Cvar_t & Cvar_t::operator=(const char *other)
+Cvar & Cvar::operator=(const char *other)
 {
 	return ((*this) = std::string(other));
 }
 
-Cvar_t & Cvar_t::operator=(float other)
+Cvar & Cvar::operator=(float other)
 {
 	std::stringstream s;
 	s << other;
-	s >> cvar_text;
+	s >> cvar_str;
 	cvar_value = other;
 	return (*this);
 }
 
-unsigned int Cvar_t::flags() const
-{
-	return(cvar_flags);
-}
-
-float Cvar_t::value() const
+Cvar* Cvar::get(const char *name, const char *value, unsigned int flags)
 {
-	return(cvar_value);
-}
-
-const std::string &Cvar_t::text() const
-{
-	return(cvar_text);
-}
-
-namespace cvar
-{
-
-std::map<std::string, Cvar> registry;
-
-Cvar get(const char *name, const char *value, int flags)
-{
-	Cvar c = find(name);
+	Cvar *c = find(name);
 	if (c) {
-		//con_debug << "cvar::get " << name << " already exist with value " << cvar->text() << std::endl;
+		//con_debug << "get " << name << " already exist with value " << cvar->str() << std::endl;
 	} else {
-		//con_debug << "cvar::get " << name << " " << value << std::endl;
-		c = new Cvar_t(flags);
+		//con_debug << "get " << name << " " << value << std::endl;
+		c = new Cvar(name, flags);
 		registry[std::string(name)] = c;
 		(*c) = value;
 	}
+	c->cvar_flags = flags;
 	return c;
 }
 
-Cvar get(const char *name, float value, int flags)
+Cvar* Cvar::get(const char *name, float value, unsigned int flags)
 {
-	Cvar c = find(name);
+	Cvar *c = find(name);
 	if (c) {
-		//con_debug << "cvar::get " << name << " already exist with value " << cvar->text() << std::endl;
+		//con_debug << "get " << name << " already exist with value " << cvar->str() << std::endl;
 	} else {
-		//con_debug << "cvar::get " << name << " " << value << std::endl;
-		c = new Cvar_t(flags);
+		//con_debug << "get " << name << " " << value << std::endl;
+		c = new Cvar(name, flags);
 		registry[std::string(name)] = c;
 		(*c) = value;
 	}
+	c->cvar_flags = flags;
 	return c;
 }
 
-Cvar set(const char *name, const char *value, int flags)
+Cvar* Cvar::set(const char *name, const char *value, unsigned int flags)
 {
-	Cvar c = find(name);
+	Cvar *c = find(name);
 	if (!c) {
-		c = new Cvar_t(flags);
+		c = new Cvar(name, flags);
 		registry[std::string(name)] = c;
 	}
 	(*c) = value;
-	//con_debug << "cvar::set " << name << " " << cvar->text() << std::endl;
+	c->cvar_flags = flags;
+
+	//con_debug << "set " << name << " " << cvar->str() << std::endl;
 	return c;
 }
 
-Cvar set(const char *name, float value, int flags)
+Cvar* Cvar::set(const char *name, float value, unsigned int flags)
 {
-	Cvar c = find(name);
+	Cvar *c = find(name);
 	if (!c) {
-		c = new Cvar_t(flags);
+		c = new Cvar(name, flags);
 		registry[std::string(name)] = c;
 	}
 	(*c) = value;
-	//con_debug << "cvar::set " << name << " " << cvar->text() << std::endl;
+	c->cvar_flags = flags;
+
+	//con_debug << "set " << name << " " << cvar->str() << std::endl;
 	return c;
 }
 
-void unset(const std::string &name)
+void Cvar::unset(std::string const &name)
 {
-	Cvar c = find(name);
+	Cvar *c = find(name);
 	if (c) {
-		con_debug << "cvar::unset " << name << std::endl;
+		con_debug << "unset " << name << std::endl;
 		registry.erase(name);
 		delete c;
 	}
 }
 
-void unset(const char *name)
+void Cvar::unset(const char *name)
 {
 	unset(std::string(name));
 }
 
-Cvar find(const std::string &name)
+Cvar *Cvar::find(std::string const &name)
 {
-	std::map<std::string, Cvar>::iterator it = registry.find(name);
+	std::map<std::string, Cvar*>::iterator it = registry.find(name);
 	if (it == registry.end())
 		return 0;
 	else
 		return (*it).second;
 }
 
-Cvar find(const char *name)
+Cvar *Cvar::find(const char *name)
 {
 	return(find(std::string(name)));
 }
 
-void list()
+void Cvar::list()
 {
-	std::map<std::string, Cvar>::iterator it;
+	std::map<std::string, Cvar*>::iterator it;
 	for (it = registry.begin(); it != registry.end(); it++) {
 		std::string typeindicator;
-		if ((*it).second->flags() & cvar::Archive)
+		if (((*it).second->flags() & Archive) == Archive)
 			typeindicator += 'A';
 		else
 			typeindicator += ' ';	
-		if ((*it).second->flags() & cvar::ReadOnly)
+		if (((*it).second->flags() & ReadOnly) == ReadOnly)
 			typeindicator += 'R';
 		else
 			typeindicator += ' ';
-		if ((*it).second->flags() & cvar::Game)
+		if (((*it).second->flags() & Game) == Game)
 			typeindicator += 'G';
 		else
 			typeindicator += ' ';
 
-		con_print << typeindicator << " " << (*it).first << " " << (*it).second->text() << std::endl;
+		con_print << std::setw(4) << (*it).second->flags() << " " << typeindicator << 
+			" " << (*it).first << " " << (*it).second->str() << std::endl;
 	}
 	con_print << registry.size() << " registered variables" << std::endl;
 }
 
-} // namespace cvar
+}
 
-} // namespace core
 
diff --git a/src/core/cvar.h b/src/core/cvar.h
index bca3d8a..7350eee 100644
--- a/src/core/cvar.h
+++ b/src/core/cvar.h
@@ -13,82 +13,106 @@
 namespace core
 {
 
-/// the cvar container class
-class Cvar_t
+/// a variable encapsulation class
+class Cvar
 {
 public:
-
-	Cvar_t(unsigned int cvflags = 0);
-	
-	Cvar_t &operator=(const char *other);
-	Cvar_t &operator=(const std::string &other);
-	Cvar_t &operator=(float other);
+	/// Cvar flags
+	/**
+	 * Archive	a cvar with this flag will be saved to the configuration file
+	 * ReadOnly	the value of cvar with this flag can not be altered from the commandline
+	 * Game		a cvar with this flag is only valid when a game is loaded
+	 */
+	enum Flags {Archive=1, ReadOnly=2, Game=4};
 	
-	unsigned int flags() const;
-	float value() const;
-	const std::string &text() const;
+	/// create a new variable
+	Cvar(const char *name = 0, unsigned int flags = 0);
+
+/*----- inspectors ------------------------------------------------ */
+
+	/// returns the name of the variable
+	inline std::string const &name() { return cvar_name; }
+
+	/// returns the flags of the variable
+	inline unsigned int flags() const { return cvar_flags; }
+
+	/// returns the float value of the variable
+	inline float value() const { return cvar_value; }
+
+	/// returns the string value of the variable
+	inline const std::string &str() const { return cvar_str; }
+
+/*----- mutators -------------------------------------------------- */
+
+	/// char * assignment operator 
+	Cvar &operator=(const char *other);
+
+	/// std::string assignment operator
+	Cvar &operator=(const std::string &other);
+
+	/// float assignment operator
+	Cvar &operator=(float other);
+
+/* ---- Static functions for the Cvar registry -------------------- */
 	
-private:
-	std::string 	cvar_text;
-	float 		cvar_value;
-	unsigned int 	cvar_flags;
-};
+	/// get a cvar value from the registry
+	/** If the a cvar with the given name already exists in the registry,
+ 	*  its value will not be changed. If the cvar does not exist,
+ 	*  it will be created
+ 	*/
+	static Cvar *get(const char *name, const char *value, unsigned int flags=0);
+
+	/// get a cvar value from the registry
+	/** If the a cvar with the given name already exists in the registry,
+ 	*  its value will not be changed. If the cvar does not exist,
+ 	*  it will be created
+ 	*/
+	static Cvar *get(const char *name, float value, unsigned int flags=0);
+
+	/// set a cvar value
+	/** If the a cvar with the given name already exists in the registry,
+ 	* its value will be replaced
+ 	*/
+	static Cvar *set(const char *name, const char *value, unsigned int flags=0);
+
+	/// set a cvar value
+	/** If the a cvar with the given name already exists in the registry,
+ 	* its value will be replaced
+ 	*/
+	static Cvar *set(const char *name, float value, unsigned int flags=0);
+
+	/// delete a cvar from the registry
+	static void unset(const char *name);
+
+	/// delete a cvar from the registry
+	static void unset(std::string const &name);
+
+	/// search for a named cvar, returns 0 if not found
+	static Cvar *find(std::string const &name);
+
+	/// search for a named cvar, returns 0 if not found
+	static Cvar *find(const char *name);
+
+	/// list the cvar registry
+	static void list();
+
+	/// the Cvar registry
+	static std::map<std::string, Cvar*> 	registry;
+
+	static Cvar		*sv_dedicated;	// dedicated server
+	static Cvar		*sv_private;	// client with private server
+	static Cvar		*net_host;	// network server ip (default binds to all interfaces)
+	static Cvar		*net_port;	// network port
 
-/// general cvar type
-typedef Cvar_t *Cvar;
+private:
+	std::string		cvar_name;
+	std::string 		cvar_str;
+	unsigned int 		cvar_flags;
+	float 			cvar_value;
 
-/// the cvar registry
-namespace cvar
-{
+};
 
-/// cvar flags
-enum Flags {Archive=1, ReadOnly=2, Game=4};
-
-/// get a cvar value from the registry
-/** If the a cvar with the given name already exists in the registry,
- *  its value will not be changed. If the cvar does not exist,
- *  it will be created
- */
-Cvar get(const char *name, const char *value, int flags=0);
-/// get a cvar value from the registry
-/** If the a cvar with the given name already exists in the registry,
- *  its value will not be changed. If the cvar does not exist,
- *  it will be created
- */
-Cvar get(const char *name, float value, int flags=0);
-
-/// set a cvar value
-/** If the a cvar with the given name already exists in the registry,
- * its value will be replaced
- */
-Cvar set(const char *name, const char *value, int flags=0);
-/// set a cvar value
-/** If the a cvar with the given name already exists in the registry,
- * its value will be replaced
- */
-Cvar set(const char *name, float value, int flags=0);
-
-/// delete a cvar from the registry
-void unset(const char *name);
-
-/// delete a cvar from the registry
-void unset(const std::string &name);
-
-/// search for a named cvar, returns 0 if not found
-Cvar find(const std::string &name);
-
-/// search for a named cvar, returns 0 if not found
-Cvar find(const char *name);
-
-/// list the cvar registry
-void list();
-
-/// the Cvar registry
-extern std::map<std::string, Cvar> registry;
-
-} // namespace cvar
-
-} // namespace core
+}
 
 #endif // __INCLUDED_CORE_CVAR_H__
 
diff --git a/src/core/entity.cc b/src/core/entity.cc
index 6115e71..229fb52 100644
--- a/src/core/entity.cc
+++ b/src/core/entity.cc
@@ -4,121 +4,141 @@
    the terms of the GNU General Public License version 2.
 */
 
+#include <vector>
+#include <iomanip>
+
 #include "sys/sys.h"
 #include "core/entity.h"
 
-#include <iomanip>
-
 namespace core
 {
 
-// --- Entity -----------------------------------------------------
+using math::Color;
+using math::Vector3f;
 
-Entity::Entity(unsigned int entity_flags)
-{
-	flags = entity_flags;
-	
-	core_shape = entity::Diamond;
-	core_color = math::Color(1.0f, 1.0f, 1.0f);
-	core_radius = 1.0f;
+/* ---- Static functions for the Entity registry ------------------- */
 
-	core::entity::add(this);
-	type = 0;
-	
-	direction = 0;
-}
+std::map<unsigned int, Entity *> Entity::registry;
 
-Entity::~Entity()
-{}
+void Entity::add(Entity *ent)
+{
+	std::map<unsigned int, Entity*>::iterator it;
+	unsigned int id = 1;
+	for (it = registry.begin(); it != registry.end() && id == (*it).second->id(); it++) {
+		id++;
+	}
+	ent->entity_id = id;
+	registry[id] = ent;
+}
 
-// --- EntityDynamic ------------------------------------------
+Entity *Entity::find(unsigned int id)
+{
+	std::map<unsigned int, Entity *>::iterator it = registry.find(id);
+	if (it == registry.end())
+		return 0;
+	else
+		return (*it).second;
+}
 
-EntityDynamic::EntityDynamic(unsigned int entity_flags) :
-	Entity(entity_flags)
+void Entity::remove(unsigned int id)
 {
-	speed = 0.0f;
+	std::map<unsigned int, Entity *>::iterator it = registry.find(id);
+	if (it != registry.end()) {
+		delete((*it).second);
+		registry.erase(it);
+	}
 }
 
-EntityDynamic::~EntityDynamic()
+void Entity::list()
 {
+	std::map<unsigned int, Entity *>::iterator it;
+	for (it = registry.begin(); it != registry.end(); it++) {
+		std::string typeindicator;
+		Entity *entity = (*it).second;
+		con_print << "  id " << std::setw(4) << entity->id()
+			<< " type " << std::setw(4) << entity->type()
+			<< ":" << std::setw(4) << entity->moduletype()
+			<< " " << entity->name() << std::endl;
+	}
+	con_print << registry.size() << " registered entities" << std::endl;
 }
 
-// --- EntityControlable ------------------------------------------
+/*----- Entity ----------------------------------------------------- */
 
-EntityControlable::EntityControlable(unsigned int entity_flags) :
-	EntityDynamic(entity_flags)
+Entity::Entity(unsigned int flags) :
+	entity_location(0.0f, 0.0f, 0.0f),
+	entity_color(1.0f, 1.0f, 1.0f, 1.0f)
 {
-	owner = 0;
-	target_direction = 0.0f;
-	target_thrust = 0.0f;
+	entity_id = 0;
+	entity_flags = flags;
+	entity_moduletypeid = 0;
+	
+	entity_radius = 1.0f;
+	entity_direction = 0;
+	entity_shape = Diamond;
+	
+	add(this);
 }
 
-EntityControlable::~EntityControlable()
+Entity::~Entity()
+{
+}
+
+void Entity::frame(float seconds)
 {
 }
 
-// --- namespace entity -------------------------------------------
+/* ---- EntityDynamic ---------------------------------------------- */
 
-namespace entity
+EntityDynamic::EntityDynamic(unsigned int flags) :
+	Entity(flags)
 {
+	entity_speed = 0.0f;
+}
 
-std::vector<Entity*> registry;
+EntityDynamic::~EntityDynamic()
+{
+}
 
-void add(Entity *ent)
+void EntityDynamic::frame(float seconds)
 {
-	std::vector<Entity *>::iterator it;
-	unsigned int entity_id = 1;
-	for (it=registry.begin(); it != registry.end() && entity_id == (*it)->id; it++) {
-		entity_id++;
-	}
-	ent->id = entity_id;
-	registry.push_back(ent);
+	// location avoid sin/cos calculations
+	entity_location.x += cosf(entity_direction * M_PI / 180) * entity_speed * seconds;
+	entity_location.z -= sinf(entity_direction * M_PI / 180) * entity_speed * seconds;
 }
 
-void remove(unsigned int entity_id)
+/*----- EntityControlable ------------------------------------------ */
+
+EntityControlable::EntityControlable(Player *player, unsigned int flags) :
+	EntityDynamic(flags)
 {
-	std::vector<Entity *>::iterator it;
-	for (it=registry.begin(); it != registry.end(); it++) {
-		if (entity_id == (*it)->id) {
-			delete((*it));
-			registry.erase(it);
-			return;
-		}
-	}
+	entity_owner = 0;
+	entity_thrust = 0;
+
+	target_direction = 0.0f;
+	target_thrust = 0.0f;
 }
 
-void clear()
+EntityControlable::~EntityControlable()
 {
-	std::vector<Entity *>::iterator it;
-	for (it=registry.begin(); it != registry.end(); it++) {
-		delete(*it);
-		(*it) = 0;
-	}
-	registry.clear();
 }
 
-void list()
+void EntityControlable::frame(float seconds)
 {
-	std::vector<Entity *>::iterator it;
-	for (it=registry.begin(); it != registry.end(); it++) {
-		con_print << "  id " << std::setw(4) << (*it)->id 
-			<< " type " << std::setw(4) << (*it)->core_type()
-			<< ":" << std::setw(4) << (*it)->type
-			<< " " << (*it)->label << std::endl;
-	}
-	con_print << registry.size() << " registered entities" << std::endl;
+	entity_direction = target_direction;
+	entity_thrust = target_thrust;
+
+	EntityDynamic::frame(seconds);
 }
 
-void frame(float seconds)
+void EntityControlable::set_thrust(float thrust)
 {
-	std::vector<Entity *>::iterator it;
-	for (it=registry.begin(); it != registry.end(); it++) {
-		if ((*it)->core_type() == entity::Controlable) {
-			static_cast<EntityControlable *>(*it)->frame(seconds);
-		}
-	}
+	target_thrust = thrust;
 }
 
+void EntityControlable::set_direction(float direction)
+{
+	target_direction = direction;
 }
 
 }
diff --git a/src/core/entity.h b/src/core/entity.h
index b3dd7ef..7b3f200 100644
--- a/src/core/entity.h
+++ b/src/core/entity.h
@@ -15,136 +15,182 @@ class EntityControlable;
 #include "core/player.h"
 #include "math/mathlib.h"
 
-#include <vector>
+#include <string>
+#include <map>
 
 namespace core
 {
 
-namespace entity
-{
-
-/// Entity flags
-enum Flags {Static=1, Solid=2};
-
-/// Entity type constants
-enum Type {Default = 0, Dynamic = 1, Controlable = 2};
-
-/// Entity shape constants
-enum Shape {Diamond=0, Sphere=1, Cube=2};
-
-}
-
 /// The base world entity. All gameworld entities must derive from this class.
 class Entity
 {
 public:
+	/// Entity flags
+	enum Flags {Static=1, Solid=2};
+
+	/// Entity type constants
+	enum Type {Default = 0, Dynamic = 1, Controlable = 2};
+
+	/// Entity shape constants
+	enum Shape {Diamond=0, Sphere=1, Cube=2};
+
 	/// create a new entity and add it to the registry
-	Entity(unsigned int entity_flags = 0);
+	Entity(unsigned int flags = 0);
+
+	/// destroy an entity
 	virtual ~Entity();
+
+/*----- inspectors ------------------------------------------------ */
 	
+	/// entity id
+	inline unsigned int id() const { return entity_id; }
+	
+	/// module type id
+	inline unsigned int moduletype() const { return entity_moduletypeid; }
+
 	///  core type id
-	virtual inline unsigned int core_type() { return entity::Default; }
+	virtual inline unsigned int type() { return Default; }
 
-	/// unique instance identifier, automaticly set
-	unsigned int id;
+	/// entity flags
+	inline unsigned int flags() const { return entity_flags; }
 
-	/// core shape id
-	entity::Shape core_shape;
+	/// entity name
+	inline std::string const & name() { return entity_name; }
 
-	/// core color
-	math::Color core_color;
+	/// entity location
+	inline math::Vector3f const & location() const { return entity_location; }
 
-	/// core radius, in game units
-	float core_radius;
-	
-	/// the entities label
-	std::string label;
+	/// direction the entity is facing, in degrees.
+	inline float direction() const { return entity_direction; }
+
+	/// base color of the entity
+	inline math::Color const & color() const { return entity_color; }
 
-	/// custom game type id of this entity
-	unsigned int type;
+	/// base shape of the entity
+	inline Shape shape() const { return entity_shape; }
 
-	/// flags
-	/// @see core::entity::Flags
-	unsigned int flags;
+	/// base radius of the entity
+	inline float radius() const { return entity_radius; }
 
-	/* updateable by game */
+/*----- mutators -------------------------------------------------- */
 
-	/// location of the entity
-	math::Vector3f location;
+	/// runs one game frame for the entity
+	/**
+	 * The default implementation does nothing
+	 */
+	virtual void frame(float seconds);
 
-	/// direction the entity is facing, in degrees
-	/// A direction of 0 degrees means the entity is looking
-	/// along the positive X-axis.
-	float direction;
+/*----- static ---------------------------------------------------- */
+	
+	/// the entity registry
+ 	static std::map<unsigned int, Entity*> registry;
+
+	/// find an entity in the registry
+	static Entity *find(unsigned int id);
+
+	/// remove one entity from the registry and deletes it
+	static void remove(unsigned int entity_id);
+
+	/// list the entity registry
+	static void list();
+
+	/* entity_ variables can be set by the module */
+	float 			entity_radius;
+	std::string		entity_name;
+	Shape 			entity_shape;
+	math::Vector3f 		entity_location;
+	math::Color 		entity_color;
+	/* 
+	 * A direction of 0 degrees means the entity is looking
+	 * along the positive X-axis. Positive angle is along the negative Z-axis.
+	 */
+	float 			entity_direction;
+	unsigned int		entity_moduletypeid;
+	unsigned int 		entity_flags;
+
+private:
+	/// add an entity to the registry
+	static void add(Entity *ent);
+
+	/// the id is set by add()
+	unsigned int		entity_id;
 };
 
 /// an entity that can move around in the game world
 class EntityDynamic : public Entity
 {
 public:
-	EntityDynamic(unsigned int entity_flags = 0);
+	EntityDynamic(unsigned int flags = 0);
 	virtual ~EntityDynamic();
 
+/*----- inspectors ------------------------------------------------ */
 	/// core type id
-	virtual inline unsigned int core_type() { return entity::Dynamic; }
-
-	/* updateable by game */
+	virtual inline unsigned int type() { return Entity::Dynamic; }
 
 	/// current speed of the entity in game units per second
-	float speed;
+	inline float speed() const { return entity_speed; }
+
+/*----- mutators -------------------------------------------------- */
+
+	/// runs one game frame for the entity
+	/**
+	 * The default implementation will update the position() of the entity,
+	 * determined by its speed() and direction()
+	 */
+	virtual void frame(float seconds);
+
+	/// speed of the entity
+	float			entity_speed;	
 };
 
 /// an entity that can be controlled by a player
 class EntityControlable : public EntityDynamic
 {
 public:
-	EntityControlable(unsigned int entity_flags = 0);
+	/// create 
+	EntityControlable(Player *player, unsigned int flags = 0);
 	virtual ~EntityControlable();
 
-	/// core type id
-	virtual inline unsigned int core_type() { return entity::Controlable; }
-
-	/// runs one game frame for the entity, to be implemented by game
-	virtual void frame(float seconds) = 0;
-
-	/* updateable by game */
+/*----- inspectors ------------------------------------------------ */
 
-	/// owner of this controllable entity
-	Player *owner;
-
-	/* updatable by client */
+	/// core type id
+	virtual inline unsigned int type() { return Entity::Controlable; }
 
-	/// the direction the client wants to travel the entity to
-	/// @see direction
-	float target_direction;
+	/// owner of this entity
+	inline Player *owner() const { return entity_owner; }
 
-	/// engine thrust as set by the client, 0.0f - 1.0f
-	float target_thrust;
-};
+	/// thrust
+	inline float thrust() const { return entity_thrust; }
 
+/*----- mutators -------------------------------------------------- */
 
-namespace entity
-{
+	/// set the target thrust
+	void set_thrust(float t);
 
-/// the entity registry
-extern std::vector<Entity*> registry;
+	/// set the target direction
+	void set_direction(float t);
 
-/// add an entity to the registry
-void add(Entity *ent);
+	/// runs one game frame for the entity
+	/**
+	 * The default implementation will set direction() and thrust() to the desired targets
+	 * and calls its parent frame() funcion.
+	 */
+	virtual void frame(float seconds);
 
-/// remove one entity from the registry
-void remove(unsigned int entity_id);
+	/* entity_ variables can be set by the module */
 
-/// clear the entity registry
-void clear();
+	/// owner of the entity
+	Player			*entity_owner;
+	/// current thrust
+	float			entity_thrust;
 
-/// list the entity registry
-void list();
+	/* target_ variables can be set by the client */
 
-/// run a game frame on each entity in the registry
-void frame(float seconds);
-
-}
+	/// target thrust as set by the client
+	float			target_thrust;
+	/// target direction as set by the client
+	float			target_direction;
+};
 
 }
 
diff --git a/src/core/func.cc b/src/core/func.cc
index 06aa5b6..0215ddf 100644
--- a/src/core/func.cc
+++ b/src/core/func.cc
@@ -4,100 +4,125 @@
    the terms of the GNU General Public License version 2
 */
 
-#include "core/func.h"
 #include <map>
 #include <string>
+#include <iomanip>
 
-namespace core
-{
-
-Func_t::Func_t(unsigned int funcflags)
-{
-	func_flags = funcflags;
-}
+#include "sys/sys.h"
+#include "core/func.h"
 
-unsigned int Func_t::flags()
+namespace core
 {
-	return func_flags;
-}
 
-namespace func
-{
+/* ---- Static functions for the Func registry -------------------- */
 
-std::map<std::string, Func> registry;
+std::map<std::string, Func*> Func::registry;
 
-void add(const char * functionname, FuncPtr functionptr, unsigned int flags)
+void Func::add(const char *name, FuncPtr functionptr, unsigned int flags)
 {
-	std::map<std::string, Func>::iterator it = registry.find(functionname);
+	std::map<std::string, Func*>::iterator it = registry.find(name);
 	if (it == registry.end()) {
-		// function does not yet exist in the registry
-		Func f = new Func_t(flags);
-		//f->name = functionname;
-		f->ptr = (void *)functionptr;
-		registry[std::string(functionname)] = f;
+		registry[std::string(name)] = new Func(name, (void *)functionptr, flags & ~Func::Game);
 	} else {
-		con_warn << "Function '" << functionname << "' already registered!" << std::endl;
+		con_warn << "Function '" << name << "' already registered!" << std::endl;
 	}
 }
 
-void add(const char * functionname, GameFuncPtr gamefunctionptr, unsigned int flags)
+void Func::add(const char *name, GameFuncPtr gamefunctionptr, unsigned int flags)
 {
-	std::map<std::string, Func>::iterator it = registry.find(functionname);
+	std::map<std::string, Func*>::iterator it = registry.find(name);
 	if (it == registry.end()) {
-		// function does not yet exist in the registry
-		Func f = new Func_t(flags & func::Game);
-		//f->name = functionname;
-		f->ptr = (void *)gamefunctionptr;
-		registry[std::string(functionname)] = f;
+		registry[std::string(name)] = new Func(name, (void *)gamefunctionptr, flags | Func::Game);
+		con_debug << "Function '" << name << "' registered." << std::endl;
 	} else {
-		con_warn << "Function '" << functionname << "' already registered!" << std::endl;
+		con_warn << "Function '" << name << "' already registered!" << std::endl;
 	}
 }
 
-void remove(const char *functionname)
+void Func::remove(const char *name)
 {
-	std::map<std::string, Func>::iterator it = registry.find(functionname);
+	std::map<std::string, Func *>::iterator it = registry.find(std::string(name));
         if (it != registry.end()) {
 		delete (*it).second;
-		registry.erase(std::string(functionname));
+		registry.erase(it);
+		con_debug << "Function '" << name << "' unregistered." << std::endl;
 	}
 }
 
-void remove(const std::string &functionname)
+void Func::remove(const std::string &name)
 {
-	std::map<std::string, Func>::iterator it = registry.find(functionname);
+	std::map<std::string, Func *>::iterator it = registry.find(name);
         if (it != registry.end()) {
                 delete (*it).second;
-                registry.erase(std::string(functionname));
+                registry.erase(it);
+		con_debug << "Function '" << name << "' unregistered." << std::endl;
         }
 
 }
 
-Func find(const std::string &functionname)
+Func *Func::find(const std::string &name)
 {
-	std::map<std::string, Func>::iterator it = registry.find(functionname);
+	std::map<std::string, Func *>::iterator it = registry.find(name);
 	if (it == registry.end())
 		return 0;
 	else
 		return (*it).second;
 }
 
-void list()
+void Func::list()
 {
-	std::map<std::string, Func>::iterator it;
+	std::map<std::string, Func*>::iterator it;
 	for (it = registry.begin(); it != registry.end(); it++) {
 		std::string typeindicator;
-		if ((*it).second->flags() & func::Game)
+		if (((*it).second->flags() & Game) == Game)
 			typeindicator += 'G';
 		else
 			typeindicator += ' ';
-		con_print << " " << typeindicator << " " << (*it).first << std::endl;
+		con_print << std::setw(4) << (*it).second->flags() << " " << typeindicator << 
+			" " << (*it).second->name() << std::endl;
 	}
 
 	con_print << registry.size() << " registered functions" << std::endl;
 }
 
-} // namespace func
+/* ---- Func ------------------------------------------------------ */
+
+Func::Func(char const * funcname, void *ptr, unsigned int funcflags)
+{
+	if (funcname)
+		func_name.assign(funcname);
+	else
+		func_name.clear();
+
+	func_flags = funcflags;
+	func_ptr = ptr;
+}
+
+Func::~Func()
+{
+	func_name.clear();
+	func_ptr = 0;
+	func_flags = 0;
+}
+
+
+void Func::exec(std::string const &args)
+{
+	if ((flags() & Game))
+		return;
+
+	FuncPtr function = (FuncPtr) func_ptr;
+	function(args);
+}
+	
+void Func::exec(Player *player, std::string const &args)
+{
+	if (!(flags() & Game))
+		return;
+
+	GameFuncPtr gamefunction = (GameFuncPtr) func_ptr;
+	gamefunction(player, args);
+}
 
 } // namespace core
 
diff --git a/src/core/func.h b/src/core/func.h
index 3d91ab1..e34e32d 100644
--- a/src/core/func.h
+++ b/src/core/func.h
@@ -7,7 +7,6 @@
 #ifndef __INCLUDED_CORE_FUNC_H__
 #define __INCLUDED_CORE_FUNC_H__
 
-#include "sys/sys.h"
 #include "core/player.h"
 
 #include <sstream>
@@ -17,65 +16,70 @@
 namespace core
 {
 
-class Func_t 
+/// function pointer type for local functions
+typedef void(* FuncPtr)(std::string const &args);
+
+/// fuction pointer for game functions
+typedef void(* GameFuncPtr)(Player *player, std::string const &args);
+
+/// a function pointer encapsulation class
+class Func 
 {
 public:
-	Func_t(unsigned int fflags = 0);
-
-	/// flags
-	unsigned int flags();
+	/// function flags
+	enum Flags {Game=1};
 	
+	/// create a new function
+	Func(char const * funcname, void *ptr, unsigned int funcflags = 0);
 	
-	/// pointer to the function
-	void 			*ptr;
+	~Func();
 
-private:
-	unsigned int 		func_flags;
-};
+/*----- inspectors ------------------------------------------------ */
 
-/// function type
-typedef Func_t *Func;
+	/// returns the fucuntion flags
+	inline unsigned int flags() const { return func_flags; }
 
-/// function pointer type for local functions
-typedef void(* FuncPtr)(std::stringstream &args);
+	/// returns the name of the function
+	inline std::string const &name() const { return func_name; }
 
-/// fuction pointer for game functions
-typedef void(* GameFuncPtr)(Player &player, std::stringstream &args);
+/*----- mutators -------------------------------------------------- */
+	
+	/// execute the function if the Game flag is not set
+	void exec(std::string const &args);
+	
+	/// execute the function if the Game flag is set
+	void exec(Player *player, std::string const &args);
 
-/// the function registry
-namespace func
-{
+/* ---- Static functions for the Func registry -------------------- */
 
-/// function flags
-enum Flags {Game=1};
+	/// add a function to the registry
+	static void add(const char *name, FuncPtr functionptr, unsigned int flags=0);
 
-/// add a function to the registry
-void add(const char *functionname, FuncPtr functionptr, unsigned int flags=0);
+	/// add a game function to the registry and set the Game flag
+	static void add(const char *name, GameFuncPtr functionptr, unsigned int flags=0);
 
-/**
- * @brief add a game function to the registry
- * the flag core::func::Game will automaticly be set
- */
-void add(const char *functionname, GameFuncPtr gamefunctionptr, unsigned int flags=0);
+	/// remove a function from the registry
+	static void remove(const char *name);
 
-/// remove a function from the registry
-void remove(const char *functionname);
-void remove(const std::string &functionname);
+	/// remove a function from the registry
+	static void remove(std::string const &name);
 
-/// find a fuction pointer
-/** Returns 0 if the function pointer could not be found
- */
-Func find(const std::string &functionname);
+	/// find a fuction pointer, return 0 if it could not be found
+	static Func *find(std::string const &name);
 
-/// list the function registry
-void list();
+	/// list the function registry
+	static void list();
 
-/// the function registry
-extern std::map<std::string, Func> registry;
+	/// the function registry
+	static std::map<std::string, Func*> registry;
 
-} // namespace func
+private:
+	std::string		func_name;
+	unsigned int 		func_flags;
+	void 			*func_ptr;
+};
 
-} // namespace core
+}
 
 #endif // __INCLUDED_CORE_FUNC_H__
 
diff --git a/src/core/gameinterface.cc b/src/core/gameinterface.cc
index d07f804..38ea6fe 100644
--- a/src/core/gameinterface.cc
+++ b/src/core/gameinterface.cc
@@ -64,10 +64,10 @@ void message_broadcast(std::string const & message, int ignoreplayer)
 	}
 }
 
-void message_send(Player const &player, const char *protohdr, std::string message)
+void message_send(Player const *player, const char *protohdr, std::string message)
 {
 	// send to console
-	if (&player == &localplayer) {
+	if (player == &Player::local) {
 		con_print << message << std::endl;
 	}
 
diff --git a/src/core/gameinterface.h b/src/core/gameinterface.h
index 457df86..9eb6880 100644
--- a/src/core/gameinterface.h
+++ b/src/core/gameinterface.h
@@ -44,10 +44,10 @@ public:
 	virtual void shutdown() = 0;
 
 	/// is called when a player connects
-	virtual void player_connect(Player &player) = 0;
+	virtual void player_connect(Player *player) = 0;
 
 	/// is called when a player disconnects
-	virtual void player_disconnect(Player &player) = 0;
+	virtual void player_disconnect(Player *player) = 0;
 	
 	static GameInterface *gameinterface_instance;
 
diff --git a/src/core/netclient.cc b/src/core/netclient.cc
index e2a9b7e..61a3e64 100644
--- a/src/core/netclient.cc
+++ b/src/core/netclient.cc
@@ -21,8 +21,8 @@ NetClient::NetClient(int clientfd, std::string host, int port) :
 	std::ostringstream osstream;
 	//osstream << "host << ":" << port;
 	osstream << "Player" << clientfd;
-	client_player.name = osstream.str();
-	client_player.id = (unsigned int) clientfd;
+	client_player.player_name = osstream.str();
+	client_player.player_id = (unsigned int) clientfd;
 
 	client_host = host;
 	client_port = port;
@@ -43,9 +43,9 @@ int NetClient::port() const
         return client_port;
 }
 
-Player &NetClient::player() 
+Player *NetClient::player() 
 {
-	return client_player;
+	return &client_player;
 }
 
 bool NetClient::has_messages() const {
diff --git a/src/core/netclient.h b/src/core/netclient.h
index dcffb3c..04234da 100644
--- a/src/core/netclient.h
+++ b/src/core/netclient.h
@@ -31,7 +31,7 @@ public:
         int port() const;
 
 	/// the player info associated with this client
-	Player & player();
+	Player *player();
 
 	/// return true if there are incoming messages
 	bool has_messages() const;
diff --git a/src/core/netconnection.cc b/src/core/netconnection.cc
index 85c0534..60b4ff8 100644
--- a/src/core/netconnection.cc
+++ b/src/core/netconnection.cc
@@ -31,7 +31,7 @@ void NetConnection::connect(std::string const &to_host, int to_port)
 	}
 
 	std::ostringstream osstream;
-	osstream << "name " << localplayer.name << std::endl;
+	osstream << "name " << Player::local.name() << std::endl;
 	send(osstream.str());
 }
 
diff --git a/src/core/netserver.cc b/src/core/netserver.cc
index 08863df..39548dd 100644
--- a/src/core/netserver.cc
+++ b/src/core/netserver.cc
@@ -37,7 +37,7 @@ NetServer::~NetServer()
 		// notify the game
 		if (game() && game()->connected) {
 			core::game()->player_disconnect((*it)->player());
-			con_print << (*it)->player().name << " disconnected."<< std::endl;
+			con_print << (*it)->player()->name() << " disconnected."<< std::endl;
 		}
 		delete (*it);
 	}
@@ -58,11 +58,11 @@ void NetServer::client_connect(int const clientfd, std::string const host, int c
 	FD_SET(client->fd(), &serverset);
 	
 	// TODO send infos
-	con_print << client->host() << ":" << client->port() << " " << client->player().name << " connected."<< std::endl;
+	con_print << client->host() << ":" << client->port() << " " << client->player()->name() << " connected."<< std::endl;
 
 	// BROADCAST connect message
 	std::ostringstream osstream;
-	osstream << "msg info " << client->player().name << " connected."<< std::endl;
+	osstream << "msg info " << client->player()->name() << " connected."<< std::endl;
 	broadcast(osstream.str(), clientfd);
 
 	// notify the game
@@ -84,14 +84,14 @@ void NetServer::reap()
 			
 			// BROADCAST disconnect message
 			std::ostringstream osstream;
-			osstream << "msg info " << client->player().name << " disconnected."<< std::endl;
+			osstream << "msg info " << client->player()->name() << " disconnected."<< std::endl;
 			broadcast(osstream.str());
 		
 			// notify the game
 			if (core::game())
 				core::game()->player_disconnect(client->player());
 
-			con_print << client->player().name << " disconnected."<< std::endl;
+			con_print << client->player()->name() << " disconnected."<< std::endl;
 
 			// remove the client
                         clients.erase(it);
@@ -163,10 +163,10 @@ void NetServer::broadcast(std::string const & message, int ignorefd)
 }
 
 // find the client corresponding to a player id
-NetClient *NetServer::find_client(Player const &player)
+NetClient *NetServer::find_client(Player const *player)
 {
 	for (std::list<NetClient *>::iterator it = clients.begin(); it != clients.end(); it++) {
-		if ((*it)->fd() == (int) player.id) {
+		if ((*it)->fd() == (int) player->id()) {
 			return (*it);
 		}
 	}
@@ -201,9 +201,9 @@ void NetServer::parse_incoming_message(NetClient *client, const std::string & me
 	if (command == "say") {		
 		if (message.size() > command.size()+1) {
 			std::ostringstream osstream;
-			osstream << "msg public " << client->player().name << " " << message.substr(command.size()+1) << "\n";
+			osstream << "msg public " << client->player()->name() << " " << message.substr(command.size()+1) << "\n";
 			broadcast(osstream.str());
-			con_print << client->player().name << " " << message.substr(command.size()+1) << std::endl;
+			con_print << client->player()->name() << " " << message.substr(command.size()+1) << std::endl;
 		}
 		return;
 	}
@@ -214,12 +214,12 @@ void NetServer::parse_incoming_message(NetClient *client, const std::string & me
 		if (msgstream >> name) {
 			if (name.size() > 16) 
 				name = name.substr(0,16);
-			if (name != client->player().name) {
+			if (name != client->player()->name()) {
 				std::ostringstream osstream;
-				osstream << "msg info " << client->player().name << " renamed to " << name << "\n";
+				osstream << "msg info " << client->player()->name() << " renamed to " << name << "\n";
 				broadcast(osstream.str());				
-				con_print << client->player().name << " renamed to " << name << std::endl;
-				client->player().name = name;	
+				con_print << client->player()->name() << " renamed to " << name << std::endl;
+				client->player()->player_name = name;	
 			}
 		}
 		return;
@@ -228,7 +228,7 @@ void NetServer::parse_incoming_message(NetClient *client, const std::string & me
 	if (command == "list_players") {
 		std::ostringstream osstream;
 		for (std::list<NetClient *>::iterator it = clients.begin(); it != clients.end(); it++) {
-			osstream << "msg info " << (*it)->player().name << " " << (*it)->host() << ":" << (*it)->port() << "\n";
+			osstream << "msg info " << (*it)->player()->name() << " " << (*it)->host() << ":" << (*it)->port() << "\n";
 		}
 		osstream << "msg info " << clients.size() << " connected players\n" << std::endl;
 		send(client, osstream.str());
@@ -245,15 +245,18 @@ void NetServer::parse_incoming_message(NetClient *client, const std::string & me
 
 	// execute game functions
 	if (game() && game()->connected) {
-		Func f = func::find(command);
-		if (f) {
-			if (f->flags() && func::Game) {	
-				GameFuncPtr function = (GameFuncPtr) f->ptr;
-				function(client->player(), msgstream);
+		Func *function = Func::find(command);
+		if (function ) {
+			std::string args;
+			char c;
+			if (msgstream >> args)
+				while (msgstream >> c)
+					args += c;
+			if (function ->flags() && Func::Game) {	
+				function->exec(client->player(), args);
 			} else {
 				// instant rcon
-				//FuncPtr function = (FuncPtr) f->ptr;
-				//function(msgstream);
+				//function->exec(args);
 			}
 		}
 	}
@@ -267,10 +270,10 @@ void NetServer::parse_client_variable(NetClient * client, const std::string varn
 			std::ostringstream osstream;
 			if (name.size() > 16) 
 				name = name.substr(0,16);
-			if (name != client->player().name) {
-				osstream << "msg info " << client->player().name << " renamed to " << name << "\n";
+			if (name != client->player()->name()) {
+				osstream << "msg info " << client->player()->name() << " renamed to " << name << "\n";
 				broadcast(osstream.str());
-				client->player().name = name;	
+				client->player()->player_name = name;	
 			}
 		}		
 		return;
diff --git a/src/core/netserver.h b/src/core/netserver.h
index 8ebd83d..8c3da65 100644
--- a/src/core/netserver.h
+++ b/src/core/netserver.h
@@ -35,7 +35,7 @@ public:
 	void send(NetClient * client, std::string const & message);
 
 	/// find the client corresponding to a player
-	NetClient *find_client(Player const &player);
+	NetClient *find_client(Player const *player);
 
 protected:
         /// called by accept() when a new client connects
diff --git a/src/core/player.cc b/src/core/player.cc
index 6bd79ec..b54bf9e 100644
--- a/src/core/player.cc
+++ b/src/core/player.cc
@@ -9,14 +9,13 @@
 namespace core
 {
 
-Player localplayer;
+Player Player::local;
 
 Player::Player()
 {
-	id = 0;
-	name.clear();
+	player_id = 0;
+	player_name.clear();
 	dirty = false;
-
 	control = 0;
 }
 
diff --git a/src/core/player.h b/src/core/player.h
index aa20d20..e19b8ae 100644
--- a/src/core/player.h
+++ b/src/core/player.h
@@ -27,21 +27,28 @@ public:
 	~Player();
 	
 	/// name of the player
-	std::string name;
-	
-	/// core id of the player
-	unsigned int id;
-	
+	inline std::string const &name() const { return player_name; }
+
+	///  id of the player
+	inline unsigned int id() const { return player_id; }
+
+	///  id of the player
+	unsigned int player_id;
+
+	/// name of the player
+	std::string player_name;
+
+
 	/// dirty state
 	bool dirty;
 
 	/// the entity the Player is currently controling
 	EntityControlable *control;
+	
+	/// the local player
+	static Player local;
 };
 
-/// the local player, always has id 0
-extern Player localplayer;
-
 }
 
 #endif // __INCLUDED_CORE_PLAYER_H__