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.6 by root, Tue Sep 12 19:20:09 2006 UTC vs.
Revision 1.21 by root, Fri Dec 15 00:34:17 2006 UTC

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

Diff Legend

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