server/include/client.h

/*
 * CrossFire, A Multiplayer game for the X Window System
 * 
 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
 * Copyright (C) 1992 Frank Tore Johansen
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * The author can be reached via e-mail to crossfire@schmorp.de
 */

#ifndef CLIENT_H
#define CLIENT_H

#include <deque>
#include <bitset>
#include <tr1/unordered_set>

// (possibly) max. number of objects "per page" in the ground container
#define FLOORBOX_PAGESIZE 50

struct MapCell
{
  UUID player;                 // this is, unfortunately, very wasteful of memory space, but pretty bandwidth-efficient
  int count;                    /* This is really darkness in the map1 command */
  uint16 faces[MAP_LAYERS];
  uint16 smooth[MAP_LAYERS];
  unsigned char stat_hp;        // health of something in this space, or 0
  unsigned char flags;
};

/* This basically defines the largest size an 
 * archetype may be - it is used for allocation of
 * some structures, as well as determining how far
 * we should look for the heads of big images.
 */
#define MAX_HEAD_OFFSET     8

#define MAX_CLIENT_X (MAP_CLIENT_X + MAX_HEAD_OFFSET)
#define MAX_CLIENT_Y (MAP_CLIENT_Y + MAX_HEAD_OFFSET)

struct Map
{
  struct MapCell cells[MAX_CLIENT_X][MAX_CLIENT_Y];
};

/* True max is 16383 given current map compaction method */
# define MAXANIMNUM  2000

struct statsinfo
{
  char *range, *title;
};

/* This contains basic information on the socket structure.  status is its
 * current state.  we set up our on buffers for sending/receiving, so we can
 * handle some higher level functions.  fd is the actual file descriptor we
 * are using.
 */

/* Only one map mode can actually be used, so lets make it a switch
 * instead of having a bunch of different fields that needed to
 * get toggled.
 */
enum MapMode { Map0Cmd = 0, Map1Cmd = 1, Map1aCmd = 2 };

/* The following is the setup for a ring buffer for storing output
 * data that the OS can't handle right away.
 */
struct Buffer
{
  char data[SOCKETBUFSIZE];
  int start;
  int len;
};

// states the socket can be in
enum {
 ST_DEAD,     // socket is dead
 ST_SETUP,    // initial handshake / setup / login
 ST_PLAYING,  // logged in an playing
 ST_CUSTOM,   // waiting for custom reply

 ST_CHANGE_CLASS,
 ST_GET_PARTY_PASSWORD,
};

// a handler for a specific type of packet
enum {
  PF_PLAYER   = 0x01, // must have valid player / will by synchronised
  PF_PLAYING  = 0x02, // must be in playing state
  PF_COMMAND0 = 0x04, // command starts at offset 0
  PF_COMMAND6 = 0x08, // command starts at offset 6
};

struct packet_type
{
  const char *name;
  void *cb;
  int flags;
};

struct command
{
  tstamp stamp;
  const packet_type *handler;
  char *data;
  int datalen;

  ~command ()
  {
    sfree<char> (data, datalen + 1);
  }
};

struct refitem
{
  object_ptr op;
};

// this represents a container on the client side.
// right now, there are only ever two of them:
// the inventory and the floor/open container
//TODO: unused as of yet
struct client_container : vector< refitem, slice_allocator<refitem> >
{
  client *ns;
  enum { CC_NONE, CC_INVENTORY, CC_MAPSPACE, CC_CONTAINER } type;

  bool item_changed; // one of the items in here possibly changed

  // for mapspace and container
  int x, y;
  maptile *map;

  // for container
  object *env;

  client_container (client *ns)
  : ns (ns), type (CC_NONE) { }

  tag_t tag () const;

  inline iterator merge_item (iterator i, object *op);

  void clear ();
  void update ();

  void set_mapspace (maptile *map, int x, int y);
  void set_container (object *env);
};

/* how many times we are allowed to give the wrong password before being kicked. */
#define MAX_PASSWORD_FAILURES 5

INTERFACE_CLASS (client) // should become player when newsocket is a baseclass of player
struct client : zero_initialised, attachable
{
  int ACC (RW, fd);
  unsigned int inbuf_len;                 // number of bytes valid in inbuf
  uint8 *faces_sent;                      // This is a bitmap on sent face status
  statsinfo stats;
  int ACC (RO, active);

  Buffer outputbuffer;                    

  char *ACC (RW, host);                   /* Which host it is connected from (ip address) */
  uint8 ACC (RW, state);                  /* Input state of the player (name, password, etc */

