ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/c_wiz.C

Comparing deliantra/server/server/c_wiz.C (file contents):
Revision 1.34 by root, Mon Feb 5 01:24:46 2007 UTC vs.
Revision 1.95 by root, Sat Nov 17 23:40:03 2018 UTC

1	/*	1	/*
2	* CrossFire, A Multiplayer game for X-windows	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
		5	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team	6	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	7	* Copyright (©) 1992 Frank Tore Johansen
7	*	8	*
8	* This program is free software; you can redistribute it and/or modify	9	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	10	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation; either version 2 of the License, or	11	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	12	* option) any later version.
12	*	13	*
13	* This program is distributed in the hope that it will be useful,	14	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	17	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	18	*
		19	* You should have received a copy of the Affero GNU General Public License
		20	* and the GNU General Public License along with this program. If not, see
		21	* <http://www.gnu.org/licenses/>.
		22	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	23	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	24	*/
24		25
25	#include <global.h>	26	#include <global.h>
26	#include <sproto.h>	27	#include <sproto.h>
27	#include <spells.h>	28	#include <spells.h>
…		…
34	/* Values for 'from' field of get_dm_object */	35	/* Values for 'from' field of get_dm_object */
35	#define STACK_FROM_NONE 0 /* Item was not found */	36	#define STACK_FROM_NONE 0 /* Item was not found */
36	#define STACK_FROM_TOP 1 /* Item is stack top */	37	#define STACK_FROM_TOP 1 /* Item is stack top */
37	#define STACK_FROM_STACK 2 /* Item is somewhere in stack */	38	#define STACK_FROM_STACK 2 /* Item is somewhere in stack */
38	#define STACK_FROM_NUMBER 3 /* Item is a number (may be top) */	39	#define STACK_FROM_NUMBER 3 /* Item is a number (may be top) */
39
40		40
41	/**	41	/**
42	* Enough of the DM functions seem to need this that I broke	42	* Enough of the DM functions seem to need this that I broke
43	* it out to a seperate function. name is the person	43	* it out to a seperate function. name is the person
44	* being saught, rq is who is looking for them. This	44	* being saught, rq is who is looking for them. This
…		…
71		71
72	new_draw_info (NDI_UNIQUE, 0, op, "No such player.");	72	new_draw_info (NDI_UNIQUE, 0, op, "No such player.");
73	return 0;	73	return 0;
74	}	74	}
75		75
		76	static void
		77	dm_stack_pop (player *pl)
		78	{
		79	if (!pl->stack_items || !pl->stack_position)
		80	{
		81	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
		82	return;
		83	}
		84
		85	pl->stack_position--;
		86	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Popped item from stack, %d left.", pl->stack_position);
		87	}
		88
76	/**	89	/**
77	* Actually hides specified player (obviously a DM).	90	* Get current stack top item for player.
78	* If 'silent_dm' is non zero, other players are informed of DM entering/leaving,	91	* Returns NULL if no stacked item.
79	* else they just think someone left/entered.	92	* If stacked item disappeared (freed), remove it.
		93	*
		94	* Ryo, august 2004
		95	*/
		96	static object *
		97	dm_stack_peek (player *pl)
		98	{
		99	object *ob;
		100
		101	if (!pl->stack_position)
		102	{
		103	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
		104	return NULL;
		105	}
		106
		107	ob = find_object (pl->stack_items[pl->stack_position - 1]);
		108	if (!ob)
		109	{
		110	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Stacked item was removed!");
		111	dm_stack_pop (pl);
		112	return NULL;
		113	}
		114
		115	return ob;
		116	}
		117
		118	/**
		119	* Push specified item on player stack.
		120	* Inform player of position.
		121	* Initializes variables if needed.
80	*/	122	*/
81	void	123	void
82	do_wizard_hide (object *op, int silent_dm)	124	dm_stack_push (player *pl, tag_t item)
83	{	125	{
84	if (op->contr->hidden)	126	if (!pl->stack_items)
		127	{
		128	pl->stack_items = (tag_t *) malloc (sizeof (tag_t) * STACK_SIZE);
		129	memset (pl->stack_items, 0, sizeof (tag_t) * STACK_SIZE);
85	{	130	}
86	op->contr->hidden = 0;	131
87	op->invisible = 1;	132	if (pl->stack_position == STACK_SIZE)
88	new_draw_info (NDI_UNIQUE, 0, op, "You are no longer hidden from other players");	133	{
89	op->map->players++;	134	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Item stack full!");
90	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s has entered the game.", &op->name);	135	return;
91	if (!silent_dm)	136	}
92	{	137
93	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master has arrived!");	138	pl->stack_items[pl->stack_position] = item;
		139	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Item stacked as %d.", pl->stack_position);
		140	pl->stack_position++;
		141	}
		142
		143	/**
		144	* Checks 'params' for object code.
		145	*
		146	* Can be:
		147	* * empty => get current object stack top for player
		148	* * number => get item with that tag, stack it for future use
		149	* * $number => get specified stack item
		150	* * "me" => player himself
		151	*
		152	* At function exit, params points to first non-object char
		153	*
		154	* 'from', if not NULL, contains at exit:
		155	* * STACK_FROM_NONE => object not found
		156	* * STACK_FROM_TOP => top item stack, may be NULL if stack was empty
		157	* * STACK_FROM_STACK => item from somewhere in the stack
		158	* * STACK_FROM_NUMBER => item by number, pushed on stack
		159	*
		160	* Ryo, august 2004
		161	*/
		162	static object *
		163	get_dm_object (player *pl, char **params, int *from)
		164	{
		165	int item_tag, item_position;
		166	object *ob;
		167
		168	if (!pl)
		169	return NULL;
		170
		171	if (!params || !*params || **params == '\0')
		172	{
		173	if (from)
		174	*from = STACK_FROM_TOP;
		175	/* No parameter => get stack item */
		176	return dm_stack_peek (pl);
		177	}
		178
		179	/* Let's clean white spaces */
		180	while (**params == ' ')
		181	(*params)++;
		182
		183	/* Next case: number => item tag */
		184	if (sscanf (*params, "%d", &item_tag))
		185	{
		186	/* Move parameter to next item */
		187	while (isdigit (**params))
		188	(*params)++;
		189
		190	/* And skip blanks, too */
		191	while (**params == ' ')
		192	(*params)++;
		193
		194	/* Get item */
		195	ob = find_object (item_tag);
		196	if (!ob)
94	}	197	{
95	}	198	if (from)
96	else	199	*from = STACK_FROM_NONE;
97	{	200	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "No such item %d!", item_tag);
98	op->contr->hidden = 1;	201	return NULL;
99	new_draw_info (NDI_UNIQUE, 0, op, "Other players will no longer see you.");
100	op->map->players--;
101	if (!silent_dm)
102	{	202	}
103	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master is gone..");	203
		204	/* Got one, let's push it on stack */
		205	dm_stack_push (pl, item_tag);
		206	if (from)
		207	*from = STACK_FROM_NUMBER;
		208	return ob;
		209	}
		210
		211	/* Next case: $number => stack item */
		212	if (sscanf (*params, "$%d", &item_position))
		213	{
		214	/* Move parameter to next item */
		215	(*params)++;
		216
		217	while (isdigit (**params))
		218	(*params)++;
		219	while (**params == ' ')
		220	(*params)++;
		221
		222	if (item_position >= pl->stack_position)
104	}	223	{
105	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s leaves the game.", &op->name);	224	if (from)
106	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s left the game.", &op->name);	225	*from = STACK_FROM_NONE;
		226	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "No such stack item %d!", item_position);
		227	return NULL;
		228	}
		229
		230	ob = find_object (pl->stack_items[item_position]);
		231	if (!ob)
		232	{
		233	if (from)
		234	*from = STACK_FROM_NONE;
		235	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Stack item %d was removed.", item_position);
		236	return NULL;
		237	}
		238
		239	if (from)
		240	*from = item_position < pl->stack_position - 1 ? STACK_FROM_STACK : STACK_FROM_TOP;
		241	return ob;
		242	}
		243
		244	/* Next case: 'me' => return pl->ob */
		245	if (!strncmp (*params, "me", 2))
107	}	246	{
108	}	247	if (from)
		248	*from = STACK_FROM_NUMBER;
		249	dm_stack_push (pl, pl->ob->count);
