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

Comparing deliantra/server/server/c_object.C (file contents):
Revision 1.80 by elmex, Sun Oct 5 12:40:21 2008 UTC vs.
Revision 1.103 by root, Sun Nov 8 20:55:39 2009 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation, either version 3 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the Affero GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
20 * 21 *
21 * The authors can be reached via e-mail to <support@deliantra.net> 22 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 23 */
23 24
24/* 25/*
… …
28#include <global.h> 29#include <global.h>
29#include <loader.h> 30#include <loader.h>
30#include <skills.h> 31#include <skills.h>
31#include <sproto.h> 32#include <sproto.h>
32#include <living.h> 33#include <living.h>
33#include <math.h>
34 34
35/* 35/*
36 * Object id parsing functions 36 * Object id parsing functions
37 */ 37 */
38 38
… …
133 { 133 {
134 new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>"); 134 new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>");
135 return 0; 135 return 0;
136 } 136 }
137 137
138 skill = find_skill_by_name (pl, params); 138 skill = find_skill_by_name_fuzzy (pl, params);
139 139
140 if (!skill) 140 if (!skill)
141 { 141 {
142 new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the skill %s", params); 142 new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the skill %s", params);
143 return 0; 143 return 0;
144 } 144 }
145 145
146 pl->change_skill (0); 146 pl->change_skill (0);
147 apply_special (pl, skill, AP_APPLY); 147 apply_special (pl, skill, AP_APPLY);
148 return 1; 148 return 1;
149}
150
151/* These functions (command_search, command_disarm) are really just wrappers for
152 * things like 'use_skill ...'). In fact, they should really be obsoleted
153 * and replaced with those.
154 */
155int
156command_search (object *op, char *params)
157{
158 return use_skill (op, skill_names[SK_FIND_TRAPS]);
159}
160
161int
162command_disarm (object *op, char *params)
163{
164 return use_skill (op, skill_names[SK_DISARM_TRAPS]);
165} 149}
166 150
167/* A little special because we do want to pass the full params along 151/* A little special because we do want to pass the full params along
168 * as it includes the object to throw. 152 * as it includes the object to throw.
169 */ 153 */
… …
377 count = tmp->nrof; 361 count = tmp->nrof;
378 362
379 /* container is open, so use it */ 363 /* container is open, so use it */
380 if (tmp->flag [FLAG_STARTEQUIP]) 364 if (tmp->flag [FLAG_STARTEQUIP])
381 alt = op; 365 alt = op;
382 else if (op->container) 366 else if ((alt = op->container_ ()))
383 { 367 {
384 alt = op->container;
385 if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count)) 368 if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))
386 goto leave; 369 goto leave;
387 } 370 }
388 else 371 else
389 { /* non container pickup */ 372 { /* non container pickup */
… …
443int 426int
444command_take (object *op, char *params) 427command_take (object *op, char *params)
445{ 428{
446 object *tmp, *next; 429 object *tmp, *next;
447 430
448 if (op->container) 431 if (op->container_ ())
449 tmp = op->container->inv; 432 tmp = op->container_ ()->inv;
450 else 433 else
451 { 434 {
452 tmp = op->above; 435 tmp = op->above;
453 if (tmp) 436 if (tmp)
454 while (tmp->above) 437 while (tmp->above)
… …
466 449
467 /* Makes processing easier */ 450 /* Makes processing easier */
468 if (params && *params == '\0') 451 if (params && *params == '\0')
469 params = 0; 452 params = 0;
470 453
471 int cnt = MAX_ITEM_PER_DROP; 454 int cnt = MAX_ITEM_PER_ACTION;
472 455
473 while (tmp) 456 while (tmp)
474 { 457 {
475 next = tmp->below; 458 next = tmp->below;
476 459
… …
520 503
521 return 0; 504 return 0;
522} 505}
523 506
524/* 507/*
525 * This function was part of drop, now is own function. 508 * This function was part of drop, now is own function.
526 * Player 'op' tries to put object 'tmp' into sack 'sack', 509 * Player 'op' tries to put object 'tmp' into sack 'sack',
527 * if nrof is non zero, then nrof objects is tried to put into sack. 510 * if nrof is non zero, then nrof objects is tried to put into sack.
511 *
528 * Note that the 'sack' in question can now be a transport, 512 * Note that the 'sack' in question can now be a transport,
529 * so this function isn't named very good anymore. 513 * so this function isn't named very good anymore.
530 */ 514 */
531void 515void
532put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof) 516put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof)
… …
535 char buf[MAX_BUF]; 519 char buf[MAX_BUF];
536 520
537 if (sack == tmp) 521 if (sack == tmp)
538 return; /* Can't put an object in itself */ 522 return; /* Can't put an object in itself */
539 523
540 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 524 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP))
541 { 525 {
542 new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack)); 526 new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack));
543 return; 527 return;
544 } 528 }
545 529
… …
554 538
555 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp) 539 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
556 { 540 {
557 tmp = tmp2->below; 541 tmp = tmp2->below;
558 542
559 if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof))) 543 if ((sack->type == CONTAINER && sack_can_hold (op, op->container_ (), tmp2, tmp2->nrof)))
560 put_object_in_sack (op, sack, tmp2, 0); 544 put_object_in_sack (op, sack, tmp2, 0);
561 else 545 else
562 { 546 {
563 sprintf (buf, "Your %s fills up.", query_name (sack)); 547 sprintf (buf, "Your %s fills up.", query_name (sack));
564 new_draw_info (NDI_UNIQUE, 0, op, buf); 548 new_draw_info (NDI_UNIQUE, 0, op, buf);
… …
585 569
586 new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack)); 570 new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));
587 sack->insert (tmp); 571 sack->insert (tmp);
588} 572}
589 573
574/* In contrast to drop_object (op, tmp, nrof) above this function takes the
575 * already split off object, and feeds it to the event handlers and does
576 * other magic with it.
577 *
578 * <droppper> is the object that dropped this object and <obj> is the
579 * object that was dropped.
580 *
581 * Make sure to check what happened with <obj> after this function returns!
582 * Otherwise you may leak this object.
583 */
584void
585drop_object (object *dropper, object *obj)
586{
587 if (INVOKE_OBJECT (DROP, obj, ARG_OBJECT (dropper)))
588 return;
589
590 if (obj->destroyed () || obj->is_inserted ())
591 return;
592
593 if (QUERY_FLAG (obj, FLAG_STARTEQUIP))
594 {
595 dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
596 dropper->statusmsg ("The god who lent it to you retrieves it.");
597
598 obj->destroy ();
599 dropper->update_stats ();
600 return;
601 }
602
603 for (object *floor = GET_MAP_OB (dropper->map, dropper->x, dropper->y);
604 floor;
605 floor = floor->above)
606 if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (obj), ARG_OBJECT (dropper)))
607 return;
608
609 if (obj->destroyed () || obj->is_inserted ())
610 return;
611
612 if (is_in_shop (dropper) && !QUERY_FLAG (obj, FLAG_UNPAID) && obj->type != MONEY)
613 if (!sell_item (obj, dropper))
614 return;
615
616 if (!obj->can_drop_at (dropper->map, dropper->x, dropper->y, dropper))
617 return;
618
619 /* If nothing special happened with this object, the default action is to
620 * insert it below the dropper:
621 */
622
623 obj->x = dropper->x;
624 obj->y = dropper->y;
625
626 insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
627}
628
590/* 629/*
591 * This function was part of drop, now is own function. 630 * This function was part of drop, now is own function.
592 * Player 'op' tries to drop object 'tmp', if tmp is non zero, then 631 * Player 'op' tries to drop object 'tmp', if tmp is non zero, then
593 * nrof objects is tried to dropped. 632 * nrof objects are tried to drop.
594 * This is used when dropping objects onto the floor. 633 * This is used when dropping objects onto the floor.
595 */ 634 */
596void 635void
597drop_object (object *op, object *tmp, uint32 nrof) 636drop_object (object *op, object *tmp, uint32 nrof)
598{ 637{
… …
600 return; 639 return;
601 640
602 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 641 if (QUERY_FLAG (tmp, FLAG_APPLIED))
603 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE)) 642 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
604 return; /* can't unapply it */ 643 return; /* can't unapply it */
605
606 //fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
607 644
608 /* We are only dropping some of the items. We split the current object 645 /* We are only dropping some of the items. We split the current object
609 * off 646 * off
610 */ 647 */
611 if (!can_split (op, tmp, nrof)) 648 if (!can_split (op, tmp, nrof))
612 return; 649 return;
613 650
614 if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op))) 651 drop_object (op, tmp);
615 return;
616 652
617 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 653 if (!tmp->destroyed () && !tmp->is_inserted ())
618 {
619 op->statusmsg (format ("You drop the %s.", query_name (tmp)));
620 op->statusmsg ("The god who lent it to you retrieves it.");
621
622 tmp->destroy ();
623 op->update_stats ();
624 return;
625 } 654 {
626 655 // if nothing happened with the object we give it back
627 /* Call this before we update the various windows/players. At least
628 * that we, we know the weight is correct.
629 */
630 // 2007-11-26: moved op->update_stats away and calling it later after
631 // all items of a drop command have been processed.
632
633 for (object *floor = GET_MAP_OB (op->map, op->x, op->y); floor; floor = floor->above)
634 if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
635 return;
636
637 if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
638 {
639 if (!sell_item (tmp, op))
640 {
641 // if we can't sell it we don't drop it, so give it back to the seller
642 op->insert (tmp); 656 op->insert (tmp);
643 return;
644 }
645 } 657 }
646
647 tmp->x = op->x;
648 tmp->y = op->y;
649
650 insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
651} 658}
652 659
653void 660void
654drop (object *op, object *tmp) 661drop (object *op, object *tmp)
655{ 662{
… …
668 */ 675 */
669 tmp->destroy (); 676 tmp->destroy ();
670 return; 677 return;
671 } 678 }
672 else 679 else
673 {
674 while (tmp && tmp->invisible) 680 while (tmp && tmp->invisible)
675 tmp = tmp->below; 681 tmp = tmp->below;
676 }
677 } 682 }
678 683
679 if (tmp == NULL) 684 if (!tmp)
680 { 685 {
681 new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop."); 686 new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");
682 return; 687 return;
683 } 688 }
684 689
… …
698 } 703 }
699 704
700 if (op->type == PLAYER && op->contr->last_used == tmp) 705 if (op->type == PLAYER && op->contr->last_used == tmp)
701 op->contr->last_used = tmp->below ? tmp->below 706 op->contr->last_used = tmp->below ? tmp->below
702 : tmp->above ? tmp->above 707 : tmp->above ? tmp->above
703 : 0; 708 : (object *)0;
704 709
705 if (op->container) 710 if (op->container_ ())
706 { 711 {
707 if (op->type == PLAYER) 712 if (op->type == PLAYER)
708 put_object_in_sack (op, op->container, tmp, op->contr->count); 713 put_object_in_sack (op, op->container_ (), tmp, op->contr->count);
709 else 714 else
710 put_object_in_sack (op, op->container, tmp, 0); 715 put_object_in_sack (op, op->container_ (), tmp, 0);
711 } 716 }
712 else 717 else
713 { 718 {
714 if (op->type == PLAYER) 719 if (op->type == PLAYER)
715 drop_object (op, tmp, op->contr->count); 720 drop_object (op, tmp, op->contr->count);
… …
742 /* 747 /*
743 Care must be taken that the next item pointer is not to money as 748 Care must be taken that the next item pointer is not to money as
744 the drop() routine will do unknown things to it when dropping 749 the drop() routine will do unknown things to it when dropping
745 in a shop. --Tero.Pelander@utu.fi 750 in a shop. --Tero.Pelander@utu.fi
746 */ 751 */
747
748 int cnt = MAX_ITEM_PER_DROP; 752 int cnt = MAX_ITEM_PER_ACTION;
749 753
750 if (!params) 754 if (!params)
751 { 755 {
752 while (curinv) 756 while (curinv)
753 { 757 {
754 nextinv = curinv->below; 758 nextinv = curinv->below;
755 759
756 while (nextinv && nextinv->type == MONEY) 760 while (nextinv && nextinv->type == MONEY)
757 nextinv = nextinv->below; 761 nextinv = nextinv->below;
758 762
759 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY && 763 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED)
760 curinv->type != FOOD && curinv->type != KEY && 764 && curinv->type != MONEY
761 curinv->type != SPECIAL_KEY && curinv->type != GEM && 765 && curinv->type != FOOD
766 && curinv->type != KEY
767 && curinv->type != SPECIAL_KEY
768 && curinv->type != GEM
769 && !curinv->invisible
762 !curinv->invisible && (curinv->type != CONTAINER || op->container != curinv)) 770 && (curinv->type != CONTAINER || op->container_ () != curinv))
763 { 771 {
764 drop (op, curinv); 772 drop (op, curinv);
765 if (--cnt <= 0) break; 773 if (--cnt <= 0) break;
766 } 774 }
767 775
… …
853 861
854/* draw_look(op);*/ 862/* draw_look(op);*/
855 return 0; 863 return 0;
856} 864}
857 865
866
867/* This function tries to drop all objects in the <objs> vector.
868 * <dropper> is the object that wants to drop them.
869 * <cnt> can be a 0 pointer or a pointer to the maximum number of
870 * drop operations to perform.
871 *
872 * Returns true if at least one item was dropped.
873 */
874static bool
875drop_vector (object *dropper, vector<object *> &objs, int *cnt)
876{
877 vector<object *>::iterator i;
878
879 bool did_one = false;
880
881 for (i = objs.begin (); i != objs.end (); i++)
882 {
883 drop (dropper, *i);
884 if (cnt && --*cnt <= 0) break;
885 did_one = true;
886 }
887
888 return did_one;
889}
890
858/* Object op wants to drop object(s) params. params can be a 891/* Object op wants to drop object(s) params. params can be a
859 * comma seperated list. 892 * comma seperated list.
860 */ 893 */
861int 894int
862command_drop (object *op, char *params) 895command_drop (object *op, char *params)
… …
869 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?"); 902 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
870 return 0; 903 return 0;
871 } 904 }
872 else 905 else
873 { 906 {
874 int cnt = MAX_ITEM_PER_DROP; 907 vector<object *> matched_objs;
875 908
876 for (tmp = op->inv; tmp; tmp = next) 909 for (tmp = op->inv; tmp; tmp = next)
877 { 910 {
878 next = tmp->below; 911 next = tmp->below;
879 if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible) 912 if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)
880 continue; 913 continue;
881 914
882 if (item_matched_string (op, tmp, params)) 915 if (item_matched_string (op, tmp, params))
883 { 916 matched_objs.push_back (tmp);
884 drop (op, tmp);
885 if (--cnt <= 0) break;
886 did_one = 1;
887 } 917 }
888 }
889 918
890 if (!did_one) 919 int cnt = MAX_ITEM_PER_ACTION;
920
921 if (!drop_vector (op, matched_objs, &cnt))
891 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop."); 922 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
892 923
893 if (cnt <= 0) 924 if (cnt <= 0)
894 op->failmsg ("Only dropped some items, can't drop that many items at once."); 925 op->failmsg ("Only dropped some items, can't drop that many items at once.");
895 } 926 }
… …
1025} 1056}
1026 1057
1027std::string 1058std::string
1028object::long_desc (object *who) 1059object::long_desc (object *who)
1029{ 1060{
1030 std::string buf (query_name (this)); 1061 std::string buf (query_name ());
1031 1062
1032 switch (type) 1063 switch (type)
1033 { 1064 {
1034 case RING: 1065 case RING:
1035 case SKILL: 1066 case SKILL:
… …
1047 case CLOAK: 1078 case CLOAK:
1048 case FOOD: 1079 case FOOD:
1049 case DRINK: 1080 case DRINK:
1050 case FLESH: 1081 case FLESH:
1051 case SKILL_TOOL: 1082 case SKILL_TOOL:
1083 case LAMP:
1052 case POWER_CRYSTAL: 1084 case POWER_CRYSTAL:
1053 { 1085 {
1054 const char *cp = ::describe_item (this, who); 1086 const char *cp = ::describe_item (this, who);
1055 1087
1056 if (*cp) 1088 if (*cp)
… …
1071examine_monster (object *op, object *tmp) 1103examine_monster (object *op, object *tmp)
1072{ 1104{
1073 new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ()); 1105 new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
1074} 1106}
1075 1107
1108static void
1109describe_dump_object (dynbuf &buf, object *ob)
1110{
1111 char *txt = dump_object (ob);
1112 for (char *p = txt; *p; ++p) if (*p == '\n') *p = '\r';
1113 buf << "\n" << txt << "\n";
1114
1115 if (!ob->is_arch ())
1116 describe_dump_object (buf, ob->arch);
1117}
1118
1076std::string 1119std::string
1077object::describe (object *who) 1120object::describe (object *who)
1078{ 1121{
1079 dynbuf_text buf (1024, 1024); 1122 dynbuf_text buf (1024, 1024);
1080 1123
… …
1085 1128
1086 switch (type) 1129 switch (type)
1087 { 1130 {
1088 case SPELLBOOK: 1131 case SPELLBOOK:
1089 if (flag [FLAG_IDENTIFIED] && inv) 1132 if (flag [FLAG_IDENTIFIED] && inv)
1090 buf.printf ("%s is a %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill); 1133 buf.printf ("%s is a level %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill);
1091 break; 1134 break;
1092 1135
1093 case BOOK: 1136 case BOOK:
1094 if (msg) 1137 if (msg)
1095 buf << "Something is written in it.\r"; 1138 buf << "Something is written in it.\r";
… …
1113 buf.printf ("It has %d charges left.\r", stats.food); 1156 buf.printf ("It has %d charges left.\r", stats.food);
1114 break; 1157 break;
1115 } 1158 }
1116 1159
1117 if (materialname && !msg) 1160 if (materialname && !msg)
1118 buf.printf ("It is made of: %s.\r", &materialname); 1161 buf << (nrof > 1 ? "They are made of " : "It is made of ")
1162 << materialname
1163 << '\r';
1119 1164
1120 if (who) 1165 if (who)
1121 /* Where to wear this item */ 1166 /* Where to wear this item */
1122 for (int i = 0; i < NUM_BODY_LOCATIONS; i++) 1167 for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1123 if (slot[i].info) 1168 if (slot[i].info)
… …
1131 } 1176 }
1132 1177
1133 if (weight) 1178 if (weight)
1134 buf.printf ("%s %3.3f kg.\r", nrof > 1 ? "They weigh" : "It weighs", weight * (nrof ? nrof : 1) / 1000.0); 1179 buf.printf ("%s %3.3f kg.\r", nrof > 1 ? "They weigh" : "It weighs", weight * (nrof ? nrof : 1) / 1000.0);
1135 1180
1181 if (flag [FLAG_STARTEQUIP])
1182 buf << (nrof > 1 ? "They were" : "It was")
1183 << " given by a god and will vanish when dropped.\r";
1184
1136 if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who) 1185 if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
1137 { 1186 {
1138 buf.printf ("You reckon %s worth %s.\r", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX)); 1187 buf.printf ("You reckon %s worth %s.\r", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
1139 1188
1140 if (is_in_shop (who)) 1189 if (is_in_shop (who))
… …
1154 buf << "This is a buildable item.\r"; 1203 buf << "This is a buildable item.\r";
1155 1204
1156 /* Does the object have a message? Don't show message for all object 1205 /* Does the object have a message? Don't show message for all object
1157 * types - especially if the first entry is a match 1206 * types - especially if the first entry is a match
1158 */ 1207 */
1208 if (msg)
1209 {
1159 if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ()) 1210 if (type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1160 { 1211 {
1212 buf << '\r';
1213
1161 /* This is just a hack so when identifying the items, we print 1214 /* This is just a hack so when identifying the items, we print
1162 * out the extra message 1215 * out the extra message
1163 */ 1216 */
1164 if (need_identify (this) && flag [FLAG_IDENTIFIED]) 1217 if (need_identify (this) && flag [FLAG_IDENTIFIED])
1165 buf << "The object has a story:\r"; 1218 buf << "The object has a story:\r";
1166 1219
1167 buf << msg << '\n'; 1220 buf << msg << '\n';
1221 }
1222 }
1223 else if (inv && inv->type == SPELL && flag [FLAG_IDENTIFIED]
1224 && (type == SPELLBOOK || type == ROD || type == WAND
1225 || type == ROD || type == POTION || type == SCROLL))
1226 // for spellbooks and other stuff that contains spells, print the spell message,
1227 // unless the object has a custom message handled above.
1228 buf << '\r' << inv->msg << '\n';
1229
1230 // try to display the duration for some potions and scrolls
1231 // this includes change ability potions and group spells,
1232 // but does not handle protection potions
1233 if (inv && inv->type == SPELL && flag [FLAG_IDENTIFIED]
1234 && (type == POTION || type == SCROLL))
1235 {
1236 object *spell = inv;
1237
1238 if (spell->subtype == SP_PARTY_SPELL)
1239 spell = spell->other_arch;
1240
1241 if (spell->subtype == SP_CHANGE_ABILITY)
1242 buf.printf ("\nH<The effect will last about %.10g seconds.>",
1243 TICK2TIME (change_ability_duration (spell, this)));
1244 }
1245
1246 // Display a hint about inscribable items [empty books]
1247 // This includes the amount of text they can hold.
1248 if (type == INSCRIBABLE)
1249 {
1250 if (other_arch && other_arch->type == SCROLL)
1251 buf.printf ("\nH<You can use the inscription skill to inscribe a spell into it.>");
1252 else
1253 buf.printf ("\nH<You can use the inscription skill to inscribe text into it. It has room for up to %d characters.>",
1254 weight_limit);
1168 } 1255 }
1169 1256
1170 buf << '\n'; 1257 buf << '\n';
1258
1259 // the dungeon master additionally gets a complete dump
1260 if (who && who->flag [FLAG_WIZLOOK])
1261 {
1262 buf << "\nT<Object>\n";
1263 describe_dump_object (buf, this);
1264
1265 if (inv)
1266 {
1267 buf << "\nT<Top Inventory>\n";
1268 describe_dump_object (buf, inv);
1269 }
1270 }
1171 1271
1172 return std::string (buf.linearise (), buf.size ()); 1272 return std::string (buf.linearise (), buf.size ());
1173} 1273}
1174 1274
1175static void 1275static void
1176display_new_pickup (object *op) 1276display_new_pickup (object *op)
1177{ 1277{
1178 int i = op->contr->mode; 1278 int i = op->contr->mode;
1179 1279
1180 if (!(i & PU_NEWMODE))
1181 return;
1182
1183 new_draw_info_format (NDI_UNIQUE, 0, op, "%d NEWMODE", i & PU_NEWMODE ? 1 : 0);
1184 new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0); 1280 new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0);
1185 new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0); 1281 new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0);
1186 new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0); 1282 new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0);
1187 1283
1188 new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5); 1284 new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5);
… …
1239 }; 1335 };
1240 1336
1241 if (!params) 1337 if (!params)
1242 { 1338 {
1243 /* if the new mode is used, just print the settings */ 1339 /* if the new mode is used, just print the settings */
1244 if (op->contr->mode & PU_NEWMODE)
1245 {
1246 display_new_pickup (op); 1340 display_new_pickup (op);
1247 return 1;
1248 }
1249 if (1)
1250 LOG (llevDebug, "command_pickup: !params\n");
1251 set_pickup_mode (op, (op->contr->mode > 6) ? 0 : op->contr->mode + 1);
1252 return 0; 1341 return 0;
1253 } 1342 }
1254 1343
1255 while (*params == ' ' && *params) 1344 while (*params == ' ' && *params)
1256 params++; 1345 params++;
… …
1262 for (mode = 0; names[mode]; mode++) 1351 for (mode = 0; names[mode]; mode++)
1263 { 1352 {
1264 if (!strcmp (names[mode], params + 1)) 1353 if (!strcmp (names[mode], params + 1))
1265 { 1354 {
1266 i = op->contr->mode; 1355 i = op->contr->mode;
1267 if (!(i & PU_NEWMODE)) 1356
1268 i = PU_NEWMODE;
1269 if (*params == '+') 1357 if (*params == '+')
1270 i = i | modes[mode]; 1358 i = i | modes[mode];
1271 else 1359 else
1272 i = i & ~modes[mode]; 1360 i = i & ~modes[mode];
1361
1273 op->contr->mode = i; 1362 op->contr->mode = i;
1274 display_new_pickup (op); 1363 display_new_pickup (op);
1275 return 1; 1364 return 1;
1276 } 1365 }
1277 } 1366 }
… …
1279 return 1; 1368 return 1;
1280 } 1369 }
1281 1370
1282 if (sscanf (params, "%u", &i) != 1) 1371 if (sscanf (params, "%u", &i) != 1)
1283 { 1372 {
1284 if (1)
1285 LOG (llevDebug, "command_pickup: params==NULL\n");
1286 new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <0-7> or <value_density> ."); 1373 new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <value_density> or [+-]type.");
1287 return 1; 1374 return 1;
1288 } 1375 }
1289 set_pickup_mode (op, i); 1376
1377 if (i <= PU_RATIO)
1378 i |= op->contr->mode & ~PU_RATIO;
1379
1380 op->contr->mode = i;
1290 1381
1291 return 1; 1382 return 1;
1292}
1293
1294void
1295set_pickup_mode (object *op, int i)
1296{
1297 switch (op->contr->mode = i)
1298 {
1299 case 0:
1300 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");
1301 break;
1302 case 1:
1303 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");
1304 break;
1305 case 2:
1306 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");
1307 break;
1308 case 3:
1309 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");
1310 break;
1311 case 4:
1312 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");
1313 break;
1314 case 5:
1315 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");
1316 break;
1317 case 6:
1318 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");
1319 break;
1320 case 7:
1321 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");
1322 break;
1323 }
1324} 1383}
1325 1384
1326int 1385int
1327command_search_items (object *op, char *params) 1386command_search_items (object *op, char *params)
1328{ 1387{
1329 char buf[MAX_BUF]; 1388 char buf[MAX_BUF];
1330 1389
1331 if (settings.search_items == FALSE)
1332 return 1;
1333
1334 if (params == NULL) 1390 if (params == NULL)
1335 { 1391 {
1336 if (op->contr->search_str[0] == '\0') 1392 if (op->contr->search_str[0] == '\0')
1337 { 1393 {
1338 new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1"); 1394 new_draw_info (NDI_UNIQUE, 0, op, "Example: search-items magic+1");
1339 new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all"); 1395 new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");
1340 new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'."); 1396 new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1341 return 1; 1397 return 1;
1342 } 1398 }
1343 1399
… …
1345 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off."); 1401 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1346 op->update_stats (); 1402 op->update_stats ();
1347 return 1; 1403 return 1;
1348 } 1404 }
1349 1405
1350 if ((int) strlen (params) >= MAX_BUF) 1406 if (strlen (params) >= MAX_BUF)
1351 { 1407 {
1352 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long."); 1408 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1353 return 1; 1409 return 1;
1354 } 1410 }
1355 1411
1356 strcpy (op->contr->search_str, params); 1412 strcpy (op->contr->search_str, params);
1357 sprintf (buf, "Searching for '%s'.", op->contr->search_str); 1413 sprintf (buf, "Now searching for '%s'.", op->contr->search_str);
1358 new_draw_info (NDI_UNIQUE, 0, op, buf); 1414 new_draw_info (NDI_UNIQUE, 0, op, buf);
1359 op->update_stats (); 1415 op->update_stats ();
1416
1360 return 1; 1417 return 1;
1361} 1418}
1362 1419

Diff Legend

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