  sint8 ACC (RW, last_level);             /* Last level we sent to client */
  uint16 ACC (RW, last_flags);            /* fire/run on flags for last tick */
  float ACC (RW, last_weapon_sp);         /* if diff than weapon_sp, update client */
  sint32 ACC (RW, last_weight);           /* Last weight as sent to client; -1 means do not send weight */
  sint32 ACC (RW, last_weight_limit);     /* Last weight limit transmitted to client */
  uint32 ACC (RW, last_path_attuned);     /* Last spell attunment sent to client */
  uint32 ACC (RW, last_path_repelled);    /* Last spell repelled sent to client */
  uint32 ACC (RW, last_path_denied);      /* Last spell denied sent to client */
  living ACC (RO, last_stats);            /* Last stats as sent to client */
  float ACC (RW, last_speed);             /* Last speed as sent to client */
  sint16 ACC (RW, last_resist[NROFATTACKS]);/* last resist values sent to client */
  sint64 ACC (RW, last_skill_exp[NUM_SKILLS]);/* shadow register. if != exp. obj update client */

  bool ACC (RW, afk);                     /* player is afk */
  bool ACC (RW, facecache);               /* If true, client is caching images */
  bool ACC (RW, sent_scroll);             
  bool ACC (RW, sound);                   /* does the client want sound */
  bool ACC (RW, newmapcmd);               /* Send newmap command when entering new map SMACFIGGEN */
  bool ACC (RW, plugincmd);               /* CF+ extend the protocol through a plug-in */
  bool ACC (RW, mapinfocmd);              /* CF+ return map info and send map change info */
  bool ACC (RW, extcmd);                  /* CF+ call into extensions/plugins */
  bool ACC (RW, extmap);                  /* CF+ extend map comamnd with extra data */
  bool ACC (RW, buggy_mapscroll);         /* CF+ client crashes on large mapscrolls */
  bool ACC (RW, darkness);                /* True if client wants darkness information */
  bool ACC (RW, image2);                  /* Client wants image2/face2 commands */
  bool ACC (RW, update_look);             /* If true, we need to send the look window */
  bool ACC (RW, has_readable_type);       /* If true client accept additional text information */
                                          /* used to arrange text in books, scrolls, or scripted dialogs */
  bool ACC (RW, monitor_spells);          /* Client wishes to be informed when their spell list changes */
  bool ACC (RW, ext_mapinfos);            /* If true client accepts additional info on maps */
                                          /* Below are flags for extedend infos to pass to client 
                                           * with S->C mapextended command */
  bool ACC (RW, EMI_smooth);              /* Send smooth in extendmapinfos */

  uint32 ACC (RW, supported_readables);   /* each bit is a readable supported by client */
  uint32 ACC (RW, cs_version), ACC (RW, sc_version);        /* versions of the client */
  enum MapMode mapmode;         /* Type of map commands the client wants. */
  uint16 ACC (RW, look_position);         /* start of drawing of look window */
  uint8 ACC (RW, mapx), ACC (RW, mapy);             /* How large a map the client wants */
  uint8 ACC (RW, itemcmd);                /* What version of the 'item' protocol command to use */
  uint8 ACC (RW, faceset);                /* Set the client is using, default 0 */

  maptile *ACC (RW, current_map);         // CF+ last/current player map
  region *ACC (RW, current_region);       // CF+ last/current player region
  int ACC (RW, current_x), ACC (RW, current_y);     // CF+ last/current map position
  char ACC (RW, version)[64];             // CF+ client name/version

  player_ptr ACC (RO, pl);

  int ACC (RW, rtt), ACC (RW, rttvar); /* round-trip time and -variance, if known */

  void do_destroy ();
  void gather_callbacks (AV *&callbacks, event_type event) const;

  iow socket_ev; void socket_cb (iow &w, int got);
  iw  cmd_ev;    void cmd_cb (iw &w);
  client_container cc_inv, cc_other;

  std::deque< command, slice_allocator<command> > cmd_queue;

  // large structures at the end please
  struct Map lastmap;
  std::bitset<MAXANIMNUM> anims_sent;
  // if we get an incomplete packet, this is used to hold the data.
  // we add 2 byte for the header, one for the trailing 0 byte
  uint8 inbuf[MAXSOCKBUF + 2 + 1];

  bool may_execute (const packet_type *pkt) const;
  void execute (const packet_type *pkt, char *data, int datalen);