109		250
110	int	251	/* Skip to next token */
111	command_hide (object *op, char *params)	252	(*params) += 2;
112	{	253	while (**params == ' ')
113	do_wizard_hide (op, 0);	254	(*params)++;
114	return 1;	255
		256	return pl->ob;
		257	}
		258
		259	/* Last case: get stack top */
		260	if (from)
		261	*from = STACK_FROM_TOP;
		262	return dm_stack_peek (pl);
115	}	263	}
116		264
117	/**	265	/**
118	* This finds and returns the object which matches the name or	266	* This finds and returns the object which matches the name or
119	* object nubmer (specified via num #whatever).	267	* object nubmer (specified via num #whatever).
…		…
169	{	317	{
170	new_draw_info_format (NDI_UNIQUE, 0, op, "No such god %s.", str);	318	new_draw_info_format (NDI_UNIQUE, 0, op, "No such god %s.", str);
171	return 1;	319	return 1;
172	}	320	}
173		321
174	become_follower (ob, god);	322	ob->become_follower (god);
175	return 1;
176	}
177
178	/**
179	* Add player's IP to ban_file and kick them off the server
180	* I know most people have dynamic IPs but this is more of a short term
181	* solution if they have to get a new IP to play maybe they'll calm down.
182	* This uses the banish_file in the local directory *not* the ban_file
183	* The action is logged with a ! for easy searching. -tm
184	*/
185	int
186	command_banish (object *op, char *params)
187	{
188	player *pl;
189	FILE *banishfile;
190	char buf[MAX_BUF];
191	time_t now;
192
193	if (!params)
194	{
195	new_draw_info (NDI_UNIQUE, 0, op, "Usage: banish <player>.");
196	return 1;
197	}
198
199	pl = get_other_player_from_name (op, params);
200	if (!pl)
201	return 1;
202
203	sprintf (buf, "%s/%s", settings.localdir, BANISHFILE);
204
205	if ((banishfile = fopen (buf, "a")) == NULL)
206	{
207	LOG (llevDebug, "Could not find file banish_file.\n");
208	new_draw_info (NDI_UNIQUE, 0, op, "Could not find banish_file.");
209	return 0;
210	}
211
212	now = time (NULL);
213	/*
214	* Record this as a comment - then we don't have to worry about changing
215	* the parsing code.
216	*/
217	fprintf (banishfile, "# %s (%s) banned by %s at %s\n", &pl->ob->name, pl->ns->host, &op->name, ctime (&now));
218	fprintf (banishfile, "*@%s\n", pl->ns->host);
219	fclose (banishfile);
220
221	LOG (llevDebug, "! %s banned %s from IP: %s.\n", &op->name, &pl->ob->name, pl->ns->host);
222	new_draw_info_format (NDI_UNIQUE | NDI_RED, 0, op, "You banish %s", &pl->ob->name);
223	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_RED, 5, op, "%s banishes %s from the land!", &op->name, &pl->ob->name);
224	command_kick (op, (char *) &pl->ob->name);
225	return 1;
226	}
227
228	int
229	command_kick (object *op, char *params)
230	{
231	for_all_players (pl)
232	if ((params == NULL || !strcmp (&pl->ob->name, params)) && !INVOKE_PLAYER (KICK, pl, ARG_STRING (params)))
233	{
234	object *op = pl->ob;
235
236	if (!QUERY_FLAG (op, FLAG_REMOVED) && !QUERY_FLAG (op, FLAG_FREED))
237	{
238	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_RED, 5, op, "%s is kicked out of the game.", &op->name);
239	strcpy (op->contr->killer, "kicked");
240	}
241
242	pl->ns->destroy ();
243	}
244
245	return 1;
246	}
247
248	//TODO
249	#if 0
250	int
251	command_save_overlay (object *op, char *params)
252	{
253	if (!op)
254	return 0;
255
256	if (op != NULL && !QUERY_FLAG (op, FLAG_WIZ))
257	{
258	new_draw_info (NDI_UNIQUE, 0, op, "Sorry, you can't force an overlay save.");
259	return 1;
260	}
261
262	new_save_map (op->map, 2);
263	new_save_map (op->map, 0);
264	new_draw_info (NDI_UNIQUE, 0, op, "Current map has been saved as an" " overlay.");
265
266	ready_map_name (op->map->path, 0);
267
268	return 1;
269	}
270	#endif
271
272	int
273	command_shutdown (object *op, char *params)
274	{
275	if (op && !QUERY_FLAG (op, FLAG_WIZ))
276	{
277	new_draw_info (NDI_UNIQUE, 0, op, "Sorry, you can't shutdown the server.");
278	return 1;
279	}
280
281	cleanup ("dm initiated shutdown", 0);
282
283	/* not reached */
284	return 1;	323	return 1;
285	}	324	}
286		325
287	int	326	int
288	command_freeze (object *op, char *params)	327	command_freeze (object *op, char *params)
…		…
345	/* we have nowhere to send the prisoner.... */	384	/* we have nowhere to send the prisoner.... */
346	new_draw_info (NDI_UNIQUE, 0, op, "can't jail player, there is no map to hold them");	385	new_draw_info (NDI_UNIQUE, 0, op, "can't jail player, there is no map to hold them");
347	return 0;	386	return 0;
348	}	387	}
349		388
350	pl->ob->enter_exit (dummy);	389	pl->ob->player_goto (dummy->slaying, dummy->stats.hp, dummy->stats.sp);//TODO
351	dummy->destroy ();	390	dummy->destroy ();
		391
