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.62 by root, Wed Apr 23 07:49:57 2008 UTC vs.
Revision 1.64 by root, Mon May 5 22:03:22 2008 UTC

… …
193query_flags (object *op) 193query_flags (object *op)
194{ 194{
195 unsigned int flags = 0; 195 unsigned int flags = 0;
196 196
197 if (QUERY_FLAG (op, FLAG_APPLIED)) 197 if (QUERY_FLAG (op, FLAG_APPLIED))
198 {
199 switch (op->type) 198 switch (op->type)
200 { 199 {
201 case BOW: 200 case BOW:
202 case WAND: 201 case WAND:
203 case ROD: 202 case ROD:
204 case HORN: 203 case HORN:
205 flags = a_readied; 204 flags = a_readied;
206 break; 205 break;
207 case WEAPON: 206 case WEAPON:
208 flags = a_wielded; 207 flags = a_wielded;
209 break; 208 break;
210 case SKILL: 209 case SKILL:
211 case ARMOUR: 210 case ARMOUR:
212 case HELMET: 211 case HELMET:
213 case SHIELD: 212 case SHIELD:
214 case RING: 213 case RING:
215 case BOOTS: 214 case BOOTS:
216 case GLOVES: 215 case GLOVES:
217 case AMULET: 216 case AMULET:
218 case GIRDLE: 217 case GIRDLE:
219 case BRACERS: 218 case BRACERS:
220 case CLOAK: 219 case CLOAK:
221 flags = a_worn; 220 flags = a_worn;
222 break; 221 break;
223 case CONTAINER: 222 case CONTAINER:
224 flags = a_active; 223 flags = a_active;
225 break; 224 break;
226 default: 225 default:
227 flags = a_applied; 226 flags = a_applied;
228 break; 227 break;
229 } 228 }
230 }
231 229
232 if (op->type == CONTAINER && ((op->env && op->env->container == op) || (!op->env && QUERY_FLAG (op, FLAG_APPLIED)))) 230 if (op->type == CONTAINER && ((op->env && op->env->container == op) || (!op->env && QUERY_FLAG (op, FLAG_APPLIED))))
233 flags |= F_OPEN; 231 flags |= F_OPEN;
234 232
235 if (QUERY_FLAG (op, FLAG_KNOWN_CURSED)) 233 if (QUERY_FLAG (op, FLAG_KNOWN_CURSED))
… …
324 sl << uint16 (head->client_type); 322 sl << uint16 (head->client_type);
325 323
326 SET_FLAG (head, FLAG_CLIENT_SENT); 324 SET_FLAG (head, FLAG_CLIENT_SENT);
327} 325}
328 326
327static faceidx
328need_face_now (player *pl, const char *name)
329{
330 faceidx face = face_find (name, empty_face);
331
332 pl->ns->send_face (face, -50);
333 pl->ns->flush_fx ();
334
335 return face;
336}
337
338#define FINGER_UP "finger_up.x11"
339#define FINGER_DOWN "finger_down.x11"
340
329/** 341/**
330 * Send the look window. Don't need to do animations here 342 * Send the look window. Don't need to do animations here
331 * This sends all the faces to the client, not just updates. This is 343 * This sends all the faces to the client, not just updates. This is
332 * because object ordering would otherwise be inconsistent. 344 * because object ordering would otherwise be inconsistent.
333 */ 345 */
334void 346void
335esrv_draw_look (player *pl) 347esrv_draw_look (player *pl)
336{ 348{
337 int got_one = 0, start_look = 0, end_look = 0;
338
339 object *ob = pl->ob; 349 object *ob = pl->ob;
340 350
341 if (!pl->ns->update_look) 351 if (!pl->ns->update_look)
342 { 352 {
343 LOG (llevDebug, "esrv_draw_look called when update_look was not set (player %s)\n", &ob->name); 353 LOG (llevDebug, "esrv_draw_look called when update_look was not set (player %s)\n", &ob->name);
344 return; 354 return;
345 } 355 }
346 else 356
347 pl->ns->update_look = 0; 357 pl->ns->update_look = 0;
348 358
349 if (QUERY_FLAG (ob, FLAG_REMOVED) 359 if (QUERY_FLAG (ob, FLAG_REMOVED)
350 || !ob->map 360 || !ob->map
351 || ob->map->in_memory != MAP_ACTIVE 361 || ob->map->in_memory != MAP_ACTIVE
352 || out_of_map (ob->map, ob->x, ob->y)) 362 || out_of_map (ob->map, ob->x, ob->y))
… …
357 packet sl; 367 packet sl;
358 sl.printf ("item%d ", pl->ns->itemcmd); 368 sl.printf ("item%d ", pl->ns->itemcmd);
359 369
360 sl << uint32 (0); 370 sl << uint32 (0);
361 371
362 pl->ns->send_face (empty_face, -50); 372 int start_pos = pl->ns->look_position;
363 pl->ns->flush_fx (); 373 bool dirty = false;
364 374
365 if (pl->ns->look_position) 375 mapspace &ms = ob->ms ();
376
377 // manage a ring buffer of the "last FLOORBOX_PAGESIZE" items and
378 // start from the top
379 object *items [FLOORBOX_PAGESIZE];
380 int item_idx = 0, item_cnt = 0;
381 int pos = 0;
382
383 // find our items by walking down
384 object *item = ms.top;
385
386 for (; item && item_cnt < FLOORBOX_PAGESIZE; item = item->below)
387 {
388 if (!item->client_visible ())
389 continue;
390
391 if (++pos < start_pos)
392 continue;
393
394 // record item
395 items [item_idx] = item; item_idx = item_idx < FLOORBOX_PAGESIZE ? item_idx + 1 : 0;
396 item_cnt++;
397
398 // stop at first floor
399 if (item->flag [FLAG_IS_FLOOR])
400 {
401 // we are finished, don't append "next group of items"
402 // by setting item to ms.bot it becomes zero which is checked after the while loop
403 item = ms.bot;
404 }
366 { 405 }
367 char buf[80];
368 snprintf (buf, 80, "Apply this to see %d previous items", FLOORBOX_PAGESIZE);
369 406
407 // see if there are more if we cared - we ignore invisible objects
408 if (item)
409 {
410 /* What we basically do is make a 'fake' object - when the user applies it,
411 * we notice the special tag the object has, and act accordingly.
412 */
370 sl << uint32 (0x80000000 | (pl->ns->look_position - FLOORBOX_PAGESIZE)) 413 sl << uint32 (0x80000000 | (start_pos + FLOORBOX_PAGESIZE))
371 << uint32 (0) 414 << uint32 (0)
372 << sint32 (-1) 415 << uint32 ((uint32) - 1)
373 << uint32 (empty_face) 416 << uint32 (need_face_now (pl, FINGER_DOWN))
374 << data8 (buf) 417 << data8 ("Apply this to see the items below")
375 << uint16 (0) 418 << uint16 (0)
376 << uint8 (0) 419 << uint8 (0)
377 << uint32 (0); 420 << uint32 (0);
378 421
379 if (pl->ns->itemcmd == 2) 422 if (pl->ns->itemcmd == 2)
380 sl << uint16 (0); 423 sl << uint16 (0);
381 }
382 424
383 object *tmp = ob->ms ().top; 425 dirty = true;
384 for (object *last = 0; tmp != last; tmp = tmp->below)
385 { 426 }
386 object *head;
387 427
388 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) && !last) 428 // now send out all items in the ring buffer in reverse order
429 while (item_cnt)
430 {
431 --item_cnt;
432 item_idx = (item_idx ? item_idx : FLOORBOX_PAGESIZE) - 1;
433 object *item = items [item_idx];
434
435 add_object_to_socklist (*pl->ns, sl, item->head_ ());
436
437 dirty = true;
438
439 // if packet got too large, send it and begin a new one
440 if (sl.length () > MAXSOCKBUF - MAXITEMLEN)
389 { 441 {
390 last = tmp->below; /* assumes double floor mode */ 442 pl->ns->send_packet (sl);
391 if (last && QUERY_FLAG (last, FLAG_IS_FLOOR)) 443
392 last = last->below; 444 sl.reset ();
445 sl.printf ("item%d ", pl->ns->itemcmd);
446 sl << uint32 (0);
447
448 dirty = false;
393 } 449 }
394
395 if (tmp->client_visible ())
396 {
397 if (++start_look < pl->ns->look_position)
398 continue;
399
400 end_look++;
401
402 if (end_look > FLOORBOX_PAGESIZE)
403 {
404 /* What we basically do is make a 'fake' object - when the user applies it,
405 * we notice the special tag the object has, and act accordingly.
406 */
407 sl << uint32 (0x80000000 | (pl->ns->look_position + FLOORBOX_PAGESIZE))
408 << uint32 (0)
409 << uint32 ((uint32) - 1)
410 << uint32 (empty_face)
411 << data8 ("Apply this to see next group of items")
412 << uint16 (0)
413 << uint8 (0)
414 << uint32 (0);
415
416 if (pl->ns->itemcmd == 2)
417 sl << uint16 (0);
418
419 break;
420 }
421
422 if (tmp->head)
423 head = tmp->head;
424 else
425 head = tmp;
426
427 add_object_to_socklist (*pl->ns, sl, head);
428 got_one++;
429
430 if (sl.length () > MAXSOCKBUF - MAXITEMLEN)
431 {
432 pl->ns->send_packet (sl);
433
434 sl.reset ();
435 sl.printf ("item%d ", pl->ns->itemcmd);
436 sl << uint32 (0);
437 got_one = 0;
438 }
439 }
440 } 450 }
441 451
442 if (got_one) 452 if (start_pos)
453 {
454 sl << uint32 (0x80000000 | (start_pos - FLOORBOX_PAGESIZE))
455 << uint32 (0)
456 << sint32 (-1)
457 << uint32 (need_face_now (pl, FINGER_UP))
458 << data8 ("Apply this to see the items higher up")
459 << uint16 (0)
460 << uint8 (0)
461 << uint32 (0);
462
463 if (pl->ns->itemcmd == 2)
464 sl << uint16 (0);
465
466 dirty = true;
467 }
468
469 if (dirty)
443 pl->ns->send_packet (sl); 470 pl->ns->send_packet (sl);
444
445} 471}
446 472
447/** 473/**
448 * Sends whole inventory. 474 * Sends whole inventory.
449 */ 475 */
… …
526 552
527 packet sl ("upditem"); 553 packet sl ("upditem");
528 554
529 sl << uint8 (flags); 555 sl << uint8 (flags);
530 556
531 if (op->head)
532 op = op->head; 557 op = op->head_ ();
533 558
534 sl << uint32 (op->count); 559 sl << uint32 (op->count);
535 560
536 if (flags & UPD_LOCATION) 561 if (flags & UPD_LOCATION)
537 sl << uint32 (op->env ? op->env->count : 0); 562 sl << uint32 (op->env ? op->env->count : 0);
… …
625esrv_send_item (object *pl, object *op) 650esrv_send_item (object *pl, object *op)
626{ 651{
627 if (!pl->contr->ns) 652 if (!pl->contr->ns)
628 return; 653 return;
629 654
630 /* If this is not the player object, do some more checks */
631 if (op != pl)
632 {
633 /* We only send 'visible' objects to the client */ 655 /* We only send 'visible' objects to the client, and sometimes the player */
634 if (!op->client_visible ()) 656 if (!op->client_visible () && op->type != PLAYER)
635 return; 657 return;
636
637 /* if the item is on the ground, mark that the look needs to
638 * be updated.
639 */
640 if (!op->env)
641 {
642 pl->contr->ns->floorbox_update ();
643 return;
644 }
645 }
646 658
647 packet sl; 659 packet sl;
648 660
649 sl.printf ("item%d ", pl->contr->ns->itemcmd); 661 sl.printf ("item%d ", pl->contr->ns->itemcmd);
650 662
651 if (op->head)
652 op = op->head; 663 op = op->head_ ();
653 664
654 sl << uint32 (op->env ? op->env->count : 0); 665 sl << uint32 (op->env ? op->env->count : 0);
655 666
656 add_object_to_socklist (*pl->contr->ns, sl, op); 667 add_object_to_socklist (*pl->contr->ns, sl, op);
657 668
… …
723void 734void
724ExamineCmd (char *buf, int len, player *pl) 735ExamineCmd (char *buf, int len, player *pl)
725{ 736{
726 tag_t tag = atoi (buf); 737 tag_t tag = atoi (buf);
727 738
739 /* If the high bit is set, player applied a pseudo object. */
740 if (tag & 0x80000000)
741 {
742 pl->ns->look_position = tag & 0x7fffffff;
743 pl->ns->floorbox_update ();
744 return;
745 }
746
728 object *op = esrv_get_ob_from_count (pl->ob, tag); 747 object *op = esrv_get_ob_from_count (pl->ob, tag);
729 748
730 if (!op) 749 if (!op)
731 { 750 {
732 LOG (llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n", &pl->ob->name, tag); 751 LOG (llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n", &pl->ob->name, tag);
… …
756/** Client wants to apply some object. Lets do so. */ 775/** Client wants to apply some object. Lets do so. */
757void 776void
758ApplyCmd (char *buf, int len, player *pl) 777ApplyCmd (char *buf, int len, player *pl)
759{ 778{
760 tag_t tag = atoi (buf); 779 tag_t tag = atoi (buf);
761
762 /* sort of a hack, but if the player saves and the player then manually
763 * applies a savebed (or otherwise tries to do stuff), we run into trouble.
764 */
765 if (QUERY_FLAG (pl->ob, FLAG_REMOVED))
766 return;
767 780
768 /* If the high bit is set, player applied a pseudo object. */ 781 /* If the high bit is set, player applied a pseudo object. */
769 if (tag & 0x80000000) 782 if (tag & 0x80000000)
770 { 783 {
771 pl->ns->look_position = tag & 0x7fffffff; 784 pl->ns->look_position = tag & 0x7fffffff;

Diff Legend

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