server/socket/image.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2001,2007 Mark Wedel
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Deliantra 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 3 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, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

/** \file
 * Image related communication
 *
 *  \date 2003-12-02
 *
 * This file deals with the image related communication to the
 * client.  I've located all the functions in this file - this
 * localizes it more, and means that we don't need to declare
 * things like all the structures as globals.
 */

#include <global.h>
#include <sproto.h>

#include "crc.h"

#define MAX_IMAGE_SIZE 10000

/**
 * client requested an image. send it rate-limited
 * before flushing.
 */
void
AskFaceCmd (char *buf, int len, client *ns)
{
  int idx = 0, pri = 0;

  sscanf (buf, "%d %d", &idx, &pri);

  //TODO: somehow fetch default priority from send_fx here

  const facedata *d = face_data (idx, ns->faceset);

  if (!d)
    return; // doh

  client::ixsend ix;

  ix.pri = pri;
  ix.idx = idx;
  ix.ofs = d->data.size ();

  auto (pos, ns->ixface.end ());

  // the by far most common case will be to insert
  // near the end, so little looping.
  while (pos != ns->ixface.begin ())
    {
      --pos;

      // sort within 2k bins, to slightly prefer smaller images
      if (pri > pos->pri || (pri == pos->pri && (ix.ofs >> 11) <= (pos->ofs >> 11)))
        {
          ++pos;
          break;
        }
    }

  ns->ixface.insert (pos, ix);

#if 0
  for (auto (i, ns->ixface.begin ()); i != ns->ixface.end (); ++i)
    fprintf (stderr, "<%d,%d> ",  i->pri, i->ofs);
  fprintf (stderr, "\n");
#endif
}

/**
 * Sends a face to a client if they are in pixmap mode
 * nothing gets sent in bitmap mode. 
 * If nocache is true (nonzero), ignore the cache setting from the client -
 * this is needed for the askface, in which we really do want to send the
 * face (and askface is the only place that should be setting it).  Otherwise,
 * we look at the facecache, and if set, send the image name.
 */
void
client::send_face (faceidx facenum, int pri)
{
  // never send face 0. ever. it does not exist.
  if (!facenum)
    return;

  faceinfo *f = face_info (facenum);

  if (!f)
    {
      LOG (llevError | logBacktrace, "client::send_face (%d) out of bounds??\n", facenum);
      return;
    }

  // refuse to send non-image faces
  if (!fx_want [f->type])
    return;

  if (faces_sent [facenum])
    return;

  faces_sent[facenum] = true;

  fxface.push_back (facenum);
}

void client::flush_fx ()
{
  while (!fxface.empty ())
    {
      packet fx ("fx");
      packet sx ("sx");
      int type = 0;

      do
        {
          faceidx facenum = fxface.back (); fxface.pop_back ();

          if (const faceinfo *f = face_info (facenum))
            {
              if (f->type != type)
                {
                  type = f->type;

                  fx << ber32 (0)
                     << uint8 (1) << uint8 (type);
                }

              const facedata *d = f->data (faceset);

              fx << ber32 (facenum)
                 << data8 (d->chksum, CHKSUM_SIZE);

              if (smoothing)
                {
                  faceinfo *f = face_info (facenum);

                  if (f->smooth)
                    {
                      send_face (f->smooth, -110);

                      sx << ber32 (facenum)
                         << ber32 (f->smooth)
                         << ber32 (f->smoothlevel);
                    }
                }
            }
        }
      while (!fxface.empty ()
             && fx.room () > ber32::size + CHKSUM_SIZE + 1 + 3 /* type switch */
             && sx.room () > ber32::size * 3);

      send_packet (fx);
      if (sx.length () > 3) send_packet (sx);
    }
}

// send all faces of this object to the client
// this uses more bandwidth initially, but makes
// animations look much smoother, and every client
// is supposed to do client-side caching anyways.
void
client::send_faces (object *ob)
{
  send_face (ob->face, 10);

  if (ob->animation_id)
    {
      const animation &anim = ob->anim ();

      for (int i = 0; i < anim.num_animations; i++)
        send_face (anim.faces [i], -10);
    }
}

