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.112 by root, Fri Apr 2 03:41:24 2010 UTC vs.
Revision 1.133 by root, Sun Jan 29 02:47:05 2017 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,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * the terms of the Affero GNU General Public License as published by the 9 * the terms of the Affero GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * 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 Affero GNU General Public License 18 * You should have received a copy of the Affero GNU General Public License
19 * and the GNU General Public License along with this program. If not, see 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>. 20 * <http://www.gnu.org/licenses/>.
21 * 21 *
22 * 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>
23 */ 23 */
24 24
25/* 25/*
26 * Object (handling) commands 26 * Object (handling) commands
… …
67 67
68 int tmpmatch = item_matched_string (pl, tmp, params); 68 int tmpmatch = item_matched_string (pl, tmp, params);
69 69
70 if (tmpmatch > match_val) 70 if (tmpmatch > match_val)
71 { 71 {
72 if ((aflag == AP_APPLY) && (QUERY_FLAG (tmp, FLAG_APPLIED))) 72 if ((aflag == AP_APPLY) && (tmp->flag [FLAG_APPLIED]))
73 continue; 73 continue;
74 74
75 if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, FLAG_APPLIED))) 75 if ((aflag == AP_UNAPPLY) && (!tmp->flag [FLAG_APPLIED]))
76 continue; 76 continue;
77 77
78 match_val = tmpmatch; 78 match_val = tmpmatch;
79 best = tmp; 79 best = tmp;
80 } 80 }
… …
136 136
137 skill = find_skill_by_name_fuzzy (pl, params); 137 skill = find_skill_by_name_fuzzy (pl, params);
138 138
139 if (!skill) 139 if (!skill)
140 { 140 {
141 new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the skill %s", params); 141 new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the %s skill.", params);
142 return 0; 142 return 0;
143 } 143 }
144 144
145 pl->apply (skill); 145 pl->apply (skill);
146 return 1; 146 return 1;
… …
150 * as it includes the object to throw. 150 * as it includes the object to throw.
151 */ 151 */
152int 152int
153command_throw (object *op, char *params) 153command_throw (object *op, char *params)
154{ 154{
155 if (object *skop = find_skill_by_name (op, skill_names[SK_THROWING])) 155 if (object *skop = find_skill_by_name (op, shstr_throwing))
156 return do_skill (op, op, skop, op->facing, params); 156 return do_skill (op, op, skop, op->facing, params);
157 else 157 else
158 new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing."); 158 new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the throwing skill.");
159 159
160 return 0; 160 return 0;
161} 161}
162 162
163int 163int
… …
189 189
190 while (*params == ' ') 190 while (*params == ' ')
191 params++; 191 params++;
192 192
193 if (object *inv = find_best_apply_object_match (op, params, aflag)) 193 if (object *inv = find_best_apply_object_match (op, params, aflag))
194 player_apply (op, inv, aflag, 0); 194 op->apply (inv, aflag);
195 else 195 else
196 new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params); 196 op->failmsgf ("Could not find any match to the %s.", params);
197 } 197 }
198 198
199 return 0; 199 return 0;
200} 200}
201 201
… …
209 * not need to use split_ob and stuff. 209 * not need to use split_ob and stuff.
210 */ 210 */
211int 211int
212sack_can_hold (object *pl, object *sack, object *op, uint32 nrof) 212sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)
213{ 213{
214 if (!QUERY_FLAG (sack, FLAG_APPLIED)) 214 if (!sack->flag [FLAG_APPLIED])
215 { 215 {
216 new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack)); 216 new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));
217 return 0; 217 return 0;
218 } 218 }
219 219
… …
233 { 233 {
234 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack)); 234 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));
235 return 0; 235 return 0;
236 } 236 }
237 237
238 if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) * 238 if (sack->weight_limit
239 && weight_t (sack->carrying
240 + sack->number_of ()
239 (op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0)) 241 * (op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))
240 * (100 - sack->stats.Str) / 100) > sack->weight_limit) 242 * (100 - sack->stats.Str) / 100)
243 > sack->weight_limit)
241 { 244 {
242 new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack)); 245 new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));
243 return 0; 246 return 0;
244 } 247 }
245 248
… …
248} 251}
249 252
250/* Pick up commands follow */ 253/* Pick up commands follow */
251 254
252/* pl = player (not always - monsters can use this now) 255/* pl = player (not always - monsters can use this now)
253 * op is the object to put tmp into, 256 * op is the object to put tmp into,
254 * tmp is the object to pick up, nrof is the number to 257 * tmp is the object to pick up, nrof is the number to
255 * pick up (0 means all of them) 258 * pick up (0 means all of them)
256 */ 259 */
257static void 260static void
258pick_up_object (object *pl, object *op, object *tmp, int nrof) 261pick_up_object (object *pl, object *op, object *tmp, int nrof)
259{ 262{
260 object *env = tmp->env;
261 uint32 weight, effective_weight_limit; 263 weight_t weight, effective_weight_limit;
262 int tmp_nrof = tmp->number_of (); 264 int tmp_nrof = tmp->number_of ();
263 265
264 /* IF the player is flying & trying to take the item out of a container 266 /* IF the player is flying & trying to take the item out of a container
265 * that is in his inventory, let him. tmp->env points to the container 267 * that is in his inventory, let him. tmp->env points to the container
266 * (sack, luggage, etc), tmp->env->env then points to the player (nested 268 * (sack, luggage, etc), tmp->env->env then points to the player (nested
267 * containers not allowed as of now) 269 * containers not allowed as of now)
268 */ 270 */
269 if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && tmp->in_player () != pl) 271 if ((pl->move_type & MOVE_FLYING) && !pl->flag [FLAG_WIZ] && tmp->in_player () != pl)
270 { 272 {
271 pl->failmsg ("You are levitating, you can't reach the ground! " 273 pl->failmsg ("You are levitating, you can't reach the ground! "
272 "H<You have to stop levitating first, if you can, either by using your levitation skill, " 274 "H<You have to stop levitating first, if you can, either by using your levitation skill, "
273 "or waiting till the levitation effect wears off.>"); 275 "or waiting till the levitation effect wears off.>");
274 return; 276 return;
275 } 277 }
276 278
277 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 279 if (tmp->flag [FLAG_NO_DROP])
278 return; 280 return;
279 281
280 if (nrof > tmp_nrof || nrof <= 0) 282 if (nrof > tmp_nrof || nrof <= 0)
281 nrof = tmp_nrof; 283 nrof = tmp_nrof;
282 284
… …
294 } 296 }
295 297
296 if (!can_split (pl, tmp, nrof)) 298 if (!can_split (pl, tmp, nrof))
297 return; 299 return;
298 300
299 if (QUERY_FLAG (tmp, FLAG_UNPAID)) 301 if (tmp->flag [FLAG_UNPAID])
300 { 302 {
301 tmp->flag.reset (FLAG_UNPAID); 303 tmp->flag.reset (FLAG_UNPAID);
302 new_draw_info_format (NDI_UNIQUE, 0, pl, "%s will cost you %s.", query_name (tmp), query_cost_string (tmp, pl, F_BUY | F_SHOP)); 304 new_draw_info_format (NDI_UNIQUE, 0, pl, "%s will cost you %s.", query_name (tmp), query_cost_string (tmp, pl, F_BUY | F_SHOP));
303 tmp->flag.set (FLAG_UNPAID); 305 tmp->flag.set (FLAG_UNPAID);
304 } 306 }
… …
367 goto leave; 369 goto leave;
368 } 370 }
369 else 371 else
370 { /* non container pickup */ 372 { /* non container pickup */
371 for (alt = op->inv; alt; alt = alt->below) 373 for (alt = op->inv; alt; alt = alt->below)
372 if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && 374 if (alt->type == CONTAINER && alt->flag [FLAG_APPLIED] &&
373 alt->race && alt->race == tmp->race && sack_can_hold (NULL, alt, tmp, count)) 375 alt->race && alt->race == tmp->race && sack_can_hold (NULL, alt, tmp, count))
374 break; /* perfect match */ 376 break; /* perfect match */
375 377
376 if (!alt) 378 if (!alt)
377 for (alt = op->inv; alt; alt = alt->below) 379 for (alt = op->inv; alt; alt = alt->below)
378 if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && sack_can_hold (NULL, alt, tmp, count)) 380 if (alt->type == CONTAINER && alt->flag [FLAG_APPLIED] && sack_can_hold (NULL, alt, tmp, count))
379 break; /* General container comes next */ 381 break; /* General container comes next */
380 382
381 if (!alt) 383 if (!alt)
382 alt = op; /* No free containers */ 384 alt = op; /* No free containers */
383 } 385 }
… …
393#ifdef PICKUP_DEBUG 395#ifdef PICKUP_DEBUG
394 LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name); 396 LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);
395#endif 397#endif
396 398
397 /* startequip items are not allowed to be put into containers: */ 399 /* startequip items are not allowed to be put into containers: */
398 if (op->type == PLAYER && alt->type == CONTAINER && QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 400 if (op->type == PLAYER && alt->type == CONTAINER && tmp->flag [FLAG_STARTEQUIP])
399 { 401 {
400 new_draw_info (NDI_UNIQUE, 0, op, "This object cannot be put into containers!"); 402 new_draw_info (NDI_UNIQUE, 0, op, "This object cannot be put into containers!");
401 goto leave; 403 goto leave;
402 } 404 }
403 405
… …
501 503
502 return 0; 504 return 0;
503} 505}
504 506
505/* 507/*
506 * This function was part of drop, now is own function. 508 * This function was part of drop, now is own function.
507 * Player 'op' tries to put object 'tmp' into sack 'sack', 509 * Player 'op' tries to put object 'tmp' into sack 'sack',
508 * 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.
509 * 511 *
510 * Note that the 'sack' in question can now be a transport, 512 * Note that the 'sack' in question can now be a transport,
511 * so this function isn't named very good anymore. 513 * so this function isn't named very good anymore.
512 */ 514 */
513void 515void
514put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof) 516put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof)
515{ 517{
516 object *tmp2, *sack2; 518 object *tmp2;
517 char buf[MAX_BUF]; 519 char buf[MAX_BUF];
518 520
519 if (sack == tmp) 521 if (sack == tmp)
520 return; /* Can't put an object in itself */ 522 return; /* Can't put an object in itself */
521 523
522 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP)) 524 if (tmp->flag [FLAG_STARTEQUIP] || tmp->flag [FLAG_NO_DROP])
523 { 525 {
524 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));
525 return; 527 return;
526 } 528 }
527 529
… …
529 { 531 {
530 /* Eneq(@csd.uu.se): If the object to be dropped is a container 532 /* Eneq(@csd.uu.se): If the object to be dropped is a container
531 * we instead move the contents of that container into the active 533 * we instead move the contents of that container into the active
532 * container, this is only done if the object has something in it. 534 * container, this is only done if the object has something in it.
533 */ 535 */
534 sack2 = tmp;
535 new_draw_info_format (NDI_UNIQUE, 0, op, "You move the items from %s into %s.", query_name (tmp), query_name (sack)); 536 new_draw_info_format (NDI_UNIQUE, 0, op, "You move the items from %s into %s.", query_name (tmp), query_name (sack));
536 537
537 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp) 538 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
538 { 539 {
539 tmp = tmp2->below; 540 tmp = tmp2->below;
… …
555 * already checked this. 556 * already checked this.
556 */ 557 */
557 if ((sack->type == CONTAINER) && !sack_can_hold (op, sack, tmp, (nrof ? nrof : tmp->nrof))) 558 if ((sack->type == CONTAINER) && !sack_can_hold (op, sack, tmp, (nrof ? nrof : tmp->nrof)))
558 return; 559 return;
559 560
560 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 561 if (tmp->flag [FLAG_APPLIED])
561 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE)) 562 if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
562 return; 563 return;
563 564
564 /* we want to put some portion of the item into the container */ 565 /* we want to put some portion of the item into the container */
565 if (!can_split (op, tmp, nrof)) 566 if (!can_split (op, tmp, nrof))
566 return; 567 return;
… …
586 return; 587 return;
587 588
588 if (obj->destroyed () || obj->is_inserted ()) 589 if (obj->destroyed () || obj->is_inserted ())
589 return; 590 return;
590 591
591 if (QUERY_FLAG (obj, FLAG_STARTEQUIP)) 592 if (obj->flag [FLAG_STARTEQUIP])
592 { 593 {
593 dropper->statusmsg (format ("You drop the %s.", query_name (obj))); 594 dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
594 dropper->statusmsg ("The god who lent it to you retrieves it."); 595 dropper->statusmsg ("The god who lent it to you retrieves it.");
595 596
596 obj->destroy (); 597 obj->destroy ();
… …
605 return; 606 return;
606 607
607 if (obj->destroyed () || obj->is_inserted ()) 608 if (obj->destroyed () || obj->is_inserted ())
608 return; 609 return;
609 610
610 if (is_in_shop (dropper) && !QUERY_FLAG (obj, FLAG_UNPAID) && obj->type != MONEY) 611 if (dropper->is_in_shop () && !obj->flag [FLAG_UNPAID] && obj->type != MONEY)
611 if (!sell_item (obj, dropper)) 612 if (!sell_item (obj, dropper))
612 return; 613 return;
613 614
614 if (!obj->can_drop_at (dropper->map, dropper->x, dropper->y, dropper)) 615 if (!obj->can_drop_at (dropper->map, dropper->x, dropper->y, dropper))
615 return; 616 return;
616 617
617 /* If nothing special happened with this object, the default action is to 618 /* If nothing special happened with this object, the default action is to
… …
631 * This is used when dropping objects onto the floor. 632 * This is used when dropping objects onto the floor.
632 */ 633 */
633void 634void
634drop_object (object *op, object *tmp, uint32 nrof) 635drop_object (object *op, object *tmp, uint32 nrof)
635{ 636{
636 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 637 if (tmp->flag [FLAG_NO_DROP])
637 return; 638 return;
638 639
639 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 640 if (tmp->flag [FLAG_APPLIED])
640 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE)) 641 if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
641 return; /* can't unapply it */ 642 return; /* can't unapply it */
642 643
643 /* We are only dropping some of the items. We split the current object 644 /* We are only dropping some of the items. We split the current object
644 * off 645 * off
645 */ 646 */
… …
683 { 684 {
684 new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop."); 685 new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");
685 return; 686 return;
686 } 687 }
687 688
688 if (QUERY_FLAG (tmp, FLAG_INV_LOCKED)) 689 if (tmp->flag [FLAG_INV_LOCKED])
689 { 690 {
690 new_draw_info (NDI_UNIQUE, 0, op, "This item is locked"); 691 new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
691 return; 692 return;
692 } 693 }
693 694
694 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 695 if (tmp->flag [FLAG_NO_DROP])
695 { 696 {
696#if 0 697#if 0
697 /* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */ 698 /* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */
698 new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped."); 699 new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");
699#endif 700#endif
… …
736 } 737 }
737 738
738 object *curinv = op->inv; 739 object *curinv = op->inv;
739 object *nextinv; 740 object *nextinv;
740 741
741 /* 742 /*
742 This is the default. Drops everything not locked or considered 743 This is the default. Drops everything not locked or considered
743 not something that should be dropped. 744 not something that should be dropped.
744 */ 745 */
745 /* 746 /*
746 Care must be taken that the next item pointer is not to money as 747 Care must be taken that the next item pointer is not to money as
… …
756 nextinv = curinv->below; 757 nextinv = curinv->below;
757 758
758 while (nextinv && nextinv->type == MONEY) 759 while (nextinv && nextinv->type == MONEY)
759 nextinv = nextinv->below; 760 nextinv = nextinv->below;
760 761
761 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) 762 if (!curinv->flag [FLAG_INV_LOCKED]
763 && !curinv->invisible
762 && curinv->type != MONEY 764 && curinv->type != MONEY
763 && curinv->type != FOOD 765 && curinv->type != FOOD
764 && curinv->type != KEY 766 && curinv->type != KEY
765 && curinv->type != SPECIAL_KEY 767 && curinv->type != SPECIAL_KEY
766 && curinv->type != GEM 768 && curinv->type != GEM
767 && !curinv->invisible 769 && curinv->type != CONTAINER)
768 && (curinv->type != CONTAINER || op->container_ () != curinv))
769 { 770 {
770 drop (op, curinv); 771 drop (op, curinv);
771 if (--cnt <= 0) break; 772 if (--cnt <= 0) break;
772 } 773 }
773 774
… …
781 nextinv = curinv->below; 782 nextinv = curinv->below;
782 783
783 while (nextinv && nextinv->type == MONEY) 784 while (nextinv && nextinv->type == MONEY)
784 nextinv = nextinv->below; 785 nextinv = nextinv->below;
785 786
786 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW))) 787 if (!curinv->flag [FLAG_INV_LOCKED] && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))
787 { 788 {
788 drop (op, curinv); 789 drop (op, curinv);
789 if (--cnt <= 0) break; 790 if (--cnt <= 0) break;
790 } 791 }
791 792
… …
799 nextinv = curinv->below; 800 nextinv = curinv->below;
800 801
801 while (nextinv && nextinv->type == MONEY) 802 while (nextinv && nextinv->type == MONEY)
802 nextinv = nextinv->below; 803 nextinv = nextinv->below;
803 804
804 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET)) 805 if (!curinv->flag [FLAG_INV_LOCKED] && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))
805 { 806 {
806 drop (op, curinv); 807 drop (op, curinv);
807 if (--cnt <= 0) break; 808 if (--cnt <= 0) break;
808 } 809 }
809 810
… …
817 nextinv = curinv->below; 818 nextinv = curinv->below;
818 819
819 while (nextinv && nextinv->type == MONEY) 820 while (nextinv && nextinv->type == MONEY)
820 nextinv = nextinv->below; 821 nextinv = nextinv->below;
821 822
822 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED)) 823 if (!curinv->flag [FLAG_INV_LOCKED] && !curinv->flag [FLAG_APPLIED])
823 { 824 {
824 switch (curinv->type) 825 switch (curinv->type)
825 { 826 {
826 case HORN: 827 case HORN:
827 case BOOK: 828 case BOOK:
… …
891 */ 892 */
892int 893int
893command_drop (object *op, char *params) 894command_drop (object *op, char *params)
894{ 895{
895 object *tmp, *next; 896 object *tmp, *next;
896 int did_one = 0;
897 897
898 if (!params) 898 if (!params)
899 { 899 {
900 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?"); 900 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
901 return 0; 901 return 0;
… …
905 vector<object *> matched_objs; 905 vector<object *> matched_objs;
906 906
907 for (tmp = op->inv; tmp; tmp = next) 907 for (tmp = op->inv; tmp; tmp = next)
908 { 908 {
909 next = tmp->below; 909 next = tmp->below;
910 if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible) 910 if (tmp->flag [FLAG_NO_DROP] || tmp->invisible)
911 continue; 911 continue;
912 912
913 if (item_matched_string (op, tmp, params)) 913 if (item_matched_string (op, tmp, params))
914 matched_objs.push_back (tmp); 914 matched_objs.push_back (tmp);
915 } 915 }
… …
950 } 950 }
951 951
952 return 0; 952 return 0;
953} 953}
954 954
955/* op should be a player.
956 * we return the object the player has marked with the 'mark' command
957 * below. If no match is found (or object has changed), we return
958 * NULL. We leave it up to the calling function to print messages if
959 * nothing is found.
960 */
961object *
962find_marked_object (object *op)
963{
964 object *tmp;
965
966 if (!op || !op->contr)
967 return NULL;
968
969 if (!op->contr->mark)
970 {
971/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
972 return 0;
973 }
974
975 /* This may seem like overkill, but we need to make sure that they
976 * player hasn't dropped the item. We use count on the off chance that
977 * an item got reincarnated at some point.
978 */
979 for (tmp = op->inv; tmp; tmp = tmp->below)
980 {
981 if (tmp->invisible)
982 continue;
983
984 if (tmp == op->contr->mark)
985 {
986 if (!tmp->destroyed ())
987 return tmp;
988 else
989 {
990 op->contr->mark = 0;
991/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
992 return 0;
993 }
994 }
995 }
996
997 return 0;
998}
999
1000std::string 955std::string
1001object::describe_monster (object *who) 956object::describe_monster (object *who)
1002{ 957{
1003 dynbuf_text buf (512, 512); 958 dynbuf_text buf (512, 512);
1004 959
1005 object *mon = head ? head : this; 960 object *mon = head ? head : this;
1006 961
1007 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 962 if (mon->flag [FLAG_UNDEAD])
1008 buf << "It is an undead force.\r"; 963 buf << "It is an undead force.\r";
1009 964
1010 if (mon->level > who->level) 965 if (mon->level > who->level)
1011 buf << "It is likely more powerful than you.\r"; 966 buf << "It is likely more powerful than you.\r";
1012 else if (mon->level < who->level) 967 else if (mon->level < who->level)
… …
1069 case SHIELD: 1024 case SHIELD:
1070 case BOOTS: 1025 case BOOTS:
1071 case GLOVES: 1026 case GLOVES:
1072 case AMULET: 1027 case AMULET:
1073 case GIRDLE: 1028 case GIRDLE:
1029 case RANGED:
1074 case BOW: 1030 case BOW:
1075 case ARROW: 1031 case ARROW:
1076 case CLOAK: 1032 case CLOAK:
1077 case FOOD: 1033 case FOOD:
1078 case DRINK: 1034 case DRINK:
… …
1099 */ 1055 */
1100void 1056void
1101examine_monster (object *op, object *tmp) 1057examine_monster (object *op, object *tmp)
1102{ 1058{
1103 new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ()); 1059 new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
1104}
1105
1106static void
1107describe_dump_object (dynbuf &buf, object *ob)
1108{
1109 char *txt = dump_object (ob);
1110 for (char *p = txt; *p; ++p) if (*p == '\n') *p = '\r';
1111 buf << "\n" << txt << "\n";
1112
1113 if (!ob->is_arch ())
1114 describe_dump_object (buf, ob->arch);
1115}
1116
1117std::string
1118object::describe (object *who)
1119{
1120 dynbuf_text buf (1024, 1024);
1121
1122 buf.printf ("That is: %s.\r", long_desc (who).c_str ());
1123
1124 if (custom_name)
1125 buf.printf ("You call it %s.\r", &custom_name);
1126
1127 switch (type)
1128 {
1129 case SPELLBOOK:
1130 if (flag [FLAG_IDENTIFIED] && inv)
1131 buf.printf ("%s is a level %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill);
1132 break;
1133
1134 case BOOK:
1135 if (msg)
1136 buf << "Something is written in it.\r";
1137 break;
1138
1139 case CONTAINER:
1140 if (race)
1141 {
1142 if (weight_limit && stats.Str < 100)
1143 buf.printf ("It can hold only %s and its weight limit is %.1f kg.\r",
1144 &race, weight_limit / (10.0 * (100 - stats.Str)));
1145 else
1146 buf.printf ("It can hold only %s.\r", &race);
1147 }
1148 else if (weight_limit && stats.Str < 100)
1149 buf.printf ("Its weight limit is %.1f kg.\r", weight_limit / (10.0 * (100 - stats.Str)));
1150 break;
1151
1152 case WAND:
1153 if (flag [FLAG_IDENTIFIED])
1154 buf.printf ("It has %d %s left.\r", stats.food, stats.food == 1 ? "charge" : "charges");
1155 break;
1156 }
1157
1158 if (material != MATERIAL_NULL && !msg)
1159 buf << (nrof > 1 ? "They are made of " : "It is made of ")
1160 << material->description
1161 << ".\r";
1162
1163 if (who)
1164 /* Where to wear this item */
1165 for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1166 if (slot[i].info)
1167 {
1168 buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
1169
1170 if (slot[i].info < -1 && who->slot[i].info)
1171 buf.printf ("(%d)", -slot[i].info);
1172
1173 buf << ".\r";
1174 }
1175
1176 if (weight)
1177 buf.printf ("%s %3.3f kg.\r", nrof > 1 ? "They weigh" : "It weighs", weight * (nrof ? nrof : 1) / 1000.0);
1178
1179 if (flag [FLAG_STARTEQUIP])
1180 buf << (nrof > 1 ? "They were" : "It was")
1181 << " given by a god and will vanish when dropped.\r";
1182
1183 if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
1184 {
1185 buf.printf ("You reckon %s worth %s.\r", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
1186
1187 if (is_in_shop (who))
1188 {
1189 if (flag [FLAG_UNPAID])
1190 buf.printf ("%s would cost you %s.\r", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1191 else
1192 buf.printf ("You are offered %s for %s.\r", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1193 }
1194 }
1195
1196 if (flag [FLAG_MONSTER])
1197 buf << describe_monster (who);
1198
1199 /* Is this item buildable? */
1200 if (flag [FLAG_IS_BUILDABLE])
1201 buf << "This is a buildable item.\r";
1202
1203 /* Does the object have a message? Don't show message for all object
1204 * types - especially if the first entry is a match
1205 */
1206 if (msg)
1207 {
1208 if (type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1209 {
1210 buf << '\r';
1211
1212 /* This is just a hack so when identifying the items, we print
1213 * out the extra message
1214 */
1215 if (need_identify (this) && flag [FLAG_IDENTIFIED])
1216 buf << "The object has a story:\r";
1217
1218 buf << msg << '\n';
1219 }
1220 }
1221 else if (inv && inv->type == SPELL && flag [FLAG_IDENTIFIED]
1222 && (type == SPELLBOOK || type == ROD || type == WAND
1223 || type == ROD || type == POTION || type == SCROLL))
1224 // for spellbooks and other stuff that contains spells, print the spell message,
1225 // unless the object has a custom message handled above.
1226 buf << '\r' << inv->msg << '\n';
1227
1228 // try to display the duration for some potions and scrolls
1229 // this includes change ability potions and group spells,
1230 // but does not handle protection potions
1231 if (inv && inv->type == SPELL && flag [FLAG_IDENTIFIED]
1232 && (type == POTION || type == SCROLL))
1233 {
1234 object *spell = inv;
1235
1236 if (spell->subtype == SP_PARTY_SPELL)
1237 spell = spell->other_arch;
1238
1239 if (spell->subtype == SP_CHANGE_ABILITY)
1240 buf.printf ("\nH<The effect will last about %.10g seconds.>",
1241 TICK2TIME (change_ability_duration (spell, this)));
1242 }
1243
1244 // Display a hint about inscribable items [empty books]
1245 // This includes the amount of text they can hold.
1246 if (type == INSCRIBABLE)
1247 {
1248 if (other_arch && other_arch->type == SCROLL)
1249 buf.printf ("\nH<You can use the inscription skill to inscribe a spell into it.>");
1250 else
1251 buf.printf ("\nH<You can use the inscription skill to inscribe text into it. It has room for up to %d characters.>",
1252 weight_limit);
1253 }
1254
1255 buf << '\n';
1256
1257 // the dungeon master additionally gets a complete dump
1258 if (who && who->flag [FLAG_WIZLOOK])
1259 {
1260 buf << "\nT<Object>\n";
1261 describe_dump_object (buf, this);
1262
1263 if (inv)
1264 {
1265 buf << "\nT<Top Inventory>\n";
1266 describe_dump_object (buf, inv);
1267 }
1268 }
1269
1270 return std::string (buf.linearise (), buf.size ());
1271} 1060}
1272 1061
1273static void 1062static void
1274display_new_pickup (object *op) 1063display_new_pickup (object *op)
1275{ 1064{
… …
1420 */ 1209 */
1421 if (params == NULL) 1210 if (params == NULL)
1422 { 1211 {
1423 for (object *item = op->inv; item; item = item->below) 1212 for (object *item = op->inv; item; item = item->below)
1424 { 1213 {
1425 CLEAR_FLAG(item, FLAG_INV_LOCKED); 1214 item->clr_flag (FLAG_INV_LOCKED);
1426 //d// new_draw_info (NDI_UNIQUE, 0, op, "unlocked items with null param."); 1215 //d// new_draw_info (NDI_UNIQUE, 0, op, "unlocked items with null param.");
1427 esrv_update_item (UPD_FLAGS, op, item); 1216 esrv_update_item (UPD_FLAGS, op, item);
1428 } 1217 }
1429 return 0; 1218 return 0;
1430 } 1219 }
… …
1433 * unlock what matches. i.e. unlock material, should unlock all the materials 1222 * unlock what matches. i.e. unlock material, should unlock all the materials
1434 */ 1223 */
1435 for (object *item = op->inv; item; item = item->below) 1224 for (object *item = op->inv; item; item = item->below)
1436 if (item->name.contains (params)) 1225 if (item->name.contains (params))
1437 { 1226 {
1438 CLEAR_FLAG (item, FLAG_INV_LOCKED); 1227 item->clr_flag (FLAG_INV_LOCKED);
1439 //d// new_draw_info (NDI_UNIQUE, 0, op, "unlocked items with a param."); 1228 //d// new_draw_info (NDI_UNIQUE, 0, op, "unlocked items with a param.");
1440 esrv_update_item (UPD_FLAGS, op, item); 1229 esrv_update_item (UPD_FLAGS, op, item);
1441 } 1230 }
1442 1231
1443 return 0; 1232 return 0;
… …
1450 */ 1239 */
1451 if (params == NULL) 1240 if (params == NULL)
1452 { 1241 {
1453 for (object *item = op->inv; item; item = item->below) 1242 for (object *item = op->inv; item; item = item->below)
1454 { 1243 {
1455 SET_FLAG (item, FLAG_INV_LOCKED); 1244 item->set_flag (FLAG_INV_LOCKED);
1456 //d// new_draw_info (NDI_UNIQUE, 0, op, "locked items with null param."); 1245 //d// new_draw_info (NDI_UNIQUE, 0, op, "locked items with null param.");
1457 esrv_update_item (UPD_FLAGS, op, item); 1246 esrv_update_item (UPD_FLAGS, op, item);
1458 } 1247 }
1459 return 0; 1248 return 0;
1460 } 1249 }
… …
1463 * i.e. lock material, should lock all the materials 1252 * i.e. lock material, should lock all the materials
1464 */ 1253 */
1465 for (object *item = op->inv; item; item = item->below) 1254 for (object *item = op->inv; item; item = item->below)
1466 if (item->name.contains (params)) 1255 if (item->name.contains (params))
1467 { 1256 {
1468 SET_FLAG (item, FLAG_INV_LOCKED); 1257 item->set_flag (FLAG_INV_LOCKED);
1469 //d// new_draw_info (NDI_UNIQUE, 0, op, "locked items with param."); 1258 //d// new_draw_info (NDI_UNIQUE, 0, op, "locked items with param.");
1470 esrv_update_item (UPD_FLAGS, op, item); 1259 esrv_update_item (UPD_FLAGS, op, item);
1471 } 1260 }
1472 1261
1473 return 0; 1262 return 0;
1474} 1263}
1264
1265/* op should be a player, params is any params.
1266 * If no params given, we print out the currently marked object.
1267 * otherwise, try to find a matching object - try best match first.
1268 */
1269int
1270command_mark (object *op, char *params)
1271{
1272 if (!params)
1273 {
1274 if (object *mark = op->mark ())
1275 op->statusmsg (format ("%s is marked.", query_name (mark)));
1276 else
1277 op->failmsg ("You have no marked object.");
1278 }
1279 else
1280 {
1281 if (object *mark = find_best_object_match (op, params))
1282 {
1283 op->contr->mark = mark;
1284 op->statusmsg (format ("Marked item %s", query_name (mark)));
1285 }
1286 else
1287 op->failmsgf ("Could not find an object that matches %s", params);
1288 }
1289
1290 return 0; /*shouldnt get here */
1291}
1292

Diff Legend

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