352	new_draw_info (NDI_UNIQUE, 0, pl->ob, "You have been arrested.");	392	new_draw_info (NDI_UNIQUE, 0, pl->ob, "You have been arrested.");
353	new_draw_info (NDI_UNIQUE, 0, op, "OK.");	393	new_draw_info (NDI_UNIQUE, 0, op, "OK.");
354	LOG (llevInfo, "Player %s arrested by %s\n", &pl->ob->name, &op->name);	394	LOG (llevInfo, "Player %s arrested by %s\n", &pl->ob->name, &op->name);
355	return 1;	395	return 1;
356	}	396	}
357		397
358	int	398	int
359	command_summon (object *op, char *params)	399	command_summon (object *op, char *params)
360	{	400	{
361	int i;	401	int i;
362	object *dummy;
363	player *pl;	402	player *pl;
364		403
365	if (!op)	404	if (!op)
366	return 0;	405	return 0;
367		406
…		…
373		412
374	pl = get_other_player_from_name (op, params);	413	pl = get_other_player_from_name (op, params);
375	if (!pl)	414	if (!pl)
376	return 1;	415	return 1;
377		416
378	i = find_free_spot (op, op->map, op->x, op->y, 1, 9);	417	maptile *m = op->map;
		418	sint16 nx = op->x;
		419	sint16 ny = op->y;
		420
		421	i = find_free_spot (op, m, nx, ny, 1, SIZEOFFREE1+1);
379	if (i == -1)	422	if (i == -1)
380	{	423	{
381	new_draw_info (NDI_UNIQUE, 0, op, "Can not find a free spot to place summoned player.");	424	new_draw_info (NDI_UNIQUE, 0, op, "Can not find a free spot to place summoned player.");
382	return 1;	425	return 1;
383	}	426	}
384		427
385	dummy = object::create ();	428	nx += DIRX (i);
386	EXIT_PATH (dummy) = op->map->path;	429	ny += DIRY (i);
387	EXIT_X (dummy) = op->x + freearr_x[i];	430
388	EXIT_Y (dummy) = op->y + freearr_y[i];	431	if (!xy_normalise (m, nx, ny))
389	pl->ob->enter_exit (dummy);	432	{
390	dummy->destroy ();	433	new_draw_info (NDI_UNIQUE, 0, op, "Can not find a free spot to place summoned player.");
		434	return 1;
		435	}
		436
		437	pl->ob->player_goto (m->path, nx, ny);
391	new_draw_info (NDI_UNIQUE, 0, pl->ob, "You are summoned.");	438	new_draw_info (NDI_UNIQUE, 0, pl->ob, "You are summoned.");
392	new_draw_info (NDI_UNIQUE, 0, op, "OK.");	439	new_draw_info (NDI_UNIQUE, 0, op, "OK.");
393		440
394	return 1;	441	return 1;
395	}	442	}
…		…
412	int	459	int
413	command_create (object *op, char *params)	460	command_create (object *op, char *params)
414	{	461	{
415	object *tmp = NULL;	462	object *tmp = NULL;
416	int nrof, i, magic, set_magic = 0, set_nrof = 0, gotquote, gotspace;	463	int nrof, i, magic, set_magic = 0, set_nrof = 0, gotquote, gotspace;
417	char buf[MAX_BUF], *cp, *bp = buf, *bp2, *bp3, *bp4, *endline;	464	char buf[MAX_BUF], *cp, *bp = buf, *bp2, *bp3, *endline;
418	archetype *at, *at_spell = NULL;	465	archetype *at, *at_spell = NULL;
419	artifact *art = NULL;	466	artifact *art = NULL;
420		467
421	if (!op)	468	if (!op)
422	return 0;	469	return 0;
…		…
488	* we also set up spell_name which is only	535	* we also set up spell_name which is only
489	* the first word.	536	* the first word.
490	*/	537	*/
491		538
492	at_spell = archetype::find (cp);	539	at_spell = archetype::find (cp);
493	if (!at_spell || at_spell->clone.type != SPELL)	540	if (!at_spell || at_spell->type != SPELL)
494	at_spell = find_archetype_by_object_name (cp);	541	at_spell = find_archetype_by_object_name (cp);
495	if (!at_spell || at_spell->clone.type != SPELL)	542	if (!at_spell || at_spell->type != SPELL)
496	{	543	{
497	assign (spell_name, cp);	544	assign (spell_name, cp);
498	fsp = strchr (spell_name, ' ');	545	fsp = strchr (spell_name, ' ');
499	if (fsp)	546	if (fsp)
500	{	547	{
501	*fsp = 0;	548	*fsp = 0;
502	fsp++;	549	fsp++;
503	at_spell = archetype::find (spell_name);	550	at_spell = archetype::find (spell_name);
504		551
505	/* Got a spell, update the first string pointer */	552	/* Got a spell, update the first string pointer */
506	if (at_spell && at_spell->clone.type == SPELL)	553	if (at_spell && at_spell->type == SPELL)
507	bp2 = cp + strlen (spell_name) + 1;	554	bp2 = cp + strlen (spell_name) + 1;
508	else	555	else
509	at_spell = NULL;	556	at_spell = NULL;
510	}	557	}
511	}	558	}
…		…
513	/* OK - we didn't find a spell - presume the 'of'	560	/* OK - we didn't find a spell - presume the 'of'
514	* in this case means its an artifact.	561	* in this case means its an artifact.
515	*/	562	*/
516	if (!at_spell)	563	if (!at_spell)
517	{	564	{
518	if (find_artifactlist (at->clone.type) == NULL)	565	if (find_artifactlist (at->type) == NULL)
519	new_draw_info_format (NDI_UNIQUE, 0, op, "No artifact list for type %d\n", at->clone.type);	566	new_draw_info_format (NDI_UNIQUE, 0, op, "No artifact list for type %d\n", at->type);
520	else	567	else
521	{	568	{
522	art = find_artifactlist (at->clone.type)->items;	569	art = find_artifactlist (at->type)->items;
523		570
524	do	571	while (art)
525	{	572	{
526	if (!strcmp (art->item->name, cp))	573	if (!strcmp (&art->item->name, cp))
527	break;	574	break;
		575
528	art = art->next;	576	art = art->next;
529	}	577	}
530	while (art != NULL);
531		578
532	if (!art)	579	if (!art)
533	new_draw_info_format (NDI_UNIQUE, 0, op, "No such artifact ([%d] of %s)", at->clone.type, cp);	580	new_draw_info_format (NDI_UNIQUE, 0, op, "No such artifact ([%d] of %s)", at->type, cp);
534	}	581	}
535		582
536	LOG (llevDebug, "%s creates: (%d) (%d) (%s) of (%s)\n", &op->name, set_nrof ? nrof : 0, set_magic ? magic : 0, bp, cp);	583	LOG (llevDebug, "%s creates: (%d) (%d) (%s) of (%s)\n", &op->name, set_nrof ? nrof : 0, set_magic ? magic : 0, bp, cp);
537	}	584	}
538	} /* if cp */	585	} /* if cp */
539		586
540	if ((at->clone.type == ROD || at->clone.type == WAND || at->clone.type == SCROLL ||	587	if ((at->type == ROD || at->type == WAND || at->type == SCROLL ||
541	at->clone.type == HORN || at->clone.type == SPELLBOOK) && !at_spell)	588	at->type == HORN || at->type == SPELLBOOK) && !at_spell)
542	{	589	{
543	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);	590	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);
544	return 1;	591	return 1;
545	}	592	}
546		593
547	/*	594	/*
548	* Rather than have two different blocks with a lot of similar code,	595	* Rather than have two different blocks with a lot of similar code,
549	* just create one object, do all the processing, and then determine	596	* just create one object, do all the processing, and then determine
550	* if that one object should be inserted or if we need to make copies.	597	* if that one object should be inserted or if we need to make copies.
551	*/	598	*/
552	tmp = arch_to_object (at);	599	tmp = at->instance ();
553
554	if (settings.real_wiz == FALSE)
555	SET_FLAG (tmp, FLAG_WAS_WIZ);
556		600
557	if (set_magic)	601	if (set_magic)
558	set_abs_magic (tmp, magic);	602	set_abs_magic (tmp, magic);
559		603
560	if (art)	604	if (art)
561	give_artifact_abilities (tmp, art->item);	605	give_artifact_abilities (tmp, art->item);
562		606
563	if (need_identify (tmp))	607	if (tmp->need_identify ())
564	{	608	{
565	SET_FLAG (tmp, FLAG_IDENTIFIED);	609	tmp->set_flag (FLAG_IDENTIFIED);
566	CLEAR_FLAG (tmp, FLAG_KNOWN_MAGICAL);	610	tmp->clr_flag (FLAG_KNOWN_MAGICAL);
567	}	611	}
568		612
569	/*	613	/*
570	* This entire block here tries to find variable pairings,	614	* This entire block here tries to find variable pairings,
571	* eg, 'hp 4' or the like. The mess here is that values	615	* eg, 'hp 4' or the like. The mess here is that values
…		…
573	* is we want to find two spaces, but if we got a quote,	617	* is we want to find two spaces, but if we got a quote,
574	* any spaces there don't count.	618	* any spaces there don't count.
575	*/	619	*/
576	while (*bp2 && bp2 <= endline)	620	while (*bp2 && bp2 <= endline)
577	{	621	{
578	bp4 = NULL;
579	gotspace = 0;	622	gotspace = 0;
580	gotquote = 0;	623	gotquote = 0;
581		624
582	/* find the first quote */	625	/* find the first quote */
583	for (bp3 = bp2; *bp3 && gotspace < 2 && gotquote < 2; bp3++)	626	for (bp3 = bp2; *bp3 && gotspace < 2 && gotquote < 2; bp3++)
…		…
640	new_draw_info_format (NDI_UNIQUE, 0, op, "(%s#%d)->%s", &tmp->name, tmp->count, bp2);	683	new_draw_info_format (NDI_UNIQUE, 0, op, "(%s#%d)->%s", &tmp->name, tmp->count, bp2);
641		684
642	bp2 = bp3 + 1;	685	bp2 = bp3 + 1;
643	}	686	}
644		687
645	if (at->clone.nrof)	688	if (at->nrof)
646	{	689	{
647	if (at_spell)	690	if (at_spell)
648	insert_ob_in_ob (arch_to_object (at_spell), tmp);	691	tmp->insert (at_spell->instance ());
649		692
650	tmp->x = op->x;	693	tmp->x = op->x;
651	tmp->y = op->y;	694	tmp->y = op->y;
		695	tmp->map = op->map;
652		696
653	if (set_nrof)	697	if (set_nrof)
654	tmp->nrof = nrof;	698	tmp->nrof = nrof;
655		699
656	tmp->map = op->map;	700	op->insert (tmp);
657
658	tmp = insert_ob_in_ob (tmp, op);
659	esrv_send_item (op, tmp);
660		701
661	/* Let's put this created item on stack so dm can access it easily. */	702	/* Let's put this created item on stack so dm can access it easily. */
662	dm_stack_push (op->contr, tmp->count);	703	dm_stack_push (op->contr, tmp->count);
663		704
664	return 1;	705	return 1;
665	}	706	}
666	else	707	else
667	{	708	{
668	for (i = 0; i < (set_nrof ? nrof : 1); i++)	709	for (i = 0; i < (set_nrof ? nrof : 1); i++)
669	{	710	{
670	archetype *atmp;
671	object *prev = 0, *head = 0;	711	object *prev = 0, *head = 0;
672		712
673	for (atmp = at; atmp; atmp = atmp->more)	713	for (archetype *atmp = at; atmp; atmp = (archetype *)atmp->more)
674	{	714	{
675	object *dup = arch_to_object (atmp);	715	object *dup = atmp->instance ();
676		716
677	if (at_spell)	717	if (at_spell)
678	insert_ob_in_ob (arch_to_object (at_spell), dup);	718	insert_ob_in_ob (at_spell->instance (), dup);
679		719
680	/*	720	/*
681	* The head is what contains all the important bits,	721	* The head is what contains all the important bits,
682	* so just copying it over should be fine.	722	* so just copying it over should be fine.
683	*/	723	*/
…		…
685	{	725	{
686	head = dup;	726	head = dup;
687	tmp->copy_to (dup);	727	tmp->copy_to (dup);
688	}	728	}
689		729
690	if (settings.real_wiz == FALSE)
691	SET_FLAG (dup, FLAG_WAS_WIZ);
692
693	dup->x = op->x + dup->arch->clone.x;	730	dup->x = op->x + dup->arch->x;
694	dup->y = op->y + dup->arch->clone.y;	731	dup->y = op->y + dup->arch->y;
695	dup->map = op->map;	732	dup->map = op->map;
696		733
697	if (head != dup)	734	if (head != dup)
698	{	735	{
699	dup->head = head;	736	dup->head = head;
…		…
701	}	738	}
702		739
703	prev = dup;	740	prev = dup;
704	}	741	}
705		742
706	if (QUERY_FLAG (head, FLAG_ALIVE))	743	if (head->flag [FLAG_ALIVE])
707	{	744	{
708	object *check = head;	745	object *check = head;
709	int size_x = 0;	746	int size_x = 0;
710	int size_y = 0;	747	int size_y = 0;
711		748
712	while (check)	749	while (check)
713	{	750	{
714	size_x = MAX (size_x, check->arch->clone.x);	751	size_x = max (size_x, check->arch->x);
715	size_y = MAX (size_y, check->arch->clone.y);	752	size_y = max (size_y, check->arch->y);
716	check = check->more;	753	check = check->more;
717	}	754	}
718		755
719	if (out_of_map (op->map, head->x + size_x, head->y + size_y))	756	if (out_of_map (op->map, head->x + size_x, head->y + size_y))
720	{	757	{
…		…
746	/* Wonder if we really want to push all of these, but since	783	/* Wonder if we really want to push all of these, but since
747	* things like rods have nrof 0, we want to cover those.	784	* things like rods have nrof 0, we want to cover those.
748	*/	785	*/
749	dm_stack_push (op->contr, head->count);	786	dm_stack_push (op->contr, head->count);
750		787
751	if (at->clone.randomitems != NULL && !at_spell)	788	if (at->randomitems && !at_spell)
752	create_treasure (at->clone.randomitems, head, GT_APPLY, op->map->difficulty, 0);	789	create_treasure (at->randomitems, head, GT_APPLY, op->map->difficulty, 0);
753
754	esrv_send_item (op, head);
755	}	790	}
756		791
757	/* free the one we used to copy */	792	/* free the one we used to copy */
758	tmp->destroy ();	793	tmp->destroy ();
759	}	794	}
…		…
766	*/	801	*/
767		802
768	int	803	int
769	command_inventory (object *op, char *params)	804	command_inventory (object *op, char *params)
770	{	805	{
		806	int i;
771	object *tmp;	807	object *tmp;
772	int i;
773		808
774	if (!params)	809	if (!params || !sscanf (params, "%d", &i) || !(tmp = find_object (i)))
775	{	810	{
776	inventory (op, NULL);	811	op->contr->failmsg ("Inventory of what object (nr)?");
777	return 0;	812	return 1;
778	}
779
780	if (!sscanf (params, "%d", &i) || (tmp = find_object (i)) == NULL)
781	{	813	}
782	new_draw_info (NDI_UNIQUE, 0, op, "Inventory of what object (nr)?");
783	return 1;
784	}
785		814
786	inventory (op, tmp);	815	op->contr->infobox (MSG_CHANNEL ("examine"), tmp->query_inventory (op));
		816
787	return 1;	817	return 1;
788	}	818	}
789		819
790	/* just show player's their skills for now. Dm's can	820	/* just show player's their skills for now. Dm's can
791	* already see skills w/ inventory command - b.t.	821	* already see skills w/ inventory command - b.t.
…		…
809		839
810	char *dump = dump_object (tmp);	840	char *dump = dump_object (tmp);
811	new_draw_info (NDI_UNIQUE, 0, op, dump);	841	new_draw_info (NDI_UNIQUE, 0, op, dump);
812	free (dump);	842	free (dump);
813		843
814	if (QUERY_FLAG (tmp, FLAG_OBJ_ORIGINAL))	844	if (tmp->flag [FLAG_OBJ_ORIGINAL])
815	new_draw_info (NDI_UNIQUE, 0, op, "Object is marked original");	845	new_draw_info (NDI_UNIQUE, 0, op, "Object is marked original");
816		846
817	return 1;
818	}
819
820	/**
821	* When DM is possessing a monster, flip aggression on and off, to allow
822	* better motion.
823	*/
824	int
825	command_mon_aggr (object *op, char *params)
826	{
827	if (op->enemy || !QUERY_FLAG (op, FLAG_UNAGGRESSIVE))
828	{
829	op->enemy = NULL;
830	SET_FLAG (op, FLAG_UNAGGRESSIVE);
831	new_draw_info (NDI_UNIQUE, 0, op, "Aggression turned OFF");
832	}
833	else
834	{
835	CLEAR_FLAG (op, FLAG_FRIENDLY);
836	CLEAR_FLAG (op, FLAG_UNAGGRESSIVE);
837	new_draw_info (NDI_UNIQUE, 0, op, "Aggression turned ON");
838	}
839
840	return 1;
841	}
842
843	/** DM can possess a monster. Basically, this tricks the client into thinking
844	* a given monster, is actually the player it controls. This allows a DM
845	* to inhabit a monster's body, and run around the game with it.
846	* This function is severely broken - it has tons of hardcoded values,
847	*/
848	int
849	command_possess (object *op, char *params)
850	{
851	object *victim, *curinv, *nextinv;
852	player *pl;
853	int i;
854	char buf[MAX_BUF];
855
856	victim = NULL;
857	if (params != NULL)
858	{
859	if (sscanf (params, "%d", &i))
860	victim = find_object (i);
861	else if (sscanf (params, "%s", buf))
862	victim = find_object_name (buf);
863	}
864	if (victim == NULL)
865	{
866	new_draw_info (NDI_UNIQUE, 0, op, "Patch what object (nr)?");
867	return 1;
868	}
869
870	if (victim == op)
871	{
872	new_draw_info (NDI_UNIQUE, 0, op, "As insane as you are, I cannot " "allow you to possess yourself.");
873	return 1;
874	}
875
876	/* clear out the old inventory */
877	curinv = op->inv;
878	while (curinv != NULL)
879	{
880	nextinv = curinv->below;
881	esrv_del_item (op->contr, curinv->count);
882	curinv = nextinv;
883	}
884
885	/* make the switch */
886	pl = op->contr;
887	victim->contr = pl;
888	pl->ob = victim;
889	victim->type = PLAYER;
890	SET_FLAG (victim, FLAG_WIZ);
891
892	/* send the inventory to the client */
893	curinv = victim->inv;
894	while (curinv != NULL)
895	{
896	nextinv = curinv->below;
897	esrv_send_item (victim, curinv);
898	curinv = nextinv;
899	}
900	/* basic patchup */
901	/* The use of hard coded values is terrible. Note
902	* that really, to be fair, this shouldn't get changed at
903	* all - if you are possessing a kobold, you should have the
904	* same limitations. As it is, as more body locations are added,
905	* this will give this player more locations than perhaps
906	* they should be allowed.
907	*/
908	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
909	if (i == 1 || i == 6 || i == 8 || i == 9)
910	victim->body_info[i] = 2;
911	else
912	victim->body_info[i] = 1;
913
914	esrv_new_player (pl, 80); /* just pick a wieght, we don't care */
915	esrv_send_inventory (victim, victim);
916
917	victim->update_stats ();
918
919	do_some_living (victim);
920	return 1;	847	return 1;
921	}	848	}
922		849
923	int	850	int
924	command_patch (object *op, char *params)	851	command_patch (object *op, char *params)
…		…
939	return 1;	866	return 1;
940	}	867	}
941		868
942	if ((arg2 = strchr (arg, ' ')))	869	if ((arg2 = strchr (arg, ' ')))
943	arg2++;	870	arg2++;
944	if (settings.real_wiz == FALSE)	871
945	SET_FLAG (tmp, FLAG_WAS_WIZ); /* To avoid cheating */
946	if (set_variable (tmp, arg) == -1)	872	if (set_variable (tmp, arg) == -1)
947	new_draw_info_format (NDI_UNIQUE, 0, op, "Unknown variable %s", arg);	873	new_draw_info_format (NDI_UNIQUE, 0, op, "Unknown variable %s", arg);
948	else	874	else
949	{
950	new_draw_info_format (NDI_UNIQUE, 0, op, "(%s#%d)->%s=%s", &tmp->name, tmp->count, arg, arg2);	875	new_draw_info_format (NDI_UNIQUE, 0, op, "(%s#%d)->%s=%s", &tmp->name, tmp->count, arg, arg2);
951	}
952		876
953	return 1;	877	return 1;
954	}	878	}
955		879
956	int	880	int
…		…
970	{	894	{
971	new_draw_info (NDI_UNIQUE, 0, op, "Unable to remove a player!");	895	new_draw_info (NDI_UNIQUE, 0, op, "Unable to remove a player!");
972	return 1;	896	return 1;
973	}	897	}
974		898
975	if (QUERY_FLAG (tmp, FLAG_REMOVED))	899	if (tmp->flag [FLAG_REMOVED])
976	{	900	{
977	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is already removed!", query_name (tmp));	901	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is already removed!", query_name (tmp));
978	return 1;	902	return 1;
979	}	903	}
980		904
…		…
1019	*/	943	*/
1020	int	944	int
1021	command_addexp (object *op, char *params)	945	command_addexp (object *op, char *params)
1022	{	946	{
1023	char buf[MAX_BUF], skill[MAX_BUF];	947	char buf[MAX_BUF], skill[MAX_BUF];
1024	int i, q;	948	int q;
		949	long long i; // use sint64 and finally provide format specifiers for sint64 etc. via configure
1025	object *skillob = NULL;	950	object *skillob = NULL;
1026		951
1027	skill[0] = '\0';	952	skill[0] = '\0';
1028	if ((params == NULL) || (strlen (params) > MAX_BUF) || ((q = sscanf (params, "%s %d %s", buf, &i, skill)) < 2))	953	if ((params == NULL) || (strlen (params) > MAX_BUF) || ((q = sscanf (params, "%s %lld %[^\n]", buf, &i, skill)) < 2))
1029	{	954	{
1030	new_draw_info (NDI_UNIQUE, 0, op, "Usage: addexp <who> <how much> [<skill>].");	955	new_draw_info (NDI_UNIQUE, 0, op, "Usage: addexp <who> <how much> [<skill>].");
1031	return 1;	956	return 1;
1032	}	957	}
1033		958
…		…
1051		976
1052	pl->ob->stats.exp += i;	977	pl->ob->stats.exp += i;
1053	calc_perm_exp (pl->ob);	978	calc_perm_exp (pl->ob);
1054	player_lvl_adj (pl->ob, NULL);	979	player_lvl_adj (pl->ob, NULL);
1055		980
1056	if (settings.real_wiz == FALSE)
1057	SET_FLAG (pl->ob, FLAG_WAS_WIZ);
1058
1059	return 1;	981	return 1;
1060	}	982	}
1061		983
1062	new_draw_info (NDI_UNIQUE, 0, op, "No such player.");	984	new_draw_info (NDI_UNIQUE, 0, op, "No such player.");
1063	return 1;	985	return 1;
…		…
1072	/**************************************************************************/	994	/**************************************************************************/
1073		995
1074	int	996	int
1075	command_stats (object *op, char *params)	997	command_stats (object *op, char *params)
1076	{	998	{
1077	char thing[20];
1078	char buf[MAX_BUF];	999	char buf[MAX_BUF];
1079		1000
1080	thing[0] = '\0';	1001	if (params == NULL || params[0] == '\0')
1081	if (params == NULL || !sscanf (params, "%s", thing) || thing == NULL)
1082	{	1002	{
1083	new_draw_info (NDI_UNIQUE, 0, op, "Who?");	1003	new_draw_info (NDI_UNIQUE, 0, op, "Who?");
1084	return 1;	1004	return 1;
1085	}	1005	}
1086		1006
1087	for_all_players (pl)	1007	for_all_players (pl)
1088	if (!strcmp (pl->ob->name, thing))	1008	if (!strcmp (&pl->ob->name, params))
1089	{	1009	{
1090	sprintf (buf, "Str : %-2d H.P. : %-4d MAX : %d", pl->ob->stats.Str, pl->ob->stats.hp, pl->ob->stats.maxhp);	1010	sprintf (buf, "Str : %-2d H.P. : %-4d MAX : %d", pl->ob->stats.Str, pl->ob->stats.hp, pl->ob->stats.maxhp);
1091	new_draw_info (NDI_UNIQUE, 0, op, buf);	1011	new_draw_info (NDI_UNIQUE, 0, op, buf);
1092	sprintf (buf, "Dex : %-2d S.P. : %-4d MAX : %d", pl->ob->stats.Dex, pl->ob->stats.sp, pl->ob->stats.maxsp);	1012	sprintf (buf, "Dex : %-2d S.P. : %-4d MAX : %d", pl->ob->stats.Dex, pl->ob->stats.sp, pl->ob->stats.maxsp);
1093	new_draw_info (NDI_UNIQUE, 0, op, buf);	1013	new_draw_info (NDI_UNIQUE, 0, op, buf);
…		…
1111	int	1031	int
1112	command_abil (object *op, char *params)	1032	command_abil (object *op, char *params)
1113	{	1033	{
1114	char thing[20], thing2[20];	1034	char thing[20], thing2[20];
1115	int iii;	1035	int iii;
1116	player *pl;
1117	char buf[MAX_BUF];	1036	char buf[MAX_BUF];
1118		1037
1119	iii = 0;	1038	iii = 0;
1120	thing[0] = '\0';	1039	thing[0] = '\0';
1121	thing2[0] = '\0';	1040	thing2[0] = '\0';
…		…
1137	return 1;	1056	return 1;
1138	}	1057	}
1139		1058
1140	for_all_players (pl)	1059	for_all_players (pl)
1141	{	1060	{
1142	if (!strcmp (pl->ob->name, thing))	1061	if (!strcmp (&pl->ob->name, thing))
1143	{	1062	{
1144	if (settings.real_wiz == FALSE)
1145	SET_FLAG (pl->ob, FLAG_WAS_WIZ);
1146	if (!strcmp ("str", thing2))
1147	pl->ob->stats.Str = iii, pl->orig_stats.Str = iii;	1063	if (!strcmp ("str", thing2)) pl->ob->stats.Str = iii, pl->orig_stats.Str = iii;
1148	if (!strcmp ("dex", thing2))
1149	pl->ob->stats.Dex = iii, pl->orig_stats.Dex = iii;	1064	if (!strcmp ("dex", thing2)) pl->ob->stats.Dex = iii, pl->orig_stats.Dex = iii;
1150	if (!strcmp ("con", thing2))
1151	pl->ob->stats.Con = iii, pl->orig_stats.Con = iii;	1065	if (!strcmp ("con", thing2)) pl->ob->stats.Con = iii, pl->orig_stats.Con = iii;
1152	if (!strcmp ("wis", thing2))
1153	pl->ob->stats.Wis = iii, pl->orig_stats.Wis = iii;	1066	if (!strcmp ("wis", thing2)) pl->ob->stats.Wis = iii, pl->orig_stats.Wis = iii;
1154	if (!strcmp ("cha", thing2))
1155	pl->ob->stats.Cha = iii, pl->orig_stats.Cha = iii;	1067	if (!strcmp ("cha", thing2)) pl->ob->stats.Cha = iii, pl->orig_stats.Cha = iii;
1156	if (!strcmp ("int", thing2))
1157	pl->ob->stats.Int = iii, pl->orig_stats.Int = iii;	1068	if (!strcmp ("int", thing2)) pl->ob->stats.Int = iii, pl->orig_stats.Int = iii;
1158	if (!strcmp ("pow", thing2))
1159	pl->ob->stats.Pow = iii, pl->orig_stats.Pow = iii;	1069	if (!strcmp ("pow", thing2)) pl->ob->stats.Pow = iii, pl->orig_stats.Pow = iii;
		1070
1160	sprintf (buf, "%s has been altered.", &pl->ob->name);	1071	sprintf (buf, "%s has been altered.", &pl->ob->name);
1161	new_draw_info (NDI_UNIQUE, 0, op, buf);	1072	new_draw_info (NDI_UNIQUE, 0, op, buf);
1162	pl->ob->update_stats ();	1073	pl->ob->update_stats ();
1163	return 1;	1074	return 1;
1164	}	1075	}
…		…
1167	new_draw_info (NDI_UNIQUE, 0, op, "No such player.");	1078	new_draw_info (NDI_UNIQUE, 0, op, "No such player.");
1168	return 1;	1079	return 1;
1169	}	1080	}
1170		1081
1171	int	1082	int
1172	command_nowiz (object *op, char *params)
1173	{ /* 'noadm' is alias */
1174	CLEAR_FLAG (op, FLAG_WIZ);
1175	CLEAR_FLAG (op, FLAG_WIZPASS);
1176	CLEAR_FLAG (op, FLAG_WIZCAST);
1177
1178	if (settings.real_wiz == TRUE)
1179	CLEAR_FLAG (op, FLAG_WAS_WIZ);
1180	if (op->contr->hidden)
1181	{
1182	new_draw_info (NDI_UNIQUE, 0, op, "You are no longer hidden from other players");
1183	op->map->players++;
1184	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s has entered the game.", &op->name);
1185	op->contr->hidden = 0;
1186	op->invisible = 1;
1187	}
1188	else
1189	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master is gone..");
1190	return 1;
1191	}
1192
1193	/**
1194	* object *op is trying to become dm.
1195	* pl_name is name supplied by player. Restrictive DM will make it harder
1196	* for socket users to become DM - in that case, it will check for the players
1197	* character name.
1198	*/
1199	static int
1200	checkdm (object *op, const char *pl_name, const char *pl_passwd, const char *pl_host)
1201	{
1202	FILE *dmfile;
1203	char buf[MAX_BUF];
1204	char line_buf[160], name[160], passwd[160], host[160];
1205
1206	#ifdef RESTRICTIVE_DM
1207	*pl_name = op->name ? op->name : "*";
1208	#endif
1209
1210	sprintf (buf, "%s/%s", settings.confdir, DMFILE);
1211	if ((dmfile = fopen (buf, "r")) == NULL)
1212	{
1213	LOG (llevDebug, "Could not find DM file.\n");
1214	return 0;
1215	}
1216
1217	while (fgets (line_buf, 160, dmfile) != NULL)
1218	{
1219	if (line_buf[0] == '#')
1220	continue;
1221	if (sscanf (line_buf, "%[^:]:%[^:]:%s\n", name, passwd, host) != 3)
1222	{
1223	LOG (llevError, "Warning - malformed dm file entry: %s\n", line_buf);
1224	}
1225	else if ((!strcmp (name, "*") || (pl_name && !strcmp (pl_name, name)))
1226	&& (!strcmp (passwd, "*") || !strcmp (passwd, pl_passwd)) && (!strcmp (host, "*") || !strcmp (host, pl_host)))
1227	{
1228	fclose (dmfile);
1229	return (1);
1230	}
1231	}
1232	fclose (dmfile);
1233	return (0);
1234	}
1235
1236	int
1237	do_wizard_dm (object *op, char *params, int silent)
1238	{
1239	if (!op->contr)
1240	return 0;
1241
1242	if (QUERY_FLAG (op, FLAG_WIZ))
1243	{
1244	new_draw_info (NDI_UNIQUE, 0, op, "You are already the Dungeon Master!");
1245	return 0;
1246	}
1247
1248	if (checkdm (op, op->name, (params ? params : "*"), op->contr->ns->host))
1249	{
1250	SET_FLAG (op, FLAG_WIZ);
1251	SET_FLAG (op, FLAG_WAS_WIZ);
1252	SET_FLAG (op, FLAG_WIZPASS);
1253	SET_FLAG (op, FLAG_WIZCAST);
1254	new_draw_info (NDI_UNIQUE, 0, op, "Ok, you are the Dungeon Master!");
1255	/*
1256	* Remove setting flying here - that won't work, because next
1257	* fix_player() is called that will get cleared - proper solution
1258	* is probably something like a wiz_force which gives that and any
1259	* other desired abilities.
1260	*/
1261	clear_los (op);
1262	op->contr->write_buf[0] = '\0';
1263
1264	if (!silent)
1265	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master has arrived!");
1266
1267	return 1;
1268	}
1269	else
1270	{
1271	new_draw_info (NDI_UNIQUE, 0, op, "Sorry Pal, I don't think so.");
1272	op->contr->write_buf[0] = '\0';
1273	return 0;
1274	}
1275	}
1276
1277	/*
1278	* Actual command to perhaps become dm. Changed aroun a bit in version 0.92.2
1279	* - allow people on sockets to become dm, and allow better dm file
1280	*/
1281	int
1282	command_dm (object *op, char *params)
1283	{
1284	if (!op->contr)
1285	return 0;
1286
1287	do_wizard_dm (op, params, 0);
1288
1289	return 1;
1290	}
1291
1292	int
1293	command_invisible (object *op, char *params)	1083	command_invisible (object *op, char *params)
1294	{	1084	{
1295	if (op)	1085	if (op)
1296	{	1086	{
1297	op->invisible += 100;	1087	op->invisible += TIME2TICK (60);
1298	update_object (op, UP_OBJ_FACE);	1088	update_object (op, UP_OBJ_CHANGE);
1299	new_draw_info (NDI_UNIQUE, 0, op, "You turn invisible.");	1089	new_draw_info (NDI_UNIQUE, 0, op, "You turn invisible.");
1300	}	1090	}
1301		1091
1302	return 0;	1092	return 0;
1303	}	1093	}
…		…
1306	* Returns spell object (from archetypes) by name.	1096	* Returns spell object (from archetypes) by name.
1307	* Returns NULL if 0 or more than one spell matches.	1097	* Returns NULL if 0 or more than one spell matches.
1308	* Used for wizard's learn spell/prayer.	1098	* Used for wizard's learn spell/prayer.
1309	*	1099	*
1310	* op is the player issuing the command.	1100	* op is the player issuing the command.
1311	*
1312	* Ignores archetypes "spelldirect_xxx" since these archetypes are not used
1313	* anymore (but may still be present in some player's inventories and thus
1314	* cannot be removed). We have to ignore them here since they have the same
1315	* name than other "spell_xxx" archetypes and would always conflict.
1316	*/	1101	*/
1317	static object *	1102	static object *
1318	get_spell_by_name (object *op, const char *spell_name)	1103	get_spell_by_name (object *op, shstr_cmp spell_name)
1319	{	1104	{
1320	archetype *ar;
1321	archetype *found;
1322	int conflict_found;
1323	size_t spell_name_length;
1324
1325	/* First check for full name matches. */	1105	/* First check for full name matches. */
1326	conflict_found = 0;	1106	int conflict_found = 0;
1327	found = NULL;	1107	archetype *found = 0;
1328	for (ar = first_archetype; ar != NULL; ar = ar->next)	1108
		1109	for_all_archetypes (at)
1329	{	1110	{
1330	if (ar->clone.type != SPELL)	1111	if (at->type != SPELL)
1331	continue;	1112	continue;
1332		1113
1333	if (strncmp (ar->name, "spelldirect_", 12) == 0)	1114	if (at->object::name != spell_name)
1334	continue;	1115	continue;
1335		1116
1336	if (strcmp (ar->clone.name, spell_name) != 0)
1337	continue;
1338
1339	if (found != NULL)	1117	if (found)
1340	{	1118	{
1341	if (!conflict_found)	1119	if (!conflict_found)
1342	{	1120	{
1343	conflict_found = 1;	1121	conflict_found = 1;
1344	new_draw_info_format (NDI_UNIQUE, 0, op, "More than one archetype matches the spell name %s:", spell_name);	1122	new_draw_info_format (NDI_UNIQUE, 0, op, "More than one archetype matches the spell name %s:", &spell_name);
1345	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &found->name);	1123	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &found->archname);
1346	}	1124	}
		1125
1347	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &ar->name);	1126	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &at->archname);
1348	continue;	1127	return 0;
1349	}	1128	}
1350		1129
1351	found = ar;	1130	found = at;
1352	}	1131	}
1353
1354	/* No match if more more than one archetype matches. */
1355	if (conflict_found)
1356	return NULL;
1357		1132
1358	/* Return if exactly one archetype matches. */	1133	/* Return if exactly one archetype matches. */
1359	if (found != NULL)	1134	if (found)
1360	return arch_to_object (found);	1135	return found->instance ();
1361
1362	/* No full match found: now check for partial matches. */
1363	spell_name_length = strlen (spell_name);
1364	conflict_found = 0;
1365	found = NULL;
1366	for (ar = first_archetype; ar != NULL; ar = ar->next)
1367	{
1368	if (ar->clone.type != SPELL)
1369	continue;
1370
1371	if (strncmp (ar->name, "spelldirect_", 12) == 0)
1372	continue;
1373
1374	if (strncmp (ar->clone.name, spell_name, spell_name_length) != 0)
1375	continue;
1376
1377	if (found != NULL)
1378	{
1379	if (!conflict_found)
1380	{
1381	conflict_found = 1;
1382	new_draw_info_format (NDI_UNIQUE, 0, op, "More than one spell matches %s:", spell_name);
1383	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &found->clone.name);
1384	}
1385	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &ar->clone.name);
1386	continue;
1387	}
1388
1389	found = ar;
1390	}
1391
1392	/* No match if more more than one archetype matches. */
1393	if (conflict_found)
1394	return NULL;
1395
1396	/* Return if exactly one archetype matches. */
1397	if (found != NULL)
1398	return arch_to_object (found);
1399		1136
1400	/* No spell found: just print an error message. */	1137	/* No spell found: just print an error message. */
1401	new_draw_info_format (NDI_UNIQUE, 0, op, "The spell %s does not exist.", spell_name);	1138	new_draw_info_format (NDI_UNIQUE, 0, op, "The spell does not exist.");
		1139