  void queue_command (packet_type *handler, char *data, int datalen);
  MTH bool handle_command ();
  // resets movement state
  MTH void reset_state ();
  // resets variable data used to send stat diffs
  MTH void reset_stats ();

  MTH bool handle_packet ();
  int next_packet ();                     // returns length of packet or 0
  void skip_packet (int len);             // we have processed the packet, skip it

  MTH void flush ();
  MTH void write_outputbuffer ();
  void send (void *buf_, int len);

  void send_packet (const char *buf);
  void send_packet (const char *buf, int len);
  void send_packet_printf (const char *format, ...);
  void send_packet (packet &sl);

  // called when something under the player changes
  MTH void floorbox_update () { update_look = 1; }
  // called when the player has been moved
  MTH void floorbox_reset  () { look_position = 0; floorbox_update (); }

  MTH static client *create (int fd, const char *peername);

protected:
  client (int fd, const char *from_ip);
  ~client ();
};

#define CLIENT_SUPPORT_READABLES(__sockPtr,__type)\
        ( ((__type)>0) &&\
          ((__sockPtr)->has_readable_type) && \
          ((__sockPtr)->supported_readables & (1<<(__type))) )

/* Bitmask for the faces_sent[] array - what
 * portion of the face have we sent?
 */
#define NS_FACESENT_FACE        0x1
#define NS_FACESENT_SMOOTH      0x2

/* Constants in the form EMI_ is for extended map infos.
 * Even if the client select the additionnal infos it wants
 * on the map, there may exist cases where this whole info
 * is not given in one buch but in separate bunches. This 
 * is done performance reasons (imagine some info related to
 * a visible object and another info related to a 4 square
 * width and height area). At the begin of an extended info packet
 * is a bit field. A bit is activated for each extended info
 * present in the data 
 */

/* Meanings:
 * EMI_NOREDRAW  Take extended infos into account but don't redraw,
 *               some additionnal datas will follow in a new packet
 * EMI_SMOOTH    Datas about smoothing  
 */
#define EMI_NOREDRAW        0x01
#define EMI_SMOOTH          0x02

/* this last one says the bitfield continue un next byte
 * There may be several on contiguous bytes. So there is 7
 * actual bits used per byte, and the number of bytes
 * is not fixed in protocol
 */
#define EMI_HASMOREBITS     0x80

#define FACE_TYPES  1
#define PNG_FACE_INDEX  0

#define VERSION_CS 1023        /* version >= 1023 understand setup cmd */
#define VERSION_SC 1026
//#define VERSION_SC 1027 // requestinfo image_info and image_sums, makes extending faces on the fly impossible
#define VERSION_INFO "Crossfire+ Server"

typedef object_vector<client, &client::active> sockvec;

extern sockvec clients;

#define for_all_clients(var)                    \
  for (int _i = 0; _i < clients.size (); ++_i)  \
    declvar (client *, var, clients [_i])

extern int nrofpixmaps; //TODO: hrmpf, should go

#endif

