Project::OSiRiON - Git repositories
Project::OSiRiON
News . About . Screenshots . Downloads . Forum . Wiki . Tracker . Git
summaryrefslogtreecommitdiff
blob: 3f71b4c5332e35afb34270b2232d1fd3810433af (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
/*
   core/application.h
   This file is part of the Osirion project and is distributed under
   the terms of the GNU General Public License version 2.
*/

#ifndef __INCLUDED_CORE_APPLICATION_H__
#define __INCLUDED_CORE_APPLICATION_H__

#include "sys/sys.h"
#include "sys/timer.h"

#include "core/commandbuffer.h"
#include "core/cvar.h"
#include "core/func.h"
#include "core/message.h"
#include "core/gameinterface.h"

namespace core
{

/// core interface for the client and server Application classes
class Application
{
public:
	/// default constructor
	Application();

	/// default destructor
	virtual ~Application();

	/*-----  inspectors ----------------------------------------------- */

	/// the current application time, in milliseconds
	inline unsigned long timestamp() const {
		return application_timer.timestamp();
	}
	
	/**
	 * @brief return the current application time, in seconds.
	 * */
	inline float time() const {
		return (float) application_timer.timestamp() / 1000.0f;
	}

	/// true if the core is connected to a running game interface
	inline bool connected() const {
		return (application_game && application_game->running());
	}

	/// return the game interface, returns 0 if the application is not connected to a game
	inline GameInterface *game() {
		return application_game;
	}

	/*-----  mutators ------------------------------------------------- */

	/// start the server or connect to remote host
	void connect(std::string const &host);

	/// disconnect from the game module
	void disconnect();

	/// load a module
	bool load(std::string const &module_name);

	/*-----  virtual mutators ------------------------------------------ */

	/// initialize the application
	virtual void init(int count, char **arguments);

	/// shutdown the application
	virtual void shutdown();

	/// quit the application without proper shutdown
	virtual void quit(int status);

	/*-----  notifications --------------------------------------------- */

	/// sound notifications from the core to the application
	virtual void notify_sound(const char * name);

	/// text notifications from the core to the application
	virtual void notify_message(const core::Message::Channel channel, const std::string &message);

	/// loading message notification
	virtual void notify_loader(const std::string &message);

	/// connect notification
	virtual void notify_connect();

	/// disconnect notification
	virtual void notify_disconnect();

	/// zone change notification
	virtual void notify_zonechange();

	/// a pointer to the current application instance
	static inline Application *instance() {
		return application_instance;
	}

protected:
	/// run a core frame
	virtual void frame();

	/// load cvar config
	void load_config();

	/// load exra config
	void load_autoexec();

	/// save cvar config
	void save_config();

	/// load command line arguments
	void load_commandline(int count, char **argments);

private:
	/// main loop timer
	sys::Timer		application_timer;

	GameInterface		*application_game;

	static Application	*application_instance;

protected:
	/*-- engine functions --*/

	static void func_help(std::string const &args);
	static void func_quit(std::string const  &args);
	static void func_connect(std::string const &args);
	static void func_disconnect(std::string const  &args);
	static void func_shout(std::string const &args);
	static void func_say(std::string const &args);
	static void func_msg(std::string const &args);
	static void func_load(std::string const &args);
	static void func_rcon(std::string const &args);
	static void func_info(std::string const &args);
};

/// pointer to the application
inline Application *application()
{
	return Application::instance();
}

/// pointer to the console
inline sys::ConsoleInterface *console()
{
	return sys::ConsoleInterface::instance();
}

/// pointer to the game interface
inline GameInterface *game()
{
	return Application::instance()->game();
}

}


#endif // __INCLUDED_CORE_APPLICATION_H__