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.102 by root, Sat Nov 7 18:30:05 2009 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 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,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 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
27 */ 27 */
28 28
29#include <global.h> 29#include <global.h>
30#include <loader.h>
31#include <skills.h> 30#include <skills.h>
32#include <sproto.h> 31#include <sproto.h>
33#include <living.h> 32#include <living.h>
34 33
35/* 34/*
… …
68 67
69 int tmpmatch = item_matched_string (pl, tmp, params); 68 int tmpmatch = item_matched_string (pl, tmp, params);
70 69
71 if (tmpmatch > match_val) 70 if (tmpmatch > match_val)
72 { 71 {
73 if ((aflag == AP_APPLY) && (QUERY_FLAG (tmp, FLAG_APPLIED))) 72 if ((aflag == AP_APPLY) && (tmp->flag [FLAG_APPLIED]))
74 continue; 73 continue;
75 74
76 if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, FLAG_APPLIED))) 75 if ((aflag == AP_UNAPPLY) && (!tmp->flag [FLAG_APPLIED]))
77 continue; 76 continue;
78 77
79 match_val = tmpmatch; 78 match_val = tmpmatch;
80 best = tmp; 79 best = tmp;
81 } 80 }
… …
137 136
138 skill = find_skill_by_name_fuzzy (pl, params); 137 skill = find_skill_by_name_fuzzy (pl, params);
139 138
140 if (!skill) 139 if (!skill)
141 { 140 {
142 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);
143 return 0; 142 return 0;
144 } 143 }
145 144
146 pl->change_skill (0); 145 pl->apply (skill);
147 apply_special (pl, skill, AP_APPLY);
148 return 1; 146 return 1;
149} 147}
150 148
151/* A little special because we do want to pass the full params along 149/* A little special because we do want to pass the full params along
152 * as it includes the object to throw. 150 * as it includes the object to throw.
153 */ 151 */
154int 152int
155command_throw (object *op, char *params) 153command_throw (object *op, char *params)
156{ 154{
157 if (object *skop = find_skill_by_name (op, skill_names[SK_THROWING])) 155 if (object *skop = find_skill_by_name (op, shstr_throwing))
158 return do_skill (op, op, skop, op->facing, params); 156 return do_skill (op, op, skop, op->facing, params);
159 else 157 else
160 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.");
161 159
162 return 0; 160 return 0;
163} 161}
164 162
165int 163int
… …
191 189
192 while (*params == ' ') 190 while (*params == ' ')
193 params++; 191 params++;
194 192
195 if (object *inv = find_best_apply_object_match (op, params, aflag)) 193 if (object *inv = find_best_apply_object_match (op, params, aflag))
196 player_apply (op, inv, aflag, 0); 194 op->apply (inv, aflag);
197 else 195 else
198 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);
199 } 197 }
200 198
201 return 0; 199 return 0;
202} 200}
203 201
… …
211 * not need to use split_ob and stuff. 209 * not need to use split_ob and stuff.
212 */ 210 */
213int 211int
214sack_can_hold (object *pl, object *sack, object *op, uint32 nrof) 212sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)
215{ 213{
216 if (!QUERY_FLAG (sack, FLAG_APPLIED)) 214 if (!sack->flag [FLAG_APPLIED])
217 { 215 {
218 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));
219 return 0; 217 return 0;
220 } 218 }
221 219
… …
225 return 0; 223 return 0;
226 } 224 }
227 225
228 if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type))) 226 if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))
229 { 227 {
230 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack)); 228 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can only put objects of type '%s' into the %s.", &sack->race, query_name (sack));
231 return 0; 229 return 0;
232 } 230 }
233 231
234 if (op->type == SPECIAL_KEY && sack->slaying && op->slaying) 232 if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)
235 { 233 {
236 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));
237 return 0; 235 return 0;
238 } 236 }
239 237
240 if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) * 238 if (sack->weight_limit
239 && weight_t (sack->carrying
240 + sack->number_of ()
241 (op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0)) 241 * (op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))
242 * (100 - sack->stats.Str) / 100) > sack->weight_limit) 242 * (100 - sack->stats.Str) / 100)
243 > sack->weight_limit)
243 { 244 {
244 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));
245 return 0; 246 return 0;
246 } 247 }
247 248
… …
250} 251}
251 252
252/* Pick up commands follow */ 253/* Pick up commands follow */
253 254
254/* pl = player (not always - monsters can use this now) 255/* pl = player (not always - monsters can use this now)
255 * op is the object to put tmp into, 256 * op is the object to put tmp into,
256 * 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
257 * pick up (0 means all of them) 258 * pick up (0 means all of them)
258 */ 259 */
259static void 260static void
260pick_up_object (object *pl, object *op, object *tmp, int nrof) 261pick_up_object (object *pl, object *op, object *tmp, int nrof)
261{ 262{
262 object *env = tmp->env;
263 uint32 weight, effective_weight_limit; 263 weight_t weight, effective_weight_limit;
264 int tmp_nrof = tmp->number_of (); 264 int tmp_nrof = tmp->number_of ();
265 265
266 /* 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
267 * 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
268 * (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
269 * containers not allowed as of now) 269 * containers not allowed as of now)
270 */ 270 */
271 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)
272 { 272 {
273 pl->failmsg ("You are levitating, you can't reach the ground! " 273 pl->failmsg ("You are levitating, you can't reach the ground! "
274 "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, "
275 "or waiting till the levitation effect wears off.>"); 275 "or waiting till the levitation effect wears off.>");
276 return; 276 return;
277 } 277 }
278 278
279 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 279 if (tmp->flag [FLAG_NO_DROP])
280 return; 280 return;
281 281
282 if (nrof > tmp_nrof || nrof <= 0) 282 if (nrof > tmp_nrof || nrof <= 0)
283 nrof = tmp_nrof; 283 nrof = tmp_nrof;
284 284
… …
296 } 296 }
297 297
298 if (!can_split (pl, tmp, nrof)) 298 if (!can_split (pl, tmp, nrof))
299 return; 299 return;
300 300
301 if (QUERY_FLAG (tmp, FLAG_UNPAID)) 301 if (tmp->flag [FLAG_UNPAID])
302 { 302 {
303 tmp->flag.reset (FLAG_UNPAID); 303 tmp->flag.reset (FLAG_UNPAID);
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)); 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));
305 tmp->flag.set (FLAG_UNPAID); 305 tmp->flag.set (FLAG_UNPAID);
306 } 306 }
… …
369 goto leave; 369 goto leave;
370 } 370 }
371 else 371 else
372 { /* non container pickup */ 372 { /* non container pickup */
373 for (alt = op->inv; alt; alt = alt->below) 373 for (alt = op->inv; alt; alt = alt->below)
374 if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && 374 if (alt->type == CONTAINER && alt->flag [FLAG_APPLIED] &&
375 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))
376 break; /* perfect match */ 376 break; /* perfect match */
377 377
378 if (!alt) 378 if (!alt)
379 for (alt = op->inv; alt; alt = alt->below) 379 for (alt = op->inv; alt; alt = alt->below)
380 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))
381 break; /* General container comes next */ 381 break; /* General container comes next */
382 382
383 if (!alt) 383 if (!alt)
384 alt = op; /* No free containers */ 384 alt = op; /* No free containers */
385 } 385 }
… …
395#ifdef PICKUP_DEBUG 395#ifdef PICKUP_DEBUG
396 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);
397#endif 397#endif
398 398
399 /* startequip items are not allowed to be put into containers: */ 399 /* startequip items are not allowed to be put into containers: */
400 if (op->type == PLAYER && alt->type == CONTAINER && QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 400 if (op->type == PLAYER && alt->type == CONTAINER && tmp->flag [FLAG_STARTEQUIP])
401 { 401 {
402 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!");
403 goto leave; 403 goto leave;
404 } 404 }
405 405
… …
449 449
450 /* Makes processing easier */ 450 /* Makes processing easier */
451 if (params && *params == '\0') 451 if (params && *params == '\0')
452 params = 0; 452 params = 0;
453 453
454 int cnt = MAX_ITEM_PER_DROP; 454 int cnt = MAX_ITEM_PER_ACTION;
455 455
456 while (tmp) 456 while (tmp)
457 { 457 {
458 next = tmp->below; 458 next = tmp->below;
459 459
… …
503 503
504 return 0; 504 return 0;
505} 505}
506 506
507/* 507/*
508 * This function was part of drop, now is own function. 508 * This function was part of drop, now is own function.
509 * Player 'op' tries to put object 'tmp' into sack 'sack', 509 * Player 'op' tries to put object 'tmp' into sack 'sack',
510 * 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 * 511 *
512 * Note that the 'sack' in question can now be a transport, 512 * Note that the 'sack' in question can now be a transport,
513 * so this function isn't named very good anymore. 513 * so this function isn't named very good anymore.
514 */ 514 */
515void 515void
516put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof) 516put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof)
517{ 517{
518 object *tmp2, *sack2; 518 object *tmp2;
519 char buf[MAX_BUF]; 519 char buf[MAX_BUF];
520 520
521 if (sack == tmp) 521 if (sack == tmp)
522 return; /* Can't put an object in itself */ 522 return; /* Can't put an object in itself */
523 523
524 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP)) 524 if (tmp->flag [FLAG_STARTEQUIP] || tmp->flag [FLAG_NO_DROP])
525 { 525 {
526 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));
527 return; 527 return;
528 } 528 }
529 529
… …
531 { 531 {
532 /* 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
533 * we instead move the contents of that container into the active 533 * we instead move the contents of that container into the active
534 * 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.
535 */ 535 */
536 sack2 = tmp;
537 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));
538 537
539 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp) 538 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
540 { 539 {
541 tmp = tmp2->below; 540 tmp = tmp2->below;
… …
557 * already checked this. 556 * already checked this.
558 */ 557 */
559 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)))
560 return; 559 return;
561 560
562 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 561 if (tmp->flag [FLAG_APPLIED])
563 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE)) 562 if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
564 return; 563 return;
565 564
566 /* 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 */
567 if (!can_split (op, tmp, nrof)) 566 if (!can_split (op, tmp, nrof))
568 return; 567 return;
569 568
570 new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack)); 569 new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));
571 sack->insert (tmp); 570 sack->insert (tmp);
572}
573
574/*
575 * This function was part of drop, now is own function.
576 * Player 'op' tries to drop object 'tmp', if tmp is non zero, then
577 * nrof objects is tried to dropped.
578 * This is used when dropping objects onto the floor.
579 */
580void
581drop_object (object *op, object *tmp, uint32 nrof)
582{
583 if (QUERY_FLAG (tmp, FLAG_NO_DROP))
584 return;
585
586 if (QUERY_FLAG (tmp, FLAG_APPLIED))
587 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
588 return; /* can't unapply it */
589
590 /* We are only dropping some of the items. We split the current object
591 * off
592 */
593 if (!can_split (op, tmp, nrof))
594 return;
595
596 drop_object (op, tmp);
597
598 if (!tmp->destroyed () && !tmp->is_inserted ())
599 {
600 // if nothing happened with the object we give it back
601 op->insert (tmp);
602 }
603} 571}
604 572
605/* In contrast to drop_object (op, tmp, nrof) above this function takes the 573/* In contrast to drop_object (op, tmp, nrof) above this function takes the
606 * already split off object, and feeds it to the event handlers and does 574 * already split off object, and feeds it to the event handlers and does
607 * other magic with it. 575 * other magic with it.
… …
619 return; 587 return;
620 588
621 if (obj->destroyed () || obj->is_inserted ()) 589 if (obj->destroyed () || obj->is_inserted ())
622 return; 590 return;
623 591
624 if (QUERY_FLAG (obj, FLAG_STARTEQUIP)) 592 if (obj->flag [FLAG_STARTEQUIP])
625 { 593 {
626 dropper->statusmsg (format ("You drop the %s.", query_name (obj))); 594 dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
627 dropper->statusmsg ("The god who lent it to you retrieves it."); 595 dropper->statusmsg ("The god who lent it to you retrieves it.");
628 596
629 obj->destroy (); 597 obj->destroy ();
… …
638 return; 606 return;
639 607
640 if (obj->destroyed () || obj->is_inserted ()) 608 if (obj->destroyed () || obj->is_inserted ())
641 return; 609 return;
642 610
643 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)
644 if (!sell_item (obj, dropper)) 612 if (!sell_item (obj, dropper))
645 return; 613 return;
614
615 if (!obj->can_drop_at (dropper->map, dropper->x, dropper->y, dropper))
616 return;
646 617
647 /* 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
648 * insert it below the dropper: 619 * insert it below the dropper:
649 */ 620 */
650 621
651 obj->x = dropper->x; 622 obj->x = dropper->x;
652 obj->y = dropper->y; 623 obj->y = dropper->y;
653 624
654 insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR); 625 insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
626}
627
628/*
629 * This function was part of drop, now is own function.
630 * Player 'op' tries to drop object 'tmp', if tmp is non zero, then
631 * nrof objects are tried to drop.
632 * This is used when dropping objects onto the floor.
633 */
634void
635drop_object (object *op, object *tmp, uint32 nrof)
636{
637 if (tmp->flag [FLAG_NO_DROP])
638 return;
639
640 if (tmp->flag [FLAG_APPLIED])
641 if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
642 return; /* can't unapply it */
643
644 /* We are only dropping some of the items. We split the current object
645 * off
646 */
647 if (!can_split (op, tmp, nrof))
648 return;
649
650 drop_object (op, tmp);
651
652 if (!tmp->destroyed () && !tmp->is_inserted ())
653 {
654 // if nothing happened with the object we give it back
655 op->insert (tmp);
656 }
655} 657}
656 658
657void 659void
658drop (object *op, object *tmp) 660drop (object *op, object *tmp)
659{ 661{
… …
672 */ 674 */
673 tmp->destroy (); 675 tmp->destroy ();
674 return; 676 return;
675 } 677 }
676 else 678 else
677 {
678 while (tmp && tmp->invisible) 679 while (tmp && tmp->invisible)
679 tmp = tmp->below; 680 tmp = tmp->below;
680 }
681 } 681 }
682 682
683 if (tmp == NULL) 683 if (!tmp)
684 { 684 {
685 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.");
686 return; 686 return;
687 } 687 }
688 688
689 if (QUERY_FLAG (tmp, FLAG_INV_LOCKED)) 689 if (tmp->flag [FLAG_INV_LOCKED])
690 { 690 {
691 new_draw_info (NDI_UNIQUE, 0, op, "This item is locked"); 691 new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
692 return; 692 return;
693 } 693 }
694 694
695 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 695 if (tmp->flag [FLAG_NO_DROP])
696 { 696 {
697#if 0 697#if 0
698 /* 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. */
699 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.");
700#endif 700#endif
… …
737 } 737 }
738 738
739 object *curinv = op->inv; 739 object *curinv = op->inv;
740 object *nextinv; 740 object *nextinv;
741 741
742 /* 742 /*
743 This is the default. Drops everything not locked or considered 743 This is the default. Drops everything not locked or considered
744 not something that should be dropped. 744 not something that should be dropped.
745 */ 745 */
746 /* 746 /*
747 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
748 the drop() routine will do unknown things to it when dropping 748 the drop() routine will do unknown things to it when dropping
749 in a shop. --Tero.Pelander@utu.fi 749 in a shop. --Tero.Pelander@utu.fi
750 */ 750 */
751
752 int cnt = MAX_ITEM_PER_DROP; 751 int cnt = MAX_ITEM_PER_ACTION;
753 752
754 if (!params) 753 if (!params)
755 { 754 {
756 while (curinv) 755 while (curinv)
757 { 756 {
758 nextinv = curinv->below; 757 nextinv = curinv->below;
759 758
760 while (nextinv && nextinv->type == MONEY) 759 while (nextinv && nextinv->type == MONEY)
761 nextinv = nextinv->below; 760 nextinv = nextinv->below;
762 761
763 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY && 762 if (!curinv->flag [FLAG_INV_LOCKED]
764 curinv->type != FOOD && curinv->type != KEY && 763 && !curinv->invisible
765 curinv->type != SPECIAL_KEY && curinv->type != GEM && 764 && curinv->type != MONEY
766 !curinv->invisible && (curinv->type != CONTAINER || op->container_ () != curinv)) 765 && curinv->type != FOOD
766 && curinv->type != KEY
767 && curinv->type != SPECIAL_KEY
768 && curinv->type != GEM
769 && curinv->type != CONTAINER)
767 { 770 {
768 drop (op, curinv); 771 drop (op, curinv);
769 if (--cnt <= 0) break; 772 if (--cnt <= 0) break;
770 } 773 }
771 774
… …
779 nextinv = curinv->below; 782 nextinv = curinv->below;
780 783
781 while (nextinv && nextinv->type == MONEY) 784 while (nextinv && nextinv->type == MONEY)
782 nextinv = nextinv->below; 785 nextinv = nextinv->below;
783 786
784 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)))
785 { 788 {
786 drop (op, curinv); 789 drop (op, curinv);
787 if (--cnt <= 0) break; 790 if (--cnt <= 0) break;
788 } 791 }
789 792
… …
797 nextinv = curinv->below; 800 nextinv = curinv->below;
798 801
799 while (nextinv && nextinv->type == MONEY) 802 while (nextinv && nextinv->type == MONEY)
800 nextinv = nextinv->below; 803 nextinv = nextinv->below;
801 804
802 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))
803 { 806 {
804 drop (op, curinv); 807 drop (op, curinv);
805 if (--cnt <= 0) break; 808 if (--cnt <= 0) break;
806 } 809 }
807 810
… …
815 nextinv = curinv->below; 818 nextinv = curinv->below;
816 819
817 while (nextinv && nextinv->type == MONEY) 820 while (nextinv && nextinv->type == MONEY)
818 nextinv = nextinv->below; 821 nextinv = nextinv->below;
819 822
820 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED)) 823 if (!curinv->flag [FLAG_INV_LOCKED] && !curinv->flag [FLAG_APPLIED])
821 { 824 {
822 switch (curinv->type) 825 switch (curinv->type)
823 { 826 {
824 case HORN: 827 case HORN:
825 case BOOK: 828 case BOOK:
… …
889 */ 892 */
890int 893int
891command_drop (object *op, char *params) 894command_drop (object *op, char *params)
892{ 895{
893 object *tmp, *next; 896 object *tmp, *next;
894 int did_one = 0;
895 897
896 if (!params) 898 if (!params)
897 { 899 {
898 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?"); 900 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
899 return 0; 901 return 0;
… …
903 vector<object *> matched_objs; 905 vector<object *> matched_objs;
904 906
905 for (tmp = op->inv; tmp; tmp = next) 907 for (tmp = op->inv; tmp; tmp = next)
906 { 908 {
907 next = tmp->below; 909 next = tmp->below;
908 if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible) 910 if (tmp->flag [FLAG_NO_DROP] || tmp->invisible)
909 continue; 911 continue;
910 912
911 if (item_matched_string (op, tmp, params)) 913 if (item_matched_string (op, tmp, params))
912 matched_objs.push_back (tmp); 914 matched_objs.push_back (tmp);
913 } 915 }
914 916
915 int cnt = MAX_ITEM_PER_DROP; 917 int cnt = MAX_ITEM_PER_ACTION;
916 918
917 if (!drop_vector (op, matched_objs, &cnt)) 919 if (!drop_vector (op, matched_objs, &cnt))
918 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop."); 920 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
919 921
920 if (cnt <= 0) 922 if (cnt <= 0)
… …
948 } 950 }
949 951
950 return 0; 952 return 0;
951} 953}
952 954
953/* op should be a player.
954 * we return the object the player has marked with the 'mark' command
955 * below. If no match is found (or object has changed), we return
956 * NULL. We leave it up to the calling function to print messages if
957 * nothing is found.
958 */
959object *
960find_marked_object (object *op)
961{
962 object *tmp;
963
964 if (!op || !op->contr)
965 return NULL;
966
967 if (!op->contr->mark)
968 {
969/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
970 return 0;
971 }
972
973 /* This may seem like overkill, but we need to make sure that they
974 * player hasn't dropped the item. We use count on the off chance that
975 * an item got reincarnated at some point.
976 */
977 for (tmp = op->inv; tmp; tmp = tmp->below)
978 {
979 if (tmp->invisible)
980 continue;
981
982 if (tmp == op->contr->mark)
983 {
984 if (!tmp->destroyed ())
985 return tmp;
986 else
987 {
988 op->contr->mark = 0;
989/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
990 return 0;
991 }
992 }
993 }
994
995 return 0;
996}
997
998std::string 955std::string
999object::describe_monster (object *who) 956object::describe_monster (object *who)
1000{ 957{
1001 dynbuf_text buf (512, 512); 958 dynbuf_text buf (512, 512);
1002 959
1003 object *mon = head ? head : this; 960 object *mon = head ? head : this;
1004 961
1005 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 962 if (mon->flag [FLAG_UNDEAD])
1006 buf << "It is an undead force.\r"; 963 buf << "It is an undead force.\r";
1007 964
1008 if (mon->level > who->level) 965 if (mon->level > who->level)
1009 buf << "It is likely more powerful than you.\r"; 966 buf << "It is likely more powerful than you.\r";
1010 else if (mon->level < who->level) 967 else if (mon->level < who->level)
… …
1067 case SHIELD: 1024 case SHIELD:
1068 case BOOTS: 1025 case BOOTS:
1069 case GLOVES: 1026 case GLOVES:
1070 case AMULET: 1027 case AMULET:
1071 case GIRDLE: 1028 case GIRDLE:
1029 case RANGED:
1072 case BOW: 1030 case BOW:
1073 case ARROW: 1031 case ARROW:
1074 case CLOAK: 1032 case CLOAK:
1075 case FOOD: 1033 case FOOD:
1076 case DRINK: 1034 case DRINK:
… …
1097 */ 1055 */
1098void 1056void
1099examine_monster (object *op, object *tmp) 1057examine_monster (object *op, object *tmp)
1100{ 1058{
1101 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 ());
1102}
1103
1104static void
1105describe_dump_object (dynbuf &buf, object *ob)
1106{
1107 char *txt = dump_object (ob);
1108 for (char *p = txt; *p; ++p) if (*p == '\n') *p = '\r';
1109 buf << "\n" << txt << "\n";
1110
1111 if (!ob->is_arch ())
1112 describe_dump_object (buf, ob->arch);
1113}
1114
1115std::string
1116object::describe (object *who)
1117{
1118 dynbuf_text buf (1024, 1024);
1119
1120 buf.printf ("That is: %s.\r", long_desc (who).c_str ());
1121
1122 if (custom_name)
1123 buf.printf ("You call it %s.\r", &custom_name);
1124
1125 switch (type)
1126 {
1127 case SPELLBOOK:
1128 if (flag [FLAG_IDENTIFIED] && inv)
1129 buf.printf ("%s is a level %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill);
1130 break;
1131
1132 case BOOK:
1133 if (msg)
1134 buf << "Something is written in it.\r";
1135 break;
1136
1137 case CONTAINER:
1138 if (race)
1139 {
1140 if (weight_limit && stats.Str < 100)
1141 buf.printf ("It can hold only %s and its weight limit is %.1f kg.\r",
1142 &race, weight_limit / (10.0 * (100 - stats.Str)));
1143 else
1144 buf.printf ("It can hold only %s.\r", &race);
1145 }
1146 else if (weight_limit && stats.Str < 100)
1147 buf.printf ("Its weight limit is %.1f kg.\r", weight_limit / (10.0 * (100 - stats.Str)));
1148 break;
1149
1150 case WAND:
1151 if (flag [FLAG_IDENTIFIED])
1152 buf.printf ("It has %d charges left.\r", stats.food);
1153 break;
1154 }
1155
1156 if (materialname && !msg)
1157 buf << (nrof > 1 ? "They are made of " : "It is made of ")
1158 << materialname
1159 << '\r';
1160
1161 if (who)
1162 /* Where to wear this item */
1163 for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1164 if (slot[i].info)
1165 {
1166 buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
1167
1168 if (slot[i].info < -1 && who->slot[i].info)
1169 buf.printf ("(%d)", -slot[i].info);
1170
1171 buf << ".\r";
1172 }
1173
1174 if (weight)
1175 buf.printf ("%s %3.3f kg.\r", nrof > 1 ? "They weigh" : "It weighs", weight * (nrof ? nrof : 1) / 1000.0);
1176
1177 if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
1178 {
1179 buf.printf ("You reckon %s worth %s.\r", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
1180
1181 if (is_in_shop (who))
1182 {
1183 if (flag [FLAG_UNPAID])
1184 buf.printf ("%s would cost you %s.\r", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1185 else
1186 buf.printf ("You are offered %s for %s.\r", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1187 }
1188 }
1189
1190 if (flag [FLAG_MONSTER])
1191 buf << describe_monster (who);
1192
1193 /* Is this item buildable? */
1194 if (flag [FLAG_IS_BUILDABLE])
1195 buf << "This is a buildable item.\r";
1196
1197 /* Does the object have a message? Don't show message for all object
1198 * types - especially if the first entry is a match
1199 */
1200 if (msg)
1201 {
1202 if (type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1203 {
1204 buf << '\r';
1205
1206 /* This is just a hack so when identifying the items, we print
1207 * out the extra message
1208 */
1209 if (need_identify (this) && flag [FLAG_IDENTIFIED])
1210 buf << "The object has a story:\r";
1211
1212 buf << msg << '\n';
1213 }
1214 }
1215 else if (inv && inv->type == SPELL && flag [FLAG_IDENTIFIED]
1216 && (type == SPELLBOOK || type == ROD || type == WAND
1217 || type == ROD || type == POTION || type == SCROLL))
1218 // for spellbooks and other stuff that contains spells, print the spell message,
1219 // unless the object has a custom message handled above.
1220 buf << '\r' << inv->msg << '\n';
1221
1222 // try to display the duration for some potions and scrolls
1223 // this includes change ability potions and group spells,
1224 // but does not handle protection potions
1225 if (inv && inv->type == SPELL && flag [FLAG_IDENTIFIED]
1226 && (type == POTION || type == SCROLL))
1227 {
1228 object *spell = inv;
1229
1230 if (spell->subtype == SP_PARTY_SPELL)
1231 spell = spell->other_arch;
1232
1233 if (spell->subtype == SP_CHANGE_ABILITY)
1234 buf.printf ("\nH<The effect will last about %.10g seconds.>",
1235 TICK2TIME (change_ability_duration (spell, this)));
1236 }
1237
1238 // Display a hint about inscribable items [empty books]
1239 // This includes the amount of text they can hold.
1240 if (type == INSCRIBABLE)
1241 {
1242 if (other_arch && other_arch->type == SCROLL)
1243 buf.printf ("\nH<You can use the inscription skill to inscribe a spell into it.>");
1244 else
1245 buf.printf ("\nH<You can use the inscription skill to inscribe text into it. It has room for up to %d characters.>",
1246 weight_limit);
1247 }
1248
1249 buf << '\n';
1250
1251 // the dungeon master additionally gets a complete dump
1252 if (who && who->flag [FLAG_WIZLOOK])
1253 {
1254 buf << "\nT<Object>\n";
1255 describe_dump_object (buf, this);
1256
1257 if (inv)
1258 {
1259 buf << "\nT<Top Inventory>\n";
1260 describe_dump_object (buf, inv);
1261 }
1262 }
1263
1264 return std::string (buf.linearise (), buf.size ());
1265} 1060}
1266 1061
1267static void 1062static void
1268display_new_pickup (object *op) 1063display_new_pickup (object *op)
1269{ 1064{
… …
1375} 1170}
1376 1171
1377int 1172int
1378command_search_items (object *op, char *params) 1173command_search_items (object *op, char *params)
1379{ 1174{
1380 char buf[MAX_BUF];
1381
1382 if (params == NULL) 1175 if (params == NULL)
1383 { 1176 {
1384 if (op->contr->search_str[0] == '\0') 1177 if (op->contr->search_str[0] == '\0')
1385 { 1178 {
1386 new_draw_info (NDI_UNIQUE, 0, op, "Example: search-items magic+1"); 1179 new_draw_info (NDI_UNIQUE, 0, op, "Example: search-items magic+1");
… …
1389 return 1; 1182 return 1;
1390 } 1183 }
1391 1184
1392 op->contr->search_str[0] = '\0'; 1185 op->contr->search_str[0] = '\0';
1393 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off."); 1186 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1394 op->update_stats (); 1187 op->contr->queue_stats_update ();
1395 return 1; 1188 return 1;
1396 } 1189 }
1397 1190
1398 if (strlen (params) >= MAX_BUF) 1191 if (strlen (params) >= sizeof (op->contr->search_str))
1399 { 1192 {
1400 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long."); 1193 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1401 return 1; 1194 return 1;
1402 } 1195 }
1403 1196
1404 strcpy (op->contr->search_str, params); 1197 strcpy (op->contr->search_str, params);
1405 sprintf (buf, "Now searching for '%s'.", op->contr->search_str); 1198 new_draw_info (NDI_UNIQUE, 0, op, format ("Now searching for '%s'.", op->contr->search_str));
1406 new_draw_info (NDI_UNIQUE, 0, op, buf); 1199 op->contr->queue_stats_update ();
1407 op->update_stats ();
1408 1200
1409 return 1; 1201 return 1;
1410} 1202}
1411 1203
1204int
1205command_unlock (object *op, char *params)
1206{
1207 /* if the unlock command typed with nothing, unlock everything,
1208 * this might be bad
1209 */
1210 if (params == NULL)
1211 {
1212 for (object *item = op->inv; item; item = item->below)
1213 {
1214 item->clr_flag (FLAG_INV_LOCKED);
1215 //d// new_draw_info (NDI_UNIQUE, 0, op, "unlocked items with null param.");
1216 esrv_update_item (UPD_FLAGS, op, item);
1217 }
1218 return 0;
1219 }
1220
1221 /* if the unlock command is used with a param,
1222 * unlock what matches. i.e. unlock material, should unlock all the materials
1223 */
1224 for (object *item = op->inv; item; item = item->below)
1225 if (item->name.contains (params))
1226 {
1227 item->clr_flag (FLAG_INV_LOCKED);
1228 //d// new_draw_info (NDI_UNIQUE, 0, op, "unlocked items with a param.");
1229 esrv_update_item (UPD_FLAGS, op, item);
1230 }
1231
1232 return 0;
1233}
1234
1235int
1236command_lock (object *op, char *params)
1237{
1238 /* if the lock command is typed by itself, lock everything
1239 */
1240 if (params == NULL)
1241 {
1242 for (object *item = op->inv; item; item = item->below)
1243 {
1244 item->set_flag (FLAG_INV_LOCKED);
1245 //d// new_draw_info (NDI_UNIQUE, 0, op, "locked items with null param.");
1246 esrv_update_item (UPD_FLAGS, op, item);
1247 }
1248 return 0;
1249 }
1250
1251 /* if the lock command is used with a param, lock what matches.
1252 * i.e. lock material, should lock all the materials
1253 */
1254 for (object *item = op->inv; item; item = item->below)
1255 if (item->name.contains (params))
1256 {
1257 item->set_flag (FLAG_INV_LOCKED);
1258 //d// new_draw_info (NDI_UNIQUE, 0, op, "locked items with param.");
1259 esrv_update_item (UPD_FLAGS, op, item);
1260 }
1261
1262 return 0;
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