1402	return NULL;	1140	return 0;
1403	}	1141	}
1404		1142
1405	static int	1143	static int
1406	command_learn_spell_or_prayer (object *op, char *params, int special_prayer)	1144	command_learn_spell_or_prayer (object *op, char *params, int special_prayer)
1407	{	1145	{
…		…
1451	{	1189	{
1452	new_draw_info (NDI_UNIQUE, 0, op, "Which spell do you want to forget?");	1190	new_draw_info (NDI_UNIQUE, 0, op, "Which spell do you want to forget?");
1453	return 0;	1191	return 0;
1454	}	1192	}
1455		1193
1456	spell = lookup_spell_by_name (op, params);	1194	spell = op->find_spell (params);
1457	if (spell == NULL)	1195	if (spell == NULL)
1458	{	1196	{
1459	new_draw_info_format (NDI_UNIQUE, 0, op, "You do not know the spell %s.", params);	1197	new_draw_info_format (NDI_UNIQUE, 0, op, "You do not know the spell %s.", params);
1460	return 0;	1198	return 0;
1461	}	1199	}
1462		1200
1463	do_forget_spell (op, spell->name);	1201	do_forget_spell (op, spell->name);
1464	return 1;	1202	return 1;
1465	}
1466
1467	/**
1468	* Lists all plugins currently loaded with their IDs and full names.
1469	*/
1470	int
1471	command_listplugins (object *op, char *params)
1472	{
1473	plugins_display_list (op);
1474	return 1;
1475	}
1476
1477	/**
1478	* Loads the given plugin. The DM specifies the name of the library to load (no
1479	* pathname is needed). Do not ever attempt to load the same plugin more than
1480	* once at a time, or bad things could happen.
1481	*/
1482	int
1483	command_loadplugin (object *op, char *params)
1484	{
1485	char buf[MAX_BUF];
1486
1487	if (params == NULL)
1488	{
1489	new_draw_info (NDI_UNIQUE, 0, op, "Load which plugin?");
1490	return 1;
1491	}
1492
1493	strcpy (buf, LIBDIR);
1494	strcat (buf, "/plugins/");
1495	strcat (buf, params);
1496	LOG (llevDebug, "Requested plugin file is %s\n", buf);
1497	if (plugins_init_plugin (buf) == 0)
1498	new_draw_info (NDI_UNIQUE, 0, op, "Plugin successfully loaded.");
1499	else
1500	new_draw_info (NDI_UNIQUE, 0, op, "Could not load plugin.");
1501	return 1;
1502	}
1503
1504	/**
1505	* Unloads the given plugin. The DM specified the ID of the library to unload.
1506	* Note that some things may behave strangely if the correct plugins are not
1507	* loaded.
1508	*/
1509	int
1510	command_unloadplugin (object *op, char *params)
1511	{
1512	if (params == NULL)
1513	{
1514	new_draw_info (NDI_UNIQUE, 0, op, "Remove which plugin?");
1515	return 1;
1516	}
1517
1518	if (plugins_remove_plugin (params) == 0)
1519	new_draw_info (NDI_UNIQUE, 0, op, "Plugin successfully removed.");
1520	else
1521	new_draw_info (NDI_UNIQUE, 0, op, "Could not remove plugin.");
1522	return 1;
1523	}
1524
1525	/**
1526	* A players wants to become DM and hide.
1527	* Let's see if that's authorized.
1528	* Make sure to not tell anything to anyone.
1529	*/
1530	int
1531	command_dmhide (object *op, char *params)
1532	{
1533	if (!do_wizard_dm (op, params, 1))
1534	return 0;
1535
1536	do_wizard_hide (op, 1);
1537
1538	return 1;
1539	}
1540
1541	void
1542	dm_stack_pop (player *pl)
1543	{
1544	if (!pl->stack_items || !pl->stack_position)
1545	{
1546	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
1547	return;
1548	}
1549
1550	pl->stack_position--;
1551	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Popped item from stack, %d left.", pl->stack_position);
1552	}
1553
1554	/**
1555	* Get current stack top item for player.
1556	* Returns NULL if no stacked item.
1557	* If stacked item disappeared (freed), remove it.
1558	*
1559	* Ryo, august 2004
1560	*/
1561	object *
1562	dm_stack_peek (player *pl)
1563	{
1564	object *ob;
1565
1566	if (!pl->stack_position)
1567	{
1568	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
1569	return NULL;
1570	}
1571
1572	ob = find_object (pl->stack_items[pl->stack_position - 1]);
1573	if (!ob)
1574	{
1575	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Stacked item was removed!");
1576	dm_stack_pop (pl);
1577	return NULL;
1578	}
1579
1580	return ob;
1581	}
1582
1583	/**
1584	* Push specified item on player stack.
1585	* Inform player of position.
1586	* Initializes variables if needed.
1587	*/
1588	void
1589	dm_stack_push (player *pl, tag_t item)
1590	{
1591	if (!pl->stack_items)
1592	{
1593	pl->stack_items = (tag_t *) malloc (sizeof (tag_t) * STACK_SIZE);
1594	memset (pl->stack_items, 0, sizeof (tag_t) * STACK_SIZE);
1595	}
1596
1597	if (pl->stack_position == STACK_SIZE)
1598	{
1599	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Item stack full!");
1600	return;
1601	}
1602
1603	pl->stack_items[pl->stack_position] = item;
1604	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Item stacked as %d.", pl->stack_position);
1605	pl->stack_position++;
1606	}
1607
1608	/**
1609	* Checks 'params' for object code.
1610	*
1611	* Can be:
1612	* * empty => get current object stack top for player
1613	* * number => get item with that tag, stack it for future use
1614	* * $number => get specified stack item
1615	* * "me" => player himself
1616	*
1617	* At function exit, params points to first non-object char
1618	*
1619	* 'from', if not NULL, contains at exit:
1620	* * STACK_FROM_NONE => object not found
1621	* * STACK_FROM_TOP => top item stack, may be NULL if stack was empty
1622	* * STACK_FROM_STACK => item from somewhere in the stack
1623	* * STACK_FROM_NUMBER => item by number, pushed on stack
1624	*
1625	* Ryo, august 2004
1626	*/
1627	object *
1628	get_dm_object (player *pl, char **params, int *from)
1629	{
1630	int item_tag, item_position;
1631	object *ob;
1632
1633	if (!pl)
1634	return NULL;
1635
1636	if (!params || !*params || **params == '\0')
1637	{
1638	if (from)
1639	*from = STACK_FROM_TOP;
1640	/* No parameter => get stack item */
1641	return dm_stack_peek (pl);
1642	}
1643
1644	/* Let's clean white spaces */
1645	while (**params == ' ')
1646	(*params)++;
1647
1648	/* Next case: number => item tag */
1649	if (sscanf (*params, "%d", &item_tag))
1650	{
1651	/* Move parameter to next item */
1652	while (isdigit (**params))
1653	(*params)++;
1654
1655	/* And skip blanks, too */
1656	while (**params == ' ')
1657	(*params)++;
1658
1659	/* Get item */
1660	ob = find_object (item_tag);
1661	if (!ob)
1662	{
1663	if (from)
1664	*from = STACK_FROM_NONE;
1665	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "No such item %d!", item_tag);
1666	return NULL;
1667	}
1668
1669	/* Got one, let's push it on stack */
1670	dm_stack_push (pl, item_tag);
1671	if (from)
1672	*from = STACK_FROM_NUMBER;
1673	return ob;
1674	}
1675
1676	/* Next case: $number => stack item */
1677	if (sscanf (*params, "$%d", &item_position))
1678	{
1679	/* Move parameter to next item */
1680	(*params)++;
1681
1682	while (isdigit (**params))
1683	(*params)++;
1684	while (**params == ' ')
1685	(*params)++;
1686
1687	if (item_position >= pl->stack_position)
1688	{
1689	if (from)
1690	*from = STACK_FROM_NONE;
1691	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "No such stack item %d!", item_position);
1692	return NULL;
1693	}
1694
1695	ob = find_object (pl->stack_items[item_position]);
1696	if (!ob)
1697	{
1698	if (from)
1699	*from = STACK_FROM_NONE;
1700	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Stack item %d was removed.", item_position);
1701	return NULL;
1702	}
1703
1704	if (from)
1705	*from = item_position < pl->stack_position - 1 ? STACK_FROM_STACK : STACK_FROM_TOP;
1706	return ob;
1707	}
1708
1709	/* Next case: 'me' => return pl->ob */
1710	if (!strncmp (*params, "me", 2))
1711	{
1712	if (from)
1713	*from = STACK_FROM_NUMBER;
1714	dm_stack_push (pl, pl->ob->count);
1715
1716	/* Skip to next token */
1717	(*params) += 2;
1718	while (**params == ' ')
1719	(*params)++;
1720
1721	return pl->ob;
1722	}
1723
1724	/* Last case: get stack top */
1725	if (from)
1726	*from = STACK_FROM_TOP;
1727	return dm_stack_peek (pl);
1728	}	1203	}
1729		1204
1730	/**	1205	/**
1731	* Pop the stack top.	1206	* Pop the stack top.
1732	*/	1207	*/
…		…
1792	}	1267	}
1793		1268
1794	int	1269	int
1795	command_insert_into (object *op, char *params)	1270	command_insert_into (object *op, char *params)
1796	{	1271	{
1797	object *left, *right, *inserted;	1272	object *left, *right;
1798	int left_from, right_from;	1273	int left_from, right_from;
1799		1274
1800	left = get_dm_object (op->contr, &params, &left_from);	1275	left = get_dm_object (op->contr, &params, &left_from);
1801	if (!left)	1276	if (!left)
1802	{	1277	{
…		…
1845	{	1320	{
1846	new_draw_info (NDI_UNIQUE, 0, op, "Can't insert a player into something!");	1321	new_draw_info (NDI_UNIQUE, 0, op, "Can't insert a player into something!");
1847	return 0;	1322	return 0;
1848	}	1323	}
1849		1324
1850	if (!QUERY_FLAG (right, FLAG_REMOVED))	1325	if (!right->flag [FLAG_REMOVED])
1851	right->remove ();	1326	right->remove ();
		1327
1852	inserted = insert_ob_in_ob (right, left);	1328	object *inserted = insert_ob_in_ob (right, left);
1853	if (left->type == PLAYER)
1854	if (inserted == right)
1855	esrv_send_item (left, right);
1856	else
1857	esrv_update_item (UPD_WEIGHT | UPD_NAME | UPD_NROF, left, inserted);
1858		1329
1859	new_draw_info_format (NDI_UNIQUE, 0, op, "Inserted %s in %s", query_name (inserted), query_name (left));	1330	new_draw_info_format (NDI_UNIQUE, 0, op, "Inserted %s in %s", query_name (inserted), query_name (left));
1860		1331
1861	return 0;	1332	return 0;
1862		1333

Diff Legend

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