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.66 by root, Mon Apr 21 07:01:40 2008 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 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 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/*
25 * Object (handling) commands 26 * Object (handling) commands
26 */ 27 */
27 28
28#include <global.h> 29#include <global.h>
29#include <loader.h>
30#include <skills.h> 30#include <skills.h>
31#include <sproto.h> 31#include <sproto.h>
32#include <living.h> 32#include <living.h>
33#include <math.h>
34 33
35/* 34/*
36 * Object id parsing functions 35 * Object id parsing functions
37 */ 36 */
38 37
… …
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 }
… …
94} 93}
95 94
96static bool 95static bool
97can_split (object *pl, object *&op, sint32 nrof) 96can_split (object *pl, object *&op, sint32 nrof)
98{ 97{
99 if (object *tmp = op->split (nrof)) 98 if (object *tmp = op->split (nrof ? nrof : op->number_of ()))
100 { 99 {
101 op = tmp; 100 op = tmp;
102 return true; 101 return true;
103 } 102 }
104 else 103 else
105 { 104 {
105 if (op->nrof > 1)
106 new_draw_info_format (NDI_UNIQUE, 0, pl, "There are only %d %ss.", op->number_of (), &op->name); 106 new_draw_info_format (NDI_UNIQUE, 0, pl, "There are only %d %s.", op->nrof, &op->name_pl);
107 else
108 new_draw_info_format (NDI_UNIQUE, 0, pl, "There is only one %s.", &op->name);
109
107 return false; 110 return false;
108 } 111 }
109} 112}
110 113
111int 114int
… …
129 { 132 {
130 new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>"); 133 new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>");
131 return 0; 134 return 0;
132 } 135 }
133 136
134 skill = find_skill_by_name (pl, params); 137 skill = find_skill_by_name_fuzzy (pl, params);
135 138
136 if (!skill) 139 if (!skill)
137 { 140 {
138 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);
139 return 0; 142 return 0;
140 } 143 }
141 144
142 pl->change_skill (0); 145 pl->apply (skill);
143 apply_special (pl, skill, AP_APPLY);
144 return 1; 146 return 1;
145}
146
147/* These functions (command_search, command_disarm) are really just wrappers for
148 * things like 'use_skill ...'). In fact, they should really be obsoleted
149 * and replaced with those.
150 */
151int
152command_search (object *op, char *params)
153{
154 return use_skill (op, skill_names[SK_FIND_TRAPS]);
155}
156
157int
158command_disarm (object *op, char *params)
159{
160 return use_skill (op, skill_names[SK_DISARM_TRAPS]);
161} 147}
162 148
163/* 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
164 * as it includes the object to throw. 150 * as it includes the object to throw.
165 */ 151 */
166int 152int
167command_throw (object *op, char *params) 153command_throw (object *op, char *params)
168{ 154{
169 if (object *skop = find_skill_by_name (op, skill_names[SK_THROWING])) 155 if (object *skop = find_skill_by_name (op, shstr_throwing))
170 return do_skill (op, op, skop, op->facing, params); 156 return do_skill (op, op, skop, op->facing, params);
171 else 157 else
172 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.");
173 159
174 return 0; 160 return 0;
175} 161}
176 162
177int 163int
… …
203 189
204 while (*params == ' ') 190 while (*params == ' ')
205 params++; 191 params++;
206 192
207 if (object *inv = find_best_apply_object_match (op, params, aflag)) 193 if (object *inv = find_best_apply_object_match (op, params, aflag))
208 player_apply (op, inv, aflag, 0); 194 op->apply (inv, aflag);
209 else 195 else
210 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);
211 } 197 }
212 198
213 return 0; 199 return 0;
214} 200}
215 201
… …
223 * not need to use split_ob and stuff. 209 * not need to use split_ob and stuff.
224 */ 210 */
225int 211int
226sack_can_hold (object *pl, object *sack, object *op, uint32 nrof) 212sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)
227{ 213{
228 if (!QUERY_FLAG (sack, FLAG_APPLIED)) 214 if (!sack->flag [FLAG_APPLIED])
229 { 215 {
230 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));
231 return 0; 217 return 0;
232 } 218 }
233 219
… …
237 return 0; 223 return 0;
238 } 224 }
239 225
240 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)))
241 { 227 {
242 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));
243 return 0; 229 return 0;
244 } 230 }
245 231
246 if (op->type == SPECIAL_KEY && sack->slaying && op->slaying) 232 if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)
247 { 233 {
248 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));
249 return 0; 235 return 0;
250 } 236 }
251 237
252 if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) * 238 if (sack->weight_limit
239 && weight_t (sack->carrying
240 + sack->number_of ()
253 (op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0)) 241 * (op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))
254 * (100 - sack->stats.Str) / 100) > sack->weight_limit) 242 * (100 - sack->stats.Str) / 100)
243 > sack->weight_limit)
255 { 244 {
256 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));
257 return 0; 246 return 0;
258 } 247 }
259 248
… …
262} 251}
263 252
264/* Pick up commands follow */ 253/* Pick up commands follow */
265 254
266/* pl = player (not always - monsters can use this now) 255/* pl = player (not always - monsters can use this now)
267 * op is the object to put tmp into, 256 * op is the object to put tmp into,
268 * 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
269 * pick up (0 means all of them) 258 * pick up (0 means all of them)
270 */ 259 */
271static void 260static void
272pick_up_object (object *pl, object *op, object *tmp, int nrof) 261pick_up_object (object *pl, object *op, object *tmp, int nrof)
273{ 262{
274 object *env = tmp->env;
275 uint32 weight, effective_weight_limit; 263 weight_t weight, effective_weight_limit;
276 int tmp_nrof = tmp->number_of (); 264 int tmp_nrof = tmp->number_of ();
277 265
278 /* 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
279 * 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
280 * (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
281 * containers not allowed as of now) 269 * containers not allowed as of now)
282 */ 270 */
283 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)
284 { 272 {
285 new_draw_info (NDI_UNIQUE, 0, pl, "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, "
275 "or waiting till the levitation effect wears off.>");
286 return; 276 return;
287 } 277 }
288 278
289 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 279 if (tmp->flag [FLAG_NO_DROP])
290 return; 280 return;
291 281
292 if (nrof > tmp_nrof || nrof == 0) 282 if (nrof > tmp_nrof || nrof <= 0)
293 nrof = tmp_nrof; 283 nrof = tmp_nrof;
294 284
295 /* Figure out how much weight this object will add to the player */ 285 /* Figure out how much weight this object will add to the player */
296 weight = tmp->weight * nrof; 286 weight = tmp->weight * nrof;
297 if (tmp->inv) 287 if (tmp->inv)
… …
306 } 296 }
307 297
308 if (!can_split (pl, tmp, nrof)) 298 if (!can_split (pl, tmp, nrof))
309 return; 299 return;
310 300
311 if (QUERY_FLAG (tmp, FLAG_UNPAID)) 301 if (tmp->flag [FLAG_UNPAID])
302 {
303 tmp->flag.reset (FLAG_UNPAID);
312 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);
306 }
313 else 307 else
314 new_draw_info_format (NDI_UNIQUE, 0, pl, "You pick up the %s.", query_name (tmp)); 308 new_draw_info_format (NDI_UNIQUE, 0, pl, "You pick up the %s.", query_name (tmp));
315 309
316 tmp = insert_ob_in_ob (tmp, op); 310 op->insert (tmp);
317
318 /* All the stuff below deals with client/server code, and is only
319 * usable by players
320 */
321 if (pl->contr)
322 {
323 esrv_send_item (pl, tmp);
324
325 /* These are needed to update the weight for the container we
326 * are putting the object in.
327 */
328 if (op != pl)
329 {
330 esrv_update_item (UPD_WEIGHT, pl, op);
331 esrv_send_item (pl, pl);
332 }
333
334 /* Update the container the object was in */
335 if (env && env != pl && env != op)
336 esrv_update_item (UPD_WEIGHT, pl, env);
337 }
338} 311}
339 312
340/* modified slightly to allow monsters use this -b.t. 5-31-95 */ 313/* modified slightly to allow monsters use this -b.t. 5-31-95 */
341void 314void
342pick_up (object *op, object *alt) 315pick_up (object *op, object *alt)
… …
388 count = tmp->nrof; 361 count = tmp->nrof;
389 362
390 /* container is open, so use it */ 363 /* container is open, so use it */
391 if (tmp->flag [FLAG_STARTEQUIP]) 364 if (tmp->flag [FLAG_STARTEQUIP])
392 alt = op; 365 alt = op;
393 else if (op->container) 366 else if ((alt = op->container_ ()))
394 { 367 {
395 alt = op->container;
396 if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count)) 368 if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))
397 goto leave; 369 goto leave;
398 } 370 }
399 else 371 else
400 { /* non container pickup */ 372 { /* non container pickup */
401 for (alt = op->inv; alt; alt = alt->below) 373 for (alt = op->inv; alt; alt = alt->below)
402 if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && 374 if (alt->type == CONTAINER && alt->flag [FLAG_APPLIED] &&
403 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))
404 break; /* perfect match */ 376 break; /* perfect match */
405 377
406 if (!alt) 378 if (!alt)
407 for (alt = op->inv; alt; alt = alt->below) 379 for (alt = op->inv; alt; alt = alt->below)
408 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))
409 break; /* General container comes next */ 381 break; /* General container comes next */
410 382
411 if (!alt) 383 if (!alt)
412 alt = op; /* No free containers */ 384 alt = op; /* No free containers */
413 } 385 }
… …
423#ifdef PICKUP_DEBUG 395#ifdef PICKUP_DEBUG
424 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);
425#endif 397#endif
426 398
427 /* startequip items are not allowed to be put into containers: */ 399 /* startequip items are not allowed to be put into containers: */
428 if (op->type == PLAYER && alt->type == CONTAINER && QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 400 if (op->type == PLAYER && alt->type == CONTAINER && tmp->flag [FLAG_STARTEQUIP])
429 { 401 {
430 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!");
431 goto leave; 403 goto leave;
432 } 404 }
433 405
… …
454int 426int
455command_take (object *op, char *params) 427command_take (object *op, char *params)
456{ 428{
457 object *tmp, *next; 429 object *tmp, *next;
458 430
459 if (op->container) 431 if (op->container_ ())
460 tmp = op->container->inv; 432 tmp = op->container_ ()->inv;
461 else 433 else
462 { 434 {
463 tmp = op->above; 435 tmp = op->above;
464 if (tmp) 436 if (tmp)
465 while (tmp->above) 437 while (tmp->above)
… …
477 449
478 /* Makes processing easier */ 450 /* Makes processing easier */
479 if (params && *params == '\0') 451 if (params && *params == '\0')
480 params = 0; 452 params = 0;
481 453
482 int cnt = MAX_ITEM_PER_DROP; 454 int cnt = MAX_ITEM_PER_ACTION;
483 455
484 while (tmp) 456 while (tmp)
485 { 457 {
486 next = tmp->below; 458 next = tmp->below;
487 459
… …
495 * but that probably will make it more difficult to read, and 467 * but that probably will make it more difficult to read, and
496 * not make it any more efficient 468 * not make it any more efficient
497 */ 469 */
498 if (params && item_matched_string (op, tmp, params)) 470 if (params && item_matched_string (op, tmp, params))
499 { 471 {
472 if (--cnt < 0) break;
500 pick_up (op, tmp); 473 pick_up (op, tmp);
501 if (--cnt <= 0) break;
502 } 474 }
503 else if (can_pick (op, tmp) && !params) 475 else if (can_pick (op, tmp) && !params)
504 { 476 {
477 if (--cnt < 0) break;
505 pick_up (op, tmp); 478 pick_up (op, tmp);
506 break; 479 break;
507 } 480 }
508 481
509 tmp = next; 482 tmp = next;
510 } 483 }
511 484
512 if (cnt <= 0) 485 if (cnt < 0)
513 { 486 {
514 op->failmsg ("Couldn't pick up so many items at once."); 487 op->failmsg ("Couldn't pick up so many items at once.");
515 return 0; 488 return 0;
516 } 489 }
517 490
… …
530 503
531 return 0; 504 return 0;
532} 505}
533 506
534/* 507/*
535 * This function was part of drop, now is own function. 508 * This function was part of drop, now is own function.
536 * Player 'op' tries to put object 'tmp' into sack 'sack', 509 * Player 'op' tries to put object 'tmp' into sack 'sack',
537 * 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 *
538 * Note that the 'sack' in question can now be a transport, 512 * Note that the 'sack' in question can now be a transport,
539 * so this function isn't named very good anymore. 513 * so this function isn't named very good anymore.
540 */ 514 */
541void 515void
542put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof) 516put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof)
543{ 517{
544 object *tmp2, *sack2; 518 object *tmp2;
545 char buf[MAX_BUF]; 519 char buf[MAX_BUF];
546 520
547 if (sack == tmp) 521 if (sack == tmp)
548 return; /* Can't put an object in itself */ 522 return; /* Can't put an object in itself */
549 523
550 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 524 if (tmp->flag [FLAG_STARTEQUIP] || tmp->flag [FLAG_NO_DROP])
551 { 525 {
552 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));
553 return; 527 return;
554 } 528 }
555 529
… …
557 { 531 {
558 /* 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
559 * we instead move the contents of that container into the active 533 * we instead move the contents of that container into the active
560 * 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.
561 */ 535 */
562 sack2 = tmp;
563 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));
564 537
565 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp) 538 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
566 { 539 {
567 tmp = tmp2->below; 540 tmp = tmp2->below;
568 541
569 if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof))) 542 if ((sack->type == CONTAINER && sack_can_hold (op, op->container_ (), tmp2, tmp2->nrof)))
570 {
571 put_object_in_sack (op, sack, tmp2, 0); 543 put_object_in_sack (op, sack, tmp2, 0);
572 }
573 else 544 else
574 { 545 {
575 sprintf (buf, "Your %s fills up.", query_name (sack)); 546 sprintf (buf, "Your %s fills up.", query_name (sack));
576 new_draw_info (NDI_UNIQUE, 0, op, buf); 547 new_draw_info (NDI_UNIQUE, 0, op, buf);
577 break; 548 break;
578 } 549 }
579 } 550 }
580 551
581 esrv_update_item (UPD_WEIGHT, op, sack2);
582 return; 552 return;
583 } 553 }
584 554
585 /* Don't worry about this for containers - our caller should have 555 /* Don't worry about this for containers - our caller should have
586 * already checked this. 556 * already checked this.
587 */ 557 */
588 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)))
589 return; 559 return;
590 560
591 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 561 if (tmp->flag [FLAG_APPLIED])
592 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE)) 562 if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
593 return; 563 return;
594 564
595 /* 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 */
596 if (nrof && tmp->nrof != nrof)
597 {
598 if (!can_split (op, tmp, nrof)) 566 if (!can_split (op, tmp, nrof))
599 return; 567 return;
600 }
601 else
602 tmp->remove ();
603 568
604 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));
605 tmp2 = insert_ob_in_ob (tmp, sack); 570 sack->insert (tmp);
571}
606 572
607 // elmex: 2007-11-26: removed update_stats and replaced 573/* In contrast to drop_object (op, tmp, nrof) above this function takes the
608 // it by update_after_inventory_change () in the caller 574 * already split off object, and feeds it to the event handlers and does
609 // of this function 575 * other magic with it.
576 *
577 * <droppper> is the object that dropped this object and <obj> is the
578 * object that was dropped.
579 *
580 * Make sure to check what happened with <obj> after this function returns!
581 * Otherwise you may leak this object.
582 */
583void
584drop_object (object *dropper, object *obj)
585{
586 if (INVOKE_OBJECT (DROP, obj, ARG_OBJECT (dropper)))
587 return;
588
589 if (obj->destroyed () || obj->is_inserted ())
590 return;
610 591
611 /* If an object merged (and thus, different object), we need to 592 if (obj->flag [FLAG_STARTEQUIP])
612 * delete the original. 593 {
594 dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
595 dropper->statusmsg ("The god who lent it to you retrieves it.");
596
597 obj->destroy ();
598 dropper->update_stats ();
599 return;
600 }
601
602 for (object *floor = GET_MAP_OB (dropper->map, dropper->x, dropper->y);
603 floor;
604 floor = floor->above)
605 if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (obj), ARG_OBJECT (dropper)))
606 return;
607
608 if (obj->destroyed () || obj->is_inserted ())
609 return;
610
611 if (dropper->is_in_shop () && !obj->flag [FLAG_UNPAID] && obj->type != MONEY)
612 if (!sell_item (obj, dropper))
613 return;
614
615 if (!obj->can_drop_at (dropper->map, dropper->x, dropper->y, dropper))
616 return;
617
618 /* If nothing special happened with this object, the default action is to
619 * insert it below the dropper:
613 */ 620 */
614 if (tmp2 != tmp)
615 esrv_del_item (op->contr, tmp->count);
616 621
617 esrv_send_item (op, tmp2); 622 obj->x = dropper->x;
623 obj->y = dropper->y;
618 624
619 /* update the sacks weight */ 625 insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
620 esrv_update_item (UPD_WEIGHT, op, sack);
621} 626}
622 627
623/* 628/*
624 * This function was part of drop, now is own function. 629 * This function was part of drop, now is own function.
625 * Player 'op' tries to drop object 'tmp', if tmp is non zero, then 630 * Player 'op' tries to drop object 'tmp', if tmp is non zero, then
626 * nrof objects is tried to dropped. 631 * nrof objects are tried to drop.
627 * This is used when dropping objects onto the floor. 632 * This is used when dropping objects onto the floor.
628 */ 633 */
629void 634void
630drop_object (object *op, object *tmp, uint32 nrof) 635drop_object (object *op, object *tmp, uint32 nrof)
631{ 636{
632 object *floor; 637 if (tmp->flag [FLAG_NO_DROP])
633
634 if (QUERY_FLAG (tmp, FLAG_NO_DROP))
635 return; 638 return;
636 639
637 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 640 if (tmp->flag [FLAG_APPLIED])
638 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE)) 641 if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
639 return; /* can't unapply it */ 642 return; /* can't unapply it */
640
641 //fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
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 */
646 if (nrof && tmp->nrof != nrof)
647 {
648 if (!can_split (op, tmp, nrof)) 647 if (!can_split (op, tmp, nrof))
649 return;
650 }
651 else
652 tmp->remove ();
653
654 if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))
655 return; 648 return;
656 649
657 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 650 drop_object (op, tmp);
658 {
659 op->statusmsg (format ("You drop the %s.", query_name (tmp)));
660 op->statusmsg ("The gods who lent it to you retrieves it.");
661 651
662 if (op->type == PLAYER) 652 if (!tmp->destroyed () && !tmp->is_inserted ())
663 esrv_del_item (op->contr, tmp->count);
664
665 tmp->destroy ();
666 op->update_stats ();
667 return;
668 } 653 {
669 654 // if nothing happened with the object we give it back
670 if (op->type == PLAYER) 655 op->insert (tmp);
671 esrv_del_item (op->contr, tmp->count);
672
673 /* Call this before we update the various windows/players. At least
674 * that we, we know the weight is correct.
675 */
676 // 2007-11-26: moved op->update_stats away and calling it later after
677 // all items of a drop command have been processed.
678
679 for (floor = GET_MAP_OB (op->map, op->x, op->y); floor; floor = floor->above)
680 if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
681 return;
682
683 if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
684 sell_item (tmp, op);
685
686 tmp->x = op->x;
687 tmp->y = op->y;
688
689 insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
690}
691
692void update_after_inventory_change (object *op)
693{
694 /* Call this before we update the various windows/players. At least
695 * that we, we know the weight is correct.
696 */
697 op->update_stats ();
698
699 // elmex: kept this for now, i have no idea what happens when i remove it:
700 if (op->type == PLAYER)
701 {
702 /* Need to update the weight for the player */
703 esrv_send_item (op, op);
704 op->contr->ns->floorbox_update ();
705 } 656 }
706} 657}
707 658
708void 659void
709drop (object *op, object *tmp) 660drop (object *op, object *tmp)
… …
719 if (tmp->env && tmp->env->type != PLAYER) 670 if (tmp->env && tmp->env->type != PLAYER)
720 { 671 {
721 /* Just toss the object - probably shouldn't be hanging 672 /* Just toss the object - probably shouldn't be hanging
722 * around anyways 673 * around anyways
723 */ 674 */
724 tmp->remove ();
725 tmp->destroy (); 675 tmp->destroy ();
726 return; 676 return;
727 } 677 }
728 else 678 else
729 {
730 while (tmp != NULL && tmp->invisible) 679 while (tmp && tmp->invisible)
731 tmp = tmp->below; 680 tmp = tmp->below;
732 }
733 } 681 }
734 682
735 if (tmp == NULL) 683 if (!tmp)
736 { 684 {
737 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.");
738 return; 686 return;
739 } 687 }
740 if (QUERY_FLAG (tmp, FLAG_INV_LOCKED)) 688
689 if (tmp->flag [FLAG_INV_LOCKED])
741 { 690 {
742 new_draw_info (NDI_UNIQUE, 0, op, "This item is locked"); 691 new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
743 return; 692 return;
744 } 693 }
745 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 694
695 if (tmp->flag [FLAG_NO_DROP])
746 { 696 {
747#if 0 697#if 0
748 /* 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. */
749 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.");
750#endif 700#endif
… …
752 } 702 }
753 703
754 if (op->type == PLAYER && op->contr->last_used == tmp) 704 if (op->type == PLAYER && op->contr->last_used == tmp)
755 op->contr->last_used = tmp->below ? tmp->below 705 op->contr->last_used = tmp->below ? tmp->below
756 : tmp->above ? tmp->above 706 : tmp->above ? tmp->above
757 : 0; 707 : (object *)0;
758 708
759 if (op->container) 709 if (op->container_ ())
760 { 710 {
761 if (op->type == PLAYER) 711 if (op->type == PLAYER)
762 put_object_in_sack (op, op->container, tmp, op->contr->count); 712 put_object_in_sack (op, op->container_ (), tmp, op->contr->count);
763 else 713 else
764 put_object_in_sack (op, op->container, tmp, 0); 714 put_object_in_sack (op, op->container_ (), tmp, 0);
765 } 715 }
766 else 716 else
767 { 717 {
768 if (op->type == PLAYER) 718 if (op->type == PLAYER)
769 drop_object (op, tmp, op->contr->count); 719 drop_object (op, tmp, op->contr->count);
… …
773 723
774 if (op->type == PLAYER) 724 if (op->type == PLAYER)
775 op->contr->count = 0; 725 op->contr->count = 0;
776} 726}
777 727
778
779
780/* Command will drop all items that have not been locked */ 728/* Command will drop all items that have not been locked */
781int 729int
782command_dropall (object *op, char *params) 730command_dropall (object *op, char *params)
783{ 731{
784 732
785 object *curinv, *nextinv;
786
787 if (op->inv == NULL) 733 if (op->inv == NULL)
788 { 734 {
789 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!"); 735 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
790 return 0; 736 return 0;
791 } 737 }
792 738
793 curinv = op->inv; 739 object *curinv = op->inv;
740 object *nextinv;
794 741
795 /* 742 /*
796 This is the default. Drops everything not locked or considered 743 This is the default. Drops everything not locked or considered
797 not something that should be dropped. 744 not something that should be dropped.
798 */ 745 */
799 /* 746 /*
800 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
801 the drop() routine will do unknown things to it when dropping 748 the drop() routine will do unknown things to it when dropping
802 in a shop. --Tero.Pelander@utu.fi 749 in a shop. --Tero.Pelander@utu.fi
803 */ 750 */
804
805 int cnt = MAX_ITEM_PER_DROP; 751 int cnt = MAX_ITEM_PER_ACTION;
806 752
807 if (params == NULL) 753 if (!params)
808 { 754 {
809 while (curinv != NULL) 755 while (curinv)
810 { 756 {
811 nextinv = curinv->below; 757 nextinv = curinv->below;
758
812 while (nextinv && nextinv->type == MONEY) 759 while (nextinv && nextinv->type == MONEY)
813 nextinv = nextinv->below; 760 nextinv = nextinv->below;
814 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY && 761
815 curinv->type != FOOD && curinv->type != KEY && 762 if (!curinv->flag [FLAG_INV_LOCKED]
816 curinv->type != SPECIAL_KEY && curinv->type != GEM && 763 && !curinv->invisible
817 !curinv->invisible && (curinv->type != CONTAINER || op->container != curinv)) 764 && curinv->type != MONEY
765 && curinv->type != FOOD
766 && curinv->type != KEY
767 && curinv->type != SPECIAL_KEY
768 && curinv->type != GEM
769 && curinv->type != CONTAINER)
818 { 770 {
819 drop (op, curinv); 771 drop (op, curinv);
820 if (--cnt <= 0) break; 772 if (--cnt <= 0) break;
821 } 773 }
774
822 curinv = nextinv; 775 curinv = nextinv;
823 } 776 }
824 } 777 }
825
826 else if (strcmp (params, "weapons") == 0) 778 else if (strcmp (params, "weapons") == 0)
827 { 779 {
828 while (curinv != NULL) 780 while (curinv)
829 { 781 {
830 nextinv = curinv->below; 782 nextinv = curinv->below;
783
831 while (nextinv && nextinv->type == MONEY) 784 while (nextinv && nextinv->type == MONEY)
832 nextinv = nextinv->below; 785 nextinv = nextinv->below;
786
833 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)))
834 { 788 {
835 drop (op, curinv); 789 drop (op, curinv);
836 if (--cnt <= 0) break; 790 if (--cnt <= 0) break;
837 } 791 }
792
838 curinv = nextinv; 793 curinv = nextinv;
839 } 794 }
840 } 795 }
841
842 else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0) 796 else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)
843 { 797 {
844 while (curinv != NULL) 798 while (curinv)
845 { 799 {
846 nextinv = curinv->below; 800 nextinv = curinv->below;
801
847 while (nextinv && nextinv->type == MONEY) 802 while (nextinv && nextinv->type == MONEY)
848 nextinv = nextinv->below; 803 nextinv = nextinv->below;
804
849 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))
850 { 806 {
851 drop (op, curinv); 807 drop (op, curinv);
852 if (--cnt <= 0) break; 808 if (--cnt <= 0) break;
853 } 809 }
810
854 curinv = nextinv; 811 curinv = nextinv;
855 } 812 }
856 } 813 }
857
858 else if (strcmp (params, "misc") == 0) 814 else if (strcmp (params, "misc") == 0)
859 { 815 {
860 while (curinv != NULL) 816 while (curinv)
861 { 817 {
862 nextinv = curinv->below; 818 nextinv = curinv->below;
819
863 while (nextinv && nextinv->type == MONEY) 820 while (nextinv && nextinv->type == MONEY)
864 nextinv = nextinv->below; 821 nextinv = nextinv->below;
865 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED)) 822
823 if (!curinv->flag [FLAG_INV_LOCKED] && !curinv->flag [FLAG_APPLIED])
866 { 824 {
867 switch (curinv->type) 825 switch (curinv->type)
868 { 826 {
869 case HORN: 827 case HORN:
870 case BOOK: 828 case BOOK:
… …
887 break; 845 break;
888 default: 846 default:
889 curinv = nextinv; 847 curinv = nextinv;
890 break; 848 break;
891 } 849 }
850
892 if (--cnt <= 0) break; 851 if (--cnt <= 0) break;
893 } 852 }
853
894 curinv = nextinv; 854 curinv = nextinv;
895 } 855 }
896 } 856 }
897 857
898 if (cnt <= 0) 858 if (cnt <= 0)
899 op->failmsg ("Only dropped some items, can't drop that many items at once."); 859 op->failmsg ("Only dropped some items, can't drop that many items at once.");
900 860
901 update_after_inventory_change (op);
902
903/* draw_look(op);*/ 861/* draw_look(op);*/
904 return 0; 862 return 0;
905} 863}
906 864
865
866/* This function tries to drop all objects in the <objs> vector.
867 * <dropper> is the object that wants to drop them.
868 * <cnt> can be a 0 pointer or a pointer to the maximum number of
869 * drop operations to perform.
870 *
871 * Returns true if at least one item was dropped.
872 */
873static bool
874drop_vector (object *dropper, vector<object *> &objs, int *cnt)
875{
876 vector<object *>::iterator i;
877
878 bool did_one = false;
879
880 for (i = objs.begin (); i != objs.end (); i++)
881 {
882 drop (dropper, *i);
883 if (cnt && --*cnt <= 0) break;
884 did_one = true;
885 }
886
887 return did_one;
888}
889
907/* Object op wants to drop object(s) params. params can be a 890/* Object op wants to drop object(s) params. params can be a
908 * comma seperated list. 891 * comma seperated list.
909 */ 892 */
910
911int 893int
912command_drop (object *op, char *params) 894command_drop (object *op, char *params)
913{ 895{
914 object *tmp, *next; 896 object *tmp, *next;
915 int did_one = 0;
916 897
917 if (!params) 898 if (!params)
918 { 899 {
919 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?"); 900 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
920 return 0; 901 return 0;
921 } 902 }
922 else 903 else
923 { 904 {
924 int cnt = MAX_ITEM_PER_DROP; 905 vector<object *> matched_objs;
925 906
926 for (tmp = op->inv; tmp; tmp = next) 907 for (tmp = op->inv; tmp; tmp = next)
927 { 908 {
928 next = tmp->below; 909 next = tmp->below;
929 if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible) 910 if (tmp->flag [FLAG_NO_DROP] || tmp->invisible)
930 continue; 911 continue;
931 912
932 if (item_matched_string (op, tmp, params)) 913 if (item_matched_string (op, tmp, params))
933 { 914 matched_objs.push_back (tmp);
934 drop (op, tmp);
935 if (--cnt <= 0) break;
936 did_one = 1;
937 } 915 }
938 }
939 916
940 if (!did_one) 917 int cnt = MAX_ITEM_PER_ACTION;
918
919 if (!drop_vector (op, matched_objs, &cnt))
941 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop."); 920 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
942 921
943 if (cnt <= 0) 922 if (cnt <= 0)
944 op->failmsg ("Only dropped some items, can't drop that many items at once."); 923 op->failmsg ("Only dropped some items, can't drop that many items at once.");
945
946 update_after_inventory_change (op);
947 } 924 }
948 925
949 return 0; 926 return 0;
950} 927}
951 928
… …
973 } 950 }
974 951
975 return 0; 952 return 0;
976} 953}
977 954
978/* op should be a player.
979 * we return the object the player has marked with the 'mark' command
980 * below. If no match is found (or object has changed), we return
981 * NULL. We leave it up to the calling function to print messages if
982 * nothing is found.
983 */
984object *
985find_marked_object (object *op)
986{
987 object *tmp;
988
989 if (!op || !op->contr)
990 return NULL;
991
992 if (!op->contr->mark)
993 {
994/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
995 return 0;
996 }
997
998 /* This may seem like overkill, but we need to make sure that they
999 * player hasn't dropped the item. We use count on the off chance that
1000 * an item got reincarnated at some point.
1001 */
1002 for (tmp = op->inv; tmp; tmp = tmp->below)
1003 {
1004 if (tmp->invisible)
1005 continue;
1006
1007 if (tmp == op->contr->mark)
1008 {
1009 if (!tmp->destroyed ())
1010 return tmp;
1011 else
1012 {
1013 op->contr->mark = 0;
1014/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
1015 return 0;
1016 }
1017 }
1018 }
1019
1020 return 0;
1021}
1022
1023std::string 955std::string
1024object::describe_monster (object *who) 956object::describe_monster (object *who)
1025{ 957{
1026 dynbuf_text buf (512, 512); 958 dynbuf_text buf (512, 512);
1027 959
1028 object *mon = head ? head : this; 960 object *mon = head ? head : this;
1029 961
1030 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 962 if (mon->flag [FLAG_UNDEAD])
1031 buf << "It is an undead force.\n"; 963 buf << "It is an undead force.\r";
1032 964
1033 if (mon->level > who->level) 965 if (mon->level > who->level)
1034 buf << "It is likely more powerful than you.\n"; 966 buf << "It is likely more powerful than you.\r";
1035 else if (mon->level < who->level) 967 else if (mon->level < who->level)
1036 buf << "It is likely less powerful than you.\n"; 968 buf << "It is likely less powerful than you.\r";
1037 else 969 else
1038 buf << "It is probably as powerful as you.\n"; 970 buf << "It is probably as powerful as you.\r";
1039 971
1040 if (mon->attacktype & AT_ACID) 972 if (mon->attacktype & AT_ACID)
1041 buf << "You seem to smell an acrid odor.\n"; 973 buf << "You seem to smell an acrid odor.\r";
1042 974
1043 /* Anyone know why this used to use the clone value instead of the 975 /* Anyone know why this used to use the clone value instead of the
1044 * maxhp field? This seems that it should give more accurate results. 976 * maxhp field? This seems that it should give more accurate results.
1045 */ 977 */
1046 switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1)) 978 switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1047 { /* From 1-4 */ 979 { /* From 1-4 */
1048 case 1: 980 case 1:
1049 buf << "It is in a bad shape.\n"; 981 buf << "It is in a bad shape.\r";
1050 break; 982 break;
1051 case 2: 983 case 2:
1052 buf << "It is hurt.\n"; 984 buf << "It is hurt.\r";
1053 break; 985 break;
1054 case 3: 986 case 3:
1055 buf << "It is somewhat hurt.\n"; 987 buf << "It is somewhat hurt.\r";
1056 break; 988 break;
1057 case 4: 989 case 4:
1058 buf << "It is in excellent shape.\n"; 990 buf << "It is in excellent shape.\r";
1059 break; 991 break;
1060 } 992 }
1061 993
1062 if (present_in_ob (POISONING, mon)) 994 if (present_in_ob (POISONING, mon))
1063 buf << "It looks very ill.\n"; 995 buf << "It looks very ill.\r";
996
997 buf << '\n';
1064 998
1065 return buf; 999 return buf;
1066} 1000}
1067 1001
1068/* tmp is the object being described, pl is who is examing it. */ 1002/* tmp is the object being described, pl is who is examing it. */
… …
1075} 1009}
1076 1010
1077std::string 1011std::string
1078object::long_desc (object *who) 1012object::long_desc (object *who)
1079{ 1013{
1080 std::string buf (query_name (this)); 1014 std::string buf (query_name ());
1081 1015
1082 switch (type) 1016 switch (type)
1083 { 1017 {
1084 case RING: 1018 case RING:
1085 case SKILL: 1019 case SKILL:
… …
1090 case SHIELD: 1024 case SHIELD:
1091 case BOOTS: 1025 case BOOTS:
1092 case GLOVES: 1026 case GLOVES:
1093 case AMULET: 1027 case AMULET:
1094 case GIRDLE: 1028 case GIRDLE:
1029 case RANGED:
1095 case BOW: 1030 case BOW:
1096 case ARROW: 1031 case ARROW:
1097 case CLOAK: 1032 case CLOAK:
1098 case FOOD: 1033 case FOOD:
1099 case DRINK: 1034 case DRINK:
1100 case FLESH: 1035 case FLESH:
1101 case SKILL_TOOL: 1036 case SKILL_TOOL:
1037 case LAMP:
1102 case POWER_CRYSTAL: 1038 case POWER_CRYSTAL:
1103 { 1039 {
1104 const char *cp = ::describe_item (this, who); 1040 const char *cp = ::describe_item (this, who);
1105 1041
1106 if (*cp) 1042 if (*cp)
… …
1121examine_monster (object *op, object *tmp) 1057examine_monster (object *op, object *tmp)
1122{ 1058{
1123 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 ());
1124} 1060}
1125 1061
1126std::string
1127object::describe (object *who)
1128{
1129 dynbuf_text buf (1024, 1024);
1130
1131 buf.printf ("That is: %s.\n", long_desc (who).c_str ());
1132
1133 if (custom_name)
1134 buf.printf ("You call it %s\n", &custom_name);
1135
1136 switch (type)
1137 {
1138 case SPELLBOOK:
1139 if (flag [FLAG_IDENTIFIED] && inv)
1140 buf.printf ("%s is a %s %s spell\n", &inv->name, get_levelnumber (inv->level), &inv->skill);
1141 break;
1142
1143 case BOOK:
1144 if (msg)
1145 buf << "Something is written in it.\n";
1146 break;
1147
1148 case CONTAINER:
1149 if (race != NULL)
1150 {
1151 if (weight_limit && stats.Str < 100)
1152 buf.printf ("It can hold only %s and its weight limit is %.1f kg.\n",
1153 &race, weight_limit / (10.0 * (100 - stats.Str)));
1154 else
1155 buf.printf ("It can hold only %s.\n", &race);
1156 }
1157 else if (weight_limit && stats.Str < 100)
1158 buf.printf ("Its weight limit is %.1f kg.\n", weight_limit / (10.0 * (100 - stats.Str)));
1159 break;
1160
1161 case WAND:
1162 if (flag [FLAG_IDENTIFIED])
1163 buf.printf ("It has %d charges left.\n", stats.food);
1164 break;
1165 }
1166
1167 if (materialname && !msg)
1168 buf.printf ("It is made of: %s.\n", &materialname);
1169
1170 if (who)
1171 /* Where to wear this item */
1172 for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1173 if (slot[i].info)
1174 {
1175 buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
1176
1177 if (slot[i].info < -1 && who->slot[i].info)
1178 buf.printf ("(%d)", -slot[i].info);
1179
1180 buf << ".\n";
1181 }
1182
1183 if (weight)
1184 buf.printf (nrof > 1 ? "They weigh %3.3f kg.\n" : "It weighs %3.3f kg.\n", weight * (nrof ? nrof : 1) / 1000.0);
1185
1186 if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
1187 {
1188 buf.printf ("You reckon %s worth %s.\n", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
1189
1190 if (is_in_shop (who))
1191 {
1192 if (flag [FLAG_UNPAID])
1193 buf.printf ("%s would cost you %s.\n", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1194 else
1195 buf.printf ("You are offered %s for %s.\n", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1196 }
1197 }
1198
1199 if (flag [FLAG_MONSTER])
1200 buf << describe_monster (who);
1201
1202 /* Is this item buildable? */
1203 if (flag [FLAG_IS_BUILDABLE])
1204 buf << "This is a buildable item.\n";
1205
1206 /* Does the object have a message? Don't show message for all object
1207 * types - especially if the first entry is a match
1208 */
1209 if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && *msg != '@')
1210 {
1211 /* This is just a hack so when identifying the items, we print
1212 * out the extra message
1213 */
1214 if (need_identify (this) && flag [FLAG_IDENTIFIED])
1215 buf << "The object has a story:\n";
1216
1217 buf << msg << '\n';
1218 }
1219
1220 buf << '\n';
1221
1222 return std::string (buf.linearise (), buf.size ());
1223}
1224
1225static void 1062static void
1226display_new_pickup (object *op) 1063display_new_pickup (object *op)
1227{ 1064{
1228 int i = op->contr->mode; 1065 int i = op->contr->mode;
1229 1066
1230 if (!(i & PU_NEWMODE))
1231 return;
1232
1233 new_draw_info_format (NDI_UNIQUE, 0, op, "%d NEWMODE", i & PU_NEWMODE ? 1 : 0);
1234 new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0); 1067 new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0);
1235 new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0); 1068 new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0);
1236 new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0); 1069 new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0);
1237 1070
1238 new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5); 1071 new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5);
… …
1289 }; 1122 };
1290 1123
1291 if (!params) 1124 if (!params)
1292 { 1125 {
1293 /* if the new mode is used, just print the settings */ 1126 /* if the new mode is used, just print the settings */
1294 if (op->contr->mode & PU_NEWMODE)
1295 {
1296 display_new_pickup (op); 1127 display_new_pickup (op);
1297 return 1;
1298 }
1299 if (1)
1300 LOG (llevDebug, "command_pickup: !params\n");
1301 set_pickup_mode (op, (op->contr->mode > 6) ? 0 : op->contr->mode + 1);
1302 return 0; 1128 return 0;
1303 } 1129 }
1304 1130
1305 while (*params == ' ' && *params) 1131 while (*params == ' ' && *params)
1306 params++; 1132 params++;
… …
1312 for (mode = 0; names[mode]; mode++) 1138 for (mode = 0; names[mode]; mode++)
1313 { 1139 {
1314 if (!strcmp (names[mode], params + 1)) 1140 if (!strcmp (names[mode], params + 1))
1315 { 1141 {
1316 i = op->contr->mode; 1142 i = op->contr->mode;
1317 if (!(i & PU_NEWMODE)) 1143
1318 i = PU_NEWMODE;
1319 if (*params == '+') 1144 if (*params == '+')
1320 i = i | modes[mode]; 1145 i = i | modes[mode];
1321 else 1146 else
1322 i = i & ~modes[mode]; 1147 i = i & ~modes[mode];
1148
1323 op->contr->mode = i; 1149 op->contr->mode = i;
1324 display_new_pickup (op); 1150 display_new_pickup (op);
1325 return 1; 1151 return 1;
1326 } 1152 }
1327 } 1153 }
… …
1329 return 1; 1155 return 1;
1330 } 1156 }
1331 1157
1332 if (sscanf (params, "%u", &i) != 1) 1158 if (sscanf (params, "%u", &i) != 1)
1333 { 1159 {
1334 if (1)
1335 LOG (llevDebug, "command_pickup: params==NULL\n");
1336 new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <0-7> or <value_density> ."); 1160 new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <value_density> or [+-]type.");
1337 return 1; 1161 return 1;
1338 } 1162 }
1339 set_pickup_mode (op, i); 1163
1164 if (i <= PU_RATIO)
1165 i |= op->contr->mode & ~PU_RATIO;
1166
1167 op->contr->mode = i;
1340 1168
1341 return 1; 1169 return 1;
1342} 1170}
1343 1171
1344void
1345set_pickup_mode (object *op, int i)
1346{
1347 switch (op->contr->mode = i)
1348 {
1349 case 0:
1350 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");
1351 break;
1352 case 1:
1353 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");
1354 break;
1355 case 2:
1356 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");
1357 break;
1358 case 3:
1359 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");
1360 break;
1361 case 4:
1362 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");
1363 break;
1364 case 5:
1365 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");
1366 break;
1367 case 6:
1368 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");
1369 break;
1370 case 7:
1371 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");
1372 break;
1373 }
1374}
1375
1376int 1172int
1377command_search_items (object *op, char *params) 1173command_search_items (object *op, char *params)
1378{ 1174{
1379 char buf[MAX_BUF];
1380
1381 if (settings.search_items == FALSE)
1382 return 1;
1383
1384 if (params == NULL) 1175 if (params == NULL)
1385 { 1176 {
1386 if (op->contr->search_str[0] == '\0') 1177 if (op->contr->search_str[0] == '\0')
1387 { 1178 {
1388 new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1"); 1179 new_draw_info (NDI_UNIQUE, 0, op, "Example: search-items magic+1");
1389 new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all"); 1180 new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");
1390 new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'."); 1181 new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1391 return 1; 1182 return 1;
1392 } 1183 }
1393 1184
1394 op->contr->search_str[0] = '\0'; 1185 op->contr->search_str[0] = '\0';
1395 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off."); 1186 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1396 op->update_stats (); 1187 op->contr->queue_stats_update ();
1397 return 1; 1188 return 1;
1398 } 1189 }
1399 1190
1400 if ((int) strlen (params) >= MAX_BUF) 1191 if (strlen (params) >= sizeof (op->contr->search_str))
1401 { 1192 {
1402 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long."); 1193 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1403 return 1; 1194 return 1;
1404 } 1195 }
1405 1196
1406 strcpy (op->contr->search_str, params); 1197 strcpy (op->contr->search_str, params);
1407 sprintf (buf, "Searching for '%s'.", op->contr->search_str); 1198 new_draw_info (NDI_UNIQUE, 0, op, format ("Now searching for '%s'.", op->contr->search_str));
1408 new_draw_info (NDI_UNIQUE, 0, op, buf); 1199 op->contr->queue_stats_update ();
1409 op->update_stats (); 1200
1410 return 1; 1201 return 1;
1411} 1202}
1412 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