ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/socket/item.C
(Generate patch)

Comparing deliantra/server/socket/item.C (file contents):
Revision 1.5 by root, Sun Sep 10 13:43:33 2006 UTC vs.
Revision 1.23 by root, Fri Dec 15 19:59:20 2006 UTC

1
2/*
3 * static char *rcsid_item_c =
4 * "$Id: item.C,v 1.5 2006/09/10 13:43:33 root Exp $";
5 */
6
7/* 1/*
8 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
9 3
10 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
22 16
23 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 20
27 The author can be reached via e-mail to crossfire-devel@real-time.com 21 The author can be reached via e-mail to <crossfire@schmorp.de>
28*/ 22*/
29 23
30/** 24/**
31 * \file 25 * \file
32 * Client/server logic. 26 * Client/server logic.
… …
39 */ 33 */
40 34
41 35
42#include <global.h> 36#include <global.h>
43#include <object.h> /* LOOK_OBJ */ 37#include <object.h> /* LOOK_OBJ */
44#include <newclient.h>
45#include <newserver.h>
46#include <sproto.h> 38#include <sproto.h>
47 39
48/** This is the maximum number of bytes we expect any one item to take up */ 40/** This is the maximum number of bytes we expect any one item to take up */
49#define MAXITEMLEN 300 41#define MAXITEMLEN 300
50 42
51/******************************************************************************* 43/*******************************************************************************
52 * 44 *
53 * Functions related to sending object data to the client. 45 * Functions related to sending object data to the client.
54 * 46 *
55 ******************************************************************************/ 47 ******************************************************************************/
56
57/**
58 * Adds string to socklist.
59 *
60 * This is a simple function that we use a lot here. It basically
61 * adds the specified buffer into the socklist, but prepends a
62 * single byte in length. If the data is longer than that byte, it is
63 * truncated approprately.
64 */
65inline void
66add_stringlen_to_sockbuf (const char *buf, SockList * sl)
67{
68 int len;
69
70 len = strlen (buf);
71 if (len > 255)
72 len = 255;
73 SockList_AddChar (sl, (char) len);
74 strncpy ((char *) sl->buf + sl->len, buf, len);
75 sl->len += len;
76}
77 48
78/** 49/**
79 * This is a similar to query_name, but returns flags 50 * This is a similar to query_name, but returns flags
80 * to be sended to client. 51 * to be sended to client.
81 */ 52 */
… …
136 flags |= F_LOCKED; 107 flags |= F_LOCKED;
137 108
138 return flags; 109 return flags;
139} 110}
140 111
141/* Used in the send_look to put object head into SockList 112/* Used in the send_look to put object head into packet
142 * sl for socket ns. Need socket to know if we need to send 113 * sl for socket ns. Need socket to know if we need to send
143 * animation of face to the client. 114 * animation of face to the client.
144 */ 115 */
145static void 116static void
146add_object_to_socklist (NewSocket * ns, SockList * sl, object *head) 117add_object_to_socklist (client &ns, packet &sl, object *head)
147{ 118{
148 int flags, len, anim_speed; 119 int flags, len, anim_speed;
149 char item_n[MAX_BUF]; 120 char item_n[MAX_BUF];
150 const char *item_p; 121 const char *item_p;
151 122
152 flags = query_flags (head); 123 flags = query_flags (head);
153 if (QUERY_FLAG (head, FLAG_NO_PICK)) 124 if (QUERY_FLAG (head, FLAG_NO_PICK))
154 flags |= F_NOPICK; 125 flags |= F_NOPICK;
155 126
156 if (!(ns->faces_sent[head->face->number] & NS_FACESENT_FACE)) 127 if (!(ns.faces_sent[head->face->number] & NS_FACESENT_FACE))
157 esrv_send_face (ns, head->face->number, 0); 128 esrv_send_face (&ns, head->face->number, 0);
158 129
159 if (QUERY_FLAG (head, FLAG_ANIMATE) && !ns->anims_sent[head->animation_id]) 130 if (QUERY_FLAG (head, FLAG_ANIMATE) && !ns.anims_sent[head->animation_id])
160 esrv_send_animation (ns, head->animation_id); 131 esrv_send_animation (&ns, head->animation_id);
161 132
162 SockList_AddInt (sl, head->count); 133 sl << uint32 (head->count)
163 SockList_AddInt (sl, flags); 134 << uint32 (flags)
164 SockList_AddInt (sl, QUERY_FLAG (head, FLAG_NO_PICK) ? -1 : WEIGHT (head)); 135 << uint32 (QUERY_FLAG (head, FLAG_NO_PICK) ? -1 : WEIGHT (head))
165 SockList_AddInt (sl, head->face->number); 136 << uint32 (head->face->number);
166 137
167 if (!head->custom_name) 138 if (!head->custom_name)
168 { 139 {
169 strncpy (item_n, query_base_name (head, 0), 127); 140 strncpy (item_n, query_base_name (head, 0), 127);
170 item_n[127] = 0; 141 item_n[127] = 0;
… …
176 strncpy (item_n, head->custom_name, 127); 147 strncpy (item_n, head->custom_name, 127);
177 item_n[127] = 0; 148 item_n[127] = 0;
178 len = strlen (item_n); 149 len = strlen (item_n);
179 item_p = head->custom_name; 150 item_p = head->custom_name;
180 } 151 }
152
181 strncpy (item_n + len + 1, item_p, 127); 153 strncpy (item_n + len + 1, item_p, 127);
182 item_n[254] = 0; 154 item_n[254] = 0;
183 len += strlen (item_n + 1 + len) + 1; 155 len += strlen (item_n + 1 + len) + 1;
184 SockList_AddChar (sl, (char) len);
185 memcpy (sl->buf + sl->len, item_n, len);
186 sl->len += len;
187 156
188 SockList_AddShort (sl, head->animation_id); 157 sl << data8 (item_n, len)
158 << uint16 (head->animation_id);
159
189 anim_speed = 0; 160 anim_speed = 0;
190 if (QUERY_FLAG (head, FLAG_ANIMATE)) 161 if (QUERY_FLAG (head, FLAG_ANIMATE))
191 { 162 {
192 if (head->anim_speed) 163 if (head->anim_speed)
193 anim_speed = head->anim_speed; 164 anim_speed = head->anim_speed;
… …
198 else if (FABS (head->speed) >= 1.0) 169 else if (FABS (head->speed) >= 1.0)
199 anim_speed = 1; 170 anim_speed = 1;
200 else 171 else
201 anim_speed = (int) (1.0 / FABS (head->speed)); 172 anim_speed = (int) (1.0 / FABS (head->speed));
202 } 173 }
174
203 if (anim_speed > 255) 175 if (anim_speed > 255)
204 anim_speed = 255; 176 anim_speed = 255;
205 } 177 }
206 SockList_AddChar (sl, (char) anim_speed);
207 SockList_AddInt (sl, head->nrof);
208 178
179 sl << uint8 (anim_speed)
180 << uint32 (head->nrof);
181
209 if (ns->itemcmd == 2) 182 if (ns.itemcmd == 2)
210 SockList_AddShort (sl, head->client_type); 183 sl << uint16 (head->client_type);
211 184
212 SET_FLAG (head, FLAG_CLIENT_SENT); 185 SET_FLAG (head, FLAG_CLIENT_SENT);
213} 186}
214 187
215 188
… …
222void 195void
223esrv_draw_look (object *pl) 196esrv_draw_look (object *pl)
224{ 197{
225 object *tmp, *last; 198 object *tmp, *last;
226 int got_one = 0, start_look = 0, end_look = 0; 199 int got_one = 0, start_look = 0, end_look = 0;
227 SockList sl;
228 char buf[MAX_BUF]; 200 char buf[MAX_BUF];
229 201
230 if (!pl->contr->socket.update_look) 202 if (!pl->contr->socket->update_look)
231 { 203 {
232 LOG (llevDebug, "esrv_draw_look called when update_look was not set\n"); 204 LOG (llevDebug, "esrv_draw_look called when update_look was not set\n");
233 return; 205 return;
234 } 206 }
235 else 207 else
236 {
237 pl->contr->socket.update_look = 0; 208 pl->contr->socket->update_look = 0;
238 }
239 209
240 if (QUERY_FLAG (pl, FLAG_REMOVED) || pl->map == NULL || pl->map->in_memory != MAP_IN_MEMORY || out_of_map (pl->map, pl->x, pl->y)) 210 if (QUERY_FLAG (pl, FLAG_REMOVED)
211 || !pl->map
212 || pl->map->in_memory != MAP_IN_MEMORY
213 || out_of_map (pl->map, pl->x, pl->y))
241 return; 214 return;
242 215
243 for (tmp = get_map_ob (pl->map, pl->x, pl->y); tmp && tmp->above; tmp = tmp->above); 216 for (tmp = get_map_ob (pl->map, pl->x, pl->y); tmp && tmp->above; tmp = tmp->above)
217 ;
244 218
245 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 219 packet sl;
246 220
247 Write_String_To_Socket (&pl->contr->socket, "delinv 0", strlen ("delinv 0")); 221 pl->contr->socket->send_packet ("delinv 0");
222
248 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd); 223 sl.printf ("item%d ", pl->contr->socket->itemcmd);
249 sl.len = strlen ((char *) sl.buf);
250 224
251 SockList_AddInt (&sl, 0); 225 sl << uint32 (0);
252 226
253 if (!(pl->contr->socket.faces_sent[empty_face->number] & NS_FACESENT_FACE)) 227 if (!(pl->contr->socket->faces_sent[empty_face->number] & NS_FACESENT_FACE))
254 esrv_send_face (&pl->contr->socket, empty_face->number, 0); 228 esrv_send_face (pl->contr->socket, empty_face->number, 0);
255 229
256 if (pl->contr->socket.look_position) 230 if (pl->contr->socket->look_position)
257 { 231 {
258 SockList_AddInt (&sl, 0x80000000 | (pl->contr->socket.look_position - NUM_LOOK_OBJECTS)); 232 char buf[80];
259 SockList_AddInt (&sl, 0);
260 SockList_AddInt (&sl, (uint32) - 1);
261 SockList_AddInt (&sl, empty_face->number);
262 sprintf (buf, "Click here to see %d previous items", NUM_LOOK_OBJECTS); 233 snprintf (buf, 80, "Apply this to see %d previous items", NUM_LOOK_OBJECTS);
263 add_stringlen_to_sockbuf (buf, &sl); 234
264 SockList_AddShort (&sl, 0); 235 sl << uint32 (0x80000000 | (pl->contr->socket->look_position - NUM_LOOK_OBJECTS))
265 SockList_AddChar (&sl, 0); 236 << uint32 (0)
266 SockList_AddInt (&sl, 0); 237 << sint32 (-1)
238 << uint32 (empty_face->number)
239 << data8 (buf)
240 << uint16 (0)
241 << uint8 (0)
242 << uint32 (0);
243
267 if (pl->contr->socket.itemcmd == 2) 244 if (pl->contr->socket->itemcmd == 2)
268 SockList_AddShort (&sl, 0); 245 sl << uint16 (0);
269 } 246 }
270 247
271 for (last = NULL; tmp != last; tmp = tmp->below) 248 for (last = NULL; tmp != last; tmp = tmp->below)
272 { 249 {
273 object *head; 250 object *head;
… …
276 { 253 {
277 last = tmp->below; /* assumes double floor mode */ 254 last = tmp->below; /* assumes double floor mode */
278 if (last && QUERY_FLAG (last, FLAG_IS_FLOOR)) 255 if (last && QUERY_FLAG (last, FLAG_IS_FLOOR))
279 last = last->below; 256 last = last->below;
280 } 257 }
258
281 if (LOOK_OBJ (tmp)) 259 if (LOOK_OBJ (tmp))
282 { 260 {
283 if (++start_look < pl->contr->socket.look_position) 261 if (++start_look < pl->contr->socket->look_position)
284 continue; 262 continue;
263
285 end_look++; 264 end_look++;
265
286 if (end_look > NUM_LOOK_OBJECTS) 266 if (end_look > NUM_LOOK_OBJECTS)
287 { 267 {
288 /* What we basically do is make a 'fake' object - when the user applies it, 268 /* What we basically do is make a 'fake' object - when the user applies it,
289 * we notice the special tag the object has, and act accordingly. 269 * we notice the special tag the object has, and act accordingly.
290 */ 270 */
291 SockList_AddInt (&sl, 0x80000000 | (pl->contr->socket.look_position + NUM_LOOK_OBJECTS)); 271 sl << uint32 (0x80000000 | (pl->contr->socket->look_position + NUM_LOOK_OBJECTS))
292 SockList_AddInt (&sl, 0); 272 << uint32 (0)
293 SockList_AddInt (&sl, (uint32) - 1); 273 << uint32 ((uint32) - 1)
294 SockList_AddInt (&sl, empty_face->number); 274 << uint32 (empty_face->number)
295 sprintf (buf, "Click here to see next group of items"); 275 << data8 ("Apply this to see next group of items")
296 add_stringlen_to_sockbuf (buf, &sl); 276 << uint16 (0)
297 SockList_AddShort (&sl, 0); 277 << uint8 (0)
298 SockList_AddChar (&sl, 0); 278 << uint32 (0);
299 SockList_AddInt (&sl, 0); 279
300 if (pl->contr->socket.itemcmd == 2) 280 if (pl->contr->socket->itemcmd == 2)
301 SockList_AddShort (&sl, 0); 281 sl << uint16 (0);
282
302 break; 283 break;
303 } 284 }
285
304 if (tmp->head) 286 if (tmp->head)
305 head = tmp->head; 287 head = tmp->head;
306 else 288 else
307 head = tmp; 289 head = tmp;
308 290
309 add_object_to_socklist (&pl->contr->socket, &sl, head); 291 add_object_to_socklist (*pl->contr->socket, sl, head);
310 got_one++; 292 got_one++;
311 293
312 if (sl.len >= (MAXSOCKBUF - MAXITEMLEN)) 294 if (sl.length () >= (MAXSOCKBUF - MAXITEMLEN))
313 { 295 {
314 Send_With_Handling (&pl->contr->socket, &sl); 296 pl->contr->socket->send_packet (sl);
297
298 sl.reset ();
315 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd); 299 sl.printf ("item%d ", pl->contr->socket->itemcmd);
316 sl.len = strlen ((char *) sl.buf); 300 sl << uint32 (0);
317 SockList_AddInt (&sl, 0);
318 got_one = 0; 301 got_one = 0;
319 } 302 }
320 } /* If LOOK_OBJ() */ 303 } /* If LOOK_OBJ() */
321 } 304 }
305
322 if (got_one) 306 if (got_one)
323 Send_With_Handling (&pl->contr->socket, &sl); 307 pl->contr->socket->send_packet (sl);
324 308
325 free (sl.buf);
326} 309}
327 310
328/** 311/**
329 * Sends whole inventory. 312 * Sends whole inventory.
330 */ 313 */
331void 314void
332esrv_send_inventory (object *pl, object *op) 315esrv_send_inventory (object *pl, object *op)
333{ 316{
334 object *tmp; 317 object *tmp;
335 int got_one = 0; 318 int got_one = 0;
336 SockList sl;
337 319
338 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 320 packet sl;
339 321
340 sprintf ((char *) sl.buf, "delinv %d", op->count); 322 sl.printf ("delinv %d", op->count);
341 sl.len = strlen ((char *) sl.buf); 323 pl->contr->socket->send_packet (sl);
342 Send_With_Handling (&pl->contr->socket, &sl);
343 324
325 sl.reset ();
344 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd); 326 sl.printf ("item%d ", pl->contr->socket->itemcmd);
345 sl.len = strlen ((char *) sl.buf);
346 327
347 SockList_AddInt (&sl, op->count); 328 sl << uint32 (op->count);
348 329
349 for (tmp = op->inv; tmp; tmp = tmp->below) 330 for (tmp = op->inv; tmp; tmp = tmp->below)
350 { 331 {
351 object *head; 332 object *head;
352 333
… …
355 else 336 else
356 head = tmp; 337 head = tmp;
357 338
358 if (LOOK_OBJ (head)) 339 if (LOOK_OBJ (head))
359 { 340 {
360 add_object_to_socklist (&pl->contr->socket, &sl, head); 341 add_object_to_socklist (*pl->contr->socket, sl, head);
361 342
362 got_one++; 343 got_one++;
363 344
364 /* IT is possible for players to accumulate a huge amount of 345 /* IT is possible for players to accumulate a huge amount of
365 * items (especially with some of the bags out there) to 346 * items (especially with some of the bags out there) to
366 * overflow the buffer. IF so, send multiple item commands. 347 * overflow the buffer. IF so, send multiple item commands.
367 */ 348 */
368 if (sl.len >= (MAXSOCKBUF - MAXITEMLEN)) 349 if (sl.length () >= (MAXSOCKBUF - MAXITEMLEN))
369 { 350 {
370 Send_With_Handling (&pl->contr->socket, &sl); 351 pl->contr->socket->send_packet (sl);
352
353 sl.reset ();
371 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd); 354 sl.printf ("item%d ", pl->contr->socket->itemcmd);
372 sl.len = strlen ((char *) sl.buf); 355 sl << uint32 (op->count);
373 SockList_AddInt (&sl, op->count);
374 got_one = 0; 356 got_one = 0;
375 } 357 }
376 } /* If LOOK_OBJ() */ 358 } /* If LOOK_OBJ() */
377 } 359 }
360
378 if (got_one) 361 if (got_one)
379 Send_With_Handling (&pl->contr->socket, &sl); 362 pl->contr->socket->send_packet (sl);
380 free (sl.buf); 363
381} 364}
382 365
383/** 366/**
384 * Updates object *op for player *pl. 367 * Updates object *op for player *pl.
385 * 368 *
… …
389 */ 372 */
390 373
391void 374void
392esrv_update_item (int flags, object *pl, object *op) 375esrv_update_item (int flags, object *pl, object *op)
393{ 376{
394 SockList sl;
395
396 /* If we have a request to send the player item, skip a few checks. */ 377 /* If we have a request to send the player item, skip a few checks. */
397 if (op != pl) 378 if (op != pl)
398 { 379 {
399 if (!LOOK_OBJ (op)) 380 if (!LOOK_OBJ (op))
400 return; 381 return;
401 /* we remove the check for op->env, because in theory, the object 382 /* we remove the check for op->env, because in theory, the object
402 * is hopefully in the same place, so the client should preserve 383 * is hopefully in the same place, so the client should preserve
403 * order. 384 * order.
404 */ 385 */
405 } 386 }
387
406 if (!QUERY_FLAG (op, FLAG_CLIENT_SENT)) 388 if (!QUERY_FLAG (op, FLAG_CLIENT_SENT))
407 { 389 {
408 /* FLAG_CLIENT_SENT is debug only. We are using it to see where 390 /* FLAG_CLIENT_SENT is debug only. We are using it to see where
409 * this is happening - we can set a breakpoint here in the debugger 391 * this is happening - we can set a breakpoint here in the debugger
410 * and track back the call. 392 * and track back the call.
411 */ 393 */
412 LOG (llevDebug, "We have not sent item %s (%d)\n", &op->name, op->count); 394 LOG (llevDebug, "We have not sent item %s (%d)\n", &op->name, op->count);
413 } 395 }
414 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
415 396
416 strcpy ((char *) sl.buf, "upditem "); 397 packet sl;
417 sl.len = strlen ((char *) sl.buf);
418 398
419 SockList_AddChar (&sl, (char) flags); 399 sl << "upditem "
400 << uint8 (flags);
420 401
421 if (op->head) 402 if (op->head)
422 op = op->head; 403 op = op->head;
423 404
424 SockList_AddInt (&sl, op->count); 405 sl << uint32 (op->count);
425 406
426 if (flags & UPD_LOCATION) 407 if (flags & UPD_LOCATION)
427 SockList_AddInt (&sl, op->env ? op->env->count : 0); 408 sl << uint32 (op->env ? op->env->count : 0);
428 409
429 if (flags & UPD_FLAGS) 410 if (flags & UPD_FLAGS)
430 SockList_AddInt (&sl, query_flags (op)); 411 sl << uint32 (query_flags (op));
431 412
432 if (flags & UPD_WEIGHT) 413 if (flags & UPD_WEIGHT)
433 { 414 {
434 sint32 weight = WEIGHT (op); 415 sint32 weight = WEIGHT (op);
435 416
436 SockList_AddInt (&sl, QUERY_FLAG (op, FLAG_NO_PICK) ? -1 : weight); 417 sl << uint32 (QUERY_FLAG (op, FLAG_NO_PICK) ? -1 : weight);
418
437 if (pl == op) 419 if (pl == op)
438 {
439 op->contr->last_weight = weight; 420 op->contr->last_weight = weight;
440 }
441 } 421 }
442 422
443 if (flags & UPD_FACE) 423 if (flags & UPD_FACE)
444 { 424 {
445 if (!(pl->contr->socket.faces_sent[op->face->number] & NS_FACESENT_FACE)) 425 if (!(pl->contr->socket->faces_sent[op->face->number] & NS_FACESENT_FACE))
446 esrv_send_face (&pl->contr->socket, op->face->number, 0); 426 esrv_send_face (pl->contr->socket, op->face->number, 0);
447 SockList_AddInt (&sl, op->face->number); 427
428 sl << uint32 (op->face->number);
448 } 429 }
430
449 if (flags & UPD_NAME) 431 if (flags & UPD_NAME)
450 { 432 {
451 int len; 433 int len;
452 const char *item_p; 434 const char *item_p;
453 char item_n[MAX_BUF]; 435 char item_n[MAX_BUF];
… …
468 } 450 }
469 451
470 strncpy (item_n + len + 1, item_p, 127); 452 strncpy (item_n + len + 1, item_p, 127);
471 item_n[254] = 0; 453 item_n[254] = 0;
472 len += strlen (item_n + 1 + len) + 1; 454 len += strlen (item_n + 1 + len) + 1;
473 SockList_AddChar (&sl, (char) len); 455
474 memcpy (sl.buf + sl.len, item_n, len); 456 sl << data8 (item_n, len);
475 sl.len += len;
476 } 457 }
458
477 if (flags & UPD_ANIM) 459 if (flags & UPD_ANIM)
478 SockList_AddShort (&sl, op->animation_id); 460 sl << uint16 (op->animation_id);
479 461
480 if (flags & UPD_ANIMSPEED) 462 if (flags & UPD_ANIMSPEED)
481 { 463 {
482 int anim_speed = 0; 464 int anim_speed = 0;
483 465
… …
492 else if (FABS (op->speed) >= 1.0) 474 else if (FABS (op->speed) >= 1.0)
493 anim_speed = 1; 475 anim_speed = 1;
494 else 476 else
495 anim_speed = (int) (1.0 / FABS (op->speed)); 477 anim_speed = (int) (1.0 / FABS (op->speed));
496 } 478 }
479
497 if (anim_speed > 255) 480 if (anim_speed > 255)
498 anim_speed = 255; 481 anim_speed = 255;
499 } 482 }
500 SockList_AddChar (&sl, (char) anim_speed); 483
484 sl << uint8 (anim_speed);
501 } 485 }
486
502 if (flags & UPD_NROF) 487 if (flags & UPD_NROF)
503 SockList_AddInt (&sl, op->nrof); 488 sl << uint32 (op->nrof);
504 489
505 Send_With_Handling (&pl->contr->socket, &sl); 490 pl->contr->socket->send_packet (sl);
506 free (sl.buf);
507} 491}
508 492
509/** 493/**
510 * Sends item's info to player. 494 * Sends item's info to player.
511 */ 495 */
512void 496void
513esrv_send_item (object *pl, object *op) 497esrv_send_item (object *pl, object *op)
514{ 498{
515 SockList sl;
516
517 /* If this is not the player object, do some more checks */ 499 /* If this is not the player object, do some more checks */
518 if (op != pl) 500 if (op != pl)
519 { 501 {
520 /* We only send 'visibile' objects to the client */ 502 /* We only send 'visibile' objects to the client */
521 if (!LOOK_OBJ (op)) 503 if (!LOOK_OBJ (op))
… …
523 /* if the item is on the ground, mark that the look needs to 505 /* if the item is on the ground, mark that the look needs to
524 * be updated. 506 * be updated.
525 */ 507 */
526 if (!op->env) 508 if (!op->env)
527 { 509 {
528 pl->contr->socket.update_look = 1; 510 pl->contr->socket->update_look = 1;
529 return; 511 return;
530 } 512 }
531 } 513 }
532 514
533 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 515 packet sl;
534 516
535 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd); 517 sl.printf ("item%d ", pl->contr->socket->itemcmd);
536 sl.len = strlen ((char *) sl.buf);
537 518
538 if (op->head) 519 if (op->head)
539 op = op->head; 520 op = op->head;
540 521
541 SockList_AddInt (&sl, op->env ? op->env->count : 0); 522 sl << uint32 (op->env ? op->env->count : 0);
542 523
543 add_object_to_socklist (&pl->contr->socket, &sl, op); 524 add_object_to_socklist (*pl->contr->socket, sl, op);
544 525
545 Send_With_Handling (&pl->contr->socket, &sl); 526 pl->contr->socket->send_packet (sl);
546 SET_FLAG (op, FLAG_CLIENT_SENT); 527 SET_FLAG (op, FLAG_CLIENT_SENT);
547 free (sl.buf); 528
548} 529}
549 530
550/** 531/**
551 * Tells the client to delete an item. Uses the item 532 * Tells the client to delete an item. Uses the item
552 * command with a -1 location. 533 * command with a -1 location.
553 */ 534 */
554 535
555void 536void
556esrv_del_item (player *pl, int tag) 537esrv_del_item (player *pl, int tag)
557{ 538{
558 SockList sl; 539 packet sl;
559 540
560 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 541 sl << "delitem "
542 << uint32 (tag);
561 543
562 strcpy ((char *) sl.buf, "delitem "); 544 pl->socket->send_packet (sl);
563 sl.len = strlen ((char *) sl.buf);
564 SockList_AddInt (&sl, tag);
565
566 Send_With_Handling (&pl->socket, &sl);
567 free (sl.buf);
568} 545}
569 546
570 547
571/******************************************************************************* 548/*******************************************************************************
572 * 549 *
… …
611 588
612/** Client wants to examine some object. So lets do so. */ 589/** Client wants to examine some object. So lets do so. */
613void 590void
614ExamineCmd (char *buf, int len, player *pl) 591ExamineCmd (char *buf, int len, player *pl)
615{ 592{
616 long tag = atoi (buf); 593 tag_t tag = atoi (buf);
594
595 /* If the high bit is set, player examined a pseudo object. */
596 if (tag & 0x80000000)
597 return;
598
617 object *op = esrv_get_ob_from_count (pl->ob, tag); 599 object *op = esrv_get_ob_from_count (pl->ob, tag);
618 600
619 if (!op) 601 if (!op)
620 { 602 {
621 LOG (llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n", &pl->ob->name, tag); 603 LOG (llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n", &pl->ob->name, tag);
622 return; 604 return;
623 } 605 }
606
624 examine (pl->ob, op); 607 examine (pl->ob, op);
625} 608}
626 609
627/** Client wants to apply some object. Lets do so. */ 610/** Client wants to apply some object. Lets do so. */
628void 611void
629ApplyCmd (char *buf, int len, player *pl) 612ApplyCmd (char *buf, int len, player *pl)
630{ 613{
631 uint32 tag = atoi (buf); 614 tag_t tag = atoi (buf);
632 object *op = esrv_get_ob_from_count (pl->ob, tag);
633 615
634 /* sort of a hack, but if the player saves and the player then manually 616 /* sort of a hack, but if the player saves and the player then manually
635 * applies a savebed (or otherwise tries to do stuff), we run into trouble. 617 * applies a savebed (or otherwise tries to do stuff), we run into trouble.
636 */ 618 */
637 if (QUERY_FLAG (pl->ob, FLAG_REMOVED)) 619 if (QUERY_FLAG (pl->ob, FLAG_REMOVED))
638 return; 620 return;
639 621
640 /* If the high bit is set, player applied a pseudo object. */ 622 /* If the high bit is set, player applied a pseudo object. */
641 if (tag & 0x80000000) 623 if (tag & 0x80000000)
642 { 624 {
643 pl->socket.look_position = tag & 0x7fffffff; 625 pl->socket->look_position = tag & 0x7fffffff;
644 pl->socket.update_look = 1; 626 pl->socket->update_look = 1;
645 return; 627 return;
646 } 628 }
629
630 object *op = esrv_get_ob_from_count (pl->ob, tag);
647 631
648 if (!op) 632 if (!op)
649 { 633 {
650 LOG (llevDebug, "Player '%s' tried to apply the unknown object (%d)\n", &pl->ob->name, tag); 634 LOG (llevDebug, "Player '%s' tried to apply the unknown object (%d)\n", &pl->ob->name, tag);
651 return; 635 return;
652 } 636 }
637
653 player_apply (pl->ob, op, 0, 0); 638 player_apply (pl->ob, op, 0, 0);
654} 639}
655 640
656/** Client wants to apply some object. Lets do so. */ 641/** Client wants to apply some object. Lets do so. */
657void 642void
658LockItem (uint8 * data, int len, player *pl) 643LockItem (char *data, int len, player *pl)
659{ 644{
660 int flag, tag;
661 object *op;
662
663 flag = data[0]; 645 int flag = data[0];
664 tag = GetInt_String (data + 1); 646 tag_t tag = net_uint32 ((uint8 *)data + 1);
665 op = esrv_get_ob_from_count (pl->ob, tag); 647 object *op = esrv_get_ob_from_count (pl->ob, tag);
666 648
667 if (!op) 649 if (!op)
668 { 650 {
669 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to lock/unlock"); 651 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to lock/unlock");
670 return; 652 return;
671 } 653 }
654
672 if (!flag) 655 if (!flag)
673 CLEAR_FLAG (op, FLAG_INV_LOCKED); 656 CLEAR_FLAG (op, FLAG_INV_LOCKED);
674 else 657 else
675 SET_FLAG (op, FLAG_INV_LOCKED); 658 SET_FLAG (op, FLAG_INV_LOCKED);
659
676 esrv_update_item (UPD_FLAGS, pl->ob, op); 660 esrv_update_item (UPD_FLAGS, pl->ob, op);
677} 661}
678 662
679/** Client wants to apply some object. Lets do so. */ 663/** Client wants to apply some object. Lets do so. */
680void 664void
681MarkItem (uint8 * data, int len, player *pl) 665MarkItem (char *data, int len, player *pl)
682{ 666{
683 int tag; 667 tag_t tag = net_uint32 ((uint8 *)data);
684 object *op;
685
686 tag = GetInt_String (data);
687 op = esrv_get_ob_from_count (pl->ob, tag); 668 object *op = esrv_get_ob_from_count (pl->ob, tag);
669
688 if (!op) 670 if (!op)
689 { 671 {
690 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to mark"); 672 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to mark");
691 return; 673 return;
692 } 674 }
675
693 pl->mark = op; 676 pl->mark = op;
694 pl->mark_count = op->count;
695 new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Marked item %s", query_name (op)); 677 new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Marked item %s", query_name (op));
696} 678}
697
698 679
699/** 680/**
700 * look_at prints items on the specified square. 681 * look_at prints items on the specified square.
701 * 682 *
702 * [ removed EARTHWALL check and added check for containers inventory. 683 * [ removed EARTHWALL check and added check for containers inventory.
… …
706look_at (object *op, int dx, int dy) 687look_at (object *op, int dx, int dy)
707{ 688{
708 object *tmp; 689 object *tmp;
709 int flag = 0; 690 int flag = 0;
710 sint16 x, y; 691 sint16 x, y;
711 mapstruct *m; 692 maptile *m;
712 693
713 x = op->x + dx; 694 x = op->x + dx;
714 y = op->y + dy; 695 y = op->y + dy;
715 696
716 if (out_of_map (op->map, x, y)) 697 if (out_of_map (op->map, x, y))
… …
775 { 756 {
776 return; 757 return;
777 } 758 }
778 dy = atoi (cp); 759 dy = atoi (cp);
779 760
780 if (FABS (dx) > pl->socket.mapx / 2 || FABS (dy) > pl->socket.mapy / 2) 761 if (FABS (dx) > pl->socket->mapx / 2 || FABS (dy) > pl->socket->mapy / 2)
781 return; 762 return;
782 763
783 if (pl->blocked_los[dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2]) 764 if (pl->blocked_los[dx + pl->socket->mapx / 2][dy + pl->socket->mapy / 2])
784 return; 765 return;
785 766
786 look_at (pl->ob, dx, dy); 767 look_at (pl->ob, dx, dy);
787} 768}
788 769
… …
799 return; 780 return;
800 } 781 }
801 782
802 if (!to) 783 if (!to)
803 { /* drop it to the ground */ 784 { /* drop it to the ground */
804
805/* LOG(llevDebug, "Drop it on the ground.\n");*/
806
807 if (op->map && !op->env) 785 if (op->map && !op->env)
808 {
809
810/* LOG(llevDebug,"Dropping object to ground that is already on ground\n");*/
811 return; 786 return;
812 } 787
813 /* If it is an active container, then we should drop all objects 788 /* If it is an active container, then we should drop all objects
814 * in the container and not the container itself. 789 * in the container and not the container itself.
815 */ 790 */
816 if (op->inv && QUERY_FLAG (op, FLAG_APPLIED)) 791 if (op->inv && QUERY_FLAG (op, FLAG_APPLIED))
817 { 792 {
… …
820 for (current = op->inv; current != NULL; current = next) 795 for (current = op->inv; current != NULL; current = next)
821 { 796 {
822 next = current->below; 797 next = current->below;
823 drop_object (pl, current, 0); 798 drop_object (pl, current, 0);
824 } 799 }
800
825 esrv_update_item (UPD_WEIGHT, pl, op); 801 esrv_update_item (UPD_WEIGHT, pl, op);
826 } 802 }
827 else 803 else
828 { 804 {
829 drop_object (pl, op, nrof); 805 drop_object (pl, op, nrof);
… …
838 814
839 pl->contr->count = nrof; 815 pl->contr->count = nrof;
840 pick_up (pl, op); 816 pick_up (pl, op);
841 return; 817 return;
842 } 818 }
819
843 env = esrv_get_ob_from_count (pl, to); 820 env = esrv_get_ob_from_count (pl, to);
844 if (!env) 821 if (!env)
845 { 822 {
846 LOG (llevDebug, "Player '%s' tried to move object to the unknown location (%d)\n", &pl->name, to); 823 LOG (llevDebug, "Player '%s' tried to move object to the unknown location (%d)\n", &pl->name, to);
847 return; 824 return;
848 } 825 }
826
849 /* put_object_in_sack presumes that necessary sanity checking 827 /* put_object_in_sack presumes that necessary sanity checking
850 * has already been done (eg, it can be picked up and fits in 828 * has already been done (eg, it can be picked up and fits in
851 * in a sack, so check for those things. We should also check 829 * in a sack, so check for those things. We should also check
852 * an make sure env is in fact a container for that matter. 830 * an make sure env is in fact a container for that matter.
853 */ 831 */
854 if (env->type == CONTAINER && can_pick (pl, op) && sack_can_hold (pl, env, op, nrof)) 832 if (env->type == CONTAINER && can_pick (pl, op) && sack_can_hold (pl, env, op, nrof))
855 { 833 {
856 put_object_in_sack (pl, env, op, nrof); 834 put_object_in_sack (pl, env, op, nrof);
857 } 835 }
858} 836}
837

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines