ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/c_wiz.C
(Generate patch)

Comparing deliantra/server/server/c_wiz.C (file contents):
Revision 1.7 by pippijn, Thu Sep 7 10:01:57 2006 UTC vs.
Revision 1.8 by root, Sun Sep 10 13:20:27 2006 UTC

1
1/* 2/*
2 * static char *rcsid_c_wiz_c = 3 * static char *rcsid_c_wiz_c =
3 * "$Id: c_wiz.C,v 1.7 2006/09/07 10:01:57 pippijn Exp $"; 4 * "$Id: c_wiz.C,v 1.8 2006/09/10 13:20:27 root Exp $";
4 */ 5 */
5 6
6/* 7/*
7 CrossFire, A Multiplayer game for X-windows 8 CrossFire, A Multiplayer game for X-windows
8 9
… …
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 27 The authors can be reached via e-mail at crossfire-devel@real-time.com
27*/ 28*/
28 29
29#include <global.h> 30#include <global.h>
30#ifndef __CEXTRACT__ 31#ifndef __CEXTRACT__
31#include <sproto.h> 32# include <sproto.h>
32#endif 33#endif
33#include <spells.h> 34#include <spells.h>
34#include <treasure.h> 35#include <treasure.h>
35#include <skills.h> 36#include <skills.h>
36 37
37/** Defines for DM item stack **/ 38/** Defines for DM item stack **/
38#define STACK_SIZE 50 /* Stack size, static */ 39#define STACK_SIZE 50 /* Stack size, static */
40
39/* Values for 'from' field of get_dm_object */ 41/* Values for 'from' field of get_dm_object */
40#define STACK_FROM_NONE 0 /* Item was not found */ 42#define STACK_FROM_NONE 0 /* Item was not found */
41#define STACK_FROM_TOP 1 /* Item is stack top */ 43#define STACK_FROM_TOP 1 /* Item is stack top */
42#define STACK_FROM_STACK 2 /* Item is somewhere in stack */ 44#define STACK_FROM_STACK 2 /* Item is somewhere in stack */
43#define STACK_FROM_NUMBER 3 /* Item is a number (may be top) */ 45#define STACK_FROM_NUMBER 3 /* Item is a number (may be top) */
… …
48 * it out to a seperate function. name is the person 50 * it out to a seperate function. name is the person
49 * being saught, rq is who is looking for them. This 51 * being saught, rq is who is looking for them. This
50 * prints diagnostics messages, and returns the 52 * prints diagnostics messages, and returns the
51 * other player, or NULL otherwise. 53 * other player, or NULL otherwise.
52 */ 54 */
55static player *
53static player *get_other_player_from_name(object *op, char *name) { 56get_other_player_from_name (object *op, char *name)
57{
54 player *pl; 58 player *pl;
55 59
56 if (!name) 60 if (!name)
57 return NULL; 61 return NULL;
58 62
59 for (pl = first_player; pl != NULL; pl = pl->next) 63 for (pl = first_player; pl != NULL; pl = pl->next)
60 if (!strncmp(pl->ob->name, name, MAX_NAME)) 64 if (!strncmp (pl->ob->name, name, MAX_NAME))
61 break; 65 break;
62 66
63 if (pl == NULL) { 67 if (pl == NULL)
68 {
64 new_draw_info(NDI_UNIQUE, 0, op, "No such player."); 69 new_draw_info (NDI_UNIQUE, 0, op, "No such player.");
65 return NULL; 70 return NULL;
66 } 71 }
67 72
68 if (pl->ob == op) { 73 if (pl->ob == op)
74 {
69 new_draw_info(NDI_UNIQUE, 0, op, "You can't do that to yourself."); 75 new_draw_info (NDI_UNIQUE, 0, op, "You can't do that to yourself.");
70 return NULL; 76 return NULL;
71 } 77 }
72 if (pl->state != ST_PLAYING) { 78 if (pl->state != ST_PLAYING)
79 {
73 new_draw_info(NDI_UNIQUE, 0, op, "That player is in no state for that right now."); 80 new_draw_info (NDI_UNIQUE, 0, op, "That player is in no state for that right now.");
74 return NULL; 81 return NULL;
75 } 82 }
76 return pl; 83 return pl;
77} 84}
78 85
79/** 86/**
80 * This command will stress server. 87 * This command will stress server.
81 */ 88 */
89int
82int command_loadtest(object *op, char *params) { 90command_loadtest (object *op, char *params)
91{
83 uint32 x, y; 92 uint32 x, y;
84 char buf[1024]; 93 char buf[1024];
85 94
86 new_draw_info(NDI_UNIQUE, 0, op, "loadtest will stress server through teleporting"); 95 new_draw_info (NDI_UNIQUE, 0, op, "loadtest will stress server through teleporting");
87 new_draw_info(NDI_UNIQUE, 0, op, "at different map places."); 96 new_draw_info (NDI_UNIQUE, 0, op, "at different map places.");
88 new_draw_info(NDI_UNIQUE, 0, op, "use at your own risks."); 97 new_draw_info (NDI_UNIQUE, 0, op, "use at your own risks.");
89 new_draw_info(NDI_UNIQUE, 0, op, "Very long loop used so server may have to be reset."); 98 new_draw_info (NDI_UNIQUE, 0, op, "Very long loop used so server may have to be reset.");
90 new_draw_info(NDI_UNIQUE, 0, op, "type loadtest TRUE to run"); 99 new_draw_info (NDI_UNIQUE, 0, op, "type loadtest TRUE to run");
91 new_draw_info_format(NDI_UNIQUE, 0, op, "{%s}", params); 100 new_draw_info_format (NDI_UNIQUE, 0, op, "{%s}", params);
92 if (!params) 101 if (!params)
93 return 0;
94 if (strncmp (params, "TRUE", 4))
95 return 0;
96
97 new_draw_info_format(NDI_UNIQUE, 0, op, "gogogo");
98 for (x = 0; x < settings.worldmaptilesx; x++) {
99 for (y = 0; y < settings.worldmaptilesy; y++) {
100 sprintf(buf, "/world/world_%d_%d", x+settings.worldmapstartx, y+settings.worldmapstarty);
101 command_goto(op, buf);
102 }
103 }
104
105 return 0; 102 return 0;
103 if (strncmp (params, "TRUE", 4))
104 return 0;
105
106 new_draw_info_format (NDI_UNIQUE, 0, op, "gogogo");
107 for (x = 0; x < settings.worldmaptilesx; x++)
108 {
109 for (y = 0; y < settings.worldmaptilesy; y++)
110 {
111 sprintf (buf, "/world/world_%d_%d", x + settings.worldmapstartx, y + settings.worldmapstarty);
112 command_goto (op, buf);
113 }
114 }
115
116 return 0;
106} 117}
107 118
108/** 119/**
109 * Actually hides specified player (obviously a DM). 120 * Actually hides specified player (obviously a DM).
110 * If 'silent_dm' is non zero, other players are informed of DM entering/leaving, 121 * If 'silent_dm' is non zero, other players are informed of DM entering/leaving,
111 * else they just think someone left/entered. 122 * else they just think someone left/entered.
112 */ 123 */
124void
113void do_wizard_hide(object *op, int silent_dm) { 125do_wizard_hide (object *op, int silent_dm)
126{
114 if (op->contr->hidden) { 127 if (op->contr->hidden)
128 {
115 op->contr->hidden = 0; 129 op->contr->hidden = 0;
116 op->invisible = 1; 130 op->invisible = 1;
117 new_draw_info(NDI_UNIQUE, 0, op, "You are no longer hidden from other players"); 131 new_draw_info (NDI_UNIQUE, 0, op, "You are no longer hidden from other players");
118 op->map->players++; 132 op->map->players++;
119 new_draw_info_format(NDI_UNIQUE|NDI_ALL|NDI_DK_ORANGE, 5, NULL, 133 new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s has entered the game.", &op->name);
120 "%s has entered the game.", &op->name);
121 if (!silent_dm) { 134 if (!silent_dm)
122 new_draw_info(NDI_UNIQUE|NDI_ALL|NDI_LT_GREEN, 1, NULL,
123 "The Dungeon Master has arrived!");
124 } 135 {
125 } else { 136 new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master has arrived!");
137 }
138 }
139 else
140 {
126 op->contr->hidden = 1; 141 op->contr->hidden = 1;
127 new_draw_info(NDI_UNIQUE, 0, op, "Other players will no longer see you."); 142 new_draw_info (NDI_UNIQUE, 0, op, "Other players will no longer see you.");
128 op->map->players--; 143 op->map->players--;
129 if (!silent_dm) { 144 if (!silent_dm)
130 new_draw_info(NDI_UNIQUE|NDI_ALL|NDI_LT_GREEN, 1, NULL,
131 "The Dungeon Master is gone..");
132 } 145 {
146 new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master is gone..");
147 }
148 new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s leaves the game.", &op->name);
133 new_draw_info_format(NDI_UNIQUE|NDI_ALL|NDI_DK_ORANGE, 5, NULL, 149 new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s left the game.", &op->name);
134 "%s leaves the game.", &op->name);
135 new_draw_info_format(NDI_UNIQUE|NDI_ALL|NDI_DK_ORANGE, 5, NULL,
136 "%s left the game.", &op->name);
137 } 150 }
138} 151}
139 152
153int
140int command_hide(object *op, char *params) 154command_hide (object *op, char *params)
141{ 155{
142 do_wizard_hide(op, 0); 156 do_wizard_hide (op, 0);
143 return 1; 157 return 1;
144} 158}
145 159
146/** 160/**
147 * This finds and returns the object which matches the name or 161 * This finds and returns the object which matches the name or
148 * object nubmer (specified via num #whatever). 162 * object nubmer (specified via num #whatever).
149 */ 163 */
164static object *
150static object *find_object_both(char *params) { 165find_object_both (char *params)
166{
151 if (!params) 167 if (!params)
152 return NULL; 168 return NULL;
153 if (params[0] == '#') 169 if (params[0] == '#')
154 return find_object(atol(params+1)); 170 return find_object (atol (params + 1));
155 else 171 else
156 return find_object_name(params); 172 return find_object_name (params);
157} 173}
158 174
159/** 175/**
160 * Sets the god for some objects. params should contain two values - 176 * Sets the god for some objects. params should contain two values -
161 * first the object to change, followed by the god to change it to. 177 * first the object to change, followed by the god to change it to.
162 */ 178 */
179int
163int command_setgod(object *op, char *params) { 180command_setgod (object *op, char *params)
181{
164 object *ob, *god; 182 object *ob, *god;
165 char *str; 183 char *str;
166 184
167 if (!params || !(str = strchr(params, ' '))) { 185 if (!params || !(str = strchr (params, ' ')))
186 {
168 new_draw_info(NDI_UNIQUE, 0, op, "Usage: setgod object god"); 187 new_draw_info (NDI_UNIQUE, 0, op, "Usage: setgod object god");
169 return 0; 188 return 0;
170 } 189 }
171 190
172 /* kill the space, and set string to the next param */ 191 /* kill the space, and set string to the next param */
173 *str++ = '\0'; 192 *str++ = '\0';
174 if (!(ob = find_object_both(params))) { 193 if (!(ob = find_object_both (params)))
194 {
175 new_draw_info_format(NDI_UNIQUE, 0, op, "Set whose god - can not find object %s?", params); 195 new_draw_info_format (NDI_UNIQUE, 0, op, "Set whose god - can not find object %s?", params);
176 return 1; 196 return 1;
177 } 197 }
178 198
179 /* 199 /*
180 * Perhaps this is overly restrictive? Should we perhaps be able 200 * Perhaps this is overly restrictive? Should we perhaps be able
181 * to rebless altars and the like? 201 * to rebless altars and the like?
182 */ 202 */
183 if (ob->type != PLAYER) { 203 if (ob->type != PLAYER)
204 {
184 new_draw_info_format(NDI_UNIQUE, 0, op, "%s is not a player - can not change its god", &ob->name); 205 new_draw_info_format (NDI_UNIQUE, 0, op, "%s is not a player - can not change its god", &ob->name);
185 return 1; 206 return 1;
186 } 207 }
187 208
188 god = find_god(str); 209 god = find_god (str);
189 if (god==NULL) { 210 if (god == NULL)
211 {
190 new_draw_info_format(NDI_UNIQUE, 0, op, "No such god %s.", str); 212 new_draw_info_format (NDI_UNIQUE, 0, op, "No such god %s.", str);
191 return 1; 213 return 1;
192 } 214 }
193 215
194 become_follower(ob, god); 216 become_follower (ob, god);
195 return 1; 217 return 1;
196} 218}
197 219
198/** 220/**
199 * Add player's IP to ban_file and kick them off the server 221 * Add player's IP to ban_file and kick them off the server
200 * I know most people have dynamic IPs but this is more of a short term 222 * I know most people have dynamic IPs but this is more of a short term
201 * solution if they have to get a new IP to play maybe they'll calm down. 223 * solution if they have to get a new IP to play maybe they'll calm down.
202 * This uses the banish_file in the local directory *not* the ban_file 224 * This uses the banish_file in the local directory *not* the ban_file
203 * The action is logged with a ! for easy searching. -tm 225 * The action is logged with a ! for easy searching. -tm
204 */ 226 */
227int
205int command_banish(object *op, char *params) { 228command_banish (object *op, char *params)
229{
206 player *pl; 230 player *pl;
207 FILE *banishfile; 231 FILE *banishfile;
208 char buf[MAX_BUF]; 232 char buf[MAX_BUF];
209 time_t now; 233 time_t now;
210 234
211 if (!params) { 235 if (!params)
236 {
212 new_draw_info(NDI_UNIQUE, 0, op, "Usage: banish <player>."); 237 new_draw_info (NDI_UNIQUE, 0, op, "Usage: banish <player>.");
213 return 1; 238 return 1;
214 } 239 }
215 240
216 pl = get_other_player_from_name(op, params); 241 pl = get_other_player_from_name (op, params);
217 if (!pl) 242 if (!pl)
218 return 1;
219
220 sprintf(buf, "%s/%s", settings.localdir, BANISHFILE);
221
222 if ((banishfile = fopen(buf, "a")) == NULL) {
223 LOG (llevDebug, "Could not find file banish_file.\n");
224 new_draw_info(NDI_UNIQUE, 0, op, "Could not find banish_file.");
225 return 0;
226 }
227
228 now = time(NULL);
229 /*
230 * Record this as a comment - then we don't have to worry about changing
231 * the parsing code.
232 */
233 fprintf(banishfile, "# %s (%s) banned by %s at %s\n", &pl->ob->name,
234 pl->socket.host, &op->name, ctime(&now));
235 fprintf(banishfile, "*@%s\n", pl->socket.host);
236 fclose(banishfile);
237
238 LOG(llevDebug, "! %s banned %s from IP: %s.\n", &op->name, &pl->ob->name, pl->socket.host);
239 new_draw_info_format(NDI_UNIQUE|NDI_RED, 0, op, "You banish %s", &pl->ob->name);
240 new_draw_info_format(NDI_UNIQUE|NDI_ALL|NDI_RED, 5, op,
241 "%s banishes %s from the land!", &op->name, &pl->ob->name);
242 command_kick(op, (char *) &pl->ob->name);
243 return 1; 243 return 1;
244}
245 244
245 sprintf (buf, "%s/%s", settings.localdir, BANISHFILE);
246
247 if ((banishfile = fopen (buf, "a")) == NULL)
248 {
249 LOG (llevDebug, "Could not find file banish_file.\n");
250 new_draw_info (NDI_UNIQUE, 0, op, "Could not find banish_file.");
251 return 0;
252 }
253
254 now = time (NULL);
255 /*
256 * Record this as a comment - then we don't have to worry about changing
257 * the parsing code.
258 */
259 fprintf (banishfile, "# %s (%s) banned by %s at %s\n", &pl->ob->name, pl->socket.host, &op->name, ctime (&now));
260 fprintf (banishfile, "*@%s\n", pl->socket.host);
261 fclose (banishfile);
262
263 LOG (llevDebug, "! %s banned %s from IP: %s.\n", &op->name, &pl->ob->name, pl->socket.host);
264 new_draw_info_format (NDI_UNIQUE | NDI_RED, 0, op, "You banish %s", &pl->ob->name);
265 new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_RED, 5, op, "%s banishes %s from the land!", &op->name, &pl->ob->name);
266 command_kick (op, (char *) &pl->ob->name);
267 return 1;
268}
269
270int
246int command_kick (object *op, char *params) { 271command_kick (object *op, char *params)
272{
247 struct pl *pl; 273 struct pl *pl;
248 274
249 for (pl = first_player; pl != NULL; pl = pl->next) 275 for (pl = first_player; pl != NULL; pl = pl->next)
250 if ((params == NULL || !strcmp (&pl->ob->name, params)) 276 if ((params == NULL || !strcmp (&pl->ob->name, params)) && !INVOKE_PLAYER (KICK, pl, ARG_STRING (params)))
251 && !INVOKE_PLAYER (KICK, pl, ARG_STRING (params)))
252 { 277 {
253 object *op = pl->ob; 278 object *op = pl->ob;
254 279
255 if (!QUERY_FLAG (op, FLAG_REMOVED) && !QUERY_FLAG (op, FLAG_FREED)) 280 if (!QUERY_FLAG (op, FLAG_REMOVED) && !QUERY_FLAG (op, FLAG_FREED))
256 { 281 {
257 new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_RED, 5, op, 282 new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_RED, 5, op, "%s is kicked out of the game.", &op->name);
258 "%s is kicked out of the game.",
259 &op->name);
260 strcpy (op->contr->killer, "kicked"); 283 strcpy (op->contr->killer, "kicked");
261 } 284 }
262 285
263 pl->socket.status = Ns_Dead; 286 pl->socket.status = Ns_Dead;
264 } 287 }
265 288
266 return 1; 289 return 1;
267} 290}
268 291
292int
269int command_save_overlay(object *op, char *params) { 293command_save_overlay (object *op, char *params)
294{
270 if (!op) 295 if (!op)
271 return 0; 296 return 0;
272 297
273 if (op != NULL && !QUERY_FLAG(op, FLAG_WIZ)) { 298 if (op != NULL && !QUERY_FLAG (op, FLAG_WIZ))
274 new_draw_info(NDI_UNIQUE, 0, op, 299 {
275 "Sorry, you can't force an overlay save."); 300 new_draw_info (NDI_UNIQUE, 0, op, "Sorry, you can't force an overlay save.");
276 return 1; 301 return 1;
277 } 302 }
278 303
279 new_save_map(op->map, 2); 304 new_save_map (op->map, 2);
280 new_save_map(op->map, 0); 305 new_save_map (op->map, 0);
281 new_draw_info(NDI_UNIQUE, 0, op, "Current map has been saved as an" 306 new_draw_info (NDI_UNIQUE, 0, op, "Current map has been saved as an" " overlay.");
282 " overlay.");
283 307
284 ready_map_name(op->map->path, 0); 308 ready_map_name (op->map->path, 0);
285 309
286 return 1; 310 return 1;
287} 311}
288 312
289int 313int
290command_shutdown (object * op, char *params) 314command_shutdown (object *op, char *params)
291{ 315{
292 struct pl *pl; 316 struct pl *pl;
293 317
294 if (op != NULL && !QUERY_FLAG (op, FLAG_WIZ)) 318 if (op != NULL && !QUERY_FLAG (op, FLAG_WIZ))
295 { 319 {
… …
307 cleanup (); 331 cleanup ();
308 /* not reached */ 332 /* not reached */
309 return 1; 333 return 1;
310} 334}
311 335
336int
312int command_goto(object *op, char *params) 337command_goto (object *op, char *params)
313{ 338{
314 char *name; 339 char *name;
315 object *dummy; 340 object *dummy;
316 341
317 if (!op) 342 if (!op)
318 return 0; 343 return 0;
319 344
320 if (params == NULL) { 345 if (params == NULL)
346 {
321 new_draw_info(NDI_UNIQUE, 0, op, "Go to what level?"); 347 new_draw_info (NDI_UNIQUE, 0, op, "Go to what level?");
322 return 1; 348 return 1;
323 } 349 }
324 350
325 name = params; 351 name = params;
326 dummy=get_object(); 352 dummy = get_object ();
327 dummy->map = op->map; 353 dummy->map = op->map;
328 EXIT_PATH(dummy) = name; 354 EXIT_PATH (dummy) = name;
329 dummy->name = name; 355 dummy->name = name;
330 356
331 enter_exit(op, dummy); 357 enter_exit (op, dummy);
332 free_object(dummy); 358 free_object (dummy);
333 if (op->contr->loading == NULL) { 359 if (op->contr->loading == NULL)
334 new_draw_info_format(NDI_UNIQUE, 0, op,
335 "Difficulty: %d.", op->map->difficulty);
336 } 360 {
361 new_draw_info_format (NDI_UNIQUE, 0, op, "Difficulty: %d.", op->map->difficulty);
362 }
337 363
364 return 1;
365}
366
367/* is this function called from somewhere ? -Tero */
368int
369command_generate (object *op, char *params)
370{
371 object *tmp;
372 int nr = 1, i, retry;
373
374 if (!op)
375 return 0;
376
377 if (params != NULL)
378 sscanf (params, "%d", &nr);
379 for (i = 0; i < nr; i++)
380 {
381 retry = 50;
382 while ((tmp = generate_treasure (0, op->map->difficulty)) == NULL && --retry)
383 ;
384 if (tmp != NULL)
385 {
386 tmp = insert_ob_in_ob (tmp, op);
387 if (op->type == PLAYER)
388 esrv_send_item (op, tmp);
389 }
390 }
391
392 return 1;
393}
394
395int
396command_freeze (object *op, char *params)
397{
398 int ticks;
399 player *pl;
400
401 if (!params)
402 {
403 new_draw_info (NDI_UNIQUE, 0, op, "Usage: freeze [ticks] <player>.");
404 return 1;
405 }
406
407 ticks = atoi (params);
408 if (ticks)
409 {
410 while ((isdigit (*params) || isspace (*params)) && *params != 0)
411 params++;
412 if (*params == 0)
413 {
414 new_draw_info (NDI_UNIQUE, 0, op, "Usage: freeze [ticks] <player>.");
415 return 1;
416 }
417 }
418 else
419 ticks = 100;
420
421 pl = get_other_player_from_name (op, params);
422 if (!pl)
338 return 1; 423 return 1;
339}
340 424
341/* is this function called from somewhere ? -Tero */ 425 new_draw_info (NDI_UNIQUE | NDI_RED, 0, pl->ob, "You have been frozen by the DM!");
426 new_draw_info_format (NDI_UNIQUE, 0, op, "You freeze %s for %d ticks", &pl->ob->name, ticks);
427 pl->ob->speed_left = -(pl->ob->speed * ticks);
428 return 0;
429}
430
431int
342int command_generate (object *op, char *params) 432command_arrest (object *op, char *params)
343{ 433{
344 object *tmp; 434 object *dummy;
345 int nr = 1, i, retry; 435 player *pl;
346 436
347 if (!op) 437 if (!op)
348 return 0; 438 return 0;
349
350 if (params != NULL) 439 if (params == NULL)
351 sscanf(params, "%d", &nr);
352 for (i = 0; i < nr; i++) {
353 retry = 50;
354 while ((tmp=generate_treasure(0, op->map->difficulty)) == NULL && --retry)
355 ;
356 if (tmp != NULL) {
357 tmp = insert_ob_in_ob(tmp, op);
358 if (op->type == PLAYER)
359 esrv_send_item(op, tmp);
360 }
361 } 440 {
362 441 new_draw_info (NDI_UNIQUE, 0, op, "Usage: arrest <player>.");
442 return 1;
443 }
444 pl = get_other_player_from_name (op, params);
445 if (!pl)
363 return 1; 446 return 1;
447 dummy = get_jail_exit (pl->ob);
448 if (!dummy)
449 {
450 /* we have nowhere to send the prisoner.... */
451 new_draw_info (NDI_UNIQUE, 0, op, "can't jail player, there is no map to hold them");
452 return 0;
453 }
454 enter_exit (pl->ob, dummy);
455 free_object (dummy);
456 new_draw_info (NDI_UNIQUE, 0, pl->ob, "You have been arrested.");
457 new_draw_info (NDI_UNIQUE, 0, op, "OK.");
458 LOG (llevInfo, "Player %s arrested by %s\n", &pl->ob->name, &op->name);
459 return 1;
364} 460}
365 461
462int
366int command_freeze(object *op, char *params) { 463command_summon (object *op, char *params)
367 int ticks; 464{
465 int i;
466 object *dummy;
368 player *pl; 467 player *pl;
369 468
370 if (!params) {
371 new_draw_info(NDI_UNIQUE, 0, op, "Usage: freeze [ticks] <player>.");
372 return 1;
373 }
374
375 ticks = atoi(params);
376 if (ticks) {
377 while ((isdigit(*params) || isspace(*params)) && *params != 0)
378 params++;
379 if (*params == 0) {
380 new_draw_info(NDI_UNIQUE, 0, op, "Usage: freeze [ticks] <player>.");
381 return 1;
382 }
383 } else
384 ticks = 100;
385
386 pl = get_other_player_from_name(op, params);
387 if (!pl) 469 if (!op)
388 return 1;
389
390 new_draw_info(NDI_UNIQUE|NDI_RED, 0, pl->ob, "You have been frozen by the DM!");
391 new_draw_info_format(NDI_UNIQUE, 0, op,
392 "You freeze %s for %d ticks", &pl->ob->name, ticks);
393 pl->ob->speed_left = -(pl->ob->speed*ticks);
394 return 0; 470 return 0;
395}
396 471
397int command_arrest(object *op, char *params) {
398 object *dummy;
399 player *pl;
400 if (!op) return 0;
401 if(params==NULL) { 472 if (params == NULL)
473 {
402 new_draw_info(NDI_UNIQUE, 0,op,"Usage: arrest <player>."); 474 new_draw_info (NDI_UNIQUE, 0, op, "Usage: summon <player>.");
403 return 1; 475 return 1;
404 } 476 }
477
405 pl = get_other_player_from_name(op, params); 478 pl = get_other_player_from_name (op, params);
406 if (!pl) return 1; 479 if (!pl)
407 dummy=get_jail_exit(pl->ob);
408 if (!dummy) {
409 /* we have nowhere to send the prisoner....*/
410 new_draw_info(NDI_UNIQUE, 0,op,"can't jail player, there is no map to hold them");
411 return 0;
412 }
413 enter_exit(pl->ob, dummy);
414 free_object(dummy);
415 new_draw_info(NDI_UNIQUE, 0,pl->ob,"You have been arrested.");
416 new_draw_info(NDI_UNIQUE, 0,op,"OK.");
417 LOG(llevInfo, "Player %s arrested by %s\n", &pl->ob->name, &op->name);
418 return 1; 480 return 1;
419}
420 481
421int command_summon(object *op, char *params) {
422 int i;
423 object *dummy;
424 player *pl;
425
426 if (!op)
427 return 0;
428
429 if (params == NULL) {
430 new_draw_info(NDI_UNIQUE, 0, op, "Usage: summon <player>.");
431 return 1;
432 }
433
434 pl = get_other_player_from_name(op, params);
435 if (!pl)
436 return 1;
437
438 i = find_free_spot(op, op->map, op->x, op->y, 1, 9); 482 i = find_free_spot (op, op->map, op->x, op->y, 1, 9);
439 if (i == -1) { 483 if (i == -1)
484 {
440 new_draw_info(NDI_UNIQUE, 0, op, "Can not find a free spot to place summoned player."); 485 new_draw_info (NDI_UNIQUE, 0, op, "Can not find a free spot to place summoned player.");
441 return 1; 486 return 1;
442 } 487 }
443 488
444 dummy = get_object(); 489 dummy = get_object ();
445 EXIT_PATH(dummy) = op->map->path; 490 EXIT_PATH (dummy) = op->map->path;
446 EXIT_X(dummy) = op->x+freearr_x[i]; 491 EXIT_X (dummy) = op->x + freearr_x[i];
447 EXIT_Y(dummy) = op->y+freearr_y[i]; 492 EXIT_Y (dummy) = op->y + freearr_y[i];
448 enter_exit(pl->ob, dummy); 493 enter_exit (pl->ob, dummy);
449 free_object(dummy); 494 free_object (dummy);
450 new_draw_info(NDI_UNIQUE, 0, pl->ob, "You are summoned."); 495 new_draw_info (NDI_UNIQUE, 0, pl->ob, "You are summoned.");
451 new_draw_info(NDI_UNIQUE, 0, op, "OK."); 496 new_draw_info (NDI_UNIQUE, 0, op, "OK.");
452 497
498 return 1;
499}
500
501/**
502 * Teleport next to target player.
503 */
504
505/* mids 01/16/2002 */
506int
507command_teleport (object *op, char *params)
508{
509 int i;
510 object *dummy;
511 player *pl;
512
513 if (!op)
514 return 0;
515
516 if (params == NULL)
517 {
518 new_draw_info (NDI_UNIQUE, 0, op, "Usage: teleport <player>.");
519 return 1;
520 }
521
522 pl = get_other_player_from_name (op, params);
523 if (!pl)
453 return 1; 524 return 1;
454}
455 525
456/**
457 * Teleport next to target player.
458 */
459/* mids 01/16/2002 */
460int command_teleport(object *op, char *params) {
461 int i;
462 object *dummy;
463 player *pl;
464
465 if (!op)
466 return 0;
467
468 if (params == NULL) {
469 new_draw_info(NDI_UNIQUE, 0, op, "Usage: teleport <player>.");
470 return 1;
471 }
472
473 pl = get_other_player_from_name(op, params);
474 if (!pl)
475 return 1;
476
477 i = find_free_spot(pl->ob, pl->ob->map, pl->ob->x, pl->ob->y, 1, 9); 526 i = find_free_spot (pl->ob, pl->ob->map, pl->ob->x, pl->ob->y, 1, 9);
478 if (i == -1) { 527 if (i == -1)
528 {
479 new_draw_info(NDI_UNIQUE, 0, op, "Can not find a free spot to teleport to."); 529 new_draw_info (NDI_UNIQUE, 0, op, "Can not find a free spot to teleport to.");
480 return 1; 530 return 1;
481 } 531 }
482 532
483 dummy = get_object(); 533 dummy = get_object ();
484 EXIT_PATH(dummy) = pl->ob->map->path; 534 EXIT_PATH (dummy) = pl->ob->map->path;
485 EXIT_X(dummy) = pl->ob->x + freearr_x[i]; 535 EXIT_X (dummy) = pl->ob->x + freearr_x[i];
486 EXIT_Y(dummy) = pl->ob->y + freearr_y[i]; 536 EXIT_Y (dummy) = pl->ob->y + freearr_y[i];
487 enter_exit(op, dummy); 537 enter_exit (op, dummy);
488 free_object(dummy); 538 free_object (dummy);
489 if (!op->contr->hidden) 539 if (!op->contr->hidden)
490 new_draw_info(NDI_UNIQUE, 0, pl->ob, "You see a portal open."); 540 new_draw_info (NDI_UNIQUE, 0, pl->ob, "You see a portal open.");
491 new_draw_info(NDI_UNIQUE, 0, op, "OK."); 541 new_draw_info (NDI_UNIQUE, 0, op, "OK.");
492 return 1; 542 return 1;
493} 543}
494 544
495/** 545/**
496 * This function is a real mess, because we're stucking getting 546 * This function is a real mess, because we're stucking getting
497 * the entire item description in one block of text, so we just 547 * the entire item description in one block of text, so we just
… …
505 * sp 30 555 * sp 30
506 * Is much easier to parse than 556 * Is much easier to parse than
507 * dragon name "big nasty creature" hp 5 sp 30 557 * dragon name "big nasty creature" hp 5 sp 30
508 * for example. 558 * for example.
509 */ 559 */
560int
510int command_create(object *op, char *params) { 561command_create (object *op, char *params)
562{
511 object *tmp = NULL; 563 object *tmp = NULL;
512 int nrof, i, magic, set_magic = 0, set_nrof = 0, gotquote, gotspace; 564 int nrof, i, magic, set_magic = 0, set_nrof = 0, gotquote, gotspace;
513 char buf[MAX_BUF], *cp, *bp = buf, *bp2, *bp3, *bp4, *endline; 565 char buf[MAX_BUF], *cp, *bp = buf, *bp2, *bp3, *bp4, *endline;
514 archetype *at, *at_spell = NULL; 566 archetype *at, *at_spell = NULL;
515 artifact *art = NULL; 567 artifact *art = NULL;
516 568
517 if (!op) 569 if (!op)
518 return 0; 570 return 0;
519 571
520 if (params == NULL) { 572 if (params == NULL)
521 new_draw_info(NDI_UNIQUE, 0, op, 573 {
522 "Usage: create [nr] [magic] <archetype> [ of <artifact>]" 574 new_draw_info (NDI_UNIQUE, 0, op, "Usage: create [nr] [magic] <archetype> [ of <artifact>]" " [variable_to_patch setting]");
523 " [variable_to_patch setting]");
524 return 1; 575 return 1;
525 } 576 }
526 bp = params; 577 bp = params;
527 578
528 /* We need to know where the line ends */ 579 /* We need to know where the line ends */
529 endline = bp+strlen(bp); 580 endline = bp + strlen (bp);
530 581
531 if (sscanf(bp, "%d ", &nrof)) { 582 if (sscanf (bp, "%d ", &nrof))
583 {
532 if ((bp = strchr(params, ' ')) == NULL) { 584 if ((bp = strchr (params, ' ')) == NULL)
533 new_draw_info(NDI_UNIQUE, 0, op, 585 {
534 "Usage: create [nr] [magic] <archetype> [ of <artifact>]" 586 new_draw_info (NDI_UNIQUE, 0, op, "Usage: create [nr] [magic] <archetype> [ of <artifact>]" " [variable_to_patch setting]");
535 " [variable_to_patch setting]");
536 return 1; 587 return 1;
537 } 588 }
538 bp++; 589 bp++;
539 set_nrof = 1; 590 set_nrof = 1;
540 LOG(llevDebug, "%s creates: (%d) %s\n", &op->name, nrof, bp); 591 LOG (llevDebug, "%s creates: (%d) %s\n", &op->name, nrof, bp);
541 } 592 }
542 if (sscanf(bp, "%d ", &magic)) { 593 if (sscanf (bp, "%d ", &magic))
594 {
543 if ((bp = strchr(bp, ' ')) == NULL) { 595 if ((bp = strchr (bp, ' ')) == NULL)
544 new_draw_info(NDI_UNIQUE, 0, op, 596 {
545 "Usage: create [nr] [magic] <archetype> [ of <artifact>]" 597 new_draw_info (NDI_UNIQUE, 0, op, "Usage: create [nr] [magic] <archetype> [ of <artifact>]" " [variable_to_patch setting]");
546 " [variable_to_patch setting]");
547 return 1; 598 return 1;
548 } 599 }
549 bp++; 600 bp++;
550 set_magic = 1; 601 set_magic = 1;
551 LOG(llevDebug, "%s creates: (%d) (%d) %s\n", &op->name, nrof, magic, bp); 602 LOG (llevDebug, "%s creates: (%d) (%d) %s\n", &op->name, nrof, magic, bp);
552 } 603 }
553 if ((cp = strstr(bp, " of ")) != NULL) { 604 if ((cp = strstr (bp, " of ")) != NULL)
605 {
554 *cp = '\0'; 606 *cp = '\0';
555 cp += 4; 607 cp += 4;
556 } 608 }
557 for (bp2 = bp; *bp2; bp2++) { 609 for (bp2 = bp; *bp2; bp2++)
610 {
558 if (*bp2 == ' ') { 611 if (*bp2 == ' ')
612 {
559 *bp2 = '\0'; 613 *bp2 = '\0';
560 bp2++; 614 bp2++;
561 break; 615 break;
562 } 616 }
563 } 617 }
564 618
565 if ((at = find_archetype(bp)) == NULL) { 619 if ((at = find_archetype (bp)) == NULL)
620 {
566 new_draw_info(NDI_UNIQUE, 0, op, "No such archetype."); 621 new_draw_info (NDI_UNIQUE, 0, op, "No such archetype.");
567 return 1; 622 return 1;
568 } 623 }
569 624
570 if (cp) { 625 if (cp)
626 {
571 char spell_name[MAX_BUF], *fsp = NULL; 627 char spell_name[MAX_BUF], *fsp = NULL;
572 628
573 /* 629 /*
574 * Try to find a spell object for this. Note that 630 * Try to find a spell object for this. Note that
575 * we also set up spell_name which is only 631 * we also set up spell_name which is only
576 * the first word. 632 * the first word.
577 */ 633 */
578 634
579 at_spell = find_archetype(cp); 635 at_spell = find_archetype (cp);
580 if (!at_spell || at_spell->clone.type != SPELL) 636 if (!at_spell || at_spell->clone.type != SPELL)
581 at_spell = find_archetype_by_object_name(cp); 637 at_spell = find_archetype_by_object_name (cp);
582 if (!at_spell || at_spell->clone.type != SPELL) { 638 if (!at_spell || at_spell->clone.type != SPELL)
639 {
583 strcpy(spell_name, cp); 640 strcpy (spell_name, cp);
584 fsp = strchr(spell_name, ' '); 641 fsp = strchr (spell_name, ' ');
585 if (fsp) { 642 if (fsp)
643 {
586 *fsp = 0; 644 *fsp = 0;
587 fsp++; 645 fsp++;
588 at_spell = find_archetype(spell_name); 646 at_spell = find_archetype (spell_name);
589 647
590 /* Got a spell, update the first string pointer */ 648 /* Got a spell, update the first string pointer */
591 if (at_spell && at_spell->clone.type == SPELL) 649 if (at_spell && at_spell->clone.type == SPELL)
592 bp2 = cp+strlen(spell_name)+1; 650 bp2 = cp + strlen (spell_name) + 1;
593 else 651 else
594 at_spell = NULL; 652 at_spell = NULL;
595 } 653 }
596 } 654 }
597 655
598 /* OK - we didn't find a spell - presume the 'of' 656 /* OK - we didn't find a spell - presume the 'of'
599 * in this case means its an artifact. 657 * in this case means its an artifact.
600 */ 658 */
601 if (!at_spell) { 659 if (!at_spell)
660 {
602 if (find_artifactlist(at->clone.type) == NULL) { 661 if (find_artifactlist (at->clone.type) == NULL)
603 new_draw_info_format(NDI_UNIQUE, 0, op, 662 {
604 "No artifact list for type %d\n", at->clone.type); 663 new_draw_info_format (NDI_UNIQUE, 0, op, "No artifact list for type %d\n", at->clone.type);
664 }
605 } else { 665 else
666 {
606 art = find_artifactlist(at->clone.type)->items; 667 art = find_artifactlist (at->clone.type)->items;
607 668
669 do
608 do { 670 {
609 if (!strcmp(art->item->name, cp)) 671 if (!strcmp (art->item->name, cp))
610 break; 672 break;
611 art = art->next; 673 art = art->next;
674 }
612 } while (art != NULL); 675 while (art != NULL);
613 if (!art) { 676 if (!art)
614 new_draw_info_format(NDI_UNIQUE, 0, op, 677 {
615 "No such artifact ([%d] of %s)", at->clone.type, cp); 678 new_draw_info_format (NDI_UNIQUE, 0, op, "No such artifact ([%d] of %s)", at->clone.type, cp);
616 } 679 }
617 } 680 }
618 LOG(llevDebug, "%s creates: (%d) (%d) (%s) of (%s)\n", &op->name, 681 LOG (llevDebug, "%s creates: (%d) (%d) (%s) of (%s)\n", &op->name, set_nrof ? nrof : 0, set_magic ? magic : 0, bp, cp);
619 set_nrof ? nrof : 0, set_magic ? magic : 0, bp, cp);
620 } 682 }
621 } /* if cp */ 683 } /* if cp */
622 684
623 if ((at->clone.type == ROD || at->clone.type == WAND || at->clone.type == SCROLL || 685 if ((at->clone.type == ROD || at->clone.type == WAND || at->clone.type == SCROLL ||
624 at->clone.type == HORN || at->clone.type == SPELLBOOK) && !at_spell) { 686 at->clone.type == HORN || at->clone.type == SPELLBOOK) && !at_spell)
625 new_draw_info_format(NDI_UNIQUE, 0, op, 687 {
626 "Unable to find spell %s for object that needs it, or it is of wrong type", 688 new_draw_info_format (NDI_UNIQUE, 0, op, "Unable to find spell %s for object that needs it, or it is of wrong type", cp);
627 cp);
628 return 1; 689 return 1;
629 } 690 }
630 691
631 /* 692 /*
632 * Rather than have two different blocks with a lot of similar code, 693 * Rather than have two different blocks with a lot of similar code,
633 * just create one object, do all the processing, and then determine 694 * just create one object, do all the processing, and then determine
634 * if that one object should be inserted or if we need to make copies. 695 * if that one object should be inserted or if we need to make copies.
635 */ 696 */
636 tmp = arch_to_object(at); 697 tmp = arch_to_object (at);
637 if (settings.real_wiz == FALSE) 698 if (settings.real_wiz == FALSE)
638 SET_FLAG(tmp, FLAG_WAS_WIZ); 699 SET_FLAG (tmp, FLAG_WAS_WIZ);
639 if (set_magic) 700 if (set_magic)
640 set_abs_magic(tmp, magic); 701 set_abs_magic (tmp, magic);
641 if (art) 702 if (art)
642 give_artifact_abilities(tmp, art->item); 703 give_artifact_abilities (tmp, art->item);
643 if (need_identify(tmp)) { 704 if (need_identify (tmp))
705 {
644 SET_FLAG(tmp, FLAG_IDENTIFIED); 706 SET_FLAG (tmp, FLAG_IDENTIFIED);
645 CLEAR_FLAG(tmp, FLAG_KNOWN_MAGICAL); 707 CLEAR_FLAG (tmp, FLAG_KNOWN_MAGICAL);
646 } 708 }
647 709
648 /* 710 /*
649 * This entire block here tries to find variable pairings, 711 * This entire block here tries to find variable pairings,
650 * eg, 'hp 4' or the like. The mess here is that values 712 * eg, 'hp 4' or the like. The mess here is that values
651 * can be quoted (eg "my cool sword"); So the basic logic 713 * can be quoted (eg "my cool sword"); So the basic logic
652 * is we want to find two spaces, but if we got a quote, 714 * is we want to find two spaces, but if we got a quote,
653 * any spaces there don't count. 715 * any spaces there don't count.
654 */ 716 */
655 while (*bp2 && bp2 <= endline) { 717 while (*bp2 && bp2 <= endline)
718 {
656 bp4 = NULL; 719 bp4 = NULL;
657 gotspace = 0; 720 gotspace = 0;
658 gotquote = 0; 721 gotquote = 0;
659 /* find the first quote */ 722 /* find the first quote */
660 for (bp3 = bp2; *bp3 && gotspace < 2 && gotquote < 2; bp3++) { 723 for (bp3 = bp2; *bp3 && gotspace < 2 && gotquote < 2; bp3++)
724 {
661 725
662 /* Found a quote - now lets find the second one */ 726 /* Found a quote - now lets find the second one */
663 if (*bp3 == '"') { 727 if (*bp3 == '"')
728 {
664 *bp3 = ' '; 729 *bp3 = ' ';
665 bp2 = bp3+1; /* Update start of string */ 730 bp2 = bp3 + 1; /* Update start of string */
666 bp3++; 731 bp3++;
667 gotquote++; 732 gotquote++;
668 while (*bp3) { 733 while (*bp3)
734 {
669 if (*bp3 == '"') { 735 if (*bp3 == '"')
736 {
670 *bp3 = '\0'; 737 *bp3 = '\0';
671 gotquote++; 738 gotquote++;
739 }
672 } else 740 else
673 bp3++; 741 bp3++;
674 } 742 }
675 } else if (*bp3==' ') {
676 gotspace++;
677 } 743 }
744 else if (*bp3 == ' ')
745 {
746 gotspace++;
678 } 747 }
748 }
679 749
680 /* 750 /*
681 * If we got two spaces, send the second one to null. 751 * If we got two spaces, send the second one to null.
682 * if we've reached the end of the line, increase gotspace - 752 * if we've reached the end of the line, increase gotspace -
683 * this is perfectly valid for the list entry listed. 753 * this is perfectly valid for the list entry listed.
684 */ 754 */
685 if (gotspace == 2 || gotquote == 2) { 755 if (gotspace == 2 || gotquote == 2)
756 {
686 bp3--; /* Undo the extra increment */ 757 bp3--; /* Undo the extra increment */
687 *bp3 = '\0'; 758 *bp3 = '\0';
759 }
688 } else if (*bp3=='\0') 760 else if (*bp3 == '\0')
689 gotspace++; 761 gotspace++;
690 762
691 if ((gotquote && gotquote != 2) || (gotspace != 2 && gotquote != 2)) { 763 if ((gotquote && gotquote != 2) || (gotspace != 2 && gotquote != 2))
764 {
692 /* 765 /*
693 * Unfortunately, we've clobbered lots of values, so printing 766 * Unfortunately, we've clobbered lots of values, so printing
694 * out what we have probably isn't useful. Break out, because 767 * out what we have probably isn't useful. Break out, because
695 * trying to recover is probably won't get anything useful 768 * trying to recover is probably won't get anything useful
696 * anyways, and we'd be confused about end of line pointers 769 * anyways, and we'd be confused about end of line pointers
697 * anyways. 770 * anyways.
698 */ 771 */
699 new_draw_info_format(NDI_UNIQUE, 0, op, 772 new_draw_info_format (NDI_UNIQUE, 0, op, "Malformed create line: %s", bp2);
700 "Malformed create line: %s", bp2);
701 break; 773 break;
702 } 774 }
703 /* bp2 should still point to the start of this line, 775 /* bp2 should still point to the start of this line,
704 * with bp3 pointing to the end 776 * with bp3 pointing to the end
705 */ 777 */
706 if (set_variable(tmp, bp2) == -1) 778 if (set_variable (tmp, bp2) == -1)
707 new_draw_info_format(NDI_UNIQUE, 0, op, 779 new_draw_info_format (NDI_UNIQUE, 0, op, "Unknown variable %s", bp2);
708 "Unknown variable %s", bp2);
709 else 780 else
710 new_draw_info_format(NDI_UNIQUE, 0, op, 781 new_draw_info_format (NDI_UNIQUE, 0, op, "(%s#%d)->%s", &tmp->name, tmp->count, bp2);
711 "(%s#%d)->%s", &tmp->name, tmp->count, bp2);
712 bp2 = bp3+1; 782 bp2 = bp3 + 1;
713 } 783 }
714 784
715 if (at->clone.nrof) { 785 if (at->clone.nrof)
786 {
716 if (at_spell) 787 if (at_spell)
717 insert_ob_in_ob(arch_to_object(at_spell), tmp); 788 insert_ob_in_ob (arch_to_object (at_spell), tmp);
718 789
719 tmp->x = op->x; 790 tmp->x = op->x;
720 tmp->y = op->y; 791 tmp->y = op->y;
721 if (set_nrof) 792 if (set_nrof)
722 tmp->nrof = nrof; 793 tmp->nrof = nrof;
723 tmp->map = op->map; 794 tmp->map = op->map;
724 795
725 tmp = insert_ob_in_ob(tmp, op); 796 tmp = insert_ob_in_ob (tmp, op);
726 esrv_send_item(op, tmp); 797 esrv_send_item (op, tmp);
727 798
728 /* Let's put this created item on stack so dm can access it easily. */ 799 /* Let's put this created item on stack so dm can access it easily. */
729 dm_stack_push(op->contr, tmp->count); 800 dm_stack_push (op->contr, tmp->count);
730 801
731 return 1; 802 return 1;
732 } else { 803 }
804 else
805 {
733 for (i = 0 ; i < (set_nrof ? nrof : 1); i++) { 806 for (i = 0; i < (set_nrof ? nrof : 1); i++)
807 {
734 archetype *atmp; 808 archetype *atmp;
735 object *prev = NULL, *head = NULL, *dup; 809 object *prev = NULL, *head = NULL, *dup;
736 810
737 for (atmp = at; atmp != NULL; atmp = atmp->more) { 811 for (atmp = at; atmp != NULL; atmp = atmp->more)
812 {
738 dup = arch_to_object(atmp); 813 dup = arch_to_object (atmp);
739 814
740 if (at_spell) 815 if (at_spell)
741 insert_ob_in_ob(arch_to_object(at_spell), dup); 816 insert_ob_in_ob (arch_to_object (at_spell), dup);
742 817
743 /* 818 /*
744 * The head is what contains all the important bits, 819 * The head is what contains all the important bits,
745 * so just copying it over should be fine. 820 * so just copying it over should be fine.
746 */ 821 */
747 if (head == NULL) { 822 if (head == NULL)
823 {
748 head=dup; 824 head = dup;
749 copy_object(tmp, dup); 825 copy_object (tmp, dup);
750 } 826 }
751 if (settings.real_wiz == FALSE) 827 if (settings.real_wiz == FALSE)
752 SET_FLAG(dup, FLAG_WAS_WIZ); 828 SET_FLAG (dup, FLAG_WAS_WIZ);
753 dup->x = op->x+dup->arch->clone.x; 829 dup->x = op->x + dup->arch->clone.x;
754 dup->y = op->y+dup->arch->clone.y; 830 dup->y = op->y + dup->arch->clone.y;
755 dup->map = op->map; 831 dup->map = op->map;
756 832
757 if (head != dup) { 833 if (head != dup)
834 {
758 dup->head = head; 835 dup->head = head;
759 prev->more = dup; 836 prev->more = dup;
760 } 837 }
761 prev = dup; 838 prev = dup;
762 } 839 }
763 840
764 if (QUERY_FLAG(head, FLAG_ALIVE)) { 841 if (QUERY_FLAG (head, FLAG_ALIVE))
842 {
765 object *check = head; 843 object *check = head;
766 int size_x = 0; 844 int size_x = 0;
767 int size_y = 0; 845 int size_y = 0;
768 846
769 while (check) { 847 while (check)
848 {
770 size_x = MAX(size_x, check->arch->clone.x); 849 size_x = MAX (size_x, check->arch->clone.x);
771 size_y = MAX(size_y, check->arch->clone.y); 850 size_y = MAX (size_y, check->arch->clone.y);
772 check = check->more; 851 check = check->more;
773 } 852 }
774 853
775 if (out_of_map(op->map, head->x+size_x, head->y+size_y)) { 854 if (out_of_map (op->map, head->x + size_x, head->y + size_y))
855 {
776 if (head->x < size_x || head->y < size_y) { 856 if (head->x < size_x || head->y < size_y)
857 {
777 dm_stack_pop(op->contr); 858 dm_stack_pop (op->contr);
778 free_object(head); 859 free_object (head);
779 new_draw_info(NDI_UNIQUE, 0, op, "Object too big to insert in map, or wrong position."); 860 new_draw_info (NDI_UNIQUE, 0, op, "Object too big to insert in map, or wrong position.");
780 free_object(tmp); 861 free_object (tmp);
781 return 1; 862 return 1;
782 } 863 }
783 864
784 check = head; 865 check = head;
785 while (check) { 866 while (check)
867 {
786 check->x -= size_x; 868 check->x -= size_x;
787 check->y -= size_y; 869 check->y -= size_y;
788 check = check->more; 870 check = check->more;
789 } 871 }
790 } 872 }
791 873
792 insert_ob_in_map(head, op->map, op, 0); 874 insert_ob_in_map (head, op->map, op, 0);
875 }
793 } else 876 else
794 head = insert_ob_in_ob(head, op); 877 head = insert_ob_in_ob (head, op);
795 878
796 /* Let's put this created item on stack so dm can access it easily. */ 879 /* Let's put this created item on stack so dm can access it easily. */
797 /* Wonder if we really want to push all of these, but since 880 /* Wonder if we really want to push all of these, but since
798 * things like rods have nrof 0, we want to cover those. 881 * things like rods have nrof 0, we want to cover those.
799 */ 882 */
800 dm_stack_push(op->contr, head->count); 883 dm_stack_push (op->contr, head->count);
801 884
802 if (at->clone.randomitems != NULL && !at_spell) 885 if (at->clone.randomitems != NULL && !at_spell)
803 create_treasure(at->clone.randomitems, head, GT_APPLY, 886 create_treasure (at->clone.randomitems, head, GT_APPLY, op->map->difficulty, 0);
804 op->map->difficulty, 0);
805 esrv_send_item(op, head); 887 esrv_send_item (op, head);
806 } 888 }
807 889
808 /* free the one we used to copy */ 890 /* free the one we used to copy */
809 free_object(tmp); 891 free_object (tmp);
810 } 892 }
811 893
812 return 1; 894 return 1;
813} 895}
814 896
815/* 897/*
816 * Now follows dm-commands which are also acceptable from sockets 898 * Now follows dm-commands which are also acceptable from sockets
817 */ 899 */
818 900
901int
819int command_inventory(object *op, char *params) { 902command_inventory (object *op, char *params)
903{
820 object *tmp; 904 object *tmp;
821 int i; 905 int i;
822 906
823 if (!params) { 907 if (!params)
908 {
824 inventory(op, NULL); 909 inventory (op, NULL);
825 return 0; 910 return 0;
826 } 911 }
827 912
828 if (!sscanf(params, "%d", &i) || (tmp = find_object(i)) == NULL) { 913 if (!sscanf (params, "%d", &i) || (tmp = find_object (i)) == NULL)
914 {
829 new_draw_info(NDI_UNIQUE, 0, op, "Inventory of what object (nr)?"); 915 new_draw_info (NDI_UNIQUE, 0, op, "Inventory of what object (nr)?");
830 return 1; 916 return 1;
831 } 917 }
832 918
833 inventory(op, tmp); 919 inventory (op, tmp);
834 return 1; 920 return 1;
835} 921}
836 922
837/* just show player's their skills for now. Dm's can 923/* just show player's their skills for now. Dm's can
838 * already see skills w/ inventory command - b.t. 924 * already see skills w/ inventory command - b.t.
839 */ 925 */
840 926
927int
841int command_skills (object *op, char *params) { 928command_skills (object *op, char *params)
929{
842 show_skills(op, params); 930 show_skills (op, params);
843 return 0; 931 return 0;
844} 932}
845 933
934int
846int command_dump (object *op, char *params) { 935command_dump (object *op, char *params)
936{
847 object *tmp; 937 object *tmp;
848 938
849 tmp = get_dm_object(op->contr, &params, NULL); 939 tmp = get_dm_object (op->contr, &params, NULL);
850 if (!tmp) 940 if (!tmp)
851 return 1;
852
853 dump_object(tmp);
854 new_draw_info(NDI_UNIQUE, 0, op, errmsg);
855 if (QUERY_FLAG(tmp, FLAG_OBJ_ORIGINAL))
856 new_draw_info(NDI_UNIQUE, 0, op, "Object is marked original");
857 return 1; 941 return 1;
942
943 dump_object (tmp);
944 new_draw_info (NDI_UNIQUE, 0, op, errmsg);
945 if (QUERY_FLAG (tmp, FLAG_OBJ_ORIGINAL))
946 new_draw_info (NDI_UNIQUE, 0, op, "Object is marked original");
947 return 1;
858} 948}
859 949
860/** 950/**
861 * When DM is possessing a monster, flip aggression on and off, to allow 951 * When DM is possessing a monster, flip aggression on and off, to allow
862 * better motion. 952 * better motion.
863 */ 953 */
954int
864int command_mon_aggr(object *op, char *params) { 955command_mon_aggr (object *op, char *params)
956{
865 if (op->enemy || !QUERY_FLAG(op, FLAG_UNAGGRESSIVE)) { 957 if (op->enemy || !QUERY_FLAG (op, FLAG_UNAGGRESSIVE))
958 {
866 op->enemy = NULL; 959 op->enemy = NULL;
867 SET_FLAG(op, FLAG_UNAGGRESSIVE); 960 SET_FLAG (op, FLAG_UNAGGRESSIVE);
868 new_draw_info(NDI_UNIQUE, 0, op, "Aggression turned OFF"); 961 new_draw_info (NDI_UNIQUE, 0, op, "Aggression turned OFF");
869 } else { 962 }
963 else
964 {
870 CLEAR_FLAG(op, FLAG_FRIENDLY); 965 CLEAR_FLAG (op, FLAG_FRIENDLY);
871 CLEAR_FLAG(op, FLAG_UNAGGRESSIVE); 966 CLEAR_FLAG (op, FLAG_UNAGGRESSIVE);
872 new_draw_info(NDI_UNIQUE, 0, op, "Aggression turned ON"); 967 new_draw_info (NDI_UNIQUE, 0, op, "Aggression turned ON");
873 } 968 }
874 969
875 return 1; 970 return 1;
876} 971}
877 972
878/** DM can possess a monster. Basically, this tricks the client into thinking 973/** DM can possess a monster. Basically, this tricks the client into thinking
879 * a given monster, is actually the player it controls. This allows a DM 974 * a given monster, is actually the player it controls. This allows a DM
880 * to inhabit a monster's body, and run around the game with it. 975 * to inhabit a monster's body, and run around the game with it.
881 * This function is severely broken - it has tons of hardcoded values, 976 * This function is severely broken - it has tons of hardcoded values,
882 */ 977 */
978int
883int command_possess(object *op, char *params) { 979command_possess (object *op, char *params)
980{
884 object *victim, *curinv, *nextinv; 981 object *victim, *curinv, *nextinv;
885 player *pl; 982 player *pl;
886 int i; 983 int i;
887 char buf[MAX_BUF]; 984 char buf[MAX_BUF];
888 985
889 victim = NULL; 986 victim = NULL;
890 if (params != NULL) { 987 if (params != NULL)
988 {
891 if (sscanf(params, "%d", &i)) 989 if (sscanf (params, "%d", &i))
892 victim = find_object(i); 990 victim = find_object (i);
893 else if (sscanf(params, "%s", buf)) 991 else if (sscanf (params, "%s", buf))
894 victim = find_object_name(buf); 992 victim = find_object_name (buf);
895 } 993 }
896 if (victim == NULL) { 994 if (victim == NULL)
995 {
897 new_draw_info(NDI_UNIQUE, 0, op, "Patch what object (nr)?"); 996 new_draw_info (NDI_UNIQUE, 0, op, "Patch what object (nr)?");
898 return 1; 997 return 1;
899 } 998 }
900 999
901 if (victim == op) { 1000 if (victim == op)
1001 {
902 new_draw_info(NDI_UNIQUE, 0, op, "As insane as you are, I cannot " 1002 new_draw_info (NDI_UNIQUE, 0, op, "As insane as you are, I cannot " "allow you to possess yourself.");
903 "allow you to possess yourself.");
904 return 1; 1003 return 1;
905 } 1004 }
906 1005
907 /* clear out the old inventory */ 1006 /* clear out the old inventory */
908 curinv = op->inv; 1007 curinv = op->inv;
909 while (curinv != NULL) { 1008 while (curinv != NULL)
1009 {
910 nextinv = curinv->below; 1010 nextinv = curinv->below;
911 esrv_del_item(op->contr, curinv->count); 1011 esrv_del_item (op->contr, curinv->count);
912 curinv = nextinv; 1012 curinv = nextinv;
913 } 1013 }
914 1014
915 /* make the switch */ 1015 /* make the switch */
916 pl = op->contr; 1016 pl = op->contr;
917 victim->contr = pl; 1017 victim->contr = pl;
918 pl->ob = victim; 1018 pl->ob = victim;
919 victim->type = PLAYER; 1019 victim->type = PLAYER;
920 SET_FLAG(victim, FLAG_WIZ); 1020 SET_FLAG (victim, FLAG_WIZ);
921 1021
922 /* send the inventory to the client */ 1022 /* send the inventory to the client */
923 curinv = victim->inv; 1023 curinv = victim->inv;
924 while (curinv != NULL) { 1024 while (curinv != NULL)
1025 {
925 nextinv = curinv->below; 1026 nextinv = curinv->below;
926 esrv_send_item(victim, curinv); 1027 esrv_send_item (victim, curinv);
927 curinv = nextinv; 1028 curinv = nextinv;
928 } 1029 }
929 /* basic patchup */ 1030 /* basic patchup */
930 /* The use of hard coded values is terrible. Note 1031 /* The use of hard coded values is terrible. Note
931 * that really, to be fair, this shouldn't get changed at 1032 * that really, to be fair, this shouldn't get changed at
932 * all - if you are possessing a kobold, you should have the 1033 * all - if you are possessing a kobold, you should have the
933 * same limitations. As it is, as more body locations are added, 1034 * same limitations. As it is, as more body locations are added,
934 * this will give this player more locations than perhaps 1035 * this will give this player more locations than perhaps
935 * they should be allowed. 1036 * they should be allowed.
936 */ 1037 */
937 for (i = 0; i < NUM_BODY_LOCATIONS; i++) 1038 for (i = 0; i < NUM_BODY_LOCATIONS; i++)
938 if (i == 1 || i == 6 || i == 8 || i == 9) 1039 if (i == 1 || i == 6 || i == 8 || i == 9)
939 victim->body_info[i] = 2; 1040 victim->body_info[i] = 2;
940 else 1041 else
941 victim->body_info[i] = 1; 1042 victim->body_info[i] = 1;
942 1043
943 esrv_new_player(pl, 80); /* just pick a wieght, we don't care */ 1044 esrv_new_player (pl, 80); /* just pick a wieght, we don't care */
944 esrv_send_inventory(victim, victim); 1045 esrv_send_inventory (victim, victim);
945 1046
946 fix_player(victim); 1047 fix_player (victim);
947 1048
948 do_some_living(victim); 1049 do_some_living (victim);
1050 return 1;
1051}
1052
1053int
1054command_patch (object *op, char *params)
1055{
1056 char *arg, *arg2;
1057 object *tmp;
1058
1059 tmp = get_dm_object (op->contr, &params, NULL);
1060 if (!tmp)
1061 /* Player already informed of failure */
949 return 1; 1062 return 1;
950}
951 1063
952int command_patch(object *op, char *params) {
953 char *arg, *arg2;
954 object *tmp;
955
956 tmp = get_dm_object(op->contr, &params, NULL);
957 if (!tmp)
958 /* Player already informed of failure */
959 return 1;
960
961 /* params set to first value by get_dm_default */ 1064 /* params set to first value by get_dm_default */
962 arg = params; 1065 arg = params;
963 if (arg == NULL) { 1066 if (arg == NULL)
1067 {
964 new_draw_info(NDI_UNIQUE, 0, op, "Patch what values?"); 1068 new_draw_info (NDI_UNIQUE, 0, op, "Patch what values?");
965 return 1; 1069 return 1;
966 } 1070 }
967 1071
968 if ((arg2 = strchr(arg, ' '))) 1072 if ((arg2 = strchr (arg, ' ')))
969 arg2++; 1073 arg2++;
970 if (settings.real_wiz == FALSE) 1074 if (settings.real_wiz == FALSE)
971 SET_FLAG(tmp, FLAG_WAS_WIZ); /* To avoid cheating */ 1075 SET_FLAG (tmp, FLAG_WAS_WIZ); /* To avoid cheating */
972 if (set_variable(tmp, arg) == -1) 1076 if (set_variable (tmp, arg) == -1)
973 new_draw_info_format(NDI_UNIQUE, 0, op, "Unknown variable %s", arg); 1077 new_draw_info_format (NDI_UNIQUE, 0, op, "Unknown variable %s", arg);
974 else { 1078 else
975 new_draw_info_format(NDI_UNIQUE, 0, op,
976 "(%s#%d)->%s=%s", &tmp->name, tmp->count, arg, arg2);
977 } 1079 {
1080 new_draw_info_format (NDI_UNIQUE, 0, op, "(%s#%d)->%s=%s", &tmp->name, tmp->count, arg, arg2);
1081 }
978 1082
979 return 1; 1083 return 1;
980 } 1084}
981 1085
1086int
982int command_remove (object *op, char *params) { 1087command_remove (object *op, char *params)
1088{
983 object *tmp; 1089 object *tmp;
984 int from; 1090 int from;
985 1091
986 tmp = get_dm_object(op->contr, &params, &from); 1092 tmp = get_dm_object (op->contr, &params, &from);
987 if (!tmp) { 1093 if (!tmp)
1094 {
988 new_draw_info(NDI_UNIQUE, 0, op, "Remove what object (nr)?"); 1095 new_draw_info (NDI_UNIQUE, 0, op, "Remove what object (nr)?");
989 return 1; 1096 return 1;
990 } 1097 }
991 1098
992 if (tmp->type == PLAYER) { 1099 if (tmp->type == PLAYER)
1100 {
993 new_draw_info(NDI_UNIQUE, 0, op, "Unable to remove a player!"); 1101 new_draw_info (NDI_UNIQUE, 0, op, "Unable to remove a player!");
994 return 1; 1102 return 1;
995 } 1103 }
996 1104
997 if (QUERY_FLAG(tmp, FLAG_REMOVED)) { 1105 if (QUERY_FLAG (tmp, FLAG_REMOVED))
1106 {
998 new_draw_info_format(NDI_UNIQUE, 0, op, "%s is already removed!", 1107 new_draw_info_format (NDI_UNIQUE, 0, op, "%s is already removed!", query_name (tmp));
999 query_name(tmp));
1000 return 1; 1108 return 1;
1001 } 1109 }
1002 1110
1003 if (from != STACK_FROM_STACK) 1111 if (from != STACK_FROM_STACK)
1004 /* Item is either stack top, or is a number thus is now stack top, let's remove it */ 1112 /* Item is either stack top, or is a number thus is now stack top, let's remove it */
1005 dm_stack_pop(op->contr); 1113 dm_stack_pop (op->contr);
1006 1114
1007 /* Always work on the head - otherwise object will get in odd state */ 1115 /* Always work on the head - otherwise object will get in odd state */
1008 if (tmp->head) 1116 if (tmp->head)
1009 tmp = tmp->head; 1117 tmp = tmp->head;
1010 remove_ob(tmp); 1118 remove_ob (tmp);
1011 return 1; 1119 return 1;
1012} 1120}
1013 1121
1122int
1014int command_free(object *op, char *params) { 1123command_free (object *op, char *params)
1124{
1015 object *tmp; 1125 object *tmp;
1016 int from; 1126 int from;
1017 1127
1018 tmp = get_dm_object(op->contr, &params, &from); 1128 tmp = get_dm_object (op->contr, &params, &from);
1019 1129
1020 if (!tmp) { 1130 if (!tmp)
1131 {
1021 new_draw_info(NDI_UNIQUE, 0, op, "Free what object (nr)?"); 1132 new_draw_info (NDI_UNIQUE, 0, op, "Free what object (nr)?");
1022 return 1; 1133 return 1;
1023 } 1134 }
1024 1135
1025 if (from != STACK_FROM_STACK) 1136 if (from != STACK_FROM_STACK)
1026 /* Item is either stack top, or is a number thus is now stack top, let's remove it */ 1137 /* Item is either stack top, or is a number thus is now stack top, let's remove it */
1027 dm_stack_pop(op->contr); 1138 dm_stack_pop (op->contr);
1028 1139
1029 if (!QUERY_FLAG(tmp, FLAG_REMOVED)) { 1140 if (!QUERY_FLAG (tmp, FLAG_REMOVED))
1141 {
1030 new_draw_info(NDI_UNIQUE, 0, op, "Warning, item wasn't removed."); 1142 new_draw_info (NDI_UNIQUE, 0, op, "Warning, item wasn't removed.");
1031 remove_ob(tmp); 1143 remove_ob (tmp);
1032 } 1144 }
1033 1145
1034 if (tmp->head) 1146 if (tmp->head)
1035 tmp = tmp->head; 1147 tmp = tmp->head;
1036 free_object(tmp); 1148 free_object (tmp);
1037 return 1; 1149 return 1;
1038} 1150}
1039 1151
1040/** 1152/**
1041 * This adds exp to a player. We now allow adding to a specific skill. 1153 * This adds exp to a player. We now allow adding to a specific skill.
1042 */ 1154 */
1155int
1043int command_addexp(object *op, char *params) { 1156command_addexp (object *op, char *params)
1157{
1044 char buf[MAX_BUF], skill[MAX_BUF]; 1158 char buf[MAX_BUF], skill[MAX_BUF];
1045 int i, q; 1159 int i, q;
1046 object *skillob = NULL; 1160 object *skillob = NULL;
1047 player *pl; 1161 player *pl;
1048 1162
1049 skill[0] = '\0'; 1163 skill[0] = '\0';
1050 if ((params == NULL) || (strlen(params) > MAX_BUF) || ((q = sscanf(params, "%s %d %s", buf, &i, skill)) < 2)) { 1164 if ((params == NULL) || (strlen (params) > MAX_BUF) || ((q = sscanf (params, "%s %d %s", buf, &i, skill)) < 2))
1165 {
1051 new_draw_info(NDI_UNIQUE, 0, op, "Usage: addexp <who> <how much> [<skill>]."); 1166 new_draw_info (NDI_UNIQUE, 0, op, "Usage: addexp <who> <how much> [<skill>].");
1052 return 1; 1167 return 1;
1053 } 1168 }
1054 1169
1055 for (pl = first_player; pl != NULL; pl = pl->next) 1170 for (pl = first_player; pl != NULL; pl = pl->next)
1056 if (!strncmp(pl->ob->name, buf, MAX_NAME)) 1171 if (!strncmp (pl->ob->name, buf, MAX_NAME))
1057 break; 1172 break;
1058 1173
1059 if (pl == NULL) { 1174 if (pl == NULL)
1175 {
1060 new_draw_info(NDI_UNIQUE, 0, op, "No such player."); 1176 new_draw_info (NDI_UNIQUE, 0, op, "No such player.");
1061 return 1; 1177 return 1;
1062 } 1178 }
1063 1179
1064 if (q >= 3) { 1180 if (q >= 3)
1181 {
1065 skillob = find_skill_by_name(pl->ob, skill); 1182 skillob = find_skill_by_name (pl->ob, skill);
1066 if (!skillob) { 1183 if (!skillob)
1184 {
1067 new_draw_info_format(NDI_UNIQUE, 0, op, "Unable to find skill %s in %s", skill, buf); 1185 new_draw_info_format (NDI_UNIQUE, 0, op, "Unable to find skill %s in %s", skill, buf);
1068 return 1; 1186 return 1;
1069 } 1187 }
1070 1188
1071 i = check_exp_adjust(skillob, i); 1189 i = check_exp_adjust (skillob, i);
1072 skillob->stats.exp += i; 1190 skillob->stats.exp += i;
1073 calc_perm_exp(skillob); 1191 calc_perm_exp (skillob);
1074 player_lvl_adj(pl->ob, skillob); 1192 player_lvl_adj (pl->ob, skillob);
1075 } 1193 }
1076 1194
1077 pl->ob->stats.exp += i; 1195 pl->ob->stats.exp += i;
1078 calc_perm_exp(pl->ob); 1196 calc_perm_exp (pl->ob);
1079 player_lvl_adj(pl->ob, NULL); 1197 player_lvl_adj (pl->ob, NULL);
1080 1198
1081 if (settings.real_wiz == FALSE) 1199 if (settings.real_wiz == FALSE)
1082 SET_FLAG(pl->ob, FLAG_WAS_WIZ); 1200 SET_FLAG (pl->ob, FLAG_WAS_WIZ);
1083 return 1; 1201 return 1;
1084} 1202}
1085 1203
1086/**************************************************************************/ 1204/**************************************************************************/
1205
1087/* Mods made by Tyler Van Gorder, May 10-13, 1992. */ 1206/* Mods made by Tyler Van Gorder, May 10-13, 1992. */
1207
1088/* CSUChico : tvangod@cscihp.ecst.csuchico.edu */ 1208/* CSUChico : tvangod@cscihp.ecst.csuchico.edu */
1209
1089/**************************************************************************/ 1210/**************************************************************************/
1090 1211
1212int
1091int command_stats(object *op, char *params) { 1213command_stats (object *op, char *params)
1214{
1092 char thing[20]; 1215 char thing[20];
1093 player *pl; 1216 player *pl;
1094 char buf[MAX_BUF]; 1217 char buf[MAX_BUF];
1095 1218
1096 thing[0] = '\0'; 1219 thing[0] = '\0';
1097 if (params == NULL || !sscanf(params, "%s", thing) || thing == NULL) { 1220 if (params == NULL || !sscanf (params, "%s", thing) || thing == NULL)
1221 {
1098 new_draw_info(NDI_UNIQUE, 0, op, "Who?"); 1222 new_draw_info (NDI_UNIQUE, 0, op, "Who?");
1099 return 1; 1223 return 1;
1100 } 1224 }
1101 1225
1102 for (pl = first_player; pl != NULL; pl = pl->next) 1226 for (pl = first_player; pl != NULL; pl = pl->next)
1103 if (!strcmp(pl->ob->name, thing)) { 1227 if (!strcmp (pl->ob->name, thing))
1104 sprintf(buf, "Str : %-2d H.P. : %-4d MAX : %d", 1228 {
1105 pl->ob->stats.Str, pl->ob->stats.hp, pl->ob->stats.maxhp); 1229 sprintf (buf, "Str : %-2d H.P. : %-4d MAX : %d", pl->ob->stats.Str, pl->ob->stats.hp, pl->ob->stats.maxhp);
1106 new_draw_info(NDI_UNIQUE, 0, op, buf); 1230 new_draw_info (NDI_UNIQUE, 0, op, buf);
1107 sprintf(buf, "Dex : %-2d S.P. : %-4d MAX : %d", 1231 sprintf (buf, "Dex : %-2d S.P. : %-4d MAX : %d", pl->ob->stats.Dex, pl->ob->stats.sp, pl->ob->stats.maxsp);
1108 pl->ob->stats.Dex, pl->ob->stats.sp, pl->ob->stats.maxsp);
1109 new_draw_info(NDI_UNIQUE, 0, op, buf); 1232 new_draw_info (NDI_UNIQUE, 0, op, buf);
1110 sprintf(buf, "Con : %-2d AC : %-4d WC : %d", 1233 sprintf (buf, "Con : %-2d AC : %-4d WC : %d", pl->ob->stats.Con, pl->ob->stats.ac, pl->ob->stats.wc);
1111 pl->ob->stats.Con, pl->ob->stats.ac, pl->ob->stats.wc) ;
1112 new_draw_info(NDI_UNIQUE, 0, op, buf); 1234 new_draw_info (NDI_UNIQUE, 0, op, buf);
1113 sprintf(buf, "Int : %-2d Damage : %d", 1235 sprintf (buf, "Int : %-2d Damage : %d", pl->ob->stats.Int, pl->ob->stats.dam);
1114 pl->ob->stats.Int, pl->ob->stats.dam);
1115 new_draw_info(NDI_UNIQUE, 0, op, buf); 1236 new_draw_info (NDI_UNIQUE, 0, op, buf);
1116 sprintf(buf, "Wis : %-2d EXP : %lld", 1237 sprintf (buf, "Wis : %-2d EXP : %lld", pl->ob->stats.Wis, (long long) pl->ob->stats.exp);
1117 pl->ob->stats.Wis, (long long)pl->ob->stats.exp);
1118 new_draw_info(NDI_UNIQUE, 0, op, buf); 1238 new_draw_info (NDI_UNIQUE, 0, op, buf);
1119 sprintf(buf, "Pow : %-2d Grace : %d", 1239 sprintf (buf, "Pow : %-2d Grace : %d", pl->ob->stats.Pow, pl->ob->stats.grace);
1120 pl->ob->stats.Pow, pl->ob->stats.grace);
1121 new_draw_info(NDI_UNIQUE, 0, op, buf); 1240 new_draw_info (NDI_UNIQUE, 0, op, buf);
1122 sprintf(buf, "Cha : %-2d Food : %d", 1241 sprintf (buf, "Cha : %-2d Food : %d", pl->ob->stats.Cha, pl->ob->stats.food);
1123 pl->ob->stats.Cha, pl->ob->stats.food);
1124 new_draw_info(NDI_UNIQUE, 0, op, buf); 1242 new_draw_info (NDI_UNIQUE, 0, op, buf);
1125 break; 1243 break;
1126 } 1244 }
1127 if (pl == NULL) 1245 if (pl == NULL)
1128 new_draw_info(NDI_UNIQUE, 0, op, "No such player.");
1129 return 1;
1130}
1131
1132int command_abil(object *op, char *params) {
1133 char thing[20], thing2[20];
1134 int iii;
1135 player *pl;
1136 char buf[MAX_BUF];
1137
1138 iii = 0;
1139 thing[0] = '\0';
1140 thing2[0] = '\0';
1141 if (params == NULL || !sscanf(params, "%s %s %d", thing, thing2, &iii) ||
1142 thing==NULL) {
1143 new_draw_info(NDI_UNIQUE, 0, op, "Who?");
1144 return 1;
1145 }
1146
1147 if (thing2 == NULL){
1148 new_draw_info(NDI_UNIQUE, 0, op, "You can't change that.");
1149 return 1;
1150 }
1151
1152 if (iii < MIN_STAT || iii > MAX_STAT) {
1153 new_draw_info(NDI_UNIQUE, 0, op, "Illegal range of stat.\n");
1154 return 1;
1155 }
1156
1157 for (pl = first_player; pl != NULL; pl = pl->next) {
1158 if (!strcmp(pl->ob->name, thing)) {
1159 if (settings.real_wiz == FALSE)
1160 SET_FLAG(pl->ob, FLAG_WAS_WIZ);
1161 if (!strcmp("str", thing2))
1162 pl->ob->stats.Str = iii, pl->orig_stats.Str = iii;
1163 if (!strcmp("dex", thing2))
1164 pl->ob->stats.Dex = iii, pl->orig_stats.Dex = iii;
1165 if (!strcmp("con", thing2))
1166 pl->ob->stats.Con = iii, pl->orig_stats.Con = iii;
1167 if (!strcmp("wis", thing2))
1168 pl->ob->stats.Wis = iii, pl->orig_stats.Wis = iii;
1169 if (!strcmp("cha", thing2))
1170 pl->ob->stats.Cha = iii, pl->orig_stats.Cha = iii;
1171 if (!strcmp("int", thing2))
1172 pl->ob->stats.Int = iii, pl->orig_stats.Int = iii;
1173 if (!strcmp("pow", thing2))
1174 pl->ob->stats.Pow = iii, pl->orig_stats.Pow = iii;
1175 sprintf(buf, "%s has been altered.", &pl->ob->name);
1176 new_draw_info(NDI_UNIQUE, 0, op, buf);
1177 fix_player(pl->ob);
1178 return 1;
1179 }
1180 }
1181
1182 new_draw_info(NDI_UNIQUE, 0, op, "No such player."); 1246 new_draw_info (NDI_UNIQUE, 0, op, "No such player.");
1247 return 1;
1248}
1249
1250int
1251command_abil (object *op, char *params)
1252{
1253 char thing[20], thing2[20];
1254 int iii;
1255 player *pl;
1256 char buf[MAX_BUF];
1257
1258 iii = 0;
1259 thing[0] = '\0';
1260 thing2[0] = '\0';
1261 if (params == NULL || !sscanf (params, "%s %s %d", thing, thing2, &iii) || thing == NULL)
1262 {
1263 new_draw_info (NDI_UNIQUE, 0, op, "Who?");
1183 return 1; 1264 return 1;
1184} 1265 }
1185 1266
1267 if (thing2 == NULL)
1268 {
1269 new_draw_info (NDI_UNIQUE, 0, op, "You can't change that.");
1270 return 1;
1271 }
1272
1273 if (iii < MIN_STAT || iii > MAX_STAT)
1274 {
1275 new_draw_info (NDI_UNIQUE, 0, op, "Illegal range of stat.\n");
1276 return 1;
1277 }
1278
1279 for (pl = first_player; pl != NULL; pl = pl->next)
1280 {
1281 if (!strcmp (pl->ob->name, thing))
1282 {
1283 if (settings.real_wiz == FALSE)
1284 SET_FLAG (pl->ob, FLAG_WAS_WIZ);
1285 if (!strcmp ("str", thing2))
1286 pl->ob->stats.Str = iii, pl->orig_stats.Str = iii;
1287 if (!strcmp ("dex", thing2))
1288 pl->ob->stats.Dex = iii, pl->orig_stats.Dex = iii;
1289 if (!strcmp ("con", thing2))
1290 pl->ob->stats.Con = iii, pl->orig_stats.Con = iii;
1291 if (!strcmp ("wis", thing2))
1292 pl->ob->stats.Wis = iii, pl->orig_stats.Wis = iii;
1293 if (!strcmp ("cha", thing2))
1294 pl->ob->stats.Cha = iii, pl->orig_stats.Cha = iii;
1295 if (!strcmp ("int", thing2))
1296 pl->ob->stats.Int = iii, pl->orig_stats.Int = iii;
1297 if (!strcmp ("pow", thing2))
1298 pl->ob->stats.Pow = iii, pl->orig_stats.Pow = iii;
1299 sprintf (buf, "%s has been altered.", &pl->ob->name);
1300 new_draw_info (NDI_UNIQUE, 0, op, buf);
1301 fix_player (pl->ob);
1302 return 1;
1303 }
1304 }
1305
1306 new_draw_info (NDI_UNIQUE, 0, op, "No such player.");
1307 return 1;
1308}
1309
1310int
1186int command_reset (object *op, char *params) { 1311command_reset (object *op, char *params)
1312{
1187 mapstruct *m; 1313 mapstruct *m;
1188 object *dummy = NULL, *tmp = NULL; 1314 object *dummy = NULL, *tmp = NULL;
1189 1315
1190 if (params == NULL) { 1316 if (params == NULL)
1317 {
1191 new_draw_info(NDI_UNIQUE, 0, op, "Reset what map [name]?"); 1318 new_draw_info (NDI_UNIQUE, 0, op, "Reset what map [name]?");
1192 return 1; 1319 return 1;
1193 } 1320 }
1194 1321
1195 if (strcmp(params, ".") == 0) 1322 if (strcmp (params, ".") == 0)
1196 params = op->map->path; 1323 params = op->map->path;
1197 m = has_been_loaded(params); 1324 m = has_been_loaded (params);
1198 if (m == NULL) { 1325 if (m == NULL)
1326 {
1199 new_draw_info(NDI_UNIQUE, 0, op, "No such map."); 1327 new_draw_info (NDI_UNIQUE, 0, op, "No such map.");
1200 return 1; 1328 return 1;
1201 } 1329 }
1202 1330
1203 if (m->in_memory != MAP_SWAPPED) { 1331 if (m->in_memory != MAP_SWAPPED)
1332 {
1204 if (m->in_memory != MAP_IN_MEMORY) { 1333 if (m->in_memory != MAP_IN_MEMORY)
1334 {
1205 LOG(llevError, "Tried to swap out map which was not in memory.\n"); 1335 LOG (llevError, "Tried to swap out map which was not in memory.\n");
1206 return 0; 1336 return 0;
1207 } 1337 }
1208 1338
1209 /* 1339 /*
1210 * Only attempt to remove the player that is doing the reset, and not other 1340 * Only attempt to remove the player that is doing the reset, and not other
1211 * players or wiz's. 1341 * players or wiz's.
1212 */ 1342 */
1213 if (op->map == m) { 1343 if (op->map == m)
1344 {
1214 dummy = get_object(); 1345 dummy = get_object ();
1215 dummy->map = NULL; 1346 dummy->map = NULL;
1216 EXIT_X(dummy) = op->x; 1347 EXIT_X (dummy) = op->x;
1217 EXIT_Y(dummy) = op->y; 1348 EXIT_Y (dummy) = op->y;
1218 EXIT_PATH(dummy) = op->map->path; 1349 EXIT_PATH (dummy) = op->map->path;
1219 remove_ob(op); 1350 remove_ob (op);
1220 op->map = NULL; 1351 op->map = NULL;
1221 tmp = op; 1352 tmp = op;
1222 } 1353 }
1223 swap_map(m); 1354 swap_map (m);
1224 } 1355 }
1225 1356
1226 if (m->in_memory == MAP_SWAPPED) { 1357 if (m->in_memory == MAP_SWAPPED)
1358 {
1227 LOG(llevDebug, "Resetting map %s.\n", m->path); 1359 LOG (llevDebug, "Resetting map %s.\n", m->path);
1228 1360
1229 /* setting this effectively causes an immediate reload */ 1361 /* setting this effectively causes an immediate reload */
1230 m->reset_time = 1; 1362 m->reset_time = 1;
1231 flush_old_maps(); 1363 flush_old_maps ();
1232 new_draw_info(NDI_UNIQUE, 0, op, "OK."); 1364 new_draw_info (NDI_UNIQUE, 0, op, "OK.");
1233 if (tmp) { 1365 if (tmp)
1366 {
1234 enter_exit(tmp, dummy); 1367 enter_exit (tmp, dummy);
1235 free_object(dummy); 1368 free_object (dummy);
1236 } 1369 }
1237 return 1; 1370 return 1;
1238 } else { 1371 }
1372 else
1373 {
1239 player *pl; 1374 player *pl;
1240 int playercount = 0; 1375 int playercount = 0;
1241 1376
1242 /* Need to re-insert player if swap failed for some reason */ 1377 /* Need to re-insert player if swap failed for some reason */
1243 if (tmp) { 1378 if (tmp)
1379 {
1244 insert_ob_in_map(op, m, NULL, 0); 1380 insert_ob_in_map (op, m, NULL, 0);
1245 free_object(dummy); 1381 free_object (dummy);
1246 } 1382 }
1247 1383
1248 new_draw_info(NDI_UNIQUE, 0, op,
1249 "Reset failed, couldn't swap map, the following players are on it:"); 1384 new_draw_info (NDI_UNIQUE, 0, op, "Reset failed, couldn't swap map, the following players are on it:");
1250 for (pl = first_player; pl != NULL; pl = pl->next) { 1385 for (pl = first_player; pl != NULL; pl = pl->next)
1386 {
1251 if (pl->ob->map == m && pl->ob != op) { 1387 if (pl->ob->map == m && pl->ob != op)
1388 {
1252 new_draw_info_format(NDI_UNIQUE, 0, op, "%s", &pl->ob->name); 1389 new_draw_info_format (NDI_UNIQUE, 0, op, "%s", &pl->ob->name);
1253 playercount++; 1390 playercount++;
1254 } 1391 }
1255 } 1392 }
1256 if (!playercount) 1393 if (!playercount)
1257 new_draw_info(NDI_UNIQUE, 0, op,
1258 "hmm, I don't see any other players on this map, something else is the problem."); 1394 new_draw_info (NDI_UNIQUE, 0, op, "hmm, I don't see any other players on this map, something else is the problem.");
1259 return 1; 1395 return 1;
1260 } 1396 }
1261} 1397}
1262 1398
1263int command_nowiz(object *op, char *params) { /* 'noadm' is alias */ 1399int
1400command_nowiz (object *op, char *params)
1401{ /* 'noadm' is alias */
1264 CLEAR_FLAG(op, FLAG_WIZ); 1402 CLEAR_FLAG (op, FLAG_WIZ);
1265 CLEAR_FLAG(op, FLAG_WIZPASS); 1403 CLEAR_FLAG (op, FLAG_WIZPASS);
1266 CLEAR_FLAG(op, FLAG_WIZCAST); 1404 CLEAR_FLAG (op, FLAG_WIZCAST);
1267 1405
1268 if (settings.real_wiz == TRUE) 1406 if (settings.real_wiz == TRUE)
1269 CLEAR_FLAG(op, FLAG_WAS_WIZ); 1407 CLEAR_FLAG (op, FLAG_WAS_WIZ);
1270 if (op->contr->hidden) { 1408 if (op->contr->hidden)
1409 {
1271 new_draw_info(NDI_UNIQUE, 0, op, "You are no longer hidden from other players"); 1410 new_draw_info (NDI_UNIQUE, 0, op, "You are no longer hidden from other players");
1272 op->map->players++; 1411 op->map->players++;
1273 new_draw_info_format(NDI_UNIQUE|NDI_ALL|NDI_DK_ORANGE, 5, NULL, 1412 new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s has entered the game.", &op->name);
1274 "%s has entered the game.", &op->name);
1275 op->contr->hidden = 0; 1413 op->contr->hidden = 0;
1276 op->invisible = 1; 1414 op->invisible = 1;
1415 }
1277 } else 1416 else
1278 new_draw_info(NDI_UNIQUE|NDI_ALL|NDI_LT_GREEN, 1, NULL, "The Dungeon Master is gone.."); 1417 new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master is gone..");
1279 return 1; 1418 return 1;
1280} 1419}
1281 1420
1282/** 1421/**
1283 * object *op is trying to become dm. 1422 * object *op is trying to become dm.
1284 * pl_name is name supplied by player. Restrictive DM will make it harder 1423 * pl_name is name supplied by player. Restrictive DM will make it harder
1285 * for socket users to become DM - in that case, it will check for the players 1424 * for socket users to become DM - in that case, it will check for the players
1286 * character name. 1425 * character name.
1287 */ 1426 */
1427static int
1288static int checkdm(object *op, const char *pl_name, const char *pl_passwd, const char *pl_host) 1428checkdm (object *op, const char *pl_name, const char *pl_passwd, const char *pl_host)
1289{ 1429{
1290 FILE *dmfile; 1430 FILE *dmfile;
1291 char buf[MAX_BUF]; 1431 char buf[MAX_BUF];
1292 char line_buf[160], name[160], passwd[160], host[160]; 1432 char line_buf[160], name[160], passwd[160], host[160];
1293 1433
1294#ifdef RESTRICTIVE_DM 1434#ifdef RESTRICTIVE_DM
1295 *pl_name = op->name ? op->name : "*"; 1435 *pl_name = op->name ? op->name : "*";
1296#endif 1436#endif
1297 1437
1298 sprintf(buf, "%s/%s", settings.confdir, DMFILE); 1438 sprintf (buf, "%s/%s", settings.confdir, DMFILE);
1299 if ((dmfile = fopen(buf, "r")) == NULL) { 1439 if ((dmfile = fopen (buf, "r")) == NULL)
1440 {
1300 LOG(llevDebug, "Could not find DM file.\n"); 1441 LOG (llevDebug, "Could not find DM file.\n");
1301 return 0; 1442 return 0;
1302 } 1443 }
1303 1444
1304 while (fgets(line_buf, 160, dmfile) != NULL) { 1445 while (fgets (line_buf, 160, dmfile) != NULL)
1446 {
1305 if (line_buf[0] == '#') 1447 if (line_buf[0] == '#')
1306 continue; 1448 continue;
1307 if (sscanf(line_buf, "%[^:]:%[^:]:%s\n", name, passwd, host) != 3) { 1449 if (sscanf (line_buf, "%[^:]:%[^:]:%s\n", name, passwd, host) != 3)
1450 {
1308 LOG(llevError, "Warning - malformed dm file entry: %s\n", line_buf); 1451 LOG (llevError, "Warning - malformed dm file entry: %s\n", line_buf);
1452 }
1309 } else if ((!strcmp(name, "*") || (pl_name && !strcmp(pl_name, name))) 1453 else if ((!strcmp (name, "*") || (pl_name && !strcmp (pl_name, name)))
1310 && (!strcmp(passwd, "*") || !strcmp(passwd, pl_passwd)) && 1454 && (!strcmp (passwd, "*") || !strcmp (passwd, pl_passwd)) && (!strcmp (host, "*") || !strcmp (host, pl_host)))
1311 (!strcmp(host, "*") || !strcmp(host, pl_host))) { 1455 {
1312 fclose(dmfile); 1456 fclose (dmfile);
1313 return (1); 1457 return (1);
1314 } 1458 }
1315 } 1459 }
1316 fclose(dmfile); 1460 fclose (dmfile);
1317 return (0); 1461 return (0);
1318} 1462}
1319 1463
1464int
1320int do_wizard_dm(object *op, char *params, int silent) { 1465do_wizard_dm (object *op, char *params, int silent)
1466{
1321 if (!op->contr) 1467 if (!op->contr)
1322 return 0; 1468 return 0;
1323 1469
1324 if (QUERY_FLAG(op, FLAG_WIZ)) { 1470 if (QUERY_FLAG (op, FLAG_WIZ))
1471 {
1325 new_draw_info(NDI_UNIQUE, 0, op, "You are already the Dungeon Master!"); 1472 new_draw_info (NDI_UNIQUE, 0, op, "You are already the Dungeon Master!");
1326 return 0; 1473 return 0;
1474 }
1475
1476 if (checkdm (op, op->name, (params ? params : "*"), op->contr->socket.host))
1327 } 1477 {
1328
1329 if (checkdm(op, op->name,
1330 (params ? params : "*"), op->contr->socket.host)) {
1331 SET_FLAG(op, FLAG_WIZ); 1478 SET_FLAG (op, FLAG_WIZ);
1332 SET_FLAG(op, FLAG_WAS_WIZ); 1479 SET_FLAG (op, FLAG_WAS_WIZ);
1333 SET_FLAG(op, FLAG_WIZPASS); 1480 SET_FLAG (op, FLAG_WIZPASS);
1334 SET_FLAG(op, FLAG_WIZCAST); 1481 SET_FLAG (op, FLAG_WIZCAST);
1335 new_draw_info(NDI_UNIQUE, 0, op, "Ok, you are the Dungeon Master!"); 1482 new_draw_info (NDI_UNIQUE, 0, op, "Ok, you are the Dungeon Master!");
1336 /* 1483 /*
1337 * Remove setting flying here - that won't work, because next 1484 * Remove setting flying here - that won't work, because next
1338 * fix_player() is called that will get cleared - proper solution 1485 * fix_player() is called that will get cleared - proper solution
1339 * is probably something like a wiz_force which gives that and any 1486 * is probably something like a wiz_force which gives that and any
1340 * other desired abilities. 1487 * other desired abilities.
1341 */ 1488 */
1342 clear_los(op); 1489 clear_los (op);
1343 op->contr->write_buf[0] ='\0'; 1490 op->contr->write_buf[0] = '\0';
1344 1491
1345 if (!silent) 1492 if (!silent)
1346 new_draw_info(NDI_UNIQUE|NDI_ALL|NDI_LT_GREEN, 1, NULL, 1493 new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master has arrived!");
1347 "The Dungeon Master has arrived!");
1348 1494
1349 return 1; 1495 return 1;
1350 } else { 1496 }
1497 else
1498 {
1351 new_draw_info(NDI_UNIQUE, 0, op, "Sorry Pal, I don't think so."); 1499 new_draw_info (NDI_UNIQUE, 0, op, "Sorry Pal, I don't think so.");
1352 op->contr->write_buf[0] ='\0'; 1500 op->contr->write_buf[0] = '\0';
1353 return 0; 1501 return 0;
1354 } 1502 }
1355} 1503}
1356 1504
1357/* 1505/*
1358 * Actual command to perhaps become dm. Changed aroun a bit in version 0.92.2 1506 * Actual command to perhaps become dm. Changed aroun a bit in version 0.92.2
1359 * - allow people on sockets to become dm, and allow better dm file 1507 * - allow people on sockets to become dm, and allow better dm file
1360 */ 1508 */
1509int
1361int command_dm(object *op, char *params) { 1510command_dm (object *op, char *params)
1511{
1362 if (!op->contr) 1512 if (!op->contr)
1363 return 0;
1364
1365 do_wizard_dm(op, params, 0);
1366
1367 return 1;
1368}
1369
1370int command_invisible(object *op, char *params) {
1371 if (op) {
1372 op->invisible += 100;
1373 update_object(op, UP_OBJ_FACE);
1374 new_draw_info(NDI_UNIQUE, 0, op, "You turn invisible.");
1375 }
1376
1377 return 0; 1513 return 0;
1514
1515 do_wizard_dm (op, params, 0);
1516
1517 return 1;
1518}
1519
1520int
1521command_invisible (object *op, char *params)
1522{
1523 if (op)
1524 {
1525 op->invisible += 100;
1526 update_object (op, UP_OBJ_FACE);
1527 new_draw_info (NDI_UNIQUE, 0, op, "You turn invisible.");
1528 }
1529
1530 return 0;
1378} 1531}
1379 1532
1380/** 1533/**
1381 * Returns spell object (from archetypes) by name. 1534 * Returns spell object (from archetypes) by name.
1382 * Returns NULL if 0 or more than one spell matches. 1535 * Returns NULL if 0 or more than one spell matches.
… …
1387 * Ignores archetypes "spelldirect_xxx" since these archetypes are not used 1540 * Ignores archetypes "spelldirect_xxx" since these archetypes are not used
1388 * anymore (but may still be present in some player's inventories and thus 1541 * anymore (but may still be present in some player's inventories and thus
1389 * cannot be removed). We have to ignore them here since they have the same 1542 * cannot be removed). We have to ignore them here since they have the same
1390 * name than other "spell_xxx" archetypes and would always conflict. 1543 * name than other "spell_xxx" archetypes and would always conflict.
1391 */ 1544 */
1545static object *
1392static object *get_spell_by_name(object *op, const char *spell_name) { 1546get_spell_by_name (object *op, const char *spell_name)
1547{
1393 archetype *ar; 1548 archetype *ar;
1394 archetype *found; 1549 archetype *found;
1395 int conflict_found; 1550 int conflict_found;
1396 size_t spell_name_length; 1551 size_t spell_name_length;
1397 1552
1398 /* First check for full name matches. */ 1553 /* First check for full name matches. */
1399 conflict_found = 0; 1554 conflict_found = 0;
1400 found = NULL; 1555 found = NULL;
1401 for (ar = first_archetype; ar != NULL; ar = ar->next) { 1556 for (ar = first_archetype; ar != NULL; ar = ar->next)
1557 {
1402 if (ar->clone.type != SPELL) 1558 if (ar->clone.type != SPELL)
1403 continue; 1559 continue;
1404 1560
1405 if (strncmp(ar->name, "spelldirect_", 12) == 0) 1561 if (strncmp (ar->name, "spelldirect_", 12) == 0)
1406 continue; 1562 continue;
1407 1563
1408 if (strcmp(ar->clone.name, spell_name) != 0) 1564 if (strcmp (ar->clone.name, spell_name) != 0)
1409 continue; 1565 continue;
1410 1566
1411 if (found != NULL) { 1567 if (found != NULL)
1568 {
1412 if (!conflict_found) { 1569 if (!conflict_found)
1570 {
1413 conflict_found = 1; 1571 conflict_found = 1;
1414 new_draw_info_format(NDI_UNIQUE, 0, op, "More than one archetype matches the spell name %s:", spell_name); 1572 new_draw_info_format (NDI_UNIQUE, 0, op, "More than one archetype matches the spell name %s:", spell_name);
1415 new_draw_info_format(NDI_UNIQUE, 0, op, "- %s", &found->name); 1573 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &found->name);
1416 } 1574 }
1417 new_draw_info_format(NDI_UNIQUE, 0, op, "- %s", &ar->name); 1575 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &ar->name);
1418 continue; 1576 continue;
1419 } 1577 }
1420 1578
1421 found = ar; 1579 found = ar;
1422 } 1580 }
1423 1581
1424 /* No match if more more than one archetype matches. */ 1582 /* No match if more more than one archetype matches. */
1425 if (conflict_found) 1583 if (conflict_found)
1426 return NULL; 1584 return NULL;
1427 1585
1428 /* Return if exactly one archetype matches. */ 1586 /* Return if exactly one archetype matches. */
1429 if (found != NULL) 1587 if (found != NULL)
1430 return arch_to_object(found); 1588 return arch_to_object (found);
1431 1589
1432 /* No full match found: now check for partial matches. */ 1590 /* No full match found: now check for partial matches. */
1433 spell_name_length = strlen(spell_name); 1591 spell_name_length = strlen (spell_name);
1434 conflict_found = 0; 1592 conflict_found = 0;
1435 found = NULL; 1593 found = NULL;
1436 for (ar = first_archetype; ar != NULL; ar = ar->next) { 1594 for (ar = first_archetype; ar != NULL; ar = ar->next)
1595 {
1437 if (ar->clone.type != SPELL) 1596 if (ar->clone.type != SPELL)
1438 continue; 1597 continue;
1439 1598
1440 if (strncmp(ar->name, "spelldirect_", 12) == 0) 1599 if (strncmp (ar->name, "spelldirect_", 12) == 0)
1441 continue; 1600 continue;
1442 1601
1443 if (strncmp(ar->clone.name, spell_name, spell_name_length) != 0) 1602 if (strncmp (ar->clone.name, spell_name, spell_name_length) != 0)
1444 continue; 1603 continue;
1445 1604
1446 if (found != NULL) { 1605 if (found != NULL)
1606 {
1447 if (!conflict_found) { 1607 if (!conflict_found)
1608 {
1448 conflict_found = 1; 1609 conflict_found = 1;
1449 new_draw_info_format(NDI_UNIQUE, 0, op, "More than one spell matches %s:", spell_name); 1610 new_draw_info_format (NDI_UNIQUE, 0, op, "More than one spell matches %s:", spell_name);
1450 new_draw_info_format(NDI_UNIQUE, 0, op, "- %s", &found->clone.name); 1611 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &found->clone.name);
1451 } 1612 }
1452 new_draw_info_format(NDI_UNIQUE, 0, op, "- %s", &ar->clone.name); 1613 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &ar->clone.name);
1453 continue; 1614 continue;
1454 } 1615 }
1455 1616
1456 found = ar; 1617 found = ar;
1457 } 1618 }
1458 1619
1459 /* No match if more more than one archetype matches. */ 1620 /* No match if more more than one archetype matches. */
1460 if (conflict_found) 1621 if (conflict_found)
1461 return NULL;
1462
1463 /* Return if exactly one archetype matches. */
1464 if (found != NULL)
1465 return arch_to_object(found);
1466
1467 /* No spell found: just print an error message. */
1468 new_draw_info_format(NDI_UNIQUE, 0, op, "The spell %s does not exist.", spell_name);
1469 return NULL; 1622 return NULL;
1470}
1471 1623
1624 /* Return if exactly one archetype matches. */
1625 if (found != NULL)
1626 return arch_to_object (found);
1627
1628 /* No spell found: just print an error message. */
1629 new_draw_info_format (NDI_UNIQUE, 0, op, "The spell %s does not exist.", spell_name);
1630 return NULL;
1631}
1632
1633static int
1472static int command_learn_spell_or_prayer(object *op, char *params, 1634command_learn_spell_or_prayer (object *op, char *params, int special_prayer)
1473 int special_prayer) { 1635{
1474 object *tmp; 1636 object *tmp;
1475 1637
1476 if (op->contr == NULL || params == NULL) { 1638 if (op->contr == NULL || params == NULL)
1639 {
1477 new_draw_info(NDI_UNIQUE, 0, op, "Which spell do you want to learn?"); 1640 new_draw_info (NDI_UNIQUE, 0, op, "Which spell do you want to learn?");
1478 return 0; 1641 return 0;
1479 } 1642 }
1480 1643
1481 tmp = get_spell_by_name(op, params); 1644 tmp = get_spell_by_name (op, params);
1482 if (tmp == NULL) { 1645 if (tmp == NULL)
1646 {
1483 return 0; 1647 return 0;
1484 } 1648 }
1485 1649
1486 if (check_spell_known(op, tmp->name)) { 1650 if (check_spell_known (op, tmp->name))
1651 {
1487 new_draw_info_format(NDI_UNIQUE, 0, op, "You already know the spell %s.", &tmp->name); 1652 new_draw_info_format (NDI_UNIQUE, 0, op, "You already know the spell %s.", &tmp->name);
1488 return 0; 1653 return 0;
1489 } 1654 }
1490 1655
1491 do_learn_spell(op, tmp, special_prayer); 1656 do_learn_spell (op, tmp, special_prayer);
1492 free_object(tmp); 1657 free_object (tmp);
1493 return 1; 1658 return 1;
1494} 1659}
1495 1660
1661int
1496int command_learn_spell(object *op, char *params) { 1662command_learn_spell (object *op, char *params)
1663{
1497 return command_learn_spell_or_prayer(op, params, 0); 1664 return command_learn_spell_or_prayer (op, params, 0);
1498} 1665}
1499 1666
1667int
1500int command_learn_special_prayer(object *op, char *params) 1668command_learn_special_prayer (object *op, char *params)
1501{ 1669{
1502 return command_learn_spell_or_prayer(op, params, 1); 1670 return command_learn_spell_or_prayer (op, params, 1);
1503} 1671}
1504 1672
1673int
1505int command_forget_spell(object *op, char *params) 1674command_forget_spell (object *op, char *params)
1506{ 1675{
1507 object *spell; 1676 object *spell;
1508 1677
1509 if (op->contr == NULL || params == NULL) { 1678 if (op->contr == NULL || params == NULL)
1679 {
1510 new_draw_info(NDI_UNIQUE, 0, op, "Which spell do you want to forget?"); 1680 new_draw_info (NDI_UNIQUE, 0, op, "Which spell do you want to forget?");
1511 return 0; 1681 return 0;
1512 } 1682 }
1513 1683
1514 spell = lookup_spell_by_name(op, params); 1684 spell = lookup_spell_by_name (op, params);
1515 if (spell == NULL) { 1685 if (spell == NULL)
1686 {
1516 new_draw_info_format(NDI_UNIQUE, 0, op, "You do not know the spell %s.", params); 1687 new_draw_info_format (NDI_UNIQUE, 0, op, "You do not know the spell %s.", params);
1517 return 0; 1688 return 0;
1518 } 1689 }
1519 1690
1520 do_forget_spell(op, spell->name); 1691 do_forget_spell (op, spell->name);
1521 return 1; 1692 return 1;
1522} 1693}
1523 1694
1524/** 1695/**
1525 * Lists all plugins currently loaded with their IDs and full names. 1696 * Lists all plugins currently loaded with their IDs and full names.
1526 */ 1697 */
1698int
1527int command_listplugins(object *op, char *params) 1699command_listplugins (object *op, char *params)
1528{ 1700{
1529 plugins_display_list(op); 1701 plugins_display_list (op);
1530 return 1; 1702 return 1;
1531} 1703}
1532 1704
1533/** 1705/**
1534 * Loads the given plugin. The DM specifies the name of the library to load (no 1706 * Loads the given plugin. The DM specifies the name of the library to load (no
1535 * pathname is needed). Do not ever attempt to load the same plugin more than 1707 * pathname is needed). Do not ever attempt to load the same plugin more than
1536 * once at a time, or bad things could happen. 1708 * once at a time, or bad things could happen.
1537 */ 1709 */
1710int
1538int command_loadplugin(object *op, char *params) { 1711command_loadplugin (object *op, char *params)
1712{
1539 char buf[MAX_BUF]; 1713 char buf[MAX_BUF];
1540 1714
1541 if (params == NULL) { 1715 if (params == NULL)
1716 {
1542 new_draw_info(NDI_UNIQUE, 0, op, "Load which plugin?"); 1717 new_draw_info (NDI_UNIQUE, 0, op, "Load which plugin?");
1543 return 1; 1718 return 1;
1544 } 1719 }
1545 1720
1546 strcpy(buf, LIBDIR); 1721 strcpy (buf, LIBDIR);
1547 strcat(buf, "/plugins/"); 1722 strcat (buf, "/plugins/");
1548 strcat(buf, params); 1723 strcat (buf, params);
1549 LOG(llevDebug, "Requested plugin file is %s\n", buf); 1724 LOG (llevDebug, "Requested plugin file is %s\n", buf);
1550 if (plugins_init_plugin(buf) == 0) 1725 if (plugins_init_plugin (buf) == 0)
1551 new_draw_info(NDI_UNIQUE, 0, op, "Plugin successfully loaded."); 1726 new_draw_info (NDI_UNIQUE, 0, op, "Plugin successfully loaded.");
1552 else 1727 else
1553 new_draw_info(NDI_UNIQUE, 0, op, "Could not load plugin."); 1728 new_draw_info (NDI_UNIQUE, 0, op, "Could not load plugin.");
1554 return 1; 1729 return 1;
1555} 1730}
1556 1731
1557/** 1732/**
1558 * Unloads the given plugin. The DM specified the ID of the library to unload. 1733 * Unloads the given plugin. The DM specified the ID of the library to unload.
1559 * Note that some things may behave strangely if the correct plugins are not 1734 * Note that some things may behave strangely if the correct plugins are not
1560 * loaded. 1735 * loaded.
1561 */ 1736 */
1737int
1562int command_unloadplugin(object *op, char *params) 1738command_unloadplugin (object *op, char *params)
1563{ 1739{
1564 if (params == NULL) { 1740 if (params == NULL)
1741 {
1565 new_draw_info(NDI_UNIQUE, 0, op, "Remove which plugin?"); 1742 new_draw_info (NDI_UNIQUE, 0, op, "Remove which plugin?");
1566 return 1; 1743 return 1;
1567 } 1744 }
1568 1745
1569 if (plugins_remove_plugin(params) == 0) 1746 if (plugins_remove_plugin (params) == 0)
1570 new_draw_info(NDI_UNIQUE, 0, op, "Plugin successfully removed."); 1747 new_draw_info (NDI_UNIQUE, 0, op, "Plugin successfully removed.");
1571 else 1748 else
1572 new_draw_info(NDI_UNIQUE, 0, op, "Could not remove plugin."); 1749 new_draw_info (NDI_UNIQUE, 0, op, "Could not remove plugin.");
1573 return 1; 1750 return 1;
1574} 1751}
1575 1752
1576/** 1753/**
1577 * A players wants to become DM and hide. 1754 * A players wants to become DM and hide.
1578 * Let's see if that's authorized. 1755 * Let's see if that's authorized.
1579 * Make sure to not tell anything to anyone. 1756 * Make sure to not tell anything to anyone.
1580 */ 1757 */
1758int
1581int command_dmhide(object *op, char *params) { 1759command_dmhide (object *op, char *params)
1760{
1582 if (!do_wizard_dm(op, params, 1)) 1761 if (!do_wizard_dm (op, params, 1))
1583 return 0; 1762 return 0;
1584 1763
1585 do_wizard_hide(op, 1); 1764 do_wizard_hide (op, 1);
1586 1765
1587 return 1; 1766 return 1;
1588} 1767}
1589 1768
1769void
1590void dm_stack_pop(player *pl) { 1770dm_stack_pop (player *pl)
1771{
1591 if (!pl->stack_items || !pl->stack_position) { 1772 if (!pl->stack_items || !pl->stack_position)
1773 {
1592 new_draw_info(NDI_UNIQUE, 0, pl->ob, "Empty stack!"); 1774 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
1593 return; 1775 return;
1594 } 1776 }
1595 1777
1596 pl->stack_position--; 1778 pl->stack_position--;
1597 new_draw_info_format(NDI_UNIQUE, 0, pl->ob, "Popped item from stack, %d left.", pl->stack_position); 1779 new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Popped item from stack, %d left.", pl->stack_position);
1598} 1780}
1599 1781
1600/** 1782/**
1601 * Get current stack top item for player. 1783 * Get current stack top item for player.
1602 * Returns NULL if no stacked item. 1784 * Returns NULL if no stacked item.
1603 * If stacked item disappeared (freed), remove it. 1785 * If stacked item disappeared (freed), remove it.
1604 * 1786 *
1605 * Ryo, august 2004 1787 * Ryo, august 2004
1606 */ 1788 */
1789object *
1607object *dm_stack_peek(player *pl) { 1790dm_stack_peek (player *pl)
1791{
1608 object* ob; 1792 object *ob;
1609 1793
1610 if (!pl->stack_position) { 1794 if (!pl->stack_position)
1795 {
1611 new_draw_info(NDI_UNIQUE, 0, pl->ob, "Empty stack!"); 1796 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
1612 return NULL; 1797 return NULL;
1613 } 1798 }
1614 1799
1615 ob = find_object(pl->stack_items[pl->stack_position-1]); 1800 ob = find_object (pl->stack_items[pl->stack_position - 1]);
1616 if (!ob) { 1801 if (!ob)
1802 {
1617 new_draw_info(NDI_UNIQUE, 0, pl->ob, "Stacked item was removed!"); 1803 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Stacked item was removed!");
1618 dm_stack_pop(pl); 1804 dm_stack_pop (pl);
1619 return NULL; 1805 return NULL;
1620 } 1806 }
1621 1807
1622 return ob; 1808 return ob;
1623} 1809}
1624 1810
1625/** 1811/**
1626 * Push specified item on player stack. 1812 * Push specified item on player stack.
1627 * Inform player of position. 1813 * Inform player of position.
1628 * Initializes variables if needed. 1814 * Initializes variables if needed.
1629 */ 1815 */
1816void
1630void dm_stack_push(player *pl, tag_t item) { 1817dm_stack_push (player *pl, tag_t item)
1818{
1631 if (!pl->stack_items) { 1819 if (!pl->stack_items)
1820 {
1632 pl->stack_items = (tag_t *)malloc(sizeof(tag_t)*STACK_SIZE); 1821 pl->stack_items = (tag_t *) malloc (sizeof (tag_t) * STACK_SIZE);
1633 memset(pl->stack_items, 0, sizeof(tag_t)*STACK_SIZE); 1822 memset (pl->stack_items, 0, sizeof (tag_t) * STACK_SIZE);
1634 } 1823 }
1635 1824
1636 if (pl->stack_position == STACK_SIZE) { 1825 if (pl->stack_position == STACK_SIZE)
1826 {
1637 new_draw_info(NDI_UNIQUE, 0, pl->ob, "Item stack full!"); 1827 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Item stack full!");
1638 return; 1828 return;
1639 } 1829 }
1640 1830
1641 pl->stack_items[pl->stack_position] = item; 1831 pl->stack_items[pl->stack_position] = item;
1642 new_draw_info_format(NDI_UNIQUE, 0, pl->ob, "Item stacked as %d.", pl->stack_position); 1832 new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Item stacked as %d.", pl->stack_position);
1643 pl->stack_position++; 1833 pl->stack_position++;
1644} 1834}
1645 1835
1646/** 1836/**
1647 * Checks 'params' for object code. 1837 * Checks 'params' for object code.
1648 * 1838 *
… …
1660 * * STACK_FROM_STACK => item from somewhere in the stack 1850 * * STACK_FROM_STACK => item from somewhere in the stack
1661 * * STACK_FROM_NUMBER => item by number, pushed on stack 1851 * * STACK_FROM_NUMBER => item by number, pushed on stack
1662 * 1852 *
1663 * Ryo, august 2004 1853 * Ryo, august 2004
1664 */ 1854 */
1855object *
1665object *get_dm_object(player *pl, char **params, int *from) { 1856get_dm_object (player *pl, char **params, int *from)
1857{
1666 int item_tag, item_position; 1858 int item_tag, item_position;
1667 object *ob; 1859 object *ob;
1668 1860
1669 if (!pl) 1861 if (!pl)
1670 return NULL; 1862 return NULL;
1671 1863
1672 if (!params || !*params || **params == '\0') { 1864 if (!params || !*params || **params == '\0')
1865 {
1673 if (from) 1866 if (from)
1674 *from = STACK_FROM_TOP; 1867 *from = STACK_FROM_TOP;
1675 /* No parameter => get stack item */ 1868 /* No parameter => get stack item */
1676 return dm_stack_peek(pl); 1869 return dm_stack_peek (pl);
1677 } 1870 }
1678 1871
1679 /* Let's clean white spaces */ 1872 /* Let's clean white spaces */
1680 while (**params == ' ') 1873 while (**params == ' ')
1874 (*params)++;
1875
1876 /* Next case: number => item tag */
1877 if (sscanf (*params, "%d", &item_tag))
1878 {
1879 /* Move parameter to next item */
1880 while (isdigit (**params))
1681 (*params)++; 1881 (*params)++;
1682 1882
1683 /* Next case: number => item tag */
1684 if (sscanf(*params, "%d", &item_tag)) {
1685 /* Move parameter to next item */
1686 while (isdigit(**params))
1687 (*params)++;
1688
1689 /* And skip blanks, too */ 1883 /* And skip blanks, too */
1690 while (**params == ' ') 1884 while (**params == ' ')
1691 (*params)++;
1692
1693 /* Get item */
1694 ob = find_object(item_tag);
1695 if (!ob) {
1696 if (from)
1697 *from = STACK_FROM_NONE;
1698 new_draw_info_format(NDI_UNIQUE, 0, pl->ob, "No such item %d!", item_tag);
1699 return NULL;
1700 }
1701
1702 /* Got one, let's push it on stack */
1703 dm_stack_push(pl, item_tag);
1704 if (from)
1705 *from = STACK_FROM_NUMBER;
1706 return ob;
1707 }
1708
1709 /* Next case: $number => stack item */
1710 if (sscanf(*params, "$%d", &item_position)) {
1711 /* Move parameter to next item */
1712 (*params)++; 1885 (*params)++;
1713 1886
1887 /* Get item */
1888 ob = find_object (item_tag);
1889 if (!ob)
1890 {
1891 if (from)
1892 *from = STACK_FROM_NONE;
1893 new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "No such item %d!", item_tag);
1894 return NULL;
1895 }
1896
1897 /* Got one, let's push it on stack */
1898 dm_stack_push (pl, item_tag);
1899 if (from)
1900 *from = STACK_FROM_NUMBER;
1901 return ob;
1902 }
1903
1904 /* Next case: $number => stack item */
1905 if (sscanf (*params, "$%d", &item_position))
1906 {
1907 /* Move parameter to next item */
1908 (*params)++;
1909
1714 while (isdigit(**params)) 1910 while (isdigit (**params))
1715 (*params)++; 1911 (*params)++;
1716 while (**params == ' ') 1912 while (**params == ' ')
1717 (*params)++; 1913 (*params)++;
1718 1914
1719 if (item_position >= pl->stack_position) { 1915 if (item_position >= pl->stack_position)
1916 {
1720 if (from) 1917 if (from)
1721 *from = STACK_FROM_NONE; 1918 *from = STACK_FROM_NONE;
1722 new_draw_info_format(NDI_UNIQUE, 0, pl->ob, "No such stack item %d!", item_position); 1919 new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "No such stack item %d!", item_position);
1723 return NULL; 1920 return NULL;
1724 } 1921 }
1725 1922
1726 ob = find_object(pl->stack_items[item_position]); 1923 ob = find_object (pl->stack_items[item_position]);
1727 if (!ob) { 1924 if (!ob)
1925 {
1728 if (from) 1926 if (from)
1729 *from = STACK_FROM_NONE; 1927 *from = STACK_FROM_NONE;
1730 new_draw_info_format(NDI_UNIQUE, 0, pl->ob, "Stack item %d was removed.", item_position); 1928 new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Stack item %d was removed.", item_position);
1731 return NULL; 1929 return NULL;
1732 } 1930 }
1733 1931
1734 if (from) 1932 if (from)
1735 *from = item_position < pl->stack_position-1 ? STACK_FROM_STACK : STACK_FROM_TOP; 1933 *from = item_position < pl->stack_position - 1 ? STACK_FROM_STACK : STACK_FROM_TOP;
1736 return ob; 1934 return ob;
1737 } 1935 }
1738 1936
1739 /* Next case: 'me' => return pl->ob */ 1937 /* Next case: 'me' => return pl->ob */
1740 if (!strncmp(*params, "me", 2)) { 1938 if (!strncmp (*params, "me", 2))
1939 {
1741 if (from) 1940 if (from)
1742 *from = STACK_FROM_NUMBER; 1941 *from = STACK_FROM_NUMBER;
1743 dm_stack_push(pl, pl->ob->count); 1942 dm_stack_push (pl, pl->ob->count);
1744 1943
1745 /* Skip to next token */ 1944 /* Skip to next token */
1746 (*params) += 2; 1945 (*params) += 2;
1747 while (**params == ' ') 1946 while (**params == ' ')
1748 (*params)++; 1947 (*params)++;
1749 1948
1750 return pl->ob; 1949 return pl->ob;
1751 } 1950 }
1752 1951
1753 /* Last case: get stack top */ 1952 /* Last case: get stack top */
1754 if (from) 1953 if (from)
1755 *from = STACK_FROM_TOP; 1954 *from = STACK_FROM_TOP;
1756 return dm_stack_peek(pl); 1955 return dm_stack_peek (pl);
1757} 1956}
1758 1957
1759/** 1958/**
1760 * Pop the stack top. 1959 * Pop the stack top.
1761 */ 1960 */
1961int
1762int command_stack_pop(object *op, char *params) { 1962command_stack_pop (object *op, char *params)
1963{
1763 dm_stack_pop(op->contr); 1964 dm_stack_pop (op->contr);
1764 return 0; 1965 return 0;
1765} 1966}
1766 1967
1767/** 1968/**
1768 * Push specified item on stack. 1969 * Push specified item on stack.
1769 */ 1970 */
1971int
1770int command_stack_push(object *op, char *params) { 1972command_stack_push (object *op, char *params)
1973{
1771 object *ob; 1974 object *ob;
1772 int from; 1975 int from;
1976
1773 ob = get_dm_object(op->contr, &params, &from); 1977 ob = get_dm_object (op->contr, &params, &from);
1774 1978
1775 if (ob && from != STACK_FROM_NUMBER) 1979 if (ob && from != STACK_FROM_NUMBER)
1776 /* Object was from stack, need to push it again */ 1980 /* Object was from stack, need to push it again */
1777 dm_stack_push(op->contr, ob->count); 1981 dm_stack_push (op->contr, ob->count);
1778 1982
1779 return 0; 1983 return 0;
1780} 1984}
1781 1985
1782/** 1986/**
1783 * Displays stack contents. 1987 * Displays stack contents.
1784 */ 1988 */
1989int
1785int command_stack_list(object *op, char *params) { 1990command_stack_list (object *op, char *params)
1991{
1786 int item; 1992 int item;
1787 object *display; 1993 object *display;
1788 player *pl = op->contr; 1994 player *pl = op->contr;
1789 1995
1790 new_draw_info(NDI_UNIQUE, 0, op, "Item stack contents:"); 1996 new_draw_info (NDI_UNIQUE, 0, op, "Item stack contents:");
1791 1997
1792 for (item = 0; item < pl->stack_position; item++) { 1998 for (item = 0; item < pl->stack_position; item++)
1999 {
1793 display = find_object(pl->stack_items[item]); 2000 display = find_object (pl->stack_items[item]);
1794 if (display) 2001 if (display)
1795 new_draw_info_format(NDI_UNIQUE, 0, op, " %d : %s [%d]", item, &display->name, display->count); 2002 new_draw_info_format (NDI_UNIQUE, 0, op, " %d : %s [%d]", item, &display->name, display->count);
1796 else 2003 else
1797 /* Item was freed */ 2004 /* Item was freed */
1798 new_draw_info_format(NDI_UNIQUE, 0, op, " %d : (lost item: %d)", item, pl->stack_items[item]); 2005 new_draw_info_format (NDI_UNIQUE, 0, op, " %d : (lost item: %d)", item, pl->stack_items[item]);
1799 } 2006 }
1800 2007
1801 return 0; 2008 return 0;
1802} 2009}
1803 2010
1804/** 2011/**
1805 * Empty DM item stack. 2012 * Empty DM item stack.
1806 */ 2013 */
2014int
1807int command_stack_clear(object *op, char *params) { 2015command_stack_clear (object *op, char *params)
2016{
1808 op->contr->stack_position = 0; 2017 op->contr->stack_position = 0;
1809 new_draw_info(NDI_UNIQUE, 0, op, "Item stack cleared."); 2018 new_draw_info (NDI_UNIQUE, 0, op, "Item stack cleared.");
1810 return 0; 2019 return 0;
1811} 2020}
1812 2021
2022int
1813int command_insert_into(object* op, char *params) 2023command_insert_into (object *op, char *params)
1814{ 2024{
1815 object *left, *right, *inserted; 2025 object *left, *right, *inserted;
1816 int left_from, right_from; 2026 int left_from, right_from;
1817 2027
1818 left = get_dm_object(op->contr, &params, &left_from); 2028 left = get_dm_object (op->contr, &params, &left_from);
1819 if (!left) { 2029 if (!left)
2030 {
1820 new_draw_info(NDI_UNIQUE, 0, op, "Insert into what object?"); 2031 new_draw_info (NDI_UNIQUE, 0, op, "Insert into what object?");
1821 return 0; 2032 return 0;
1822 } 2033 }
1823 2034
1824 if (left_from == STACK_FROM_NUMBER) 2035 if (left_from == STACK_FROM_NUMBER)
1825 /* Item was stacked, remove it else right will be the same... */ 2036 /* Item was stacked, remove it else right will be the same... */
1826 dm_stack_pop(op->contr); 2037 dm_stack_pop (op->contr);
1827 2038
1828 right = get_dm_object(op->contr, &params, &right_from); 2039 right = get_dm_object (op->contr, &params, &right_from);
1829 2040
1830 if (!right) { 2041 if (!right)
2042 {
1831 new_draw_info(NDI_UNIQUE, 0, op, "Insert what item?"); 2043 new_draw_info (NDI_UNIQUE, 0, op, "Insert what item?");
1832 return 0; 2044 return 0;
1833 } 2045 }
1834 2046
1835 if (left_from == STACK_FROM_TOP && right_from == STACK_FROM_TOP) { 2047 if (left_from == STACK_FROM_TOP && right_from == STACK_FROM_TOP)
2048 {
1836 /* 2049 /*
1837 * Special case: both items were taken from stack top. 2050 * Special case: both items were taken from stack top.
1838 * Override the behaviour, taking left as item just below top, if exists. 2051 * Override the behaviour, taking left as item just below top, if exists.
1839 * See function description for why. 2052 * See function description for why.
1840 * Besides, can't insert an item into itself. 2053 * Besides, can't insert an item into itself.
1841 */ 2054 */
1842 if (op->contr->stack_position > 1) { 2055 if (op->contr->stack_position > 1)
2056 {
1843 left = find_object(op->contr->stack_items[op->contr->stack_position-2]); 2057 left = find_object (op->contr->stack_items[op->contr->stack_position - 2]);
1844 if (left) 2058 if (left)
1845 new_draw_info(NDI_UNIQUE, 0, op, "(Note: item to insert into taken from undertop)"); 2059 new_draw_info (NDI_UNIQUE, 0, op, "(Note: item to insert into taken from undertop)");
1846 else 2060 else
1847 /* Stupid case: item under top was freed, fallback to stack top */ 2061 /* Stupid case: item under top was freed, fallback to stack top */
1848 left = right; 2062 left = right;
1849 } 2063 }
1850 } 2064 }
1851 2065
1852 if (left == right) 2066 if (left == right)
1853 { 2067 {
1854 new_draw_info(NDI_UNIQUE, 0, op, "Can't insert an object into itself!"); 2068 new_draw_info (NDI_UNIQUE, 0, op, "Can't insert an object into itself!");
1855 return 0; 2069 return 0;
1856 } 2070 }
1857 2071
1858 if (right->type == PLAYER) 2072 if (right->type == PLAYER)
1859 { 2073 {
1860 new_draw_info(NDI_UNIQUE, 0, op, "Can't insert a player into something!"); 2074 new_draw_info (NDI_UNIQUE, 0, op, "Can't insert a player into something!");
1861 return 0; 2075 return 0;
1862 } 2076 }
1863 2077
1864 if (!QUERY_FLAG(right,FLAG_REMOVED)) 2078 if (!QUERY_FLAG (right, FLAG_REMOVED))
1865 remove_ob(right); 2079 remove_ob (right);
1866 inserted = insert_ob_in_ob(right,left); 2080 inserted = insert_ob_in_ob (right, left);
1867 if (left->type == PLAYER) 2081 if (left->type == PLAYER)
1868 if (inserted == right) 2082 if (inserted == right)
1869 esrv_send_item(left,right); 2083 esrv_send_item (left, right);
1870 else 2084 else
1871 esrv_update_item(UPD_WEIGHT|UPD_NAME|UPD_NROF,left,inserted); 2085 esrv_update_item (UPD_WEIGHT | UPD_NAME | UPD_NROF, left, inserted);
1872 2086
1873 new_draw_info_format(NDI_UNIQUE, 0, op, "Inserted %s in %s", query_name(inserted),query_name(left)); 2087 new_draw_info_format (NDI_UNIQUE, 0, op, "Inserted %s in %s", query_name (inserted), query_name (left));
1874 2088
1875 return 0; 2089 return 0;
1876 2090
1877} 2091}

Diff Legend

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