/**
 * Need to send an animation sequence to the client.
 * We will send appropriate face commands to the client if we haven't
 * sent them the face yet (this can become quite costly in terms of
 * how much we are sending - on the other hand, this should only happen
 * when the player logs in and picks stuff up.
 */
void
client::send_animation (short anim_num)
{
  /* Do some checking on the anim_num we got.  Note that the animations
   * are added in contigous order, so if the number is in the valid
   * range, it must be a valid animation.
   */
  if (anim_num < 0 || anim_num >= animations.size ())
    {
      LOG (llevError, "esrv_send_anim (%d) out of bounds??\n", anim_num);
      return;
    }

  packet sl ("anim");

  sl << uint16 (anim_num)
     << uint16 (0); /* flags - not used right now */

  /* Build up the list of faces.  Also, send any information (ie, the
   * the face itself) down to the client.
   */
  for (int i = 0; i < animations[anim_num].num_animations; i++)
    {
      send_face (animations[anim_num].faces[i], -20);
      sl << uint16 (animations[anim_num].faces[i]);   /* flags - not used right now */
    }

  send_packet (sl);

  anims_sent[anim_num] = 1;
}

/**
 * Sends the number of images, checksum of the face file,
 * and the image_info file information.  See the doc/Developers/protocol
 * if you want further detail.
 */
void
send_image_info (client *ns, char *params)
{
  packet sl;

  //TODO: second parameter is a checksum, but it makes no sense in this current framework
  sl.printf ("replyinfo image_info\n%d\n%u\n", MAX_FACES, 0);

  sl << "0:base:standard:0:32x32:none:The old 32x32 faceset.\n";

  ns->send_packet (sl);
}

/**
 * Sends requested face information.
 * \param ns socket to send to
 * \param params contains first and last index of face
 *
 * For each image in [start..stop] sends
 *  - checksum
 *  - name
 */
void
send_image_sums (client *ns, char *params)
{
  int start, stop;
  char *cp;

  packet sl;

  start = atoi (params);
  for (cp = params; *cp != '\0'; cp++)
    if (*cp == ' ')
      break;

  stop = atoi (cp);
  if (stop < start || *cp == '\0' || (stop - start) > 1000 || stop >= MAX_FACES)
    {
      sl.printf ("replyinfo image_sums %d %d", start, stop);
      ns->send_packet (sl);
      sl.reset ();
      return;
    }

  sl.printf ("replyinfo image_sums %d %d ", start, stop);

  for (int i = start; i <= stop && i < faces.size (); i++)
    if (const faceinfo *f = face_info (i))
      if (ns->fx_want [f->type])
        {
          ns->faces_sent[i] = true;

          const facedata *d = f->data (ns->faceset);

          if (sl.room () < 2 + 4 + 1 + d->data.size () + 1)
            break;

          sl << uint16 (i)
             << uint32 (0) // checksum
             << uint8  (ns->faceset);

          for (int i = 0; i < CHKSUM_SIZE; ++i)
            sl.printf ("%02x", d->chksum [i]);

          sl << uint8 (0);
        }

  /* It would make more sense to catch this pre-emptively in the code above.
   * however, if this really happens, we probably just want to cut down the
   * size to less than 1000, since that is what we claim the protocol would
   * support.
   */
  //TODO: taken care of above, should simply abort or make sure the above code is correct
  if (sl.length () > MAXSOCKBUF)
    {
      LOG (llevError, "send_image_send: buffer overrun, %d > %d\n", sl.length (), MAXSOCKBUF);
      abort ();
    }

  ns->send_packet (sl);
}

