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.14 by root, Sun Sep 10 15:59:57 2006 UTC vs.
Revision 1.89 by elmex, Mon Jan 12 00:17:23 2009 UTC

1
2/* 1/*
3 * static char *rcsid_c_object_c = 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
4 * "$Id: c_object.C,v 1.14 2006/09/10 15:59:57 root Exp $"; 3 *
4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 *
8 * Deliantra is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 *
21 * The authors can be reached via e-mail to <support@deliantra.net>
5 */ 22 */
6 23
7/* 24/*
8 CrossFire, A Multiplayer game for X-windows
9
10 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen
12
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
27 The author can be reached via e-mail to crossfire-devel@real-time.com
28
29 Object (handling) commands 25 * Object (handling) commands
30*/ 26 */
31 27
32#include <global.h> 28#include <global.h>
33#include <loader.h> 29#include <loader.h>
34#include <skills.h> 30#include <skills.h>
35#ifndef __CEXTRACT__
36# include <sproto.h> 31#include <sproto.h>
37#endif
38#include <living.h> 32#include <living.h>
39#include <math.h> 33#include <math.h>
40 34
41/* 35/*
42 * Object id parsing functions 36 * Object id parsing functions
43 */ 37 */
44 38
45#define OBLINKMALLOC(p) if(!((p)=(objectlink *)malloc(sizeof(objectlink))))\
46 fatal(OUT_OF_MEMORY);
47
48#define ADD_ITEM(NEW,COUNT)\ 39#define ADD_ITEM(NEW,COUNT)\
49 if(!first) {\ 40 if(!first) {\
50 OBLINKMALLOC(first);\ 41 first = new objectlink;\
51 last=first;\ 42 last=first;\
52 } else {\ 43 } else {\
53 OBLINKMALLOC(last->next);\ 44 last->next = new objectlink;\
54 last=last->next;\ 45 last=last->next;\
55 }\ 46 }\
56 last->next=NULL;\ 47 last->next=0;\
57 last->ob=(NEW);\ 48 last->ob=(NEW);\
58 last->id=(COUNT); 49 last->id=(COUNT);
59 50
60/** 51/**
61 * Search the inventory of 'pl' for what matches best with params. 52 * Search the inventory of 'pl' for what matches best with params.
… …
65 * only unapply applied, or apply unapplied objects 56 * only unapply applied, or apply unapplied objects
66 **/ 57 **/
67static object * 58static object *
68find_best_apply_object_match (object *pl, const char *params, enum apply_flag aflag) 59find_best_apply_object_match (object *pl, const char *params, enum apply_flag aflag)
69{ 60{
70 object *tmp, *best = NULL; 61 object *best = 0;
71 int match_val = 0, tmpmatch; 62 int match_val = 0;
72 63
73 for (tmp = pl->inv; tmp; tmp = tmp->below) 64 for (object *tmp = pl->inv; tmp; tmp = tmp->below)
74 { 65 {
75 if (tmp->invisible) 66 if (tmp->invisible)
76 continue; 67 continue;
68
77 if ((tmpmatch = item_matched_string (pl, tmp, params)) > match_val) 69 int tmpmatch = item_matched_string (pl, tmp, params);
70
71 if (tmpmatch > match_val)
78 { 72 {
79 if ((aflag == AP_APPLY) && (QUERY_FLAG (tmp, FLAG_APPLIED))) 73 if ((aflag == AP_APPLY) && (QUERY_FLAG (tmp, FLAG_APPLIED)))
80 continue; 74 continue;
75
81 if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, FLAG_APPLIED))) 76 if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, FLAG_APPLIED)))
82 continue; 77 continue;
78
83 match_val = tmpmatch; 79 match_val = tmpmatch;
84 best = tmp; 80 best = tmp;
85 } 81 }
86 } 82 }
83
87 return best; 84 return best;
88} 85}
89 86
90/** 87/**
91 * Shortcut to find_best_apply_object_match(pl, params, AF_NULL); 88 * Shortcut to find_best_apply_object_match(pl, params, AF_NULL);
92 **/ 89 **/
93object * 90object *
94find_best_object_match (object *pl, const char *params) 91find_best_object_match (object *pl, const char *params)
95{ 92{
96 return find_best_apply_object_match (pl, params, AP_NULL); 93 return find_best_apply_object_match (pl, params, AP_TOGGLE);
94}
95
96static bool
97can_split (object *pl, object *&op, sint32 nrof)
98{
99 if (object *tmp = op->split (nrof ? nrof : op->number_of ()))
100 {
101 op = tmp;
102 return true;
103 }
104 else
105 {
106 if (op->nrof > 1)
107 new_draw_info_format (NDI_UNIQUE, 0, pl, "There are only %d %s.", op->nrof, &op->name_pl);
108 else
109 new_draw_info_format (NDI_UNIQUE, 0, pl, "There is only one %s.", &op->name);
110
111 return false;
112 }
97} 113}
98 114
99int 115int
100command_uskill (object *pl, char *params) 116command_uskill (object *pl, char *params)
101{ 117{
102 if (!params) 118 if (!params)
103 { 119 {
104 new_draw_info (NDI_UNIQUE, 0, pl, "Usage: use_skill <skill name>"); 120 new_draw_info (NDI_UNIQUE, 0, pl, "Usage: use_skill <skill name>");
105 return 0; 121 return 0;
106 } 122 }
123
107 return use_skill (pl, params); 124 return use_skill (pl, params);
108} 125}
109 126
110int 127int
111command_rskill (object *pl, char *params) 128command_rskill (object *pl, char *params)
… …
115 if (!params) 132 if (!params)
116 { 133 {
117 new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>"); 134 new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>");
118 return 0; 135 return 0;
119 } 136 }
137
120 skill = find_skill_by_name (pl, params); 138 skill = find_skill_by_name_fuzzy (pl, params);
121 139
122 if (!skill) 140 if (!skill)
123 { 141 {
124 new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the skill %s", params); 142 new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the skill %s", params);
125 return 0; 143 return 0;
126 } 144 }
127 return change_skill (pl, skill, 0);
128}
129 145
130 146 pl->change_skill (0);
131/* These functions (command_search, command_disarm) are really just wrappers for 147 apply_special (pl, skill, AP_APPLY);
132 * things like 'use_skill ...'). In fact, they should really be obsoleted 148 return 1;
133 * and replaced with those.
134 */
135int
136command_search (object *op, char *params)
137{
138 return use_skill (op, skill_names[SK_FIND_TRAPS]);
139} 149}
140
141int
142command_disarm (object *op, char *params)
143{
144 return use_skill (op, skill_names[SK_DISARM_TRAPS]);
145}
146
147 150
148/* A little special because we do want to pass the full params along 151/* A little special because we do want to pass the full params along
149 * as it includes the object to throw. 152 * as it includes the object to throw.
150 */ 153 */
151int 154int
152command_throw (object *op, char *params) 155command_throw (object *op, char *params)
153{ 156{
154 object *skop;
155
156 skop = find_skill_by_name (op, skill_names[SK_THROWING]); 157 if (object *skop = find_skill_by_name (op, skill_names[SK_THROWING]))
157 if (skop)
158 return do_skill (op, op, skop, op->facing, params); 158 return do_skill (op, op, skop, op->facing, params);
159 else 159 else
160 {
161 new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing."); 160 new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing.");
162 } 161
163 return 0; 162 return 0;
164} 163}
165
166 164
167int 165int
168command_apply (object *op, char *params) 166command_apply (object *op, char *params)
169{ 167{
170 if (!params) 168 if (!params)
… …
172 player_apply_below (op); 170 player_apply_below (op);
173 return 0; 171 return 0;
174 } 172 }
175 else 173 else
176 { 174 {
177 apply_flag aflag = (apply_flag) 0; 175 apply_flag aflag = (apply_flag)0;
178 object *inv;
179 176
180 while (*params == ' ') 177 while (*params == ' ')
181 params++; 178 params++;
179
182 if (!strncmp (params, "-a ", 3)) 180 if (!strncmp (params, "-a ", 3))
183 { 181 {
184 aflag = AP_APPLY; 182 aflag = AP_APPLY;
185 params += 3; 183 params += 3;
186 } 184 }
185
187 if (!strncmp (params, "-u ", 3)) 186 if (!strncmp (params, "-u ", 3))
188 { 187 {
189 aflag = AP_UNAPPLY; 188 aflag = AP_UNAPPLY;
190 params += 3; 189 params += 3;
191 } 190 }
191
192 while (*params == ' ') 192 while (*params == ' ')
193 params++; 193 params++;
194 194
195 inv = find_best_apply_object_match (op, params, aflag); 195 if (object *inv = find_best_apply_object_match (op, params, aflag))
196 if (inv)
197 {
198 player_apply (op, inv, aflag, 0); 196 player_apply (op, inv, aflag, 0);
199 }
200 else 197 else
201 new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params); 198 new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params);
202 } 199 }
200
203 return 0; 201 return 0;
204} 202}
205 203
206/* 204/*
207 * Check if an item op can be put into a sack. If pl exists then tell 205 * Check if an item op can be put into a sack. If pl exists then tell
… …
213 * not need to use split_ob and stuff. 211 * not need to use split_ob and stuff.
214 */ 212 */
215int 213int
216sack_can_hold (object *pl, object *sack, object *op, uint32 nrof) 214sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)
217{ 215{
218
219 if (!QUERY_FLAG (sack, FLAG_APPLIED)) 216 if (!QUERY_FLAG (sack, FLAG_APPLIED))
220 { 217 {
221 new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack)); 218 new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));
222 return 0; 219 return 0;
223 } 220 }
221
224 if (sack == op) 222 if (sack == op)
225 { 223 {
226 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack)); 224 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));
227 return 0; 225 return 0;
228 } 226 }
227
229 if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type))) 228 if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))
230 { 229 {
231 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack)); 230 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack));
232 return 0; 231 return 0;
233 } 232 }
233
234 if (op->type == SPECIAL_KEY && sack->slaying && op->slaying) 234 if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)
235 { 235 {
236 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack)); 236 new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));
237 return 0; 237 return 0;
238 } 238 }
239
239 if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) * 240 if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) *
240 (op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0)) 241 (op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))
241 * (100 - sack->stats.Str) / 100) > sack->weight_limit) 242 * (100 - sack->stats.Str) / 100) > sack->weight_limit)
242 { 243 {
243 new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack)); 244 new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));
244 return 0; 245 return 0;
245 } 246 }
247
246 /* All other checks pass, must be OK */ 248 /* All other checks pass, must be OK */
247 return 1; 249 return 1;
248} 250}
249 251
250/* Pick up commands follow */ 252/* Pick up commands follow */
… …
255 * pick up (0 means all of them) 257 * pick up (0 means all of them)
256 */ 258 */
257static void 259static void
258pick_up_object (object *pl, object *op, object *tmp, int nrof) 260pick_up_object (object *pl, object *op, object *tmp, int nrof)
259{ 261{
260 /* buf needs to be big (more than 256 chars) because you can get
261 * very long item names.
262 */
263 char buf[HUGE_BUF];
264 object *env = tmp->env; 262 object *env = tmp->env;
265 uint32 weight, effective_weight_limit; 263 uint32 weight, effective_weight_limit;
266 int tmp_nrof = tmp->nrof ? tmp->nrof : 1; 264 int tmp_nrof = tmp->number_of ();
267 265
268 /* 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
269 * 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
270 * (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
271 * containers not allowed as of now) 269 * containers not allowed as of now)
272 */ 270 */
273 if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && is_player_inv (tmp) != pl) 271 if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && tmp->in_player () != pl)
274 { 272 {
275 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.>");
276 return; 276 return;
277 } 277 }
278
278 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 279 if (QUERY_FLAG (tmp, FLAG_NO_DROP))
279 return; 280 return;
280 if (QUERY_FLAG (tmp, FLAG_WAS_WIZ) && !QUERY_FLAG (pl, FLAG_WAS_WIZ))
281 {
282 new_draw_info (NDI_UNIQUE, 0, pl, "The object disappears in a puff of smoke!");
283 new_draw_info (NDI_UNIQUE, 0, pl, "It must have been an illusion.");
284 if (pl->type == PLAYER)
285 esrv_del_item (pl->contr, tmp->count);
286 if (!QUERY_FLAG (tmp, FLAG_REMOVED))
287 remove_ob (tmp);
288 free_object (tmp);
289 return;
290 }
291 281
292 if (nrof > tmp_nrof || nrof == 0) 282 if (nrof > tmp_nrof || nrof <= 0)
293 nrof = tmp_nrof; 283 nrof = tmp_nrof;
284
294 /* 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 */
295 weight = tmp->weight * nrof; 286 weight = tmp->weight * nrof;
296 if (tmp->inv) 287 if (tmp->inv)
297 weight += tmp->carrying * (100 - tmp->stats.Str) / 100; 288 weight += tmp->carrying * (100 - tmp->stats.Str) / 100;
298 if (pl->stats.Str <= MAX_STAT) 289
299 effective_weight_limit = weight_limit[pl->stats.Str]; 290 effective_weight_limit = weight_limit [min (MAX_STAT, pl->stats.Str)];
300 else 291
301 effective_weight_limit = weight_limit[MAX_STAT];
302 if ((pl->weight + pl->carrying + weight) > effective_weight_limit) 292 if ((pl->weight + pl->carrying + weight) > effective_weight_limit)
303 { 293 {
304 new_draw_info (0, 0, pl, "That item is too heavy for you to pick up."); 294 new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");
305 return; 295 return;
306 } 296 }
307 if (settings.real_wiz == FALSE && QUERY_FLAG (pl, FLAG_WAS_WIZ))
308 SET_FLAG (tmp, FLAG_WAS_WIZ);
309 if (nrof != tmp_nrof)
310 {
311 object *tmp2 = tmp;
312 tag_t tmp2_tag = tmp2->count;
313 297
314 tmp = get_split_ob (tmp, nrof); 298 if (!can_split (pl, tmp, nrof))
315 if (!tmp)
316 {
317 new_draw_info (NDI_UNIQUE, 0, pl, errmsg);
318 return; 299 return;
319 } 300
320 /* Tell a client what happened rest of objects */ 301 if (QUERY_FLAG (tmp, FLAG_UNPAID))
321 if (pl->type == PLAYER) 302 {
322 { 303 tmp->flag.reset (FLAG_UNPAID);
323 if (was_destroyed (tmp2, tmp2_tag)) 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));
324 esrv_del_item (pl->contr, tmp2_tag); 305 tmp->flag.set (FLAG_UNPAID);
325 else
326 esrv_send_item (pl, tmp2);
327 }
328 } 306 }
329 else 307 else
330 { 308 new_draw_info_format (NDI_UNIQUE, 0, pl, "You pick up the %s.", query_name (tmp));
331 /* If the object is in a container, send a delete to the client.
332 * - we are moving all the items from the container to elsewhere,
333 * so it needs to be deleted.
334 */
335 if (!QUERY_FLAG (tmp, FLAG_REMOVED))
336 {
337 if (tmp->env && pl->type == PLAYER)
338 esrv_del_item (pl->contr, tmp->count);
339 remove_ob (tmp); /* Unlink it */
340 }
341 }
342 if (QUERY_FLAG (tmp, FLAG_UNPAID))
343 (void) sprintf (buf, "%s will cost you %s.", query_name (tmp), query_cost_string (tmp, pl, F_BUY | F_SHOP));
344 else
345 (void) sprintf (buf, "You pick up the %s.", query_name (tmp));
346 new_draw_info (NDI_UNIQUE, 0, pl, buf);
347 309
348 tmp = insert_ob_in_ob (tmp, op); 310 op->insert (tmp);
349
350 /* All the stuff below deals with client/server code, and is only
351 * usable by players
352 */
353 if (pl->type != PLAYER)
354 return;
355
356 esrv_send_item (pl, tmp);
357 /* These are needed to update the weight for the container we
358 * are putting the object in.
359 */
360 if (op != pl)
361 {
362 esrv_update_item (UPD_WEIGHT, pl, op);
363 esrv_send_item (pl, pl);
364 }
365
366 /* Update the container the object was in */
367 if (env && env != pl && env != op)
368 esrv_update_item (UPD_WEIGHT, pl, env);
369} 311}
370 312
371 313/* modified slightly to allow monsters use this -b.t. 5-31-95 */
372void 314void
373pick_up (object *op, object *alt) 315pick_up (object *op, object *alt)
374
375/* modified slightly to allow monsters use this -b.t. 5-31-95 */
376{ 316{
377 int need_fix_tmp = 0; 317 int need_fix_tmp = 0;
378 object *tmp = NULL; 318 object *tmp = NULL;
379 mapstruct *tmp_map = NULL; 319 maptile *tmp_map = NULL;
380 int count; 320 int count;
381 tag_t tag;
382 321
383 /* Decide which object to pick. */ 322 /* Decide which object to pick. */
384 if (alt) 323 if (alt)
385 { 324 {
386 if (!can_pick (op, alt)) 325 if (!can_pick (op, alt))
387 { 326 {
388 new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name); 327 new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);
389 goto leave; 328 goto leave;
390 } 329 }
330
391 tmp = alt; 331 tmp = alt;
392 } 332 }
393 else 333 else
394 { 334 {
395 if (op->below == NULL || !can_pick (op, op->below)) 335 if (op->below == NULL || !can_pick (op, op->below))
396 { 336 {
397 new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up here."); 337 new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up here.");
398 goto leave; 338 goto leave;
399 } 339 }
340
400 tmp = op->below; 341 tmp = op->below;
401 } 342 }
402 343
403 /* Try to catch it. */ 344 /* Try to catch it. */
404 tmp_map = tmp->map; 345 tmp_map = tmp->map;
405 tmp = stop_item (tmp); 346 tmp = stop_item (tmp);
406 if (tmp == NULL) 347 if (tmp == NULL)
407 goto leave; 348 goto leave;
349
408 need_fix_tmp = 1; 350 need_fix_tmp = 1;
409 if (!can_pick (op, tmp)) 351 if (!can_pick (op, tmp))
410 goto leave; 352 goto leave;
411 353
412 if (op->type == PLAYER) 354 if (op->type == PLAYER)
… …
417 } 359 }
418 else 360 else
419 count = tmp->nrof; 361 count = tmp->nrof;
420 362
421 /* container is open, so use it */ 363 /* container is open, so use it */
364 if (tmp->flag [FLAG_STARTEQUIP])
365 alt = op;
422 if (op->container) 366 else if (op->container)
423 { 367 {
424 alt = op->container; 368 alt = op->container;
425 if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count)) 369 if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))
426 goto leave; 370 goto leave;
427 } 371 }
… …
434 378
435 if (!alt) 379 if (!alt)
436 for (alt = op->inv; alt; alt = alt->below) 380 for (alt = op->inv; alt; alt = alt->below)
437 if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && sack_can_hold (NULL, alt, tmp, count)) 381 if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && sack_can_hold (NULL, alt, tmp, count))
438 break; /* General container comes next */ 382 break; /* General container comes next */
383
439 if (!alt) 384 if (!alt)
440 alt = op; /* No free containers */ 385 alt = op; /* No free containers */
441 } 386 }
387
442 if (tmp->env == alt) 388 if (tmp->env == alt)
443 { 389 {
444 /* here it could be possible to check rent, 390 /* here it could be possible to check rent,
445 * if someone wants to implement it 391 * if someone wants to implement it
446 */ 392 */
447 alt = op; 393 alt = op;
448 } 394 }
395
449#ifdef PICKUP_DEBUG 396#ifdef PICKUP_DEBUG
450 LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name); 397 LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);
451#endif 398#endif
452 399
453 /* startequip items are not allowed to be put into containers: */ 400 /* startequip items are not allowed to be put into containers: */
… …
455 { 402 {
456 new_draw_info (NDI_UNIQUE, 0, op, "This object cannot be put into containers!"); 403 new_draw_info (NDI_UNIQUE, 0, op, "This object cannot be put into containers!");
457 goto leave; 404 goto leave;
458 } 405 }
459 406
460 tag = tmp->count;
461 pick_up_object (op, alt, tmp, count); 407 pick_up_object (op, alt, tmp, count);
408
462 if (was_destroyed (tmp, tag) || tmp->env) 409 if (tmp->destroyed () || tmp->env)
463 need_fix_tmp = 0; 410 need_fix_tmp = 0;
411
464 if (op->type == PLAYER) 412 if (op->type == PLAYER)
465 op->contr->count = 0; 413 op->contr->count = 0;
414
466 goto leave; 415 goto leave;
467 416
468leave: 417leave:
469 if (need_fix_tmp) 418 if (need_fix_tmp)
470 fix_stopped_item (tmp, tmp_map, op); 419 fix_stopped_item (tmp, tmp_map, op);
471} 420}
472
473 421
474/* This takes (picks up) and item. op is the player 422/* This takes (picks up) and item. op is the player
475 * who issued the command. params is a string to 423 * who issued the command. params is a string to
476 * match against the item name. Basically, always 424 * match against the item name. Basically, always
477 * returns zero, but that should be improved. 425 * returns zero, but that should be improved.
… …
486 else 434 else
487 { 435 {
488 tmp = op->above; 436 tmp = op->above;
489 if (tmp) 437 if (tmp)
490 while (tmp->above) 438 while (tmp->above)
491 {
492 tmp = tmp->above; 439 tmp = tmp->above;
493 } 440
494 if (!tmp) 441 if (!tmp)
495 tmp = op->below; 442 tmp = op->below;
496 } 443 }
497 444
498 if (tmp == NULL) 445 if (!tmp)
499 { 446 {
500 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!"); 447 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!");
501 return 0; 448 return 0;
502 } 449 }
503 450
504 /* Makes processing easier */ 451 /* Makes processing easier */
505 if (params && *params == '\0') 452 if (params && *params == '\0')
506 params = NULL; 453 params = 0;
454
455 int cnt = MAX_ITEM_PER_DROP;
507 456
508 while (tmp) 457 while (tmp)
509 { 458 {
510 next = tmp->below; 459 next = tmp->below;
511 460
512 if (tmp->invisible) 461 if (tmp->invisible)
513 { 462 {
514 tmp = next; 463 tmp = next;
515 continue; 464 continue;
516 } 465 }
466
517 /* This following two if and else if could be merged into line 467 /* This following two if and else if could be merged into line
518 * but that probably will make it more difficult to read, and 468 * but that probably will make it more difficult to read, and
519 * not make it any more efficient 469 * not make it any more efficient
520 */ 470 */
521 if (params && item_matched_string (op, tmp, params)) 471 if (params && item_matched_string (op, tmp, params))
522 { 472 {
473 if (--cnt < 0) break;
523 pick_up (op, tmp); 474 pick_up (op, tmp);
524 } 475 }
525 else if (can_pick (op, tmp) && !params) 476 else if (can_pick (op, tmp) && !params)
526 { 477 {
478 if (--cnt < 0) break;
527 pick_up (op, tmp); 479 pick_up (op, tmp);
528 break; 480 break;
529 } 481 }
482
530 tmp = next; 483 tmp = next;
531 /* Might as well just skip over the player immediately - 484 }
532 * we know it can't be picked up 485
533 */ 486 if (cnt < 0)
534 if (tmp == op)
535 tmp = tmp->below;
536 } 487 {
488 op->failmsg ("Couldn't pick up so many items at once.");
489 return 0;
490 }
491
537 if (!params && !tmp) 492 if (!params && !tmp)
538 { 493 {
539 for (tmp = op->below; tmp != NULL; tmp = tmp->next) 494 for (tmp = op->below; tmp; tmp = tmp->below)
540 if (!tmp->invisible) 495 if (!tmp->invisible)
541 { 496 {
542 char buf[MAX_BUF];
543
544 sprintf (buf, "You can't pick up a %s.", &tmp->name); 497 new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up a %s.", &tmp->name);
545 new_draw_info (NDI_UNIQUE, 0, op, buf);
546 break; 498 break;
547 } 499 }
500
548 if (!tmp) 501 if (!tmp)
549 new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up."); 502 new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up.");
550 } 503 }
504
551 return 0; 505 return 0;
552} 506}
553 507
554
555/* 508/*
556 * This function was part of drop, now is own function. 509 * This function was part of drop, now is own function.
557 * Player 'op' tries to put object 'tmp' into sack 'sack', 510 * Player 'op' tries to put object 'tmp' into sack 'sack',
558 * if nrof is non zero, then nrof objects is tried to put into sack. 511 * if nrof is non zero, then nrof objects is tried to put into sack.
512 *
559 * Note that the 'sack' in question can now be a transport, 513 * Note that the 'sack' in question can now be a transport,
560 * so this function isn't named very good anymore. 514 * so this function isn't named very good anymore.
561 */ 515 */
562void 516void
563put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof) 517put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof)
564{ 518{
565 tag_t tmp_tag, tmp2_tag;
566 object *tmp2, *sack2; 519 object *tmp2, *sack2;
567 char buf[MAX_BUF]; 520 char buf[MAX_BUF];
568 521
569 if (sack == tmp) 522 if (sack == tmp)
570 return; /* Can't put an object in itself */ 523 return; /* Can't put an object in itself */
524
571 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 525 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))
572 { 526 {
573 new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack)); 527 new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack));
574 return; 528 return;
575 } 529 }
530
576 if (tmp->type == CONTAINER && tmp->inv) 531 if (tmp->type == CONTAINER && tmp->inv)
577 { 532 {
578
579 /* Eneq(@csd.uu.se): If the object to be dropped is a container 533 /* Eneq(@csd.uu.se): If the object to be dropped is a container
580 * we instead move the contents of that container into the active 534 * we instead move the contents of that container into the active
581 * container, this is only done if the object has something in it. 535 * container, this is only done if the object has something in it.
582 */ 536 */
583 sack2 = tmp; 537 sack2 = tmp;
584 new_draw_info_format (NDI_UNIQUE, 0, op, "You move the items from %s into %s.", query_name (tmp), query_name (sack)); 538 new_draw_info_format (NDI_UNIQUE, 0, op, "You move the items from %s into %s.", query_name (tmp), query_name (sack));
539
585 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp) 540 for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
586 { 541 {
587 tmp = tmp2->below; 542 tmp = tmp2->below;
543
588 if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof))) 544 if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))
589 {
590 put_object_in_sack (op, sack, tmp2, 0); 545 put_object_in_sack (op, sack, tmp2, 0);
591 }
592 else 546 else
593 { 547 {
594 sprintf (buf, "Your %s fills up.", query_name (sack)); 548 sprintf (buf, "Your %s fills up.", query_name (sack));
595 new_draw_info (NDI_UNIQUE, 0, op, buf); 549 new_draw_info (NDI_UNIQUE, 0, op, buf);
596 break; 550 break;
597 } 551 }
598 } 552 }
599 esrv_update_item (UPD_WEIGHT, op, sack2); 553
600 return; 554 return;
601 } 555 }
602 556
603 /* Don't worry about this for containers - our caller should have 557 /* Don't worry about this for containers - our caller should have
604 * already checked this. 558 * already checked this.
605 */ 559 */
606 if ((sack->type == CONTAINER) && !sack_can_hold (op, sack, tmp, (nrof ? nrof : tmp->nrof))) 560 if ((sack->type == CONTAINER) && !sack_can_hold (op, sack, tmp, (nrof ? nrof : tmp->nrof)))
607 return; 561 return;
608 562
609 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 563 if (QUERY_FLAG (tmp, FLAG_APPLIED))
610 {
611 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE)) 564 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
612 return; 565 return;
613 }
614 566
615 /* we want to put some portion of the item into the container */ 567 /* we want to put some portion of the item into the container */
616 if (nrof && tmp->nrof != nrof) 568 if (!can_split (op, tmp, nrof))
617 {
618 object *tmp2 = tmp;
619
620 tmp2_tag = tmp2->count;
621 tmp = get_split_ob (tmp, nrof);
622
623 if (!tmp)
624 {
625 new_draw_info (NDI_UNIQUE, 0, op, errmsg);
626 return; 569 return;
627 }
628 /* Tell a client what happened other objects */
629 if (was_destroyed (tmp2, tmp2_tag))
630 esrv_del_item (op->contr, tmp2_tag);
631 else /* this can proably be replaced with an update */
632 esrv_send_item (op, tmp2);
633 }
634 else
635 remove_ob (tmp);
636 570
637 new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack)); 571 new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));
638 tmp_tag = tmp->count; 572 sack->insert (tmp);
639 tmp2 = insert_ob_in_ob (tmp, sack);
640 fix_player (op); /* This is overkill, fix_player() is called somewhere */
641 /* in object.c */
642
643 /* If an object merged (and thus, different object), we need to
644 * delete the original.
645 */
646 if (tmp2 != tmp)
647 esrv_del_item (op->contr, tmp_tag);
648
649 esrv_send_item (op, tmp2);
650
651 /* update the sacks weight */
652 esrv_update_item (UPD_WEIGHT, op, sack);
653} 573}
654 574
655/* 575/*
656 * This function was part of drop, now is own function. 576 * This function was part of drop, now is own function.
657 * Player 'op' tries to drop object 'tmp', if tmp is non zero, then 577 * Player 'op' tries to drop object 'tmp', if tmp is non zero, then
… …
659 * This is used when dropping objects onto the floor. 579 * This is used when dropping objects onto the floor.
660 */ 580 */
661void 581void
662drop_object (object *op, object *tmp, uint32 nrof) 582drop_object (object *op, object *tmp, uint32 nrof)
663{ 583{
664 char buf[MAX_BUF];
665 object *floor;
666
667 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 584 if (QUERY_FLAG (tmp, FLAG_NO_DROP))
668 return; 585 return;
669 586
670 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 587 if (QUERY_FLAG (tmp, FLAG_APPLIED))
671 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE)) 588 if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
672 return; /* can't unapply it */ 589 return; /* can't unapply it */
673 590
591 //fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
592
674 /* We are only dropping some of the items. We split the current objec 593 /* We are only dropping some of the items. We split the current object
675 * off 594 * off
676 */ 595 */
677 if (nrof && tmp->nrof != nrof) 596 if (!can_split (op, tmp, nrof))
678 {
679 object *tmp2 = tmp;
680 tag_t tmp2_tag = tmp2->count;
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 (was_destroyed (tmp2, tmp2_tag))
694 esrv_del_item (op->contr, tmp2_tag);
695 else
696 esrv_send_item (op, tmp2);
697 }
698 }
699 else
700 remove_ob (tmp);
701
702 if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))
703 return; 597 return;
704 598
599 drop_object (op, tmp);
600
601 if (!tmp->destroyed () && !tmp->is_inserted ())
602 {
603 // if nothing happened with the object we give it back
604 op->insert (tmp);
605 }
606}
607
608/* In contrast to drop_object (op, tmp, nrof) above this function takes the
609 * already split off object, and feeds it to the event handlers and does
610 * other magic with it.
611 *
612 * <droppper> is the object that dropped this object and <obj> is the
613 * object that was dropped.
614 *
615 * Make sure to check what happened with <obj> after this function returns!
616 * Otherwise you may leak this object.
617 */
618
619void
620drop_object (object *dropper, object *obj)
621{
622 if (INVOKE_OBJECT (DROP, obj, ARG_OBJECT (dropper)))
623 return;
624
625 if (obj->destroyed () || obj->is_inserted ())
626 return;
627
705 if (QUERY_FLAG (tmp, FLAG_STARTEQUIP)) 628 if (QUERY_FLAG (obj, FLAG_STARTEQUIP))
706 { 629 {
707 sprintf (buf, "You drop the %s.", query_name (tmp)); 630 dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
708 new_draw_info (NDI_UNIQUE, 0, op, buf); 631 dropper->statusmsg ("The god who lent it to you retrieves it.");
709 new_draw_info (NDI_UNIQUE, 0, op, "The gods who lent it to you retrieves it."); 632
710 if (op->type == PLAYER) 633 obj->destroy ();
711 esrv_del_item (op->contr, tmp->count); 634 dropper->update_stats ();
712 free_object (tmp);
713 fix_player (op);
714 return; 635 return;
715 } 636 }
716 637
717/* If SAVE_INTERVAL is commented out, we never want to save 638 for (object *floor = GET_MAP_OB (dropper->map, dropper->x, dropper->y);
718 * the player here. 639 floor;
719 */ 640 floor = floor->above)
720#ifdef SAVE_INTERVAL 641 if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (obj), ARG_OBJECT (dropper)))
721 /* I'm not sure why there is a value check - since the save 642 return;
722 * is done every SAVE_INTERVAL seconds, why care the value 643
723 * of what he is dropping? 644 if (obj->destroyed () || obj->is_inserted ())
645 return;
646
647 if (is_in_shop (dropper) && !QUERY_FLAG (obj, FLAG_UNPAID) && obj->type != MONEY)
648 if (!sell_item (obj, dropper))
649 return;
650
651 /* If nothing special happened with this object, the default action is to
652 * insert it below the dropper:
724 */ 653 */
725 if (op->type == PLAYER && !QUERY_FLAG (tmp, FLAG_UNPAID) &&
726 (tmp->nrof ? tmp->value * tmp->nrof : tmp->value > 2000) && (op->contr->last_save_time + SAVE_INTERVAL) <= time (NULL))
727 {
728 save_player (op, 1);
729 op->contr->last_save_time = time (NULL);
730 }
731#endif /* SAVE_INTERVAL */
732 654
733 if (op->type == PLAYER) 655 obj->x = dropper->x;
734 esrv_del_item (op->contr, tmp->count); 656 obj->y = dropper->y;
735 657
736 /* Call this before we update the various windows/players. At least
737 * that we, we know the weight is correct.
738 */
739 fix_player (op); /* This is overkill, fix_player() is called somewhere */
740 /* in object.c */
741
742 if (op->type == PLAYER)
743 {
744 op->contr->socket.update_look = 1;
745 /* Need to update the weight for the player */
746 esrv_send_item (op, op);
747 }
748
749 for (floor = get_map_ob (op->map, op->x, op->y); floor; floor = floor->above)
750 if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
751 return;
752
753 if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
754 sell_item (tmp, op);
755
756 tmp->x = op->x;
757 tmp->y = op->y;
758
759 insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR); 658 insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
760} 659}
761 660
762void 661void
763drop (object *op, object *tmp) 662drop (object *op, object *tmp)
764{ 663{
… …
773 if (tmp->env && tmp->env->type != PLAYER) 672 if (tmp->env && tmp->env->type != PLAYER)
774 { 673 {
775 /* Just toss the object - probably shouldn't be hanging 674 /* Just toss the object - probably shouldn't be hanging
776 * around anyways 675 * around anyways
777 */ 676 */
778 remove_ob (tmp); 677 tmp->destroy ();
779 free_object (tmp);
780 return; 678 return;
781 } 679 }
782 else 680 else
783 { 681 {
784 while (tmp != NULL && tmp->invisible) 682 while (tmp && tmp->invisible)
785 tmp = tmp->below; 683 tmp = tmp->below;
786 } 684 }
787 } 685 }
788 686
789 if (tmp == NULL) 687 if (tmp == NULL)
790 { 688 {
791 new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop."); 689 new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");
792 return; 690 return;
793 } 691 }
692
794 if (QUERY_FLAG (tmp, FLAG_INV_LOCKED)) 693 if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))
795 { 694 {
796 new_draw_info (NDI_UNIQUE, 0, op, "This item is locked"); 695 new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
797 return; 696 return;
798 } 697 }
698
799 if (QUERY_FLAG (tmp, FLAG_NO_DROP)) 699 if (QUERY_FLAG (tmp, FLAG_NO_DROP))
800 { 700 {
801#if 0 701#if 0
802 /* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */ 702 /* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */
803 new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped."); 703 new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");
804#endif 704#endif
805 return; 705 return;
806 } 706 }
807 707
808 if (op->type == PLAYER) 708 if (op->type == PLAYER && op->contr->last_used == tmp)
809 { 709 op->contr->last_used = tmp->below ? tmp->below
810 if (op->contr->last_used == tmp && op->contr->last_used_id == tmp->count) 710 : tmp->above ? tmp->above
811 { 711 : 0;
812 object *n = NULL;
813
814 if (tmp->below != NULL)
815 n = tmp->below;
816 else if (tmp->above != NULL)
817 n = tmp->above;
818 op->contr->last_used = n;
819 if (n != NULL)
820 op->contr->last_used_id = n->count;
821 else
822 op->contr->last_used_id = 0;
823 }
824 };
825 712
826 if (op->container) 713 if (op->container)
827 { 714 {
828 if (op->type == PLAYER) 715 if (op->type == PLAYER)
829 {
830 put_object_in_sack (op, op->container, tmp, op->contr->count); 716 put_object_in_sack (op, op->container, tmp, op->contr->count);
831 }
832 else 717 else
833 {
834 put_object_in_sack (op, op->container, tmp, 0); 718 put_object_in_sack (op, op->container, tmp, 0);
835 };
836 } 719 }
837 else 720 else
838 { 721 {
839 if (op->type == PLAYER) 722 if (op->type == PLAYER)
840 {
841 drop_object (op, tmp, op->contr->count); 723 drop_object (op, tmp, op->contr->count);
842 }
843 else 724 else
844 {
845 drop_object (op, tmp, 0); 725 drop_object (op, tmp, 0);
846 };
847 } 726 }
727
848 if (op->type == PLAYER) 728 if (op->type == PLAYER)
849 op->contr->count = 0; 729 op->contr->count = 0;
850} 730}
851
852
853 731
854/* Command will drop all items that have not been locked */ 732/* Command will drop all items that have not been locked */
855int 733int
856command_dropall (object *op, char *params) 734command_dropall (object *op, char *params)
857{ 735{
858 736
859 object *curinv, *nextinv;
860
861 if (op->inv == NULL) 737 if (op->inv == NULL)
862 { 738 {
863 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!"); 739 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
864 return 0; 740 return 0;
865 } 741 }
866 742
867 curinv = op->inv; 743 object *curinv = op->inv;
744 object *nextinv;
868 745
869 /* 746 /*
870 This is the default. Drops everything not locked or considered 747 This is the default. Drops everything not locked or considered
871 not something that should be dropped. 748 not something that should be dropped.
872 */ 749 */
… …
874 Care must be taken that the next item pointer is not to money as 751 Care must be taken that the next item pointer is not to money as
875 the drop() routine will do unknown things to it when dropping 752 the drop() routine will do unknown things to it when dropping
876 in a shop. --Tero.Pelander@utu.fi 753 in a shop. --Tero.Pelander@utu.fi
877 */ 754 */
878 755
879 if (params == NULL) 756 int cnt = MAX_ITEM_PER_DROP;
757
758 if (!params)
880 { 759 {
881 while (curinv != NULL) 760 while (curinv)
882 { 761 {
883 nextinv = curinv->below; 762 nextinv = curinv->below;
763
884 while (nextinv && nextinv->type == MONEY) 764 while (nextinv && nextinv->type == MONEY)
885 nextinv = nextinv->below; 765 nextinv = nextinv->below;
766
886 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY && 767 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&
887 curinv->type != FOOD && curinv->type != KEY && 768 curinv->type != FOOD && curinv->type != KEY &&
888 curinv->type != SPECIAL_KEY && curinv->type != GEM && 769 curinv->type != SPECIAL_KEY && curinv->type != GEM &&
889 !curinv->invisible && (curinv->type != CONTAINER || op->container != curinv)) 770 !curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))
890 { 771 {
891 drop (op, curinv); 772 drop (op, curinv);
773 if (--cnt <= 0) break;
892 } 774 }
775
893 curinv = nextinv; 776 curinv = nextinv;
894 } 777 }
895 } 778 }
896
897 else if (strcmp (params, "weapons") == 0) 779 else if (strcmp (params, "weapons") == 0)
898 { 780 {
899 while (curinv != NULL) 781 while (curinv)
900 { 782 {
901 nextinv = curinv->below; 783 nextinv = curinv->below;
784
902 while (nextinv && nextinv->type == MONEY) 785 while (nextinv && nextinv->type == MONEY)
903 nextinv = nextinv->below; 786 nextinv = nextinv->below;
787
904 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW))) 788 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))
905 { 789 {
906 drop (op, curinv); 790 drop (op, curinv);
791 if (--cnt <= 0) break;
907 } 792 }
793
908 curinv = nextinv; 794 curinv = nextinv;
909 } 795 }
910 } 796 }
911
912 else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0) 797 else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)
913 { 798 {
914 while (curinv != NULL) 799 while (curinv)
915 { 800 {
916 nextinv = curinv->below; 801 nextinv = curinv->below;
802
917 while (nextinv && nextinv->type == MONEY) 803 while (nextinv && nextinv->type == MONEY)
918 nextinv = nextinv->below; 804 nextinv = nextinv->below;
805
919 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET)) 806 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))
920 { 807 {
921 drop (op, curinv); 808 drop (op, curinv);
809 if (--cnt <= 0) break;
922 } 810 }
811
923 curinv = nextinv; 812 curinv = nextinv;
924 } 813 }
925 } 814 }
926
927 else if (strcmp (params, "misc") == 0) 815 else if (strcmp (params, "misc") == 0)
928 { 816 {
929 while (curinv != NULL) 817 while (curinv)
930 { 818 {
931 nextinv = curinv->below; 819 nextinv = curinv->below;
820
932 while (nextinv && nextinv->type == MONEY) 821 while (nextinv && nextinv->type == MONEY)
933 nextinv = nextinv->below; 822 nextinv = nextinv->below;
823
934 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED)) 824 if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))
935 { 825 {
936 switch (curinv->type) 826 switch (curinv->type)
937 { 827 {
938 case HORN: 828 case HORN:
939 case BOOK: 829 case BOOK:
940 case SPELLBOOK: 830 case SPELLBOOK:
941 case GIRDLE: 831 case GIRDLE:
942 case AMULET: 832 case AMULET:
943 case RING: 833 case RING:
944 case CLOAK: 834 case CLOAK:
945 case BOOTS: 835 case BOOTS:
946 case GLOVES: 836 case GLOVES:
947 case BRACERS: 837 case BRACERS:
948 case SCROLL: 838 case SCROLL:
949 case ARMOUR_IMPROVER: 839 case ARMOUR_IMPROVER:
950 case WEAPON_IMPROVER: 840 case WEAPON_IMPROVER:
951 case WAND: 841 case WAND:
952 case ROD: 842 case ROD:
953 case POTION: 843 case POTION:
954 drop (op, curinv); 844 drop (op, curinv);
955 curinv = nextinv; 845 curinv = nextinv;
956 break; 846 break;
957 default: 847 default:
958 curinv = nextinv; 848 curinv = nextinv;
959 break; 849 break;
960 } 850 }
851
852 if (--cnt <= 0) break;
961 } 853 }
854
962 curinv = nextinv; 855 curinv = nextinv;
963 } 856 }
964 } 857 }
965 op->contr->socket.update_look = 1; 858
859 if (cnt <= 0)
860 op->failmsg ("Only dropped some items, can't drop that many items at once.");
966 861
967/* draw_look(op);*/ 862/* draw_look(op);*/
968 return 0; 863 return 0;
864}
865
866
867/* This function tries to drop all objects in the <objs> vector.
868 * <dropper> is the object that wants to drop them.
869 * <cnt> can be a 0 pointer or a pointer to the maximum number of
870 * drop operations to perform.
871 *
872 * Returns true if at least one item was dropped.
873 */
874bool
875drop_vector (object *dropper, vector<object *> &objs, int *cnt)
876{
877 vector<object *>::iterator i;
878
879 bool did_one = false;
880
881 for (i = objs.begin (); i != objs.end (); i++)
882 {
883 drop (dropper, *i);
884 if (cnt && --*cnt <= 0) break;
885 did_one = true;
886 }
887
888 return did_one;
969} 889}
970 890
971/* Object op wants to drop object(s) params. params can be a 891/* Object op wants to drop object(s) params. params can be a
972 * comma seperated list. 892 * comma seperated list.
973 */ 893 */
974
975int 894int
976command_drop (object *op, char *params) 895command_drop (object *op, char *params)
977{ 896{
978 object *tmp, *next; 897 object *tmp, *next;
979 int did_one = 0; 898 int did_one = 0;
… …
983 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?"); 902 new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
984 return 0; 903 return 0;
985 } 904 }
986 else 905 else
987 { 906 {
907 vector<object *> matched_objs;
908
988 for (tmp = op->inv; tmp; tmp = next) 909 for (tmp = op->inv; tmp; tmp = next)
989 { 910 {
990 next = tmp->below; 911 next = tmp->below;
991 if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible) 912 if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)
992 continue; 913 continue;
914
993 if (item_matched_string (op, tmp, params)) 915 if (item_matched_string (op, tmp, params))
994 { 916 matched_objs.push_back (tmp);
995 drop (op, tmp);
996 did_one = 1;
997 } 917 }
998 } 918
999 if (!did_one) 919 int cnt = MAX_ITEM_PER_DROP;
920
921 if (!drop_vector (op, matched_objs, &cnt))
1000 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop."); 922 new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
1001 } 923
1002 if (op->type == PLAYER) 924 if (cnt <= 0)
1003 { 925 op->failmsg ("Only dropped some items, can't drop that many items at once.");
1004 op->contr->count = 0;
1005 op->contr->socket.update_look = 1;
1006 }; 926 }
1007 927
1008/* draw_look(op);*/
1009 return 0; 928 return 0;
1010} 929}
1011 930
1012int 931int
1013command_examine (object *op, char *params) 932command_examine (object *op, char *params)
1014{ 933{
1015 if (!params) 934 if (!params)
1016 { 935 {
1017 object *tmp = op->below; 936 object *tmp = op->below;
1018 937
1019 while (tmp && !LOOK_OBJ (tmp)) 938 while (tmp && !tmp->client_visible ())
1020 tmp = tmp->below; 939 tmp = tmp->below;
940
1021 if (tmp) 941 if (tmp)
1022 examine (op, tmp); 942 examine (op, tmp);
1023 } 943 }
1024 else 944 else
1025 { 945 {
1026 object *tmp = find_best_object_match (op, params); 946 object *tmp = find_best_object_match (op, params);
1027 947
1028 if (tmp) 948 if (tmp)
1029 examine (op, tmp); 949 examine (op, tmp);
1030 else 950 else
1031 new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params); 951 op->contr->infobox (MSG_CHANNEL ("examine"), format ("Could not find an object that matches %s", params));
1032 } 952 }
953
1033 return 0; 954 return 0;
1034} 955}
1035 956
1036/* op should be a player. 957/* op should be a player.
1037 * we return the object the player has marked with the 'mark' command 958 * we return the object the player has marked with the 'mark' command
… …
1044{ 965{
1045 object *tmp; 966 object *tmp;
1046 967
1047 if (!op || !op->contr) 968 if (!op || !op->contr)
1048 return NULL; 969 return NULL;
970
1049 if (!op->contr->mark) 971 if (!op->contr->mark)
1050 { 972 {
1051
1052/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/ 973/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
1053 return NULL; 974 return 0;
1054 } 975 }
976
1055 /* This may seem like overkill, but we need to make sure that they 977 /* This may seem like overkill, but we need to make sure that they
1056 * player hasn't dropped the item. We use count on the off chance that 978 * player hasn't dropped the item. We use count on the off chance that
1057 * an item got reincarnated at some point. 979 * an item got reincarnated at some point.
1058 */ 980 */
1059 for (tmp = op->inv; tmp; tmp = tmp->below) 981 for (tmp = op->inv; tmp; tmp = tmp->below)
1060 { 982 {
1061 if (tmp->invisible) 983 if (tmp->invisible)
1062 continue; 984 continue;
985
1063 if (tmp == op->contr->mark) 986 if (tmp == op->contr->mark)
1064 { 987 {
1065 if (tmp->count == op->contr->mark_count) 988 if (!tmp->destroyed ())
1066 return tmp; 989 return tmp;
1067 else 990 else
1068 { 991 {
1069 op->contr->mark = NULL; 992 op->contr->mark = 0;
1070 op->contr->mark_count = 0;
1071
1072/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/ 993/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
1073 return NULL; 994 return 0;
1074 } 995 }
1075 } 996 }
1076 } 997 }
1077 return NULL;
1078}
1079 998
1080
1081/* op should be a player, params is any params.
1082 * If no params given, we print out the currently marked object.
1083 * otherwise, try to find a matching object - try best match first.
1084 */
1085int
1086command_mark (object *op, char *params)
1087{
1088 if (!op->contr)
1089 return 1; 999 return 0;
1090 if (!params) 1000}
1091 {
1092 object *mark = find_marked_object (op);
1093 1001
1094 if (!mark) 1002std::string
1095 new_draw_info (NDI_UNIQUE, 0, op, "You have no marked object."); 1003object::describe_monster (object *who)
1096 else 1004{
1097 new_draw_info_format (NDI_UNIQUE, 0, op, "%s is marked.", query_name (mark)); 1005 dynbuf_text buf (512, 512);
1098 } 1006
1007 object *mon = head ? head : this;
1008
1009 if (QUERY_FLAG (mon, FLAG_UNDEAD))
1010 buf << "It is an undead force.\r";
1011
1012 if (mon->level > who->level)
1013 buf << "It is likely more powerful than you.\r";
1014 else if (mon->level < who->level)
1015 buf << "It is likely less powerful than you.\r";
1099 else 1016 else
1017 buf << "It is probably as powerful as you.\r";
1018
1019 if (mon->attacktype & AT_ACID)
1020 buf << "You seem to smell an acrid odor.\r";
1021
1022 /* Anyone know why this used to use the clone value instead of the
1023 * maxhp field? This seems that it should give more accurate results.
1024 */
1025 switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1026 { /* From 1-4 */
1027 case 1:
1028 buf << "It is in a bad shape.\r";
1029 break;
1030 case 2:
1031 buf << "It is hurt.\r";
1032 break;
1033 case 3:
1034 buf << "It is somewhat hurt.\r";
1035 break;
1036 case 4:
1037 buf << "It is in excellent shape.\r";
1038 break;
1100 { 1039 }
1101 object *mark1 = find_best_object_match (op, params);
1102 1040
1103 if (!mark1) 1041 if (present_in_ob (POISONING, mon))
1104 { 1042 buf << "It looks very ill.\r";
1105 new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params); 1043
1106 return 1; 1044 buf << '\n';
1045
1046 return buf;
1047}
1048
1049/* tmp is the object being described, pl is who is examing it. */
1050const char *
1051long_desc (object *tmp, object *pl)
1052{
1053 static std::string s;
1054
1055 return (s = tmp->long_desc (pl)).c_str ();
1056}
1057
1058std::string
1059object::long_desc (object *who)
1060{
1061 std::string buf (query_name ());
1062
1063 switch (type)
1064 {
1065 case RING:
1066 case SKILL:
1067 case WEAPON:
1068 case ARMOUR:
1069 case BRACERS:
1070 case HELMET:
1071 case SHIELD:
1072 case BOOTS:
1073 case GLOVES:
1074 case AMULET:
1075 case GIRDLE:
1076 case BOW:
1077 case ARROW:
1078 case CLOAK:
1079 case FOOD:
1080 case DRINK:
1081 case FLESH:
1082 case SKILL_TOOL:
1083 case LAMP:
1084 case POWER_CRYSTAL:
1107 } 1085 {
1108 else 1086 const char *cp = ::describe_item (this, who);
1087
1088 if (*cp)
1089 {
1090 buf.append (" ");
1091 buf.append (cp);
1092 }
1109 { 1093 }
1110 op->contr->mark = mark1;
1111 op->contr->mark_count = mark1->count;
1112 new_draw_info_format (NDI_UNIQUE, 0, op, "Marked item %s", query_name (mark1));
1113 return 0;
1114 }
1115 } 1094 }
1116 return 0; /*shouldnt get here */
1117}
1118 1095
1096 return buf;
1097}
1119 1098
1120/* op is the player 1099/* op is the player
1121 * tmp is the monster being examined. 1100 * tmp is the monster being examined.
1122 */ 1101 */
1123void 1102void
1124examine_monster (object *op, object *tmp) 1103examine_monster (object *op, object *tmp)
1125{ 1104{
1126 object *mon = tmp->head ? tmp->head : tmp; 1105 new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
1127
1128 if (QUERY_FLAG (mon, FLAG_UNDEAD))
1129 new_draw_info (NDI_UNIQUE, 0, op, "It is an undead force.");
1130 if (mon->level > op->level)
1131 new_draw_info (NDI_UNIQUE, 0, op, "It is likely more powerful than you.");
1132 else if (mon->level < op->level)
1133 new_draw_info (NDI_UNIQUE, 0, op, "It is likely less powerful than you.");
1134 else
1135 new_draw_info (NDI_UNIQUE, 0, op, "It is probably as powerful as you.");
1136 if (mon->attacktype & AT_ACID)
1137 new_draw_info (NDI_UNIQUE, 0, op, "You seem to smell an acrid odor.");
1138
1139 /* Anyone know why this used to use the clone value instead of the
1140 * maxhp field? This seems that it should give more accurate results.
1141 */
1142 switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1143 { /* From 1-4 */
1144 case 1:
1145 new_draw_info (NDI_UNIQUE, 0, op, "It is in a bad shape.");
1146 break;
1147 case 2:
1148 new_draw_info (NDI_UNIQUE, 0, op, "It is hurt.");
1149 break;
1150 case 3:
1151 new_draw_info (NDI_UNIQUE, 0, op, "It is somewhat hurt.");
1152 break;
1153 case 4:
1154 new_draw_info (NDI_UNIQUE, 0, op, "It is in excellent shape.");
1155 break;
1156 }
1157 if (present_in_ob (POISONING, mon) != NULL)
1158 new_draw_info (NDI_UNIQUE, 0, op, "It looks very ill.");
1159} 1106}
1160 1107
1161 1108std::string
1162/* tmp is the object being described, pl is who is examing it. */ 1109object::describe (object *who)
1163char *
1164long_desc (object *tmp, object *pl)
1165{ 1110{
1166 static char buf[VERY_BIG_BUF]; 1111 dynbuf_text buf (1024, 1024);
1167 char *cp;
1168 1112
1169 if (tmp == NULL) 1113 buf.printf ("That is: %s.\r", long_desc (who).c_str ());
1170 return "";
1171 1114
1172 buf[0] = '\0';
1173 switch (tmp->type)
1174 {
1175 case RING:
1176 case SKILL:
1177 case WEAPON:
1178 case ARMOUR:
1179 case BRACERS:
1180 case HELMET:
1181 case SHIELD:
1182 case BOOTS:
1183 case GLOVES:
1184 case AMULET:
1185 case GIRDLE:
1186 case BOW:
1187 case ARROW:
1188 case CLOAK:
1189 case FOOD:
1190 case DRINK:
1191 case FLESH:
1192 case SKILL_TOOL:
1193 case POWER_CRYSTAL:
1194 if (*(cp = describe_item (tmp, pl)) != '\0')
1195 {
1196 int len;
1197
1198 strncpy (buf, query_name (tmp), VERY_BIG_BUF - 1);
1199 buf[VERY_BIG_BUF - 1] = 0;
1200 len = strlen (buf);
1201 if (len < VERY_BIG_BUF - 5)
1202 {
1203 /* Since we know the length, we save a few cpu cycles by using
1204 * it instead of calling strcat */
1205 strcpy (buf + len, " ");
1206 len++;
1207 strncpy (buf + len, cp, VERY_BIG_BUF - len - 1);
1208 buf[VERY_BIG_BUF - 1] = 0;
1209 }
1210 }
1211 }
1212 if (buf[0] == '\0')
1213 {
1214 strncpy (buf, query_name (tmp), VERY_BIG_BUF - 1);
1215 buf[VERY_BIG_BUF - 1] = 0;
1216 }
1217
1218 return buf;
1219}
1220
1221void
1222examine (object *op, object *tmp)
1223{
1224 char buf[VERY_BIG_BUF];
1225 int i;
1226
1227 if (tmp == NULL || tmp->type == CLOSE_CON)
1228 return;
1229
1230 strcpy (buf, "That is ");
1231 strncat (buf, long_desc (tmp, op), VERY_BIG_BUF - strlen (buf) - 1);
1232 buf[VERY_BIG_BUF - 1] = 0;
1233
1234 new_draw_info (NDI_UNIQUE, 0, op, buf);
1235 buf[0] = '\0';
1236
1237 if (tmp->custom_name) 1115 if (custom_name)
1238 { 1116 buf.printf ("You call it %s.\r", &custom_name);
1239 strcpy (buf, "You call it ");
1240 strncat (buf, tmp->custom_name, VERY_BIG_BUF - strlen (buf) - 1);
1241 buf[VERY_BIG_BUF - 1] = 0;
1242 new_draw_info (NDI_UNIQUE, 0, op, buf);
1243 buf[0] = '\0';
1244 }
1245 1117
1246 switch (tmp->type) 1118 switch (type)
1247 { 1119 {
1248 case SPELLBOOK: 1120 case SPELLBOOK:
1249 if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) && tmp->inv) 1121 if (flag [FLAG_IDENTIFIED] && inv)
1250 {
1251 sprintf (buf, "%s is a %s level %s spell", &tmp->inv->name, get_levelnumber (tmp->inv->level), &tmp->inv->skill); 1122 buf.printf ("%s is a level %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill);
1252 }
1253 break; 1123 break;
1254 1124
1255 case BOOK: 1125 case BOOK:
1256 if (tmp->msg != NULL) 1126 if (msg)
1257 strcpy (buf, "Something is written in it."); 1127 buf << "Something is written in it.\r";
1258 break; 1128 break;
1259 1129
1260 case CONTAINER: 1130 case CONTAINER:
1261 if (tmp->race != NULL) 1131 if (race)
1262 { 1132 {
1263 if (tmp->weight_limit && tmp->stats.Str < 100) 1133 if (weight_limit && stats.Str < 100)
1264 sprintf (buf, "It can hold only %s and its weight limit is %.1f kg.", 1134 buf.printf ("It can hold only %s and its weight limit is %.1f kg.\r",
1265 &tmp->race, tmp->weight_limit / (10.0 * (100 - tmp->stats.Str))); 1135 &race, weight_limit / (10.0 * (100 - stats.Str)));
1266 else 1136 else
1267 sprintf (buf, "It can hold only %s.", &tmp->race); 1137 buf.printf ("It can hold only %s.\r", &race);
1268 } 1138 }
1269 else if (tmp->weight_limit && tmp->stats.Str < 100) 1139 else if (weight_limit && stats.Str < 100)
1270 sprintf (buf, "Its weight limit is %.1f kg.", tmp->weight_limit / (10.0 * (100 - tmp->stats.Str))); 1140 buf.printf ("Its weight limit is %.1f kg.\r", weight_limit / (10.0 * (100 - stats.Str)));
1271 break; 1141 break;
1272 1142
1273 case WAND: 1143 case WAND:
1274 if (QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 1144 if (flag [FLAG_IDENTIFIED])
1275 sprintf (buf, "It has %d charges left.", tmp->stats.food); 1145 buf.printf ("It has %d charges left.\r", stats.food);
1276 break; 1146 break;
1277 }
1278
1279 if (buf[0] != '\0')
1280 new_draw_info (NDI_UNIQUE, 0, op, buf);
1281
1282 if (tmp->materialname != NULL && !tmp->msg)
1283 { 1147 }
1148
1149 if (materialname && !msg)
1284 sprintf (buf, "It is made of: %s.", &tmp->materialname); 1150 buf.printf ("It is made of: %s.\r", &materialname);
1285 new_draw_info (NDI_UNIQUE, 0, op, buf); 1151
1286 } 1152 if (who)
1287 /* Where to wear this item */ 1153 /* Where to wear this item */
1288 for (i = 0; i < NUM_BODY_LOCATIONS; i++) 1154 for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1289 { 1155 if (slot[i].info)
1290 if (tmp->body_info[i] < -1) 1156 {
1157 buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
1158
1159 if (slot[i].info < -1 && who->slot[i].info)
1160 buf.printf ("(%d)", -slot[i].info);
1161
1162 buf << ".\r";
1291 { 1163 }
1292 if (op->body_info[i]) 1164
1293 new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s (%d)", body_locations[i].use_name, -tmp->body_info[i]); 1165 if (weight)
1166 buf.printf ("%s %3.3f kg.\r", nrof > 1 ? "They weigh" : "It weighs", weight * (nrof ? nrof : 1) / 1000.0);
1167
1168 if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
1169 {
1170 buf.printf ("You reckon %s worth %s.\r", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
1171
1172 if (is_in_shop (who))
1173 {
1174 if (flag [FLAG_UNPAID])
1175 buf.printf ("%s would cost you %s.\r", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1294 else 1176 else
1295 new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1296 }
1297 else if (tmp->body_info[i])
1298 {
1299 if (op->body_info[i])
1300 new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].use_name);
1301 else
1302 new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1303 }
1304 }
1305
1306 if (tmp->weight)
1307 {
1308 sprintf (buf, tmp->nrof > 1 ? "They weigh %3.3f kg." : "It weighs %3.3f kg.", tmp->weight * (tmp->nrof ? tmp->nrof : 1) / 1000.0);
1309 new_draw_info (NDI_UNIQUE, 0, op, buf);
1310 }
1311
1312 if (tmp->value && !QUERY_FLAG (tmp, FLAG_STARTEQUIP) && !QUERY_FLAG (tmp, FLAG_NO_PICK))
1313 {
1314 sprintf (buf, "You reckon %s worth %s.", tmp->nrof > 1 ? "they are" : "it is", query_cost_string (tmp, op, F_TRUE | F_APPROX));
1315 new_draw_info (NDI_UNIQUE, 0, op, buf);
1316 if (is_in_shop (op))
1317 {
1318 if (QUERY_FLAG (tmp, FLAG_UNPAID))
1319 sprintf (buf, "%s would cost you %s.", tmp->nrof > 1 ? "They" : "It", query_cost_string (tmp, op, F_BUY | F_SHOP));
1320 else
1321 sprintf (buf, "You are offered %s for %s.", query_cost_string (tmp, op, F_SELL + F_SHOP), tmp->nrof > 1 ? "them" : "it"); 1177 buf.printf ("You are offered %s for %s.\r", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1322 new_draw_info (NDI_UNIQUE, 0, op, buf);
1323 } 1178 }
1324 } 1179 }
1325 1180
1326 if (QUERY_FLAG (tmp, FLAG_MONSTER)) 1181 if (flag [FLAG_MONSTER])
1327 examine_monster (op, tmp); 1182 buf << describe_monster (who);
1328 1183
1329 /* Is this item buildable? */ 1184 /* Is this item buildable? */
1330 if (QUERY_FLAG (tmp, FLAG_IS_BUILDABLE)) 1185 if (flag [FLAG_IS_BUILDABLE])
1331 new_draw_info (NDI_UNIQUE, 0, op, "This is a buildable item."); 1186 buf << "This is a buildable item.\r";
1332 1187
1333 /* Does the object have a message? Don't show message for all object 1188 /* Does the object have a message? Don't show message for all object
1334 * types - especially if the first entry is a match 1189 * types - especially if the first entry is a match
1335 */ 1190 */
1336 if (tmp->msg && tmp->type != EXIT && tmp->type != BOOK && tmp->type != CORPSE && !tmp->move_on && strncasecmp (tmp->msg, "@match", 7)) 1191 if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1337 { 1192 {
1338
1339 /* This is just a hack so when identifying the items, we print 1193 /* This is just a hack so when identifying the items, we print
1340 * out the extra message 1194 * out the extra message
1341 */ 1195 */
1342 if (need_identify (tmp) && QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 1196 if (need_identify (this) && flag [FLAG_IDENTIFIED])
1343 new_draw_info (NDI_UNIQUE, 0, op, "The object has a story:"); 1197 buf << "The object has a story:\r";
1344 1198
1345 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg); 1199 buf << msg << '\n';
1346 }
1347 new_draw_info (NDI_UNIQUE, 0, op, " "); /* Blank line */
1348}
1349
1350/*
1351 * inventory prints object's inventory. If inv==NULL then print player's
1352 * inventory.
1353 * [ Only items which are applied are showed. Tero.Haatanen@lut.fi ]
1354 */
1355void
1356inventory (object *op, object *inv)
1357{
1358 object *tmp;
1359 char *in;
1360 int items = 0, length;
1361
1362 if (inv == NULL && op == NULL)
1363 { 1200 }
1364 new_draw_info (NDI_UNIQUE, 0, op, "Inventory of what object?");
1365 return;
1366 }
1367 tmp = inv ? inv->inv : op->inv;
1368 1201
1369 while (tmp) 1202 buf << '\n';
1370 { 1203
1371 if ((!tmp->invisible && 1204 return std::string (buf.linearise (), buf.size ());
1372 (inv == NULL || inv->type == CONTAINER || QUERY_FLAG (tmp, FLAG_APPLIED))) || (!op || QUERY_FLAG (op, FLAG_WIZ)))
1373 items++;
1374 tmp = tmp->below;
1375 }
1376 if (inv == NULL)
1377 { /* player's inventory */
1378 if (items == 0)
1379 {
1380 new_draw_info (NDI_UNIQUE, 0, op, "You carry nothing.");
1381 return;
1382 }
1383 else
1384 {
1385 length = 28;
1386 in = "";
1387 if (op)
1388 clear_win_info (op);
1389 new_draw_info (NDI_UNIQUE, 0, op, "Inventory:");
1390 }
1391 }
1392 else
1393 {
1394 if (items == 0)
1395 return;
1396 else
1397 {
1398 length = 28;
1399 in = " ";
1400 }
1401 }
1402 for (tmp = inv ? inv->inv : op->inv; tmp; tmp = tmp->below)
1403 {
1404 if ((!op || !QUERY_FLAG (op, FLAG_WIZ)) && (tmp->invisible || (inv && inv->type != CONTAINER && !QUERY_FLAG (tmp, FLAG_APPLIED))))
1405 continue;
1406 if ((!op || QUERY_FLAG (op, FLAG_WIZ)))
1407 new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s (%5d) %-8s", in, length, length,
1408 query_name (tmp), tmp->count, query_weight (tmp));
1409 else
1410 new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s %-8s", in, length + 8, length + 8, query_name (tmp), query_weight (tmp));
1411 }
1412 if (!inv && op)
1413 {
1414 new_draw_info_format (NDI_UNIQUE, 0, op, "%-*s %-8s", 41, "Total weight :", query_weight (op));
1415 }
1416} 1205}
1417 1206
1418static void 1207static void
1419display_new_pickup (object *op) 1208display_new_pickup (object *op)
1420{ 1209{
1421 int i = op->contr->mode; 1210 int i = op->contr->mode;
1422 1211
1423 if (!(i & PU_NEWMODE))
1424 return;
1425
1426 new_draw_info_format (NDI_UNIQUE, 0, op, "%d NEWMODE", i & PU_NEWMODE ? 1 : 0);
1427 new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0); 1212 new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0);
1428 new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0); 1213 new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0);
1429 new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0); 1214 new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0);
1430 1215
1431 new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5); 1216 new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5);
… …
1457 new_draw_info_format (NDI_UNIQUE, 0, op, "%d MAGICDEVICE", i & PU_MAGIC_DEVICE ? 1 : 0); 1242 new_draw_info_format (NDI_UNIQUE, 0, op, "%d MAGICDEVICE", i & PU_MAGIC_DEVICE ? 1 : 0);
1458 1243
1459 new_draw_info_format (NDI_UNIQUE, 0, op, "%d NOT CURSED", i & PU_NOT_CURSED ? 1 : 0); 1244 new_draw_info_format (NDI_UNIQUE, 0, op, "%d NOT CURSED", i & PU_NOT_CURSED ? 1 : 0);
1460 1245
1461 new_draw_info_format (NDI_UNIQUE, 0, op, "%d JEWELS", i & PU_JEWELS ? 1 : 0); 1246 new_draw_info_format (NDI_UNIQUE, 0, op, "%d JEWELS", i & PU_JEWELS ? 1 : 0);
1247 new_draw_info_format (NDI_UNIQUE, 0, op, "%d FLESH", i & PU_FLESH ? 1 : 0);
1462 1248
1463 new_draw_info_format (NDI_UNIQUE, 0, op, ""); 1249 new_draw_info_format (NDI_UNIQUE, 0, op, "");
1464} 1250}
1465 1251
1466int 1252int
… …
1468{ 1254{
1469 uint32 i; 1255 uint32 i;
1470 static const char *names[] = { 1256 static const char *names[] = {
1471 "debug", "inhibit", "stop", "food", "drink", "valuables", "bow", "arrow", "helmet", 1257 "debug", "inhibit", "stop", "food", "drink", "valuables", "bow", "arrow", "helmet",
1472 "shield", "armour", "boots", "gloves", "cloak", "key", "missile", "allweapon", 1258 "shield", "armour", "boots", "gloves", "cloak", "key", "missile", "allweapon",
1473 "magical", "potion", "spellbook", "skillscroll", "readables", "magicdevice", "notcursed", "jewels", NULL 1259 "magical", "potion", "spellbook", "skillscroll", "readables", "magicdevice", "notcursed",
1260 "jewels", "flesh", NULL
1474 }; 1261 };
1475 static uint32 modes[] = { 1262 static uint32 modes[] = {
1476 PU_DEBUG, PU_INHIBIT, PU_STOP, PU_FOOD, PU_DRINK, PU_VALUABLES, PU_BOW, PU_ARROW, PU_HELMET, 1263 PU_DEBUG, PU_INHIBIT, PU_STOP, PU_FOOD, PU_DRINK, PU_VALUABLES, PU_BOW, PU_ARROW, PU_HELMET,
1477 PU_SHIELD, PU_ARMOUR, PU_BOOTS, PU_GLOVES, PU_CLOAK, PU_KEY, PU_MISSILEWEAPON, PU_ALLWEAPON, 1264 PU_SHIELD, PU_ARMOUR, PU_BOOTS, PU_GLOVES, PU_CLOAK, PU_KEY, PU_MISSILEWEAPON, PU_ALLWEAPON,
1478 PU_MAGICAL, PU_POTION, PU_SPELLBOOK, PU_SKILLSCROLL, PU_READABLES, PU_MAGIC_DEVICE, PU_NOT_CURSED, PU_JEWELS, 0 1265 PU_MAGICAL, PU_POTION, PU_SPELLBOOK, PU_SKILLSCROLL, PU_READABLES, PU_MAGIC_DEVICE, PU_NOT_CURSED,
1266 PU_JEWELS, PU_FLESH, 0
1479 }; 1267 };
1480 1268
1481 if (!params) 1269 if (!params)
1482 { 1270 {
1483 /* if the new mode is used, just print the settings */ 1271 /* if the new mode is used, just print the settings */
1484 if (op->contr->mode & PU_NEWMODE)
1485 {
1486 display_new_pickup (op); 1272 display_new_pickup (op);
1487 return 1;
1488 }
1489 if (1)
1490 LOG (llevDebug, "command_pickup: !params\n");
1491 set_pickup_mode (op, (op->contr->mode > 6) ? 0 : op->contr->mode + 1);
1492 return 0; 1273 return 0;
1493 } 1274 }
1494 1275
1495 while (*params == ' ' && *params) 1276 while (*params == ' ' && *params)
1496 params++; 1277 params++;
… …
1502 for (mode = 0; names[mode]; mode++) 1283 for (mode = 0; names[mode]; mode++)
1503 { 1284 {
1504 if (!strcmp (names[mode], params + 1)) 1285 if (!strcmp (names[mode], params + 1))
1505 { 1286 {
1506 i = op->contr->mode; 1287 i = op->contr->mode;
1507 if (!(i & PU_NEWMODE)) 1288
1508 i = PU_NEWMODE;
1509 if (*params == '+') 1289 if (*params == '+')
1510 i = i | modes[mode]; 1290 i = i | modes[mode];
1511 else 1291 else
1512 i = i & ~modes[mode]; 1292 i = i & ~modes[mode];
1293
1513 op->contr->mode = i; 1294 op->contr->mode = i;
1514 display_new_pickup (op); 1295 display_new_pickup (op);
1515 return 1; 1296 return 1;
1516 } 1297 }
1517 } 1298 }
… …
1519 return 1; 1300 return 1;
1520 } 1301 }
1521 1302
1522 if (sscanf (params, "%u", &i) != 1) 1303 if (sscanf (params, "%u", &i) != 1)
1523 { 1304 {
1524 if (1)
1525 LOG (llevDebug, "command_pickup: params==NULL\n");
1526 new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <0-7> or <value_density> ."); 1305 new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <value_density> or [+-]type.");
1527 return 1; 1306 return 1;
1528 } 1307 }
1529 set_pickup_mode (op, i); 1308
1309 if (i <= PU_RATIO)
1310 i |= op->contr->mode & ~PU_RATIO;
1311
1312 op->contr->mode = i;
1530 1313
1531 return 1; 1314 return 1;
1532}
1533
1534void
1535set_pickup_mode (object *op, int i)
1536{
1537 switch (op->contr->mode = i)
1538 {
1539 case 0:
1540 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");
1541 break;
1542 case 1:
1543 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");
1544 break;
1545 case 2:
1546 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");
1547 break;
1548 case 3:
1549 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");
1550 break;
1551 case 4:
1552 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");
1553 break;
1554 case 5:
1555 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");
1556 break;
1557 case 6:
1558 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");
1559 break;
1560 case 7:
1561 new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");
1562 break;
1563 }
1564} 1315}
1565 1316
1566int 1317int
1567command_search_items (object *op, char *params) 1318command_search_items (object *op, char *params)
1568{ 1319{
1569 char buf[MAX_BUF]; 1320 char buf[MAX_BUF];
1570 1321
1571 if (settings.search_items == FALSE)
1572 return 1;
1573
1574 if (params == NULL) 1322 if (params == NULL)
1575 { 1323 {
1576 if (op->contr->search_str[0] == '\0') 1324 if (op->contr->search_str[0] == '\0')
1577 { 1325 {
1578 new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1"); 1326 new_draw_info (NDI_UNIQUE, 0, op, "Example: search-items magic+1");
1579 new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all"); 1327 new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");
1580 new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'."); 1328 new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1581 return 1; 1329 return 1;
1582 } 1330 }
1331
1583 op->contr->search_str[0] = '\0'; 1332 op->contr->search_str[0] = '\0';
1584 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off."); 1333 new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1585 fix_player (op); 1334 op->update_stats ();
1586 return 1; 1335 return 1;
1587 } 1336 }
1337
1588 if ((int) strlen (params) >= MAX_BUF) 1338 if (strlen (params) >= MAX_BUF)
1589 { 1339 {
1590 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long."); 1340 new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1591 return 1; 1341 return 1;
1592 } 1342 }
1343
1593 strcpy (op->contr->search_str, params); 1344 strcpy (op->contr->search_str, params);
1594 sprintf (buf, "Searching for '%s'.", op->contr->search_str); 1345 sprintf (buf, "Now searching for '%s'.", op->contr->search_str);
1595 new_draw_info (NDI_UNIQUE, 0, op, buf); 1346 new_draw_info (NDI_UNIQUE, 0, op, buf);
1596 fix_player (op); 1347 op->update_stats ();
1348
1597 return 1; 1349 return 1;
1598} 1350}
1599 1351
1600/*
1601 * Changing the custom name of an item
1602 *
1603 * Syntax is: rename <what object> to <new name>
1604 * if '<what object>' is omitted, marked object is used
1605 * if 'to <new name>' is omitted, custom name is cleared
1606 *
1607 * Names are considered for all purpose having a length <=127 (max length sent to client
1608 * by server) */
1609
1610int
1611command_rename_item (object *op, char *params)
1612{
1613 char buf[VERY_BIG_BUF];
1614 int itemnumber;
1615 object *item = NULL;
1616 char *closebrace;
1617 size_t counter;
1618
1619 if (params)
1620 {
1621 /* Let's skip white spaces */
1622 while (' ' == *params)
1623 params++;
1624
1625 /* Checking the first part */
1626 if ((itemnumber = atoi (params)) != 0)
1627 {
1628 for (item = op->inv; item && ((item->count != (tag_t) itemnumber) || item->invisible); item = item->below);
1629 if (!item)
1630 {
1631 new_draw_info (NDI_UNIQUE, 0, op, "Tried to rename an invalid item.");
1632 return 1;
1633 }
1634 while (isdigit (*params) || ' ' == *params)
1635 params++;
1636 }
1637 else if ('<' == *params)
1638 {
1639 /* Got old name, let's get it & find appropriate matching item */
1640 closebrace = strchr (params, '>');
1641 if (!closebrace)
1642 {
1643 new_draw_info (NDI_UNIQUE, 0, op, "Syntax error!");
1644 return 1;
1645 }
1646 /* Sanity check for buffer overruns */
1647 if ((closebrace - params) > 127)
1648 {
1649 new_draw_info (NDI_UNIQUE, 0, op, "Old name too long (up to 127 characters allowed)!");
1650 return 1;
1651 }
1652 /* Copy the old name */
1653 strncpy (buf, params + 1, closebrace - params - 1);
1654 buf[closebrace - params - 1] = '\0';
1655
1656 /* Find best matching item */
1657 item = find_best_object_match (op, buf);
1658 if (!item)
1659 {
1660 new_draw_info (NDI_UNIQUE, 0, op, "Could not find a matching item to rename.");
1661 return 1;
1662 }
1663
1664 /* Now need to move pointer to just after > */
1665 params = closebrace + 1;
1666 while (' ' == *params)
1667 params++;
1668
1669 }
1670 else
1671 {
1672 /* Use marked item */
1673 item = find_marked_object (op);
1674 if (!item)
1675 {
1676 new_draw_info (NDI_UNIQUE, 0, op, "No marked item to rename.");
1677 return 1;
1678 }
1679 }
1680
1681 /* Now let's find the new name */
1682 if (!strncmp (params, "to ", 3))
1683 {
1684 params += 3;
1685 while (' ' == *params)
1686 params++;
1687 if ('<' != *params)
1688 {
1689 new_draw_info (NDI_UNIQUE, 0, op, "Syntax error, expecting < at start of new name!");
1690 return 1;
1691 }
1692 closebrace = strchr (params + 1, '>');
1693 if (!closebrace)
1694 {
1695 new_draw_info (NDI_UNIQUE, 0, op, "Syntax error, expecting > at end of new name!");
1696 return 1;
1697 }
1698
1699 /* Sanity check for buffer overruns */
1700 if ((closebrace - params) > 127)
1701 {
1702 new_draw_info (NDI_UNIQUE, 0, op, "New name too long (up to 127 characters allowed)!");
1703 return 1;
1704 }
1705
1706 /* Copy the new name */
1707 strncpy (buf, params + 1, closebrace - params - 1);
1708 buf[closebrace - params - 1] = '\0';
1709
1710 /* Let's check it for weird characters */
1711 for (counter = 0; counter < strlen (buf); counter++)
1712 {
1713 if (isalnum (buf[counter]))
1714 continue;
1715 if (' ' == buf[counter])
1716 continue;
1717 if ('\'' == buf[counter])
1718 continue;
1719 if ('+' == buf[counter])
1720 continue;
1721 if ('_' == buf[counter])
1722 continue;
1723 if ('-' == buf[counter])
1724 continue;
1725
1726 /* If we come here, then the name contains an invalid character...
1727 tell the player & exit */
1728 new_draw_info (NDI_UNIQUE, 0, op, "Invalid new name!");
1729 return 1;
1730 }
1731
1732 }
1733 else
1734 {
1735 /* If param contains something, then syntax error... */
1736 if (strlen (params))
1737 {
1738 new_draw_info (NDI_UNIQUE, 0, op, "Syntax error, expected 'to <' after old name!");
1739 return 1;
1740 }
1741 /* New name is empty */
1742 buf[0] = '\0';
1743 }
1744 }
1745 else
1746 {
1747 /* Last case: params==NULL */
1748 item = find_marked_object (op);
1749 if (!item)
1750 {
1751 new_draw_info (NDI_UNIQUE, 0, op, "No marked item to rename.");
1752 return 1;
1753 }
1754 buf[0] = '\0';
1755 }
1756
1757 if (QUERY_FLAG (item, FLAG_UNPAID))
1758 {
1759 new_draw_info (NDI_UNIQUE, 0, op, "You can't rename an unpaid item! You should pay for it first.");
1760 return 1;
1761 }
1762
1763 /* Coming here, everything is fine... */
1764 if (!strlen (buf))
1765 {
1766 /* Clear custom name */
1767 if (item->custom_name)
1768 {
1769 item->custom_name = 0;
1770
1771 new_draw_info_format (NDI_UNIQUE, 0, op, "You stop calling your %s with weird names.",
1772 query_base_name (item, item->nrof > 1 ? 1 : 0));
1773 esrv_update_item (UPD_NAME, op, item);
1774 }
1775 else
1776 {
1777 new_draw_info (NDI_UNIQUE, 0, op, "This item has no custom name.");
1778 }
1779 }
1780 else
1781 {
1782 /* Set custom name */
1783 item->custom_name = buf;
1784
1785 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s will now be called %s.", query_base_name (item, item->nrof > 1 ? 1 : 0), buf);
1786 esrv_update_item (UPD_NAME, op, item);
1787 }
1788
1789 return 1;
1790}

Diff Legend

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