Revision:	1.31
Committed:	Sat Mar 10 19:48:16 2007 UTC (17 years, 3 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.30:	+2 -1 lines
Log Message:	- improve image_sums - DOWNGRADE server protocol version to 1026. * this disables requestinfo image_sums and image_info in gcfclient, allowing us to use up to 10000 faces dynamically (right now, we already sue up to 7500 faces, but the 10000 face limit is, of coruse, hardcoded into gcfclient)) -- A student, in hopes of understanding the Lambda-nature, came to Greenblatt. As they spoke a Multics system hacker walked by. "Is it true", asked the student, "that PL-1 has many of the same data types as Lisp". Almost before the student had finshed his question, Greenblatt shouted, "FOO!", and hit the student with a stick.
#	User	Rev	Content
1	root	1.1	/*
2	pippijn	1.26	* CrossFire, A Multiplayer game for the X Window System
3			*
4			* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5			* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
6			* Copyright (C) 1992 Frank Tore Johansen
7			*
8			* This program is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation; either version 2 of the License, or
11			* (at your option) any later version.
12			*
13			* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program; if not, write to the Free Software
20			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21			*
22			* The author can be reached via e-mail to crossfire@schmorp.de
23			*/
24	root	1.1
25			#ifndef CLIENT_H
26			#define CLIENT_H
27
28	root	1.4	#include <deque>
29	root	1.7	#include <bitset>
30	root	1.13	#include <tr1/unordered_set>
31	root	1.1
32	root	1.4	// (possibly) max. number of objects "per page" in the ground container
33	root	1.11	#define FLOORBOX_PAGESIZE 50
34	root	1.1
35			struct MapCell
36			{
37			UUID player; // this is, unfortunately, very wasteful of memory space, but pretty bandwidth-efficient
38			int count; /* This is really darkness in the map1 command */
39			uint16 faces[MAP_LAYERS];
40			uint16 smooth[MAP_LAYERS];
41			unsigned char stat_hp; // health of something in this space, or 0
42			unsigned char flags;
43			};
44
45			/* This basically defines the largest size an
46			* archetype may be - it is used for allocation of
47			* some structures, as well as determining how far
48			* we should look for the heads of big images.
49			*/
50			#define MAX_HEAD_OFFSET 8
51
52			#define MAX_CLIENT_X (MAP_CLIENT_X + MAX_HEAD_OFFSET)
53			#define MAX_CLIENT_Y (MAP_CLIENT_Y + MAX_HEAD_OFFSET)
54
55			struct Map
56			{
57			struct MapCell cells[MAX_CLIENT_X][MAX_CLIENT_Y];
58			};
59
60			/* True max is 16383 given current map compaction method */
61			# define MAXANIMNUM 2000
62
63			struct statsinfo
64			{
65			char range, title;
66			};
67
68			/* This contains basic information on the socket structure. status is its
69			* current state. we set up our on buffers for sending/receiving, so we can
70			* handle some higher level functions. fd is the actual file descriptor we
71			* are using.
72			*/
73
74			/* Only one map mode can actually be used, so lets make it a switch
75			* instead of having a bunch of different fields that needed to
76			* get toggled.
77			*/
78			enum MapMode { Map0Cmd = 0, Map1Cmd = 1, Map1aCmd = 2 };
79
80	root	1.13	/* The following is the setup for a ring buffer for storing output
81	root	1.1	* data that the OS can't handle right away.
82			*/
83			struct Buffer
84			{
85			char data[SOCKETBUFSIZE];
86			int start;
87			int len;
88			};
89
90	root	1.15	// states the socket can be in
91			enum {
92			ST_DEAD, // socket is dead
93			ST_SETUP, // initial handshake / setup / login
94			ST_PLAYING, // logged in an playing
95			ST_CUSTOM, // waiting for custom reply
96
97			ST_CHANGE_CLASS,
98			ST_GET_PARTY_PASSWORD,
99			};
100
101	root	1.4	// a handler for a specific type of packet
102			enum {
103	root	1.28	PF_PLAYER = 0x01, // must have valid player / will by synchronised
104			PF_PLAYING = 0x02, // must be in playing state
105			PF_COMMAND0 = 0x04, // command starts at offset 0
106			PF_COMMAND6 = 0x08, // command starts at offset 6
107	root	1.4	};
108
109			struct packet_type
110			{
111			const char *name;
112			void *cb;
113			int flags;
114			};
115
116			struct command
117			{
118			tstamp stamp;
119			const packet_type *handler;
120			char *data;
121			int datalen;
122
123	root	1.6	~command ()
124	root	1.4	{
125	root	1.8	sfree<char> (data, datalen + 1);
126	root	1.4	}
127			};
128
129	root	1.13	struct refitem
130			{
131			object_ptr op;
132			};
133
134	root	1.12	// this represents a container on the client side.
135			// right now, there are only ever two of them:
136			// the inventory and the floor/open container
137			//TODO: unused as of yet
138	root	1.13	struct client_container : vector< refitem, slice_allocator<refitem> >
139	root	1.12	{
140	root	1.13	client *ns;
141	root	1.12	enum { CC_NONE, CC_INVENTORY, CC_MAPSPACE, CC_CONTAINER } type;
142
143	root	1.13	bool item_changed; // one of the items in here possibly changed
144
145	root	1.12	// for mapspace and container
146	root	1.13	int x, y;
147	root	1.12	maptile *map;
148
149			// for container
150			object *env;
151	root	1.13
152			client_container (client *ns)
153			: ns (ns), type (CC_NONE) { }
154
155			tag_t tag () const;
156
157			inline iterator merge_item (iterator i, object *op);
158
159			void clear ();
160			void update ();
161
162			void set_mapspace (maptile *map, int x, int y);
163			void set_container (object *env);
164	root	1.12	};
165
166	root	1.1	/* how many times we are allowed to give the wrong password before being kicked. */
167			#define MAX_PASSWORD_FAILURES 5
168
169	root	1.21	INTERFACE_CLASS (client) // should become player when newsocket is a baseclass of player
170			struct client : zero_initialised, attachable
171	root	1.1	{
172			int ACC (RW, fd);
173	root	1.10	unsigned int inbuf_len; // number of bytes valid in inbuf
174			uint8 *faces_sent; // This is a bitmap on sent face status
175	root	1.20	statsinfo stats;
176	root	1.24	int ACC (RO, active);
177	root	1.12
178	root	1.15	Buffer outputbuffer;
179	root	1.10
180			char ACC (RW, host); / Which host it is connected from (ip address) */
181	root	1.15	uint8 ACC (RW, state); /* Input state of the player (name, password, etc */
182	root	1.25
183			sint8 ACC (RW, last_level); /* Last level we sent to client */
184			uint16 ACC (RW, last_flags); /* fire/run on flags for last tick */
185			float ACC (RW, last_weapon_sp); /* if diff than weapon_sp, update client */
186			sint32 ACC (RW, last_weight); /* Last weight as sent to client; -1 means do not send weight */
187			sint32 ACC (RW, last_weight_limit); /* Last weight limit transmitted to client */
188			uint32 ACC (RW, last_path_attuned); /* Last spell attunment sent to client */
189			uint32 ACC (RW, last_path_repelled); /* Last spell repelled sent to client */
190			uint32 ACC (RW, last_path_denied); /* Last spell denied sent to client */
191			living ACC (RO, last_stats); /* Last stats as sent to client */
192			float ACC (RW, last_speed); /* Last speed as sent to client */
193			sint16 ACC (RW, last_resist[NROFATTACKS]);/* last resist values sent to client */
194			sint64 ACC (RW, last_skill_exp[NUM_SKILLS]);/* shadow register. if != exp. obj update client */
195	root	1.10
196	root	1.20	bool ACC (RW, afk); /* player is afk */
197	root	1.10	bool ACC (RW, facecache); /* If true, client is caching images */
198			bool ACC (RW, sent_scroll);
199			bool ACC (RW, sound); /* does the client want sound */
200			bool ACC (RW, newmapcmd); /* Send newmap command when entering new map SMACFIGGEN */
201			bool ACC (RW, plugincmd); /* CF+ extend the protocol through a plug-in */
202			bool ACC (RW, mapinfocmd); /* CF+ return map info and send map change info */
203			bool ACC (RW, extcmd); /* CF+ call into extensions/plugins */
204			bool ACC (RW, extmap); /* CF+ extend map comamnd with extra data */
205			bool ACC (RW, buggy_mapscroll); /* CF+ client crashes on large mapscrolls */
206			bool ACC (RW, darkness); /* True if client wants darkness information */
207			bool ACC (RW, image2); /* Client wants image2/face2 commands */
208			bool ACC (RW, update_look); /* If true, we need to send the look window */
209			bool ACC (RW, has_readable_type); /* If true client accept additional text information */
210			/* used to arrange text in books, scrolls, or scripted dialogs */
211			bool ACC (RW, monitor_spells); /* Client wishes to be informed when their spell list changes */
212			bool ACC (RW, ext_mapinfos); /* If true client accepts additional info on maps */
213			/* Below are flags for extedend infos to pass to client
214			* with S->C mapextended command */
215			bool ACC (RW, EMI_smooth); /* Send smooth in extendmapinfos */
216	root	1.1
217			uint32 ACC (RW, supported_readables); /* each bit is a readable supported by client */
218			uint32 ACC (RW, cs_version), ACC (RW, sc_version); /* versions of the client */
219			enum MapMode mapmode; /* Type of map commands the client wants. */
220			uint16 ACC (RW, look_position); /* start of drawing of look window */
221			uint8 ACC (RW, mapx), ACC (RW, mapy); /* How large a map the client wants */
222			uint8 ACC (RW, itemcmd); /* What version of the 'item' protocol command to use */
223			uint8 ACC (RW, faceset); /* Set the client is using, default 0 */
224
225			maptile *ACC (RW, current_map); // CF+ last/current player map
226	root	1.29	region *ACC (RW, current_region); // CF+ last/current player region
227	root	1.1	int ACC (RW, current_x), ACC (RW, current_y); // CF+ last/current map position
228	root	1.10	char ACC (RW, version)[64]; // CF+ client name/version
229	root	1.1
230	root	1.18	player_ptr ACC (RO, pl);
231	root	1.1
232			int ACC (RW, rtt), ACC (RW, rttvar); /* round-trip time and -variance, if known */
233
234	root	1.21	void do_destroy ();
235			void gather_callbacks (AV *&callbacks, event_type event) const;
236	root	1.4
237	pippijn	1.30	iow socket_ev; void socket_cb (iow &w, int got);
238	root	1.4	iw cmd_ev; void cmd_cb (iw &w);
239	pippijn	1.30	client_container cc_inv, cc_other;
240	root	1.1
241	root	1.4	std::deque< command, slice_allocator<command> > cmd_queue;
242
243	root	1.14	// large structures at the end please
244			struct Map lastmap;
245			std::bitset<MAXANIMNUM> anims_sent;
246			// if we get an incomplete packet, this is used to hold the data.
247			// we add 2 byte for the header, one for the trailing 0 byte
248			uint8 inbuf[MAXSOCKBUF + 2 + 1];
249
250	root	1.4	bool may_execute (const packet_type *pkt) const;
251			void execute (const packet_type pkt, char data, int datalen);
252
253			void queue_command (packet_type handler, char data, int datalen);
254	root	1.22	MTH bool handle_command ();
255	root	1.14	// resets movement state
256	root	1.22	MTH void reset_state ();
257	root	1.25	// resets variable data used to send stat diffs
258			MTH void reset_stats ();
259	root	1.1
260	root	1.22	MTH bool handle_packet ();
261	root	1.4	int next_packet (); // returns length of packet or 0
262	root	1.1	void skip_packet (int len); // we have processed the packet, skip it
263
264	root	1.22	MTH void flush ();
265			MTH void write_outputbuffer ();
266	root	1.1	void send (void *buf_, int len);
267
268			void send_packet (const char *buf);
269			void send_packet (const char *buf, int len);
270	root	1.4	void send_packet_printf (const char *format, ...);
271	root	1.1	void send_packet (packet &sl);
272	root	1.7
273	root	1.10	// called when something under the player changes
274	root	1.22	MTH void floorbox_update () { update_look = 1; }
275	root	1.10	// called when the player has been moved
276	root	1.22	MTH void floorbox_reset () { look_position = 0; floorbox_update (); }
277
278			MTH static client create (int fd, const char peername);
279	root	1.10
280	root	1.22	protected:
281			client (int fd, const char *from_ip);
282			~client ();
283	root	1.1	};
284
285			#define CLIENT_SUPPORT_READABLES(__sockPtr,__type)\
286			( ((__type)>0) &&\
287			((__sockPtr)->has_readable_type) && \
288			((__sockPtr)->supported_readables & (1<<(__type))) )
289
290			/* Bitmask for the faces_sent[] array - what
291			* portion of the face have we sent?
292			*/
293			#define NS_FACESENT_FACE 0x1
294			#define NS_FACESENT_SMOOTH 0x2
295
296			/* Constants in the form EMI_ is for extended map infos.
297			* Even if the client select the additionnal infos it wants
298			* on the map, there may exist cases where this whole info
299			* is not given in one buch but in separate bunches. This
300			* is done performance reasons (imagine some info related to
301			* a visible object and another info related to a 4 square
302			* width and height area). At the begin of an extended info packet
303			* is a bit field. A bit is activated for each extended info
304			* present in the data
305			*/
306
307			/* Meanings:
308			* EMI_NOREDRAW Take extended infos into account but don't redraw,
309			* some additionnal datas will follow in a new packet
310			* EMI_SMOOTH Datas about smoothing
311			*/
312			#define EMI_NOREDRAW 0x01
313			#define EMI_SMOOTH 0x02
314
315			/* this last one says the bitfield continue un next byte
316			* There may be several on contiguous bytes. So there is 7
317			* actual bits used per byte, and the number of bytes
318			* is not fixed in protocol
319			*/
320			#define EMI_HASMOREBITS 0x80
321
322			#define FACE_TYPES 1
323			#define PNG_FACE_INDEX 0
324
325			#define VERSION_CS 1023 /* version >= 1023 understand setup cmd */
326	root	1.31	#define VERSION_SC 1026
327			//#define VERSION_SC 1027 // requestinfo image_info and image_sums, makes extending faces on the fly impossible
328	root	1.1	#define VERSION_INFO "Crossfire+ Server"
329
330	root	1.24	typedef object_vector<client, &client::active> sockvec;
331	root	1.1
332			extern sockvec clients;
333	root	1.24
334			#define for_all_clients(var) \
335			for (int _i = 0; _i < clients.size (); ++_i) \
336			declvar (client *, var, clients [_i])
337
338	root	1.1	extern int nrofpixmaps; //TODO: hrmpf, should go
339
340			#endif
341