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.63 by root, Mon Dec 17 08:35:49 2007 UTC vs.
Revision 1.119 by root, Sat Apr 10 04:54:09 2010 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 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
… …
91find_best_object_match (object *pl, const char *params) 90find_best_object_match (object *pl, const char *params)
92{ 91{
93 return find_best_apply_object_match (pl, params, AP_TOGGLE); 92 return find_best_apply_object_match (pl, params, AP_TOGGLE);
94} 93}
95 94
95static bool
96can_split (object *pl, object *&op, sint32 nrof)
97{
98 if (object *tmp = op->split (nrof ? nrof : op->number_of ()))
99 {
100 op = tmp;
101 return true;
102 }
103 else
104 {
105 if (op->nrof > 1)
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
110 return false;
111 }
112}
113
96int 114int
97command_uskill (object *pl, char *params) 115command_uskill (object *pl, char *params)
98{ 116{
99 if (!params) 117 if (!params)
100 { 118 {
… …
114 { 132 {
115 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>");
116 return 0; 134 return 0;
117 } 135 }
118 136
119 skill = find_skill_by_name (pl, params); 137 skill = find_skill_by_name_fuzzy (pl, params);
120 138
121 if (!skill) 139 if (!skill)
122 { 140 {
123 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);
124 return 0; 142 return 0;
125 } 143 }
126 144
127 pl->change_skill (0); 145 pl->apply (skill);
128 apply_special (pl, skill, AP_APPLY);
129 return 1; 146 return 1;
130}
131
132/* These functions (command_search, command_disarm) are really just wrappers for
133 * things like 'use_skill ...'). In fact, they should really be obsoleted
134 * and replaced with those.
135 */
136int
137command_search (object *op, char *params)
138{
139 return use_skill (op, skill_names[SK_FIND_TRAPS]);
140}
141
142int
143command_disarm (object *op, char *params)
144{
145 return use_skill (op, skill_names[SK_DISARM_TRAPS]);
146} 147}
147 148
148/* 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
149 * as it includes the object to throw. 150 * as it includes the object to throw.
150 */ 151 */
… …
152command_throw (object *op, char *params) 153command_throw (object *op, char *params)
153{ 154{
154 if (object *skop = find_skill_by_name (op, skill_names[SK_THROWING])) 155 if (object *skop = find_skill_by_name (op, skill_names[SK_THROWING]))
155 return do_skill (op, op, skop, op->facing, params); 156 return do_skill (op, op, skop, op->facing, params);
156 else 157 else
157 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.");
158 159
159 return 0; 160 return 0;
160} 161}
161 162
162int 163int
… …
188 189
189 while (*params == ' ') 190 while (*params == ' ')
190 params++; 191 params++;
191 192
192 if (object *inv = find_best_apply_object_match (op, params, aflag)) 193 if (object *inv = find_best_apply_object_match (op, params, aflag))
193 player_apply (op, inv, aflag, 0); 194 op->apply (inv, aflag);
194 else 195 else
195 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);
196 } 197 }
197 198
198 return 0; 199 return 0;
199} 200}
200 201
… …
208 * not need to use split_ob and stuff. 209 * not need to use split_ob and stuff.
209 */ 210 */
210int 211int
211sack_can_hold (object *pl, object *sack, object *op, uint32 nrof) 212sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)
212{ 213{
213
214 if (!QUERY_FLAG (sack, FLAG_APPLIED)) 214 if (!QUERY_FLAG (sack, 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 if (sack == op) 220 if (sack == op)
220 { 221 {
221 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack)); 222 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));
222 return 0; 223 return 0;
223 } 224 }
225
224 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)))
225 { 227 {
226 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));
227 return 0; 229 return 0;
228 } 230 }
231
229 if (op->type == SPECIAL_KEY && sack->slaying && op->slaying) 232 if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)
230 { 233 {
231 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));
232 return 0; 235 return 0;
233 } 236 }
237
234 if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) * 238 if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) *
235 (op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0)) 239 (op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))
236 * (100 - sack->stats.Str) / 100) > sack->weight_limit) 240 * (100 - sack->stats.Str) / 100) > sack->weight_limit)
237 { 241 {
238 new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack)); 242 new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));
239 return 0; 243 return 0;
240 } 244 }
245
241 /* All other checks pass, must be OK */ 246 /* All other checks pass, must be OK */
242 return 1; 247 return 1;
243} 248}
244 249
245/* Pick up commands follow */ 250/* Pick up commands follow */
… …
250 * pick up (0 means all of them) 255 * pick up (0 means all of them)
251 */ 256 */
252static void 257static void
253pick_up_object (object *pl, object *op, object *tmp, int nrof) 258pick_up_object (object *pl, object *op, object *tmp, int nrof)
254{ 259{
255 /* buf needs to be big (more than 256 chars) because you can get
256 * very long item names.
257 */
258 char buf[HUGE_BUF];
259 object *env = tmp->env; 260 object *env = tmp->env;
260 uint32 weight, effective_weight_limit; 261 uint32 weight, effective_weight_limit;
261 int tmp_nrof = tmp->nrof ? tmp->nrof : 1; 262 int tmp_nrof = tmp->number_of ();
262 263
263 /* IF the player is flying & trying to take the item out of a container 264 /* IF the player is flying & trying to take the item out of a container
264 * that is in his inventory, let him. tmp->env points to the container 265 * that is in his inventory, let him. tmp->env points to the container
265 * (sack, luggage, etc), tmp->env->env then points to the player (nested 266 * (sack, luggage, etc), tmp->env->env then points to the player (nested
266 * containers not allowed as of now) 267 * containers not allowed as of now)
267 */ 268 */
268 if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && tmp->in_player () != pl) 269 if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && tmp->in_player () != pl)
269 { 270 {
270 new_draw_info (NDI_UNIQUE, 0, pl, "You are levitating, you can't reach the ground!"); 271 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, "
273 "or waiting till the levitation effect wears off.>");
271 return; 274 return;
272 } 275 }
273 276
274 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 277 if (QUERY_FLAG (tmp, FLAG_NO_DROP))
275 return; 278 return;
276 279
277 if (nrof > tmp_nrof || nrof == 0) 280 if (nrof > tmp_nrof || nrof <= 0)
278 nrof = tmp_nrof; 281 nrof = tmp_nrof;
279 282
280 /* Figure out how much weight this object will add to the player */ 283 /* Figure out how much weight this object will add to the player */
281 weight = tmp->weight * nrof; 284 weight = tmp->weight * nrof;
282 if (tmp->inv) 285 if (tmp->inv)
283 weight += tmp->carrying * (100 - tmp->stats.Str) / 100; 286 weight += tmp->carrying * (100 - tmp->stats.Str) / 100;
284 287
285 if (pl->stats.Str <= MAX_STAT)
286 effective_weight_limit = weight_limit[pl->stats.Str]; 288 effective_weight_limit = weight_limit [min (MAX_STAT, pl->stats.Str)];
287 else
288 effective_weight_limit = weight_limit[MAX_STAT];
289 289
290 if ((pl->weight + pl->carrying + weight) > effective_weight_limit) 290 if ((pl->weight + pl->carrying + weight) > effective_weight_limit)
291 { 291 {
292 new_draw_info (0, 0, pl, "That item is too heavy for you to pick up."); 292 new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");
293 return; 293 return;
294 } 294 }
295 295
296 if (nrof != tmp_nrof) 296 if (!can_split (pl, tmp, nrof))
297 {
298 object *tmp2 = tmp;
299
300 tmp = get_split_ob (tmp, nrof);
301 if (!tmp)
302 {
303 new_draw_info (NDI_UNIQUE, 0, pl, errmsg);
304 return; 297 return;
305 }
306 298
307 /* Tell the client what happened to the rest of objects */ 299 if (QUERY_FLAG (tmp, FLAG_UNPAID))
308 if (pl->contr) 300 {
309 if (tmp2->destroyed ()) 301 tmp->flag.reset (FLAG_UNPAID);
310 esrv_del_item (pl->contr, tmp2->count); 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));
311 else 303 tmp->flag.set (FLAG_UNPAID);
312 esrv_update_item (UPD_NROF, pl, tmp2);
313 } 304 }
314 else 305 else
315 { 306 new_draw_info_format (NDI_UNIQUE, 0, pl, "You pick up the %s.", query_name (tmp));
316 /* If the object is in a container, send a delete to the client.
317 * - we are moving all the items from the container to elsewhere,
318 * so it needs to be deleted.
319 */
320 if (!QUERY_FLAG (tmp, FLAG_REMOVED))
321 {
322 if (tmp->env && pl->type == PLAYER)
323 esrv_del_item (pl->contr, tmp->count);
324 307
325 tmp->remove (); /* Unlink it */ 308 op->insert (tmp);
326 }
327 }
328
329 if (QUERY_FLAG (tmp, FLAG_UNPAID))
330 sprintf (buf, "%s will cost you %s.", query_name (tmp), query_cost_string (tmp, pl, F_BUY | F_SHOP));
331 else
332 sprintf (buf, "You pick up the %s.", query_name (tmp));
333
334 new_draw_info (NDI_UNIQUE, 0, pl, buf);
335
336 tmp = insert_ob_in_ob (tmp, op);
337
338 /* All the stuff below deals with client/server code, and is only
339 * usable by players
340 */
341 if (pl->contr)
342 {
343 esrv_send_item (pl, tmp);
344
345 /* These are needed to update the weight for the container we
346 * are putting the object in.
347 */
348 if (op != pl)
349 {
350 esrv_update_item (UPD_WEIGHT, pl, op);
351 esrv_send_item (pl, pl);
352 }
353
354 /* Update the container the object was in */
355 if (env && env != pl && env != op)
356 esrv_update_item (UPD_WEIGHT, pl, env);
357 }
358} 309}
359 310
360/* modified slightly to allow monsters use this -b.t. 5-31-95 */ 311/* modified slightly to allow monsters use this -b.t. 5-31-95 */
361void 312void
362pick_up (object *op, object *alt) 313pick_up (object *op, object *alt)
… …
372 if (!can_pick (op, alt)) 323 if (!can_pick (op, alt))
373 { 324 {
374 new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name); 325 new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);
375 goto leave; 326 goto leave;
376 } 327 }
328
377 tmp = alt; 329 tmp = alt;
378 } 330 }
379 else 331 else
380 { 332 {
381 if (op->below == NULL || !can_pick (op, op->below)) 333 if (op->below == NULL || !can_pick (op, op->below))
… …
390 /* Try to catch it. */ 342 /* Try to catch it. */
391 tmp_map = tmp->map; 343 tmp_map = tmp->map;
392 tmp = stop_item (tmp); 344 tmp = stop_item (tmp);
393 if (tmp == NULL) 345 if (tmp == NULL)
394 goto leave; 346 goto leave;
347
395 need_fix_tmp = 1; 348 need_fix_tmp = 1;
396 if (!can_pick (op, tmp)) 349 if (!can_pick (op, tmp))
397 goto leave; 350 goto leave;
398 351
399 if (op->type == PLAYER) 352 if (op->type == PLAYER)
… …
404 } 357 }
405 else 358 else
406 count = tmp->nrof; 359 count = tmp->nrof;
407 360
408 /* container is open, so use it */ 361 /* container is open, so use it */
409 if (op->container) 362 if (tmp->flag [FLAG_STARTEQUIP])
363 alt = op;
364 else if ((alt = op->container_ ()))
410 { 365 {
411 alt = op->container;
412 if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count)) 366 if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))
413 goto leave; 367 goto leave;
414 } 368 }
415 else 369 else
416 { /* non container pickup */ 370 { /* non container pickup */
… …
433 /* here it could be possible to check rent, 387 /* here it could be possible to check rent,
434 * if someone wants to implement it 388 * if someone wants to implement it
435 */ 389 */
436 alt = op; 390 alt = op;
437 } 391 }
392
438#ifdef PICKUP_DEBUG 393#ifdef PICKUP_DEBUG
439 LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name); 394 LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);
440#endif 395#endif
441 396
442 /* startequip items are not allowed to be put into containers: */ 397 /* startequip items are not allowed to be put into containers: */
… …
469int 424int
470command_take (object *op, char *params) 425command_take (object *op, char *params)
471{ 426{
472 object *tmp, *next; 427 object *tmp, *next;
473 428
474 if (op->container) 429 if (op->container_ ())
475 tmp = op->container->inv; 430 tmp = op->container_ ()->inv;
476 else 431 else
477 { 432 {
478 tmp = op->above; 433 tmp = op->above;
479 if (tmp) 434 if (tmp)
480 while (tmp->above) 435 while (tmp->above)
… …
492 447
493 /* Makes processing easier */ 448 /* Makes processing easier */
494 if (params && *params == '\0') 449 if (params && *params == '\0')
495 params = 0; 450 params = 0;
496 451
497 int cnt = MAX_ITEM_PER_DROP; 452 int cnt = MAX_ITEM_PER_ACTION;
498 453
499 while (tmp) 454 while (tmp)
500 { 455 {
501 next = tmp->below; 456 next = tmp->below;
502 457
… …
510 * but that probably will make it more difficult to read, and 465 * but that probably will make it more difficult to read, and
511 * not make it any more efficient 466 * not make it any more efficient
512 */ 467 */
513 if (params && item_matched_string (op, tmp, params)) 468 if (params && item_matched_string (op, tmp, params))
514 { 469 {
470 if (--cnt < 0) break;
515 pick_up (op, tmp); 471 pick_up (op, tmp);
516 if (--cnt <= 0) break;
517 } 472 }
518 else if (can_pick (op, tmp) && !params) 473 else if (can_pick (op, tmp) && !params)
519 { 474 {
475 if (--cnt < 0) break;
520 pick_up (op, tmp); 476 pick_up (op, tmp);
521 break; 477 break;
522 } 478 }
523 479
524 tmp = next; 480 tmp = next;
525 } 481 }
526 482
527 if (cnt <= 0) 483 if (cnt < 0)
528 { 484 {
529 op->failmsg ("Couldn't pick up so many items at once."); 485 op->failmsg ("Couldn't pick up so many items at once.");
530 return 0; 486 return 0;
531 } 487 }
532 488
533 if (!params && !tmp) 489 if (!params && !tmp)
534 { 490 {
535 for (tmp = op->below; tmp; tmp = tmp->below) 491 for (tmp = op->below; tmp; tmp = tmp->below)
536 if (!tmp->invisible) 492 if (!tmp->invisible)
537 { 493 {
538 char buf[MAX_BUF];
539
540 sprintf (buf, "You can't pick up a %s.", &tmp->name); 494 new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up a %s.", &tmp->name);
541 new_draw_info (NDI_UNIQUE, 0, op, buf);
542 break; 495 break;
543 } 496 }
544 497
545 if (!tmp) 498 if (!tmp)
546 new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up."); 499 new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up.");
547 } 500 }
548 501
549 return 0; 502 return 0;
550} 503}
551 504
552
553/* 505/*
554 * This function was part of drop, now is own function. 506 * This function was part of drop, now is own function.
555 * Player 'op' tries to put object 'tmp' into sack 'sack', 507 * Player 'op' tries to put object 'tmp' into sack 'sack',
556 * if nrof is non zero, then nrof objects is tried to put into sack. 508 * if nrof is non zero, then nrof objects is tried to put into sack.
509 *
557 * Note that the 'sack' in question can now be a transport, 510 * Note that the 'sack' in question can now be a transport,
558 * so this function isn't named very good anymore. 511 * so this function isn't named very good anymore.
559 */ 512 */
560void 513void
561put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof) 514put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof)
… …
564 char buf[MAX_BUF]; 517 char buf[MAX_BUF];
565 518
566 if (sack == tmp) 519 if (sack == tmp)
567 return; /* Can't put an object in itself */ 520 return; /* Can't put an object in itself */
568 521
569 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 522 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP))
570 { 523 {
571 new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack)); 524 new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack));
572 return; 525 return;
573 } 526 }
574 527
575 if (tmp->type == CONTAINER && tmp->inv) 528 if (tmp->type == CONTAINER && tmp->inv)
576 { 529 {
577
578 /* Eneq(@csd.uu.se): If the object to be dropped is a container 530 /* Eneq(@csd.uu.se): If the object to be dropped is a container
579 * we instead move the contents of that container into the active 531 * we instead move the contents of that container into the active
580 * container, this is only done if the object has something in it. 532 * container, this is only done if the object has something in it.
581 */ 533 */
582 sack2 = tmp; 534 sack2 = tmp;
… …
584 536
585 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp) 537 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
586 { 538 {
587 tmp = tmp2->below; 539 tmp = tmp2->below;
588 540
589 if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof))) 541 if ((sack->type == CONTAINER && sack_can_hold (op, op->container_ (), tmp2, tmp2->nrof)))
590 {
591 put_object_in_sack (op, sack, tmp2, 0); 542 put_object_in_sack (op, sack, tmp2, 0);
592 }
593 else 543 else
594 { 544 {
595 sprintf (buf, "Your %s fills up.", query_name (sack)); 545 sprintf (buf, "Your %s fills up.", query_name (sack));
596 new_draw_info (NDI_UNIQUE, 0, op, buf); 546 new_draw_info (NDI_UNIQUE, 0, op, buf);
597 break; 547 break;
598 } 548 }
599 } 549 }
600 550
601 esrv_update_item (UPD_WEIGHT, op, sack2);
602 return; 551 return;
603 } 552 }
604 553
605 /* Don't worry about this for containers - our caller should have 554 /* Don't worry about this for containers - our caller should have
606 * already checked this. 555 * already checked this.
607 */ 556 */
608 if ((sack->type == CONTAINER) && !sack_can_hold (op, sack, tmp, (nrof ? nrof : tmp->nrof))) 557 if ((sack->type == CONTAINER) && !sack_can_hold (op, sack, tmp, (nrof ? nrof : tmp->nrof)))
609 return; 558 return;
610 559
611 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 560 if (QUERY_FLAG (tmp, FLAG_APPLIED))
612 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE)) 561 if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
613 return; 562 return;
614 563
615 /* we want to put some portion of the item into the container */ 564 /* we want to put some portion of the item into the container */
616 if (nrof && tmp->nrof != nrof) 565 if (!can_split (op, tmp, nrof))
617 {
618 object *tmp2 = tmp;
619
620 tmp = get_split_ob (tmp, nrof);
621
622 if (!tmp)
623 {
624 new_draw_info (NDI_UNIQUE, 0, op, errmsg);
625 return; 566 return;
626 }
627 /* Tell a client what happened other objects */
628 if (tmp2->destroyed ())
629 esrv_del_item (op->contr, tmp2->count);
630 else /* this can proably be replaced with an update */
631 esrv_send_item (op, tmp2);
632 }
633 else
634 tmp->remove ();
635 567
636 new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack)); 568 new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));
637 tmp2 = insert_ob_in_ob (tmp, sack); 569 sack->insert (tmp);
570}
638 571
639 // elmex: 2007-11-26: removed update_stats and replaced 572/* In contrast to drop_object (op, tmp, nrof) above this function takes the
640 // it by update_after_inventory_change () in the caller 573 * already split off object, and feeds it to the event handlers and does
641 // of this function 574 * other magic with it.
575 *
576 * <droppper> is the object that dropped this object and <obj> is the
577 * object that was dropped.
578 *
579 * Make sure to check what happened with <obj> after this function returns!
580 * Otherwise you may leak this object.
581 */
582void
583drop_object (object *dropper, object *obj)
584{
585 if (INVOKE_OBJECT (DROP, obj, ARG_OBJECT (dropper)))
586 return;
587
588 if (obj->destroyed () || obj->is_inserted ())
589 return;
642 590
643 /* If an object merged (and thus, different object), we need to 591 if (QUERY_FLAG (obj, FLAG_STARTEQUIP))
644 * delete the original. 592 {
593 dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
594 dropper->statusmsg ("The god who lent it to you retrieves it.");
595
596 obj->destroy ();
597 dropper->update_stats ();
598 return;
599 }
600
601 for (object *floor = GET_MAP_OB (dropper->map, dropper->x, dropper->y);
602 floor;
603 floor = floor->above)
604 if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (obj), ARG_OBJECT (dropper)))
605 return;
606
607 if (obj->destroyed () || obj->is_inserted ())
608 return;
609
610 if (dropper->is_in_shop () && !QUERY_FLAG (obj, FLAG_UNPAID) && obj->type != MONEY)
611 if (!sell_item (obj, dropper))
612 return;
613
614 if (!obj->can_drop_at (dropper->map, dropper->x, dropper->y, dropper))
615 return;
616
617 /* If nothing special happened with this object, the default action is to
618 * insert it below the dropper:
645 */ 619 */
646 if (tmp2 != tmp)
647 esrv_del_item (op->contr, tmp->count);
648 620
649 esrv_send_item (op, tmp2); 621 obj->x = dropper->x;
622 obj->y = dropper->y;
650 623
651 /* update the sacks weight */ 624 insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
652 esrv_update_item (UPD_WEIGHT, op, sack);
653} 625}
654 626
655/* 627/*
656 * This function was part of drop, now is own function. 628 * This function was part of drop, now is own function.
657 * Player 'op' tries to drop object 'tmp', if tmp is non zero, then 629 * Player 'op' tries to drop object 'tmp', if tmp is non zero, then
658 * nrof objects is tried to dropped. 630 * nrof objects are tried to drop.
659 * This is used when dropping objects onto the floor. 631 * This is used when dropping objects onto the floor.
660 */ 632 */
661void 633void
662drop_object (object *op, object *tmp, uint32 nrof) 634drop_object (object *op, object *tmp, uint32 nrof)
663{ 635{
664 object *floor;
665
666 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 636 if (QUERY_FLAG (tmp, FLAG_NO_DROP))
667 return; 637 return;
668 638
669 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 639 if (QUERY_FLAG (tmp, FLAG_APPLIED))
670 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE)) 640 if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
671 return; /* can't unapply it */ 641 return; /* can't unapply it */
672
673 //fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
674 642
675 /* We are only dropping some of the items. We split the current object 643 /* We are only dropping some of the items. We split the current object
676 * off 644 * off
677 */ 645 */
678 if (nrof && tmp->nrof != nrof) 646 if (!can_split (op, tmp, nrof))
679 {
680 object *tmp2 = tmp;
681
682 tmp = get_split_ob (tmp, nrof);
683 if (!tmp)
684 {
685 new_draw_info (NDI_UNIQUE, 0, op, errmsg);
686 return;
687 }
688 /* Tell a client what happened rest of objects. tmp2 is now the
689 * original object
690 */
691 if (op->type == PLAYER)
692 {
693 if (tmp2->destroyed ())
694 esrv_del_item (op->contr, tmp2->count);
695 else
696 esrv_send_item (op, tmp2);
697 }
698 }
699 else
700 tmp->remove ();
701
702 if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))
703 return; 647 return;
704 648
705 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 649 drop_object (op, tmp);
706 {
707 op->statusmsg (format ("You drop the %s.", query_name (tmp)));
708 op->statusmsg ("The gods who lent it to you retrieves it.");
709 650
710 if (op->type == PLAYER) 651 if (!tmp->destroyed () && !tmp->is_inserted ())
711 esrv_del_item (op->contr, tmp->count);
712
713 tmp->destroy ();
714 op->update_stats ();
715 return;
716 } 652 {
717 653 // if nothing happened with the object we give it back
718 if (op->type == PLAYER) 654 op->insert (tmp);
719 esrv_del_item (op->contr, tmp->count);
720
721 /* Call this before we update the various windows/players. At least
722 * that we, we know the weight is correct.
723 */
724 // 2007-11-26: moved op->update_stats away and calling it later after
725 // all items of a drop command have been processed.
726
727 for (floor = GET_MAP_OB (op->map, op->x, op->y); floor; floor = floor->above)
728 if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
729 return;
730
731 if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
732 sell_item (tmp, op);
733
734 tmp->x = op->x;
735 tmp->y = op->y;
736
737 insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
738}
739
740void update_after_inventory_change (object *op)
741{
742 /* Call this before we update the various windows/players. At least
743 * that we, we know the weight is correct.
744 */
745 op->update_stats ();
746
747 // elmex: kept this for now, i have no idea what happens when i remove it:
748 if (op->type == PLAYER)
749 {
750 /* Need to update the weight for the player */
751 esrv_send_item (op, op);
752 op->contr->ns->floorbox_update ();
753 } 655 }
754} 656}
755 657
756void 658void
757drop (object *op, object *tmp) 659drop (object *op, object *tmp)
… …
767 if (tmp->env && tmp->env->type != PLAYER) 669 if (tmp->env && tmp->env->type != PLAYER)
768 { 670 {
769 /* Just toss the object - probably shouldn't be hanging 671 /* Just toss the object - probably shouldn't be hanging
770 * around anyways 672 * around anyways
771 */ 673 */
772 tmp->remove ();
773 tmp->destroy (); 674 tmp->destroy ();
774 return; 675 return;
775 } 676 }
776 else 677 else
777 {
778 while (tmp != NULL && tmp->invisible) 678 while (tmp && tmp->invisible)
779 tmp = tmp->below; 679 tmp = tmp->below;
780 }
781 } 680 }
782 681
783 if (tmp == NULL) 682 if (!tmp)
784 { 683 {
785 new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop."); 684 new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");
786 return; 685 return;
787 } 686 }
687
788 if (QUERY_FLAG (tmp, FLAG_INV_LOCKED)) 688 if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))
789 { 689 {
790 new_draw_info (NDI_UNIQUE, 0, op, "This item is locked"); 690 new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
791 return; 691 return;
792 } 692 }
693
793 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 694 if (QUERY_FLAG (tmp, FLAG_NO_DROP))
794 { 695 {
795#if 0 696#if 0
796 /* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */ 697 /* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */
797 new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped."); 698 new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");
… …
800 } 701 }
801 702
802 if (op->type == PLAYER && op->contr->last_used == tmp) 703 if (op->type == PLAYER && op->contr->last_used == tmp)
803 op->contr->last_used = tmp->below ? tmp->below 704 op->contr->last_used = tmp->below ? tmp->below
804 : tmp->above ? tmp->above 705 : tmp->above ? tmp->above
805 : 0; 706 : (object *)0;
806 707
807 if (op->container) 708 if (op->container_ ())
808 { 709 {
809 if (op->type == PLAYER) 710 if (op->type == PLAYER)
810 put_object_in_sack (op, op->container, tmp, op->contr->count); 711 put_object_in_sack (op, op->container_ (), tmp, op->contr->count);
811 else 712 else
812 put_object_in_sack (op, op->container, tmp, 0); 713 put_object_in_sack (op, op->container_ (), tmp, 0);
813 } 714 }
814 else 715 else
815 { 716 {
816 if (op->type == PLAYER) 717 if (op->type == PLAYER)
817 drop_object (op, tmp, op->contr->count); 718 drop_object (op, tmp, op->contr->count);
… …
821 722
822 if (op->type == PLAYER) 723 if (op->type == PLAYER)
823 op->contr->count = 0; 724 op->contr->count = 0;
824} 725}
825 726
826
827
828/* Command will drop all items that have not been locked */ 727/* Command will drop all items that have not been locked */
829int 728int
830command_dropall (object *op, char *params) 729command_dropall (object *op, char *params)
831{ 730{
832 731
833 object *curinv, *nextinv;
834
835 if (op->inv == NULL) 732 if (op->inv == NULL)
836 { 733 {
837 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!"); 734 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
838 return 0; 735 return 0;
839 } 736 }
840 737
841 curinv = op->inv; 738 object *curinv = op->inv;
739 object *nextinv;
842 740
843 /* 741 /*
844 This is the default. Drops everything not locked or considered 742 This is the default. Drops everything not locked or considered
845 not something that should be dropped. 743 not something that should be dropped.
846 */ 744 */
847 /* 745 /*
848 Care must be taken that the next item pointer is not to money as 746 Care must be taken that the next item pointer is not to money as
849 the drop() routine will do unknown things to it when dropping 747 the drop() routine will do unknown things to it when dropping
850 in a shop. --Tero.Pelander@utu.fi 748 in a shop. --Tero.Pelander@utu.fi
851 */ 749 */
852
853 int cnt = MAX_ITEM_PER_DROP; 750 int cnt = MAX_ITEM_PER_ACTION;
854 751
855 if (params == NULL) 752 if (!params)
856 { 753 {
857 while (curinv != NULL) 754 while (curinv)
858 { 755 {
859 nextinv = curinv->below; 756 nextinv = curinv->below;
757
860 while (nextinv && nextinv->type == MONEY) 758 while (nextinv && nextinv->type == MONEY)
861 nextinv = nextinv->below; 759 nextinv = nextinv->below;
760
862 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY && 761 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED)
863 curinv->type != FOOD && curinv->type != KEY && 762 && curinv->type != MONEY
864 curinv->type != SPECIAL_KEY && curinv->type != GEM && 763 && curinv->type != FOOD
764 && curinv->type != KEY
765 && curinv->type != SPECIAL_KEY
766 && curinv->type != GEM
767 && !curinv->invisible
865 !curinv->invisible && (curinv->type != CONTAINER || op->container != curinv)) 768 && (curinv->type != CONTAINER || op->container_ () != curinv))
866 { 769 {
867 drop (op, curinv); 770 drop (op, curinv);
868 if (--cnt <= 0) break; 771 if (--cnt <= 0) break;
869 } 772 }
773
870 curinv = nextinv; 774 curinv = nextinv;
871 } 775 }
872 } 776 }
873
874 else if (strcmp (params, "weapons") == 0) 777 else if (strcmp (params, "weapons") == 0)
875 { 778 {
876 while (curinv != NULL) 779 while (curinv)
877 { 780 {
878 nextinv = curinv->below; 781 nextinv = curinv->below;
782
879 while (nextinv && nextinv->type == MONEY) 783 while (nextinv && nextinv->type == MONEY)
880 nextinv = nextinv->below; 784 nextinv = nextinv->below;
785
881 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW))) 786 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))
882 { 787 {
883 drop (op, curinv); 788 drop (op, curinv);
884 if (--cnt <= 0) break; 789 if (--cnt <= 0) break;
885 } 790 }
791
886 curinv = nextinv; 792 curinv = nextinv;
887 } 793 }
888 } 794 }
889
890 else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0) 795 else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)
891 { 796 {
892 while (curinv != NULL) 797 while (curinv)
893 { 798 {
894 nextinv = curinv->below; 799 nextinv = curinv->below;
800
895 while (nextinv && nextinv->type == MONEY) 801 while (nextinv && nextinv->type == MONEY)
896 nextinv = nextinv->below; 802 nextinv = nextinv->below;
803
897 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET)) 804 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))
898 { 805 {
899 drop (op, curinv); 806 drop (op, curinv);
900 if (--cnt <= 0) break; 807 if (--cnt <= 0) break;
901 } 808 }
809
902 curinv = nextinv; 810 curinv = nextinv;
903 } 811 }
904 } 812 }
905
906 else if (strcmp (params, "misc") == 0) 813 else if (strcmp (params, "misc") == 0)
907 { 814 {
908 while (curinv != NULL) 815 while (curinv)
909 { 816 {
910 nextinv = curinv->below; 817 nextinv = curinv->below;
818
911 while (nextinv && nextinv->type == MONEY) 819 while (nextinv && nextinv->type == MONEY)
912 nextinv = nextinv->below; 820 nextinv = nextinv->below;
821
913 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED)) 822 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))
914 { 823 {
915 switch (curinv->type) 824 switch (curinv->type)
916 { 825 {
917 case HORN: 826 case HORN:
… …
935 break; 844 break;
936 default: 845 default:
937 curinv = nextinv; 846 curinv = nextinv;
938 break; 847 break;
939 } 848 }
849
940 if (--cnt <= 0) break; 850 if (--cnt <= 0) break;
941 } 851 }
852
942 curinv = nextinv; 853 curinv = nextinv;
943 } 854 }
944 } 855 }
945 856
946 if (cnt <= 0) 857 if (cnt <= 0)
947 op->failmsg ("Only dropped some items, can't drop that many items at once."); 858 op->failmsg ("Only dropped some items, can't drop that many items at once.");
948 859
949 update_after_inventory_change (op);
950
951/* draw_look(op);*/ 860/* draw_look(op);*/
952 return 0; 861 return 0;
953} 862}
954 863
864
865/* This function tries to drop all objects in the <objs> vector.
866 * <dropper> is the object that wants to drop them.
867 * <cnt> can be a 0 pointer or a pointer to the maximum number of
868 * drop operations to perform.
869 *
870 * Returns true if at least one item was dropped.
871 */
872static bool
873drop_vector (object *dropper, vector<object *> &objs, int *cnt)
874{
875 vector<object *>::iterator i;
876
877 bool did_one = false;
878
879 for (i = objs.begin (); i != objs.end (); i++)
880 {
881 drop (dropper, *i);
882 if (cnt && --*cnt <= 0) break;
883 did_one = true;
884 }
885
886 return did_one;
887}
888
955/* Object op wants to drop object(s) params. params can be a 889/* Object op wants to drop object(s) params. params can be a
956 * comma seperated list. 890 * comma seperated list.
957 */ 891 */
958
959int 892int
960command_drop (object *op, char *params) 893command_drop (object *op, char *params)
961{ 894{
962 object *tmp, *next; 895 object *tmp, *next;
963 int did_one = 0; 896 int did_one = 0;
… …
967 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?"); 900 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
968 return 0; 901 return 0;
969 } 902 }
970 else 903 else
971 { 904 {
972 int cnt = MAX_ITEM_PER_DROP; 905 vector<object *> matched_objs;
973 906
974 for (tmp = op->inv; tmp; tmp = next) 907 for (tmp = op->inv; tmp; tmp = next)
975 { 908 {
976 next = tmp->below; 909 next = tmp->below;
977 if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible) 910 if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)
978 continue; 911 continue;
979 912
980 if (item_matched_string (op, tmp, params)) 913 if (item_matched_string (op, tmp, params))
981 { 914 matched_objs.push_back (tmp);
982 drop (op, tmp);
983 if (--cnt <= 0) break;
984 did_one = 1;
985 } 915 }
986 }
987 916
988 if (!did_one) 917 int cnt = MAX_ITEM_PER_ACTION;
918
919 if (!drop_vector (op, matched_objs, &cnt))
989 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop."); 920 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
990 921
991 if (cnt <= 0) 922 if (cnt <= 0)
992 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.");
993
994 update_after_inventory_change (op);
995 } 924 }
996 925
997 return 0; 926 return 0;
998} 927}
999 928
… …
1004 { 933 {
1005 object *tmp = op->below; 934 object *tmp = op->below;
1006 935
1007 while (tmp && !tmp->client_visible ()) 936 while (tmp && !tmp->client_visible ())
1008 tmp = tmp->below; 937 tmp = tmp->below;
938
1009 if (tmp) 939 if (tmp)
1010 examine (op, tmp); 940 examine (op, tmp);
1011 } 941 }
1012 else 942 else
1013 { 943 {
1014 object *tmp = find_best_object_match (op, params); 944 object *tmp = find_best_object_match (op, params);
1015 945
1016 if (tmp) 946 if (tmp)
1017 examine (op, tmp); 947 examine (op, tmp);
1018 else 948 else
1019 new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params); 949 op->contr->infobox (MSG_CHANNEL ("examine"), format ("Could not find an object that matches %s", params));
1020 } 950 }
951
1021 return 0; 952 return 0;
1022} 953}
1023 954
1024/* op should be a player. 955/* op should be a player.
1025 * we return the object the player has marked with the 'mark' command 956 * we return the object the player has marked with the 'mark' command
… …
1072 dynbuf_text buf (512, 512); 1003 dynbuf_text buf (512, 512);
1073 1004
1074 object *mon = head ? head : this; 1005 object *mon = head ? head : this;
1075 1006
1076 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 1007 if (QUERY_FLAG (mon, FLAG_UNDEAD))
1077 buf << "It is an undead force.\n"; 1008 buf << "It is an undead force.\r";
1078 1009
1079 if (mon->level > who->level) 1010 if (mon->level > who->level)
1080 buf << "It is likely more powerful than you.\n"; 1011 buf << "It is likely more powerful than you.\r";
1081 else if (mon->level < who->level) 1012 else if (mon->level < who->level)
1082 buf << "It is likely less powerful than you.\n"; 1013 buf << "It is likely less powerful than you.\r";
1083 else 1014 else
1084 buf << "It is probably as powerful as you.\n"; 1015 buf << "It is probably as powerful as you.\r";
1085 1016
1086 if (mon->attacktype & AT_ACID) 1017 if (mon->attacktype & AT_ACID)
1087 buf << "You seem to smell an acrid odor.\n"; 1018 buf << "You seem to smell an acrid odor.\r";
1088 1019
1089 /* Anyone know why this used to use the clone value instead of the 1020 /* Anyone know why this used to use the clone value instead of the
1090 * maxhp field? This seems that it should give more accurate results. 1021 * maxhp field? This seems that it should give more accurate results.
1091 */ 1022 */
1092 switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1)) 1023 switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1093 { /* From 1-4 */ 1024 { /* From 1-4 */
1094 case 1: 1025 case 1:
1095 buf << "It is in a bad shape.\n"; 1026 buf << "It is in a bad shape.\r";
1096 break; 1027 break;
1097 case 2: 1028 case 2:
1098 buf << "It is hurt.\n"; 1029 buf << "It is hurt.\r";
1099 break; 1030 break;
1100 case 3: 1031 case 3:
1101 buf << "It is somewhat hurt.\n"; 1032 buf << "It is somewhat hurt.\r";
1102 break; 1033 break;
1103 case 4: 1034 case 4:
1104 buf << "It is in excellent shape.\n"; 1035 buf << "It is in excellent shape.\r";
1105 break; 1036 break;
1106 } 1037 }
1107 1038
1108 if (present_in_ob (POISONING, mon)) 1039 if (present_in_ob (POISONING, mon))
1109 buf << "It looks very ill.\n"; 1040 buf << "It looks very ill.\r";
1041
1042 buf << '\n';
1110 1043
1111 return buf; 1044 return buf;
1112} 1045}
1113 1046
1114/* tmp is the object being described, pl is who is examing it. */ 1047/* tmp is the object being described, pl is who is examing it. */
… …
1121} 1054}
1122 1055
1123std::string 1056std::string
1124object::long_desc (object *who) 1057object::long_desc (object *who)
1125{ 1058{
1126 std::string buf (query_name (this)); 1059 std::string buf (query_name ());
1127 1060
1128 switch (type) 1061 switch (type)
1129 { 1062 {
1130 case RING: 1063 case RING:
1131 case SKILL: 1064 case SKILL:
… …
1143 case CLOAK: 1076 case CLOAK:
1144 case FOOD: 1077 case FOOD:
1145 case DRINK: 1078 case DRINK:
1146 case FLESH: 1079 case FLESH:
1147 case SKILL_TOOL: 1080 case SKILL_TOOL:
1081 case LAMP:
1148 case POWER_CRYSTAL: 1082 case POWER_CRYSTAL:
1149 { 1083 {
1150 const char *cp = ::describe_item (this, who); 1084 const char *cp = ::describe_item (this, who);
1151 1085
1152 if (*cp) 1086 if (*cp)
… …
1167examine_monster (object *op, object *tmp) 1101examine_monster (object *op, object *tmp)
1168{ 1102{
1169 new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ()); 1103 new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
1170} 1104}
1171 1105
1172std::string
1173object::describe (object *who)
1174{
1175 dynbuf_text buf (1024, 1024);
1176
1177 buf.printf ("That is: %s.\n", long_desc (who).c_str ());
1178
1179 if (custom_name)
1180 buf.printf ("You call it %s\n", &custom_name);
1181
1182 switch (type)
1183 {
1184 case SPELLBOOK:
1185 if (flag [FLAG_IDENTIFIED] && inv)
1186 buf.printf ("%s is a %s %s spell\n", &inv->name, get_levelnumber (inv->level), &inv->skill);
1187 break;
1188
1189 case BOOK:
1190 if (msg)
1191 buf << "Something is written in it.\n";
1192 break;
1193
1194 case CONTAINER:
1195 if (race != NULL)
1196 {
1197 if (weight_limit && stats.Str < 100)
1198 buf.printf ("It can hold only %s and its weight limit is %.1f kg.\n",
1199 &race, weight_limit / (10.0 * (100 - stats.Str)));
1200 else
1201 buf.printf ("It can hold only %s.\n", &race);
1202 }
1203 else if (weight_limit && stats.Str < 100)
1204 buf.printf ("Its weight limit is %.1f kg.\n", weight_limit / (10.0 * (100 - stats.Str)));
1205 break;
1206
1207 case WAND:
1208 if (flag [FLAG_IDENTIFIED])
1209 buf.printf ("It has %d charges left.\n", stats.food);
1210 break;
1211 }
1212
1213 if (materialname && !msg)
1214 buf.printf ("It is made of: %s.\n", &materialname);
1215
1216 if (who)
1217 /* Where to wear this item */
1218 for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1219 if (slot[i].info)
1220 {
1221 buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
1222
1223 if (slot[i].info < -1 && who->slot[i].info)
1224 buf.printf ("(%d)", -slot[i].info);
1225
1226 buf << ".\n";
1227 }
1228
1229 if (weight)
1230 buf.printf (nrof > 1 ? "They weigh %3.3f kg.\n" : "It weighs %3.3f kg.\n", weight * (nrof ? nrof : 1) / 1000.0);
1231
1232 if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
1233 {
1234 buf.printf ("You reckon %s worth %s.\n", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
1235
1236 if (is_in_shop (who))
1237 {
1238 if (flag [FLAG_UNPAID])
1239 buf.printf ("%s would cost you %s.\n", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1240 else
1241 buf.printf ("You are offered %s for %s.\n", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1242 }
1243 }
1244
1245 if (flag [FLAG_MONSTER])
1246 buf << describe_monster (who);
1247
1248 /* Is this item buildable? */
1249 if (flag [FLAG_IS_BUILDABLE])
1250 buf << "This is a buildable item.\n";
1251
1252 /* Does the object have a message? Don't show message for all object
1253 * types - especially if the first entry is a match
1254 */
1255 if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && *msg != '@')
1256 {
1257 /* This is just a hack so when identifying the items, we print
1258 * out the extra message
1259 */
1260 if (need_identify (this) && flag [FLAG_IDENTIFIED])
1261 buf << "The object has a story:\n";
1262
1263 buf << msg << '\n';
1264 }
1265
1266 buf << '\n';
1267
1268 return std::string (buf.linearise (), buf.size ());
1269}
1270
1271static void 1106static void
1272display_new_pickup (object *op) 1107display_new_pickup (object *op)
1273{ 1108{
1274 int i = op->contr->mode; 1109 int i = op->contr->mode;
1275 1110
1276 if (!(i & PU_NEWMODE))
1277 return;
1278
1279 new_draw_info_format (NDI_UNIQUE, 0, op, "%d NEWMODE", i & PU_NEWMODE ? 1 : 0);
1280 new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0); 1111 new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0);
1281 new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0); 1112 new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0);
1282 new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0); 1113 new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0);
1283 1114
1284 new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5); 1115 new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5);
… …
1335 }; 1166 };
1336 1167
1337 if (!params) 1168 if (!params)
1338 { 1169 {
1339 /* if the new mode is used, just print the settings */ 1170 /* if the new mode is used, just print the settings */
1340 if (op->contr->mode & PU_NEWMODE)
1341 {
1342 display_new_pickup (op); 1171 display_new_pickup (op);
1343 return 1;
1344 }
1345 if (1)
1346 LOG (llevDebug, "command_pickup: !params\n");
1347 set_pickup_mode (op, (op->contr->mode > 6) ? 0 : op->contr->mode + 1);
1348 return 0; 1172 return 0;
1349 } 1173 }
1350 1174
1351 while (*params == ' ' && *params) 1175 while (*params == ' ' && *params)
1352 params++; 1176 params++;
… …
1358 for (mode = 0; names[mode]; mode++) 1182 for (mode = 0; names[mode]; mode++)
1359 { 1183 {
1360 if (!strcmp (names[mode], params + 1)) 1184 if (!strcmp (names[mode], params + 1))
1361 { 1185 {
1362 i = op->contr->mode; 1186 i = op->contr->mode;
1363 if (!(i & PU_NEWMODE)) 1187
1364 i = PU_NEWMODE;
1365 if (*params == '+') 1188 if (*params == '+')
1366 i = i | modes[mode]; 1189 i = i | modes[mode];
1367 else 1190 else
1368 i = i & ~modes[mode]; 1191 i = i & ~modes[mode];
1192
1369 op->contr->mode = i; 1193 op->contr->mode = i;
1370 display_new_pickup (op); 1194 display_new_pickup (op);
1371 return 1; 1195 return 1;
1372 } 1196 }
1373 } 1197 }
… …
1375 return 1; 1199 return 1;
1376 } 1200 }
1377 1201
1378 if (sscanf (params, "%u", &i) != 1) 1202 if (sscanf (params, "%u", &i) != 1)
1379 { 1203 {
1380 if (1)
1381 LOG (llevDebug, "command_pickup: params==NULL\n");
1382 new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <0-7> or <value_density> ."); 1204 new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <value_density> or [+-]type.");
1383 return 1; 1205 return 1;
1384 } 1206 }
1385 set_pickup_mode (op, i); 1207
1208 if (i <= PU_RATIO)
1209 i |= op->contr->mode & ~PU_RATIO;
1210
1211 op->contr->mode = i;
1386 1212
1387 return 1; 1213 return 1;
1388}
1389
1390void
1391set_pickup_mode (object *op, int i)
1392{
1393 switch (op->contr->mode = i)
1394 {
1395 case 0:
1396 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");
1397 break;
1398 case 1:
1399 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");
1400 break;
1401 case 2:
1402 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");
1403 break;
1404 case 3:
1405 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");
1406 break;
1407 case 4:
1408 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");
1409 break;
1410 case 5:
1411 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");
1412 break;
1413 case 6:
1414 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");
1415 break;
1416 case 7:
1417 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");
1418 break;
1419 }
1420} 1214}
1421 1215
1422int 1216int
1423command_search_items (object *op, char *params) 1217command_search_items (object *op, char *params)
1424{ 1218{
1425 char buf[MAX_BUF];
1426
1427 if (settings.search_items == FALSE)
1428 return 1;
1429
1430 if (params == NULL) 1219 if (params == NULL)
1431 { 1220 {
1432 if (op->contr->search_str[0] == '\0') 1221 if (op->contr->search_str[0] == '\0')
1433 { 1222 {
1434 new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1"); 1223 new_draw_info (NDI_UNIQUE, 0, op, "Example: search-items magic+1");
1435 new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all"); 1224 new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");
1436 new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'."); 1225 new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1437 return 1; 1226 return 1;
1438 } 1227 }
1439 1228
1440 op->contr->search_str[0] = '\0'; 1229 op->contr->search_str[0] = '\0';
1441 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off."); 1230 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1442 op->update_stats (); 1231 op->contr->queue_stats_update ();
1443 return 1; 1232 return 1;
1444 } 1233 }
1445 1234
1446 if ((int) strlen (params) >= MAX_BUF) 1235 if (strlen (params) >= sizeof (op->contr->search_str))
1447 { 1236 {
1448 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long."); 1237 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1449 return 1; 1238 return 1;
1450 } 1239 }
1451 1240
1452 strcpy (op->contr->search_str, params); 1241 strcpy (op->contr->search_str, params);
1453 sprintf (buf, "Searching for '%s'.", op->contr->search_str); 1242 new_draw_info (NDI_UNIQUE, 0, op, format ("Now searching for '%s'.", op->contr->search_str));
1454 new_draw_info (NDI_UNIQUE, 0, op, buf); 1243 op->contr->queue_stats_update ();
1455 op->update_stats (); 1244
1456 return 1; 1245 return 1;
1457} 1246}
1458 1247
1248int
1249command_unlock (object *op, char *params)
1250{
1251 /* if the unlock command typed with nothing, unlock everything,
1252 * this might be bad
1253 */
1254 if (params == NULL)
1255 {
1256 for (object *item = op->inv; item; item = item->below)
1257 {
1258 CLEAR_FLAG(item, FLAG_INV_LOCKED);
1259 //d// new_draw_info (NDI_UNIQUE, 0, op, "unlocked items with null param.");
1260 esrv_update_item (UPD_FLAGS, op, item);
1261 }
1262 return 0;
1263 }
1264
1265 /* if the unlock command is used with a param,
1266 * unlock what matches. i.e. unlock material, should unlock all the materials
1267 */
1268 for (object *item = op->inv; item; item = item->below)
1269 if (item->name.contains (params))
1270 {
1271 CLEAR_FLAG (item, FLAG_INV_LOCKED);
1272 //d// new_draw_info (NDI_UNIQUE, 0, op, "unlocked items with a param.");
1273 esrv_update_item (UPD_FLAGS, op, item);
1274 }
1275
1276 return 0;
1277}
1278
1279int
1280command_lock (object *op, char *params)
1281{
1282 /* if the lock command is typed by itself, lock everything
1283 */
1284 if (params == NULL)
1285 {
1286 for (object *item = op->inv; item; item = item->below)
1287 {
1288 SET_FLAG (item, FLAG_INV_LOCKED);
1289 //d// new_draw_info (NDI_UNIQUE, 0, op, "locked items with null param.");
1290 esrv_update_item (UPD_FLAGS, op, item);
1291 }
1292 return 0;
1293 }
1294
1295 /* if the lock command is used with a param, lock what matches.
1296 * i.e. lock material, should lock all the materials
1297 */
1298 for (object *item = op->inv; item; item = item->below)
1299 if (item->name.contains (params))
1300 {
1301 SET_FLAG (item, FLAG_INV_LOCKED);
1302 //d// new_draw_info (NDI_UNIQUE, 0, op, "locked items with param.");
1303 esrv_update_item (UPD_FLAGS, op, item);
1304 }
1305
1306 return 0;
1307}
1308
1309/* op should be a player, params is any params.
1310 * If no params given, we print out the currently marked object.
1311 * otherwise, try to find a matching object - try best match first.
1312 */
1313int
1314command_mark (object *op, char *params)
1315{
1316 if (!params)
1317 {
1318 if (object *mark = find_marked_object (op))
1319 op->statusmsg (format ("%s is marked.", query_name (mark)));
1320 else
1321 op->failmsg ("You have no marked object.");
1322 }
1323 else
1324 {
1325 if (object *mark = find_best_object_match (op, params))
1326 {
1327 op->contr->mark = mark;
1328 op->statusmsg (format ("Marked item %s", query_name (mark)));
1329 }
1330 else
1331 op->failmsgf ("Could not find an object that matches %s", params);
1332 }
1333
1334 return 0; /*shouldnt get here */
1335}
1336

Diff Legend

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