Revision:	1.59
Committed:	Thu Sep 17 01:57:31 2009 UTC (14 years, 9 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.58:	+1 -1 lines
Log Message:	just a simplification
#	Content
1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*
8	* Deliantra 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 3 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, see <http://www.gnu.org/licenses/>.
20	*
21	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/
23
24	/** \file
25	* Image related communication
26	*
27	* \date 2003-12-02
28	*
29	* This file deals with the image related communication to the
30	* client. I've located all the functions in this file - this
31	* localizes it more, and means that we don't need to declare
32	* things like all the structures as globals.
33	*/
34
35	#include <global.h>
36	#include <sproto.h>
37
38	#include "crc.h"
39
40	#define MAX_IMAGE_SIZE 10000
41
42	/**
43	* client requested an image. send it rate-limited
44	* before flushing.
45	*/
46	void
47	AskFaceCmd (char buf, int len, client ns)
48	{
49	int idx = 0, pri = 0;
50
51	sscanf (buf, "%d %d", &idx, &pri);
52
53	//TODO: somehow fetch default priority from send_fx here
54
55	const facedata *d = face_data (idx, ns->faceset);
56
57	if (!d)
58	return; // doh
59
60	client::ixsend ix;
61
62	ix.pri = pri;
63	ix.idx = idx;
64	ix.ofs = d->data.size ();
65
66	auto (pos, ns->ixface.end ());
67
68	// the by far most common case will be to insert
69	// near the end, so little looping.
70	while (pos != ns->ixface.begin ())
71	{
72	--pos;
73
74	// sort within 2k bins, to slightly prefer smaller images
75	if (pri > pos->pri \|\| (pri == pos->pri && (ix.ofs >> 11) <= (pos->ofs >> 11)))
76	{
77	++pos;
78	break;
79	}
80	}
81
82	ns->ixface.insert (pos, ix);
83
84	#if 0
85	for (auto (i, ns->ixface.begin ()); i != ns->ixface.end (); ++i)
86	fprintf (stderr, "<%d,%d> ", i->pri, i->ofs);
87	fprintf (stderr, "\n");
88	#endif
89	}
90
91	/**
92	* Sends a face to a client if they are in pixmap mode
93	* nothing gets sent in bitmap mode.
94	* If nocache is true (nonzero), ignore the cache setting from the client -
95	* this is needed for the askface, in which we really do want to send the
96	* face (and askface is the only place that should be setting it). Otherwise,
97	* we look at the facecache, and if set, send the image name.
98	*/
99	void
100	client::send_face (faceidx facenum, int pri)
101	{
102	// never send face 0. ever. it does not exist.
103	if (!facenum)
104	return;
105
106	faceinfo *f = face_info (facenum);
107
108	if (!f)
109	{
110	LOG (llevError \| logBacktrace, "client::send_face (%d) out of bounds??\n", facenum);
111	return;
112	}
113
114	// refuse to send non-image faces
115	if (!fx_want [f->type])
116	return;
117
118	if (faces_sent [facenum])
119	return;
120
121	faces_sent[facenum] = true;
122
123	fxface.push_back (facenum);
124	}
125
126	void client::flush_fx ()
127	{
128	while (!fxface.empty ())
129	{
130	packet fx ("fx");
131	packet sx ("sx");
132	int type = 0;
133
134	do
135	{
136	faceidx facenum = fxface.back (); fxface.pop_back ();
137
138	if (const faceinfo *f = face_info (facenum))
139	{
140	if (f->type != type)
141	{
142	type = f->type;
143
144	fx << ber32 (0)
145	<< uint8 (1) << uint8 (type);
146	}
147
148	const facedata *d = f->data (faceset);
149
150	fx << ber32 (facenum)
151	<< data8 (d->chksum, CHKSUM_SIZE);
152
153	if (smoothing)
154	{
155	faceinfo *f = face_info (facenum);
156
157	if (f->smooth)
158	{
159	send_face (f->smooth, -110);
160
161	sx << ber32 (facenum)
162	<< ber32 (f->smooth)
163	<< ber32 (f->smoothlevel);
164	}
165	}
166	}
167	}
168	while (!fxface.empty ()
169	&& fx.room () > ber32::size + CHKSUM_SIZE + 1 + 3 /* type switch */
170	&& sx.room () > ber32::size * 3);
171
172	send_packet (fx);
173	if (sx.length () > 3) send_packet (sx);
174	}
175	}
176
177	// send all faces of this object to the client
178	// this uses more bandwidth initially, but makes
179	// animations look much smoother, and every client
180	// is supposed to do client-side caching anyways.
181	void
182	client::send_faces (object *ob)
183	{
184	send_face (ob->face, 10);
185
186	if (ob->animation_id)
187	{
188	const animation &anim = ob->anim ();
189
190	for (int i = 0; i < anim.num_animations; i++)
191	send_face (anim.faces [i], -10);
192	}
193	}
194
195	/**
196	* Need to send an animation sequence to the client.
197	* We will send appropriate face commands to the client if we haven't
198	* sent them the face yet (this can become quite costly in terms of
199	* how much we are sending - on the other hand, this should only happen
200	* when the player logs in and picks stuff up.
201	*/
202	void
203	client::send_animation (short anim_num)
204	{
205	/* Do some checking on the anim_num we got. Note that the animations
206	* are added in contigous order, so if the number is in the valid
207	* range, it must be a valid animation.
208	*/
209	if (anim_num < 0 \|\| anim_num >= animations.size ())
210	{
211	LOG (llevError, "esrv_send_anim (%d) out of bounds??\n", anim_num);
212	return;
213	}
214
215	packet sl ("anim");
216
217	sl << uint16 (anim_num)
218	<< uint16 (0); /* flags - not used right now */
219
220	/* Build up the list of faces. Also, send any information (ie, the
221	* the face itself) down to the client.
222	*/
223	for (int i = 0; i < animations[anim_num].num_animations; i++)
224	{
225	send_face (animations[anim_num].faces[i], -20);
226	sl << uint16 (animations[anim_num].faces[i]); /* flags - not used right now */
227	}
228
229	send_packet (sl);
230
231	anims_sent[anim_num] = 1;
232	}
233
234	/**
235	* Sends the number of images, checksum of the face file,
236	* and the image_info file information. See the doc/Developers/protocol
237	* if you want further detail.
238	*/
239	void
240	send_image_info (client ns, char params)
241	{
242	packet sl;
243
244	//TODO: second parameter is a checksum, but it makes no sense in this current framework
245	sl.printf ("replyinfo image_info\n%d\n%u\n", MAX_FACES, 0);
246
247	sl << "0:base:standard:0:32x32:none:The old 32x32 faceset.\n";
248
249	ns->send_packet (sl);
250	}
251
252	/**
253	* Sends requested face information.
254	* \param ns socket to send to
255	* \param params contains first and last index of face
256	*
257	* For each image in [start..stop] sends
258	* - checksum
259	* - name
260	*/
261	void
262	send_image_sums (client ns, char params)
263	{
264	int start, stop;
265	char *cp;
266
267	packet sl;
268
269	start = atoi (params);
270	for (cp = params; *cp != '\0'; cp++)
271	if (*cp == ' ')
272	break;
273
274	stop = atoi (cp);
275	if (stop < start \|\| *cp == '\0' \|\| (stop - start) > 1000 \|\| stop >= MAX_FACES)
276	{
277	sl.printf ("replyinfo image_sums %d %d", start, stop);
278	ns->send_packet (sl);
279	sl.reset ();
280	return;
281	}
282
283	sl.printf ("replyinfo image_sums %d %d ", start, stop);
284
285	for (int i = start; i <= stop && i < faces.size (); i++)
286	if (const faceinfo *f = face_info (i))
287	if (ns->fx_want [f->type])
288	{
289	ns->faces_sent[i] = true;
290
291	const facedata *d = f->data (ns->faceset);
292
293	if (sl.room () < 2 + 4 + 1 + d->data.size () + 1)
294	break;
295
296	sl << uint16 (i)
297	<< uint32 (0) // checksum
298	<< uint8 (ns->faceset);
299
300	for (int i = 0; i < CHKSUM_SIZE; ++i)
301	sl.printf ("%02x", d->chksum [i]);
302
303	sl << uint8 (0);
304	}
305
306	/* It would make more sense to catch this pre-emptively in the code above.
307	* however, if this really happens, we probably just want to cut down the
308	* size to less than 1000, since that is what we claim the protocol would
309	* support.
310	*/
311	//TODO: taken care of above, should simply abort or make sure the above code is correct
312	if (sl.length () > MAXSOCKBUF)
313	{
314	LOG (llevError, "send_image_send: buffer overrun, %d > %d\n", sl.length (), MAXSOCKBUF);
315	abort ();
316	}
317
318	ns->send_packet (sl);
319	}
320