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.4 by root, Tue Aug 29 08:01:37 2006 UTC vs.
Revision 1.88 by root, Fri Jan 27 22:00:40 2012 UTC

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

Diff Legend

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