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.100 by root, Mon Oct 19 21:48:49 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/*
… …
133 { 134 {
134 new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>"); 135 new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>");
135 return 0; 136 return 0;
136 } 137 }
137 138
138 skill = find_skill_by_name (pl, params); 139 skill = find_skill_by_name_fuzzy (pl, params);
139 140
140 if (!skill) 141 if (!skill)
141 { 142 {
142 new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the skill %s", params); 143 new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the skill %s", params);
143 return 0; 144 return 0;
144 } 145 }
145 146
146 pl->change_skill (0); 147 pl->change_skill (0);
147 apply_special (pl, skill, AP_APPLY); 148 apply_special (pl, skill, AP_APPLY);
148 return 1; 149 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} 150}
166 151
167/* A little special because we do want to pass the full params along 152/* A little special because we do want to pass the full params along
168 * as it includes the object to throw. 153 * as it includes the object to throw.
169 */ 154 */
… …
377 count = tmp->nrof; 362 count = tmp->nrof;
378 363
379 /* container is open, so use it */ 364 /* container is open, so use it */
380 if (tmp->flag [FLAG_STARTEQUIP]) 365 if (tmp->flag [FLAG_STARTEQUIP])
381 alt = op; 366 alt = op;
382 else if (op->container) 367 else if ((alt = op->container_ ()))
383 { 368 {
384 alt = op->container;
385 if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count)) 369 if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))
386 goto leave; 370 goto leave;
387 } 371 }
388 else 372 else
389 { /* non container pickup */ 373 { /* non container pickup */
… …
443int 427int
444command_take (object *op, char *params) 428command_take (object *op, char *params)
445{ 429{
446 object *tmp, *next; 430 object *tmp, *next;
447 431
448 if (op->container) 432 if (op->container_ ())
449 tmp = op->container->inv; 433 tmp = op->container_ ()->inv;
450 else 434 else
451 { 435 {
452 tmp = op->above; 436 tmp = op->above;
453 if (tmp) 437 if (tmp)
454 while (tmp->above) 438 while (tmp->above)
… …
520 504
521 return 0; 505 return 0;
522} 506}
523 507
524/* 508/*
525 * This function was part of drop, now is own function. 509 * This function was part of drop, now is own function.
526 * Player 'op' tries to put object 'tmp' into sack 'sack', 510 * 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. 511 * if nrof is non zero, then nrof objects is tried to put into sack.
512 *
528 * Note that the 'sack' in question can now be a transport, 513 * Note that the 'sack' in question can now be a transport,
529 * so this function isn't named very good anymore. 514 * so this function isn't named very good anymore.
530 */ 515 */
531void 516void
532put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof) 517put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof)
… …
535 char buf[MAX_BUF]; 520 char buf[MAX_BUF];
536 521
537 if (sack == tmp) 522 if (sack == tmp)
538 return; /* Can't put an object in itself */ 523 return; /* Can't put an object in itself */
539 524
540 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 525 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP))
541 { 526 {
542 new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack)); 527 new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack));
543 return; 528 return;
544 } 529 }
545 530
… …
554 539
555 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp) 540 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
556 { 541 {
557 tmp = tmp2->below; 542 tmp = tmp2->below;
558 543
559 if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof))) 544 if ((sack->type == CONTAINER && sack_can_hold (op, op->container_ (), tmp2, tmp2->nrof)))
560 put_object_in_sack (op, sack, tmp2, 0); 545 put_object_in_sack (op, sack, tmp2, 0);
561 else 546 else
562 { 547 {
563 sprintf (buf, "Your %s fills up.", query_name (sack)); 548 sprintf (buf, "Your %s fills up.", query_name (sack));
564 new_draw_info (NDI_UNIQUE, 0, op, buf); 549 new_draw_info (NDI_UNIQUE, 0, op, buf);
… …
601 586
602 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 587 if (QUERY_FLAG (tmp, FLAG_APPLIED))
603 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE)) 588 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
604 return; /* can't unapply it */ 589 return; /* can't unapply it */
605 590
606 //fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
607
608 /* We are only dropping some of the items. We split the current object 591 /* We are only dropping some of the items. We split the current object
609 * off 592 * off
610 */ 593 */
611 if (!can_split (op, tmp, nrof)) 594 if (!can_split (op, tmp, nrof))
612 return; 595 return;
613 596
597 drop_object (op, tmp);
598
599 if (!tmp->destroyed () && !tmp->is_inserted ())
600 {
601 // if nothing happened with the object we give it back
602 op->insert (tmp);
603 }
604}
605
606/* In contrast to drop_object (op, tmp, nrof) above this function takes the
607 * already split off object, and feeds it to the event handlers and does
608 * other magic with it.
609 *
610 * <droppper> is the object that dropped this object and <obj> is the
611 * object that was dropped.
612 *
613 * Make sure to check what happened with <obj> after this function returns!
614 * Otherwise you may leak this object.
615 */
616void
617drop_object (object *dropper, object *obj)
618{
614 if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op))) 619 if (INVOKE_OBJECT (DROP, obj, ARG_OBJECT (dropper)))
615 return; 620 return;
621
622 if (obj->destroyed () || obj->is_inserted ())
623 return;
616 624
617 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 625 if (QUERY_FLAG (obj, FLAG_STARTEQUIP))
618 { 626 {
619 op->statusmsg (format ("You drop the %s.", query_name (tmp))); 627 dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
620 op->statusmsg ("The god who lent it to you retrieves it."); 628 dropper->statusmsg ("The god who lent it to you retrieves it.");
621 629
622 tmp->destroy (); 630 obj->destroy ();
623 op->update_stats (); 631 dropper->update_stats ();
624 return; 632 return;
625 } 633 }
626 634
627 /* Call this before we update the various windows/players. At least 635 for (object *floor = GET_MAP_OB (dropper->map, dropper->x, dropper->y);
628 * that we, we know the weight is correct. 636 floor;
637 floor = floor->above)
638 if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (obj), ARG_OBJECT (dropper)))
639 return;
640
641 if (obj->destroyed () || obj->is_inserted ())
642 return;
643
644 if (is_in_shop (dropper) && !QUERY_FLAG (obj, FLAG_UNPAID) && obj->type != MONEY)
645 if (!sell_item (obj, dropper))
646 return;
647
648 /* If nothing special happened with this object, the default action is to
649 * insert it below the dropper:
629 */ 650 */
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 651
633 for (object *floor = GET_MAP_OB (op->map, op->x, op->y); floor; floor = floor->above) 652 obj->x = dropper->x;
634 if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op))) 653 obj->y = dropper->y;
635 return;
636 654
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);
643 return;
644 }
645 }
646
647 tmp->x = op->x;
648 tmp->y = op->y;
649
650 insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR); 655 insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
651} 656}
652 657
653void 658void
654drop (object *op, object *tmp) 659drop (object *op, object *tmp)
655{ 660{
… …
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);
… …
757 nextinv = nextinv->below; 762 nextinv = nextinv->below;
758 763
759 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY && 764 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&
760 curinv->type != FOOD && curinv->type != KEY && 765 curinv->type != FOOD && curinv->type != KEY &&
761 curinv->type != SPECIAL_KEY && curinv->type != GEM && 766 curinv->type != SPECIAL_KEY && curinv->type != GEM &&
762 !curinv->invisible && (curinv->type != CONTAINER || op->container != curinv)) 767 !curinv->invisible && (curinv->type != CONTAINER || op->container_ () != curinv))
763 { 768 {
764 drop (op, curinv); 769 drop (op, curinv);
765 if (--cnt <= 0) break; 770 if (--cnt <= 0) break;
766 } 771 }
767 772
… …
853 858
854/* draw_look(op);*/ 859/* draw_look(op);*/
855 return 0; 860 return 0;
856} 861}
857 862
863
864/* This function tries to drop all objects in the <objs> vector.
865 * <dropper> is the object that wants to drop them.
866 * <cnt> can be a 0 pointer or a pointer to the maximum number of
867 * drop operations to perform.
868 *
869 * Returns true if at least one item was dropped.
870 */
871bool
872drop_vector (object *dropper, vector<object *> &objs, int *cnt)
873{
874 vector<object *>::iterator i;
875
876 bool did_one = false;
877
878 for (i = objs.begin (); i != objs.end (); i++)
879 {
880 drop (dropper, *i);
881 if (cnt && --*cnt <= 0) break;
882 did_one = true;
883 }
884
885 return did_one;
886}
887
858/* Object op wants to drop object(s) params. params can be a 888/* Object op wants to drop object(s) params. params can be a
859 * comma seperated list. 889 * comma seperated list.
860 */ 890 */
861int 891int
862command_drop (object *op, char *params) 892command_drop (object *op, char *params)
… …
869 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?"); 899 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
870 return 0; 900 return 0;
871 } 901 }
872 else 902 else
873 { 903 {
874 int cnt = MAX_ITEM_PER_DROP; 904 vector<object *> matched_objs;
875 905
876 for (tmp = op->inv; tmp; tmp = next) 906 for (tmp = op->inv; tmp; tmp = next)
877 { 907 {
878 next = tmp->below; 908 next = tmp->below;
879 if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible) 909 if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)
880 continue; 910 continue;
881 911
882 if (item_matched_string (op, tmp, params)) 912 if (item_matched_string (op, tmp, params))
883 { 913 matched_objs.push_back (tmp);
884 drop (op, tmp);
885 if (--cnt <= 0) break;
886 did_one = 1;
887 } 914 }
888 }
889 915
890 if (!did_one) 916 int cnt = MAX_ITEM_PER_DROP;
917
918 if (!drop_vector (op, matched_objs, &cnt))
891 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop."); 919 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
892 920
893 if (cnt <= 0) 921 if (cnt <= 0)
894 op->failmsg ("Only dropped some items, can't drop that many items at once."); 922 op->failmsg ("Only dropped some items, can't drop that many items at once.");
895 } 923 }
… …
1025} 1053}
1026 1054
1027std::string 1055std::string
1028object::long_desc (object *who) 1056object::long_desc (object *who)
1029{ 1057{
1030 std::string buf (query_name (this)); 1058 std::string buf (query_name ());
1031 1059
1032 switch (type) 1060 switch (type)
1033 { 1061 {
1034 case RING: 1062 case RING:
1035 case SKILL: 1063 case SKILL:
… …
1047 case CLOAK: 1075 case CLOAK:
1048 case FOOD: 1076 case FOOD:
1049 case DRINK: 1077 case DRINK:
1050 case FLESH: 1078 case FLESH:
1051 case SKILL_TOOL: 1079 case SKILL_TOOL:
1080 case LAMP:
1052 case POWER_CRYSTAL: 1081 case POWER_CRYSTAL:
1053 { 1082 {
1054 const char *cp = ::describe_item (this, who); 1083 const char *cp = ::describe_item (this, who);
1055 1084
1056 if (*cp) 1085 if (*cp)
… …
1071examine_monster (object *op, object *tmp) 1100examine_monster (object *op, object *tmp)
1072{ 1101{
1073 new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ()); 1102 new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
1074} 1103}
1075 1104
1105static void
1106describe_dump_object (dynbuf &buf, object *ob)
1107{
1108 char *txt = dump_object (ob);
1109 for (char *p = txt; *p; ++p) if (*p == '\n') *p = '\r';
1110 buf << "\n" << txt << "\n";
1111
1112 if (!ob->is_arch ())
1113 describe_dump_object (buf, ob->arch);
1114}
1115
1076std::string 1116std::string
1077object::describe (object *who) 1117object::describe (object *who)
1078{ 1118{
1079 dynbuf_text buf (1024, 1024); 1119 dynbuf_text buf (1024, 1024);
1080 1120
… …
1085 1125
1086 switch (type) 1126 switch (type)
1087 { 1127 {
1088 case SPELLBOOK: 1128 case SPELLBOOK:
1089 if (flag [FLAG_IDENTIFIED] && inv) 1129 if (flag [FLAG_IDENTIFIED] && inv)
1090 buf.printf ("%s is a %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill); 1130 buf.printf ("%s is a level %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill);
1091 break; 1131 break;
1092 1132
1093 case BOOK: 1133 case BOOK:
1094 if (msg) 1134 if (msg)
1095 buf << "Something is written in it.\r"; 1135 buf << "Something is written in it.\r";
… …
1113 buf.printf ("It has %d charges left.\r", stats.food); 1153 buf.printf ("It has %d charges left.\r", stats.food);
1114 break; 1154 break;
1115 } 1155 }
1116 1156
1117 if (materialname && !msg) 1157 if (materialname && !msg)
1118 buf.printf ("It is made of: %s.\r", &materialname); 1158 buf << (nrof > 1 ? "They are made of " : "It is made of ")
1159 << materialname
1160 << '\r';
1119 1161
1120 if (who) 1162 if (who)
1121 /* Where to wear this item */ 1163 /* Where to wear this item */
1122 for (int i = 0; i < NUM_BODY_LOCATIONS; i++) 1164 for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1123 if (slot[i].info) 1165 if (slot[i].info)
… …
1154 buf << "This is a buildable item.\r"; 1196 buf << "This is a buildable item.\r";
1155 1197
1156 /* Does the object have a message? Don't show message for all object 1198 /* Does the object have a message? Don't show message for all object
1157 * types - especially if the first entry is a match 1199 * types - especially if the first entry is a match
1158 */ 1200 */
1201 if (msg)
1202 {
1159 if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ()) 1203 if (type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1160 { 1204 {
1205 buf << '\r';
1206
1161 /* This is just a hack so when identifying the items, we print 1207 /* This is just a hack so when identifying the items, we print
1162 * out the extra message 1208 * out the extra message
1163 */ 1209 */
1164 if (need_identify (this) && flag [FLAG_IDENTIFIED]) 1210 if (need_identify (this) && flag [FLAG_IDENTIFIED])
1165 buf << "The object has a story:\r"; 1211 buf << "The object has a story:\r";
1166 1212
1167 buf << msg << '\n'; 1213 buf << msg << '\n';
1214 }
1215 }
1216 else if (inv && inv->type == SPELL && flag [FLAG_IDENTIFIED]
1217 && (type == SPELLBOOK || type == ROD || type == WAND
1218 || type == ROD || type == POTION || type == SCROLL))
1219 // for spellbooks and other stuff that contains spells, print the spell message,
1220 // unless the object has a custom message handled above.
1221 buf << '\r' << inv->msg << '\n';
1222
1223 // try to display the duration for some potions and scrolls
1224 // this includes change ability potions and group spells,
1225 // but does not handle protection potions
1226 if (inv && inv->type == SPELL && flag [FLAG_IDENTIFIED]
1227 && (type == POTION || type == SCROLL))
1228 {
1229 object *spell = inv;
1230
1231 if (spell->subtype == SP_PARTY_SPELL)
1232 spell = spell->other_arch;
1233
1234 if (spell->subtype == SP_CHANGE_ABILITY)
1235 buf.printf ("\nH<The effect will last about %.10g seconds.>",
1236 TICK2TIME (change_ability_duration (spell, this)));
1237 }
1238
1239 // Display a hint about inscribable items [empty books]
1240 // This includes the amount of text they can hold.
1241 if (type == INSCRIBABLE)
1242 {
1243 if (other_arch && other_arch->type == SCROLL)
1244 buf.printf ("\nH<You can use the inscription skill to inscribe a spell into it.>");
1245 else
1246 buf.printf ("\nH<You can use the inscription skill to inscribe text into it. It has room for up to %d characters.>",
1247 weight_limit);
1168 } 1248 }
1169 1249
1170 buf << '\n'; 1250 buf << '\n';
1251
1252 // the dungeon master additionally gets a complete dump
1253 if (who && who->flag [FLAG_WIZLOOK])
1254 {
1255 buf << "\nT<Object>\n";
1256 describe_dump_object (buf, this);
1257
1258 if (inv)
1259 {
1260 buf << "\nT<Top Inventory>\n";
1261 describe_dump_object (buf, inv);
1262 }
1263 }
1171 1264
1172 return std::string (buf.linearise (), buf.size ()); 1265 return std::string (buf.linearise (), buf.size ());
1173} 1266}
1174 1267
1175static void 1268static void
1176display_new_pickup (object *op) 1269display_new_pickup (object *op)
1177{ 1270{
1178 int i = op->contr->mode; 1271 int i = op->contr->mode;
1179 1272
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); 1273 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); 1274 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); 1275 new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0);
1187 1276
1188 new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5); 1277 new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5);
… …
1239 }; 1328 };
1240 1329
1241 if (!params) 1330 if (!params)
1242 { 1331 {
1243 /* if the new mode is used, just print the settings */ 1332 /* if the new mode is used, just print the settings */
1244 if (op->contr->mode & PU_NEWMODE)
1245 {
1246 display_new_pickup (op); 1333 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; 1334 return 0;
1253 } 1335 }
1254 1336
1255 while (*params == ' ' && *params) 1337 while (*params == ' ' && *params)
1256 params++; 1338 params++;
… …
1262 for (mode = 0; names[mode]; mode++) 1344 for (mode = 0; names[mode]; mode++)
1263 { 1345 {
1264 if (!strcmp (names[mode], params + 1)) 1346 if (!strcmp (names[mode], params + 1))
1265 { 1347 {
1266 i = op->contr->mode; 1348 i = op->contr->mode;
1267 if (!(i & PU_NEWMODE)) 1349
1268 i = PU_NEWMODE;
1269 if (*params == '+') 1350 if (*params == '+')
1270 i = i | modes[mode]; 1351 i = i | modes[mode];
1271 else 1352 else
1272 i = i & ~modes[mode]; 1353 i = i & ~modes[mode];
1354
1273 op->contr->mode = i; 1355 op->contr->mode = i;
1274 display_new_pickup (op); 1356 display_new_pickup (op);
1275 return 1; 1357 return 1;
1276 } 1358 }
1277 } 1359 }
… …
1279 return 1; 1361 return 1;
1280 } 1362 }
1281 1363
1282 if (sscanf (params, "%u", &i) != 1) 1364 if (sscanf (params, "%u", &i) != 1)
1283 { 1365 {
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> ."); 1366 new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <value_density> or [+-]type.");
1287 return 1; 1367 return 1;
1288 } 1368 }
1289 set_pickup_mode (op, i); 1369
1370 if (i <= PU_RATIO)
1371 i |= op->contr->mode & ~PU_RATIO;
1372
1373 op->contr->mode = i;
1290 1374
1291 return 1; 1375 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} 1376}
1325 1377
1326int 1378int
1327command_search_items (object *op, char *params) 1379command_search_items (object *op, char *params)
1328{ 1380{
1329 char buf[MAX_BUF]; 1381 char buf[MAX_BUF];
1330 1382
1331 if (settings.search_items == FALSE)
1332 return 1;
1333
1334 if (params == NULL) 1383 if (params == NULL)
1335 { 1384 {
1336 if (op->contr->search_str[0] == '\0') 1385 if (op->contr->search_str[0] == '\0')
1337 { 1386 {
1338 new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1"); 1387 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"); 1388 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'."); 1389 new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1341 return 1; 1390 return 1;
1342 } 1391 }
1343 1392
… …
1345 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off."); 1394 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1346 op->update_stats (); 1395 op->update_stats ();
1347 return 1; 1396 return 1;
1348 } 1397 }
1349 1398
1350 if ((int) strlen (params) >= MAX_BUF) 1399 if (strlen (params) >= MAX_BUF)
1351 { 1400 {
1352 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long."); 1401 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1353 return 1; 1402 return 1;
1354 } 1403 }
1355 1404
1356 strcpy (op->contr->search_str, params); 1405 strcpy (op->contr->search_str, params);
1357 sprintf (buf, "Searching for '%s'.", op->contr->search_str); 1406 sprintf (buf, "Now searching for '%s'.", op->contr->search_str);
1358 new_draw_info (NDI_UNIQUE, 0, op, buf); 1407 new_draw_info (NDI_UNIQUE, 0, op, buf);
1359 op->update_stats (); 1408 op->update_stats ();
1409
1360 return 1; 1410 return 1;
1361} 1411}
1362 1412

Diff Legend

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