Project::OSiRiON - Git repositories
Project::OSiRiON
News . About . Screenshots . Downloads . Forum . Wiki . Tracker . Git
summaryrefslogtreecommitdiff
blob: f204c04fe62484cf51151bfe7cfb08c8e3465925 (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
/*
   core/gameinterface.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_GAMEINTERFACE_H__
#define __INCLUDED_CORE_GAMEINTERFACE_H__

#include "core/player.h"
#include "core/info.h"
#include "core/inventory.h"
#include "model/vertexarray.h"

namespace core
{

/// abstract interface from the core to the game-specific code
class GameInterface
{
public:
	/// create a new game
	GameInterface();

	/// destroy the game
	virtual ~GameInterface();

	/// type definition for the Players collection
	typedef std::list<Player *> Players;

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

	/// return the local player
	inline Player *localplayer() {
		return &game_localplayer;
	}

	inline Players & players() {
		return game_players;
	}
	
	inline const unsigned long playerlist_timestamp() const {
		return game_playerlist_timestamp;
	}

	inline model::VertexArray *vertexarray() {
		return game_vertexarray;
	}

	/// find the first player who's id or name matches the search string
	Player *find_player(const std::string &search);
	
	/// find a player id
	Player *find_player(const int playerid);
	
	/// find a player
	Player *find_player(const Player *player);

	/// show a list of connected players
	void list_players();

	/// returns true if the game server can run a time frime
	inline bool running() const {
		return game_running;
	}
	
	inline bool error() const {
		return !game_running;
	}

	/// returns true if the game is running an interactive module
	inline bool interactive() const {
		return game_interactive;
	}

	/**
	 * @brief return the current game time, in seconds.
	 * */
	inline float time() const {
		return (float) game_timestamp / 1000.0f;
	}
	
	/**
	 * @brief return the current game time, in milliseconds.
	 * 1000 milliseconds equals one second.
	 */
	inline unsigned long timestamp() const {
		return game_timestamp;
	}
	
	/*----- virtual inspectors --------------------------------------- */
	
	/// request info record with id 
	virtual Info *request_info(const unsigned int id) = 0;
	
	/// request inventory for entity with id
	virtual Inventory *request_inventory(Entity *entity)  = 0;
	
	/*-----  mutators ------------------------------------------------- */

	/// clear all game variables, game functions and entities
	void clear();

	void set_playerlist_timestamp(const unsigned long timestamp);
	
	virtual void abort();
	
	/// run one game time frame
	/// @param timestamp current application time
	virtual void frame(const unsigned long timestamp) = 0;

protected:
	/// the local player
	static Player 			game_localplayer;

	/// all the players
	Players				game_players;

	/// timestamp of the time the playerlist was last changed
	unsigned long			game_playerlist_timestamp;
	
	/// set the current game time
	void set_timestamp(const unsigned long timestamp);
	
	void set_running(const bool running);
	
	void set_interactive(const bool interactive);

	model::VertexArray 		*game_vertexarray;
	
private:
	bool				game_running;
	bool				game_interactive;
	
	unsigned long			game_timestamp;
};

/// global local player instance
Player *localplayer();

/// global local control instance
EntityControlable *localcontrol();

}

#endif // __INCLUDED_CORE_GAMEINTERFACE_H__