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.13 by pippijn, Thu Sep 7 10:01:57 2006 UTC vs.
Revision 1.14 by root, Sun Sep 10 15:59:57 2006 UTC

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

Diff Legend

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