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.28 by root, Sat Dec 30 10:16:11 2006 UTC vs.
Revision 1.85 by root, Thu May 13 12:28:13 2010 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 (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
6		7	*
7	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
8	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
9	the Free Software Foundation; either version 2 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
10	(at your option) any later version.	11	* option) any later version.
11		12	*
12	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,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	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
18	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
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* <http://www.gnu.org/licenses/>.
20		21	*
21	The authors can be reached via e-mail at <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	#include <global.h>	25	#include <global.h>
25	#ifndef __CEXTRACT__
26	# include <sproto.h>	26	#include <sproto.h>
27	#endif
28	#include <spells.h>	27	#include <spells.h>
29	#include <treasure.h>	28	#include <treasure.h>
30	#include <skills.h>	29	#include <skills.h>
31		30
32	/** Defines for DM item stack **/	31	/** Defines for DM item stack **/
…		…
35	/* Values for 'from' field of get_dm_object */	34	/* Values for 'from' field of get_dm_object */
36	#define STACK_FROM_NONE 0 /* Item was not found */	35	#define STACK_FROM_NONE 0 /* Item was not found */
37	#define STACK_FROM_TOP 1 /* Item is stack top */	36	#define STACK_FROM_TOP 1 /* Item is stack top */
38	#define STACK_FROM_STACK 2 /* Item is somewhere in stack */	37	#define STACK_FROM_STACK 2 /* Item is somewhere in stack */
39	#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) */
40
41		39
42	/**	40	/**
43	* 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
44	* it out to a seperate function. name is the person	42	* it out to a seperate function. name is the person
45	* being saught, rq is who is looking for them. This	43	* being saught, rq is who is looking for them. This
…		…
72		70
73	new_draw_info (NDI_UNIQUE, 0, op, "No such player.");	71	new_draw_info (NDI_UNIQUE, 0, op, "No such player.");
74	return 0;	72	return 0;
75	}	73	}
76		74
		75	static void
		76	dm_stack_pop (player *pl)
		77	{
		78	if (!pl->stack_items || !pl->stack_position)
		79	{
		80	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
		81	return;
		82	}
		83
		84	pl->stack_position--;
		85	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Popped item from stack, %d left.", pl->stack_position);
		86	}
		87
		88	/**
		89	* Get current stack top item for player.
		90	* Returns NULL if no stacked item.
		91	* If stacked item disappeared (freed), remove it.
		92	*
		93	* Ryo, august 2004
		94	*/
		95	static object *
		96	dm_stack_peek (player *pl)
		97	{
		98	object *ob;
		99
		100	if (!pl->stack_position)
		101	{
		102	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
		103	return NULL;
		104	}
		105
		106	ob = find_object (pl->stack_items[pl->stack_position - 1]);
		107	if (!ob)
		108	{
		109	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Stacked item was removed!");
		110	dm_stack_pop (pl);
		111	return NULL;
		112	}
		113
		114	return ob;
		115	}
		116
		117	/**
		118	* Push specified item on player stack.
		119	* Inform player of position.
		120	* Initializes variables if needed.
		121	*/
		122	void
		123	dm_stack_push (player *pl, tag_t item)
		124	{
		125	if (!pl->stack_items)
		126	{
		127	pl->stack_items = (tag_t *) malloc (sizeof (tag_t) * STACK_SIZE);
		128	memset (pl->stack_items, 0, sizeof (tag_t) * STACK_SIZE);
		129	}
		130
		131	if (pl->stack_position == STACK_SIZE)
		132	{
		133	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Item stack full!");
		134	return;
		135	}
		136
		137	pl->stack_items[pl->stack_position] = item;
		138	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Item stacked as %d.", pl->stack_position);
		139	pl->stack_position++;
		140	}
		141
		142	/**
		143	* Checks 'params' for object code.
		144	*
		145	* Can be:
		146	* * empty => get current object stack top for player
		147	* * number => get item with that tag, stack it for future use
		148	* * $number => get specified stack item
		149	* * "me" => player himself
		150	*
		151	* At function exit, params points to first non-object char
		152	*
		153	* 'from', if not NULL, contains at exit:
		154	* * STACK_FROM_NONE => object not found
		155	* * STACK_FROM_TOP => top item stack, may be NULL if stack was empty
		156	* * STACK_FROM_STACK => item from somewhere in the stack
		157	* * STACK_FROM_NUMBER => item by number, pushed on stack
		158	*
		159	* Ryo, august 2004
		160	*/
		161	static object *
		162	get_dm_object (player *pl, char **params, int *from)
		163	{
		164	int item_tag, item_position;
		165	object *ob;
		166
		167	if (!pl)
		168	return NULL;
		169
		170	if (!params || !*params || **params == '\0')
		171	{
		172	if (from)
		173	*from = STACK_FROM_TOP;
		174	/* No parameter => get stack item */
		175	return dm_stack_peek (pl);
		176	}
		177
		178	/* Let's clean white spaces */
		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))
		187	(*params)++;
		188
		189	/* And skip blanks, too */
		190	while (**params == ' ')
		191	(*params)++;
		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
		216	while (isdigit (**params))
		217	(*params)++;
		218	while (**params == ' ')
		219	(*params)++;
		220
		221	if (item_position >= pl->stack_position)
		222	{
		223	if (from)
		224	*from = STACK_FROM_NONE;
		225	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "No such stack item %d!", item_position);
		226	return NULL;
		227	}
		228
		229	ob = find_object (pl->stack_items[item_position]);
		230	if (!ob)
		231	{
		232	if (from)
		233	*from = STACK_FROM_NONE;
		234	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Stack item %d was removed.", item_position);
		235	return NULL;
		236	}
		237
		238	if (from)
		239	*from = item_position < pl->stack_position - 1 ? STACK_FROM_STACK : STACK_FROM_TOP;
		240	return ob;
		241	}
		242
		243	/* Next case: 'me' => return pl->ob */
		244	if (!strncmp (*params, "me", 2))
		245	{
		246	if (from)
		247	*from = STACK_FROM_NUMBER;
		248	dm_stack_push (pl, pl->ob->count);
		249
		250	/* Skip to next token */
		251	(*params) += 2;
		252	while (**params == ' ')
		253	(*params)++;
		254
		255	return pl->ob;
		256	}
		257
		258	/* Last case: get stack top */
		259	if (from)
		260	*from = STACK_FROM_TOP;
		261	return dm_stack_peek (pl);
		262	}
		263
77	/**	264	/**
78	* Actually hides specified player (obviously a DM).	265	* Actually hides specified player (obviously a DM).
79	* If 'silent_dm' is non zero, other players are informed of DM entering/leaving,	266	* If 'silent_dm' is non zero, other players are informed of DM entering/leaving,
80	* else they just think someone left/entered.	267	* else they just think someone left/entered.
81	*/	268	*/
82	void	269	static void
83	do_wizard_hide (object *op, int silent_dm)	270	do_wizard_hide (object *op, int silent_dm)
84	{	271	{
85	if (op->contr->hidden)	272	if (op->contr->hidden)
86	{	273	{
87	op->contr->hidden = 0;	274	op->contr->hidden = 0;
88	op->invisible = 1;	275	op->invisible = 1;
89	new_draw_info (NDI_UNIQUE, 0, op, "You are no longer hidden from other players");	276	new_draw_info (NDI_UNIQUE, 0, op, "You are no longer hidden from other players");
90	op->map->players++;	277	op->map->players++;
91	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s has entered the game.", &op->name);	278	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s has entered the game.", &op->name);
		279
92	if (!silent_dm)	280	if (!silent_dm)
93	{
94	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master has arrived!");	281	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master has arrived!");
95	}
96	}	282	}
97	else	283	else
98	{	284	{
99	op->contr->hidden = 1;	285	op->contr->hidden = 1;
100	new_draw_info (NDI_UNIQUE, 0, op, "Other players will no longer see you.");	286	new_draw_info (NDI_UNIQUE, 0, op, "Other players will no longer see you.");
101	op->map->players--;	287	op->map->players--;
		288
102	if (!silent_dm)	289	if (!silent_dm)
103	{
104	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master is gone..");	290	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master is gone..");
105	}	291
106	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s leaves the game.", &op->name);	292	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s leaves the game.", &op->name);
107	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s left the game.", &op->name);	293	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s left the game.", &op->name);
108	}	294	}
109	}	295	}
110		296
…		…
170	{	356	{
171	new_draw_info_format (NDI_UNIQUE, 0, op, "No such god %s.", str);	357	new_draw_info_format (NDI_UNIQUE, 0, op, "No such god %s.", str);
172	return 1;	358	return 1;
173	}	359	}
174		360
175	become_follower (ob, god);	361	ob->become_follower (god);
176	return 1;
177	}
178
179	/**
180	* Add player's IP to ban_file and kick them off the server
181	* I know most people have dynamic IPs but this is more of a short term
182	* solution if they have to get a new IP to play maybe they'll calm down.
183	* This uses the banish_file in the local directory *not* the ban_file
184	* The action is logged with a ! for easy searching. -tm
185	*/
186	int
187	command_banish (object *op, char *params)
188	{
189	player *pl;
190	FILE *banishfile;
191	char buf[MAX_BUF];
192	time_t now;
193
194	if (!params)
195	{
196	new_draw_info (NDI_UNIQUE, 0, op, "Usage: banish <player>.");
197	return 1;
198	}
199
200	pl = get_other_player_from_name (op, params);
201	if (!pl)
202	return 1;
203
204	sprintf (buf, "%s/%s", settings.localdir, BANISHFILE);
205
206	if ((banishfile = fopen (buf, "a")) == NULL)
207	{
208	LOG (llevDebug, "Could not find file banish_file.\n");
209	new_draw_info (NDI_UNIQUE, 0, op, "Could not find banish_file.");
210	return 0;
211	}
212
213	now = time (NULL);
214	/*
215	* Record this as a comment - then we don't have to worry about changing
216	* the parsing code.
217	*/
218	fprintf (banishfile, "# %s (%s) banned by %s at %s\n", &pl->ob->name, pl->ns->host, &op->name, ctime (&now));
219	fprintf (banishfile, "*@%s\n", pl->ns->host);
220	fclose (banishfile);
221
222	LOG (llevDebug, "! %s banned %s from IP: %s.\n", &op->name, &pl->ob->name, pl->ns->host);
223	new_draw_info_format (NDI_UNIQUE | NDI_RED, 0, op, "You banish %s", &pl->ob->name);
224	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_RED, 5, op, "%s banishes %s from the land!", &op->name, &pl->ob->name);
225	command_kick (op, (char *) &pl->ob->name);
226	return 1;
227	}
228
229	int
230	command_kick (object *op, char *params)
231	{
232	for_all_players (pl)
233	if ((params == NULL || !strcmp (&pl->ob->name, params)) && !INVOKE_PLAYER (KICK, pl, ARG_STRING (params)))
234	{
235	object *op = pl->ob;
236
237	if (!QUERY_FLAG (op, FLAG_REMOVED) && !QUERY_FLAG (op, FLAG_FREED))
238	{
239	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_RED, 5, op, "%s is kicked out of the game.", &op->name);
240	strcpy (op->contr->killer, "kicked");
241	}
242
243	pl->ns->destroy ();
244	}
245
246	return 1;
247	}
248
249	//TODO
250	#if 0
251	int
252	command_save_overlay (object *op, char *params)
253	{
254	if (!op)
255	return 0;
256
257	if (op != NULL && !QUERY_FLAG (op, FLAG_WIZ))
258	{
259	new_draw_info (NDI_UNIQUE, 0, op, "Sorry, you can't force an overlay save.");
260	return 1;
261	}
262
263	new_save_map (op->map, 2);
264	new_save_map (op->map, 0);
265	new_draw_info (NDI_UNIQUE, 0, op, "Current map has been saved as an" " overlay.");
266
267	ready_map_name (op->map->path, 0);
268
269	return 1;
270	}
271	#endif
272
273	int
274	command_shutdown (object *op, char *params)
275	{
276	if (op != NULL && !QUERY_FLAG (op, FLAG_WIZ))
277	{
278	new_draw_info (NDI_UNIQUE, 0, op, "Sorry, you can't shutdown the server.");
279	return 1;
280	}
281
282	cleanup (0);
283
284	/* not reached */
285	return 1;	362	return 1;
286	}	363	}
287		364
288	int	365	int
289	command_freeze (object *op, char *params)	366	command_freeze (object *op, char *params)
…		…
346	/* we have nowhere to send the prisoner.... */	423	/* we have nowhere to send the prisoner.... */
347	new_draw_info (NDI_UNIQUE, 0, op, "can't jail player, there is no map to hold them");	424	new_draw_info (NDI_UNIQUE, 0, op, "can't jail player, there is no map to hold them");
348	return 0;	425	return 0;
349	}	426	}
350		427
351	pl->ob->enter_exit (dummy);	428	pl->ob->player_goto (dummy->slaying, dummy->stats.hp, dummy->stats.sp);//TODO
352	dummy->destroy ();	429	dummy->destroy ();
		430
353	new_draw_info (NDI_UNIQUE, 0, pl->ob, "You have been arrested.");	431	new_draw_info (NDI_UNIQUE, 0, pl->ob, "You have been arrested.");
354	new_draw_info (NDI_UNIQUE, 0, op, "OK.");	432	new_draw_info (NDI_UNIQUE, 0, op, "OK.");
355	LOG (llevInfo, "Player %s arrested by %s\n", &pl->ob->name, &op->name);	433	LOG (llevInfo, "Player %s arrested by %s\n", &pl->ob->name, &op->name);
356	return 1;	434	return 1;
357	}	435	}
…		…
374		452
375	pl = get_other_player_from_name (op, params);	453	pl = get_other_player_from_name (op, params);
376	if (!pl)	454	if (!pl)
377	return 1;	455	return 1;
378		456
379	i = find_free_spot (op, op->map, op->x, op->y, 1, 9);	457	maptile *m = op->map;
		458	sint16 nx = op->x;
		459	sint16 ny = op->y;
		460
		461	i = find_free_spot (op, m, nx, ny, 1, SIZEOFFREE1+1);
380	if (i == -1)	462	if (i == -1)
381	{	463	{
382	new_draw_info (NDI_UNIQUE, 0, op, "Can not find a free spot to place summoned player.");	464	new_draw_info (NDI_UNIQUE, 0, op, "Can not find a free spot to place summoned player.");
383	return 1;	465	return 1;
384	}	466	}
385		467
386	dummy = object::create ();	468	nx += freearr_x [i];
387	EXIT_PATH (dummy) = op->map->path;	469	ny += freearr_y [i];
388	EXIT_X (dummy) = op->x + freearr_x[i];	470
389	EXIT_Y (dummy) = op->y + freearr_y[i];	471	if (!xy_normalise (m, nx, ny))
390	pl->ob->enter_exit (dummy);	472	{
391	dummy->destroy ();	473	new_draw_info (NDI_UNIQUE, 0, op, "Can not find a free spot to place summoned player.");
		474	return 1;
		475	}
		476
		477	pl->ob->player_goto (m->path, nx, ny);
392	new_draw_info (NDI_UNIQUE, 0, pl->ob, "You are summoned.");	478	new_draw_info (NDI_UNIQUE, 0, pl->ob, "You are summoned.");
393	new_draw_info (NDI_UNIQUE, 0, op, "OK.");	479	new_draw_info (NDI_UNIQUE, 0, op, "OK.");
394		480
395	return 1;
396	}
397
398	/**
399	* Teleport next to target player.
400	*/
401
402	/* mids 01/16/2002 */
403	int
404	command_teleport (object *op, char *params)
405	{
406	int i;
407	object *dummy;
408	player *pl;
409
410	if (!op)
411	return 0;
412
413	if (params == NULL)
414	{
415	new_draw_info (NDI_UNIQUE, 0, op, "Usage: teleport <player>.");
416	return 1;
417	}
418
419	pl = get_other_player_from_name (op, params);
420	if (!pl)
421	return 1;
422
423	i = find_free_spot (pl->ob, pl->ob->map, pl->ob->x, pl->ob->y, 1, 9);
424	if (i == -1)
425	{
426	new_draw_info (NDI_UNIQUE, 0, op, "Can not find a free spot to teleport to.");
427	return 1;
428	}
429
430	dummy = object::create ();
431	EXIT_PATH (dummy) = pl->ob->map->path;
432	EXIT_X (dummy) = pl->ob->x + freearr_x[i];
433	EXIT_Y (dummy) = pl->ob->y + freearr_y[i];
434	op->enter_exit (dummy);
435	dummy->destroy ();
436	if (!op->contr->hidden)
437	new_draw_info (NDI_UNIQUE, 0, pl->ob, "You see a portal open.");
438	new_draw_info (NDI_UNIQUE, 0, op, "OK.");
439	return 1;	481	return 1;
440	}	482	}
441		483
442	/**	484	/**
443	* This function is a real mess, because we're stucking getting	485	* This function is a real mess, because we're stucking getting
…		…
533	* we also set up spell_name which is only	575	* we also set up spell_name which is only
534	* the first word.	576	* the first word.
535	*/	577	*/
536		578
537	at_spell = archetype::find (cp);	579	at_spell = archetype::find (cp);
538	if (!at_spell || at_spell->clone.type != SPELL)	580	if (!at_spell || at_spell->type != SPELL)
539	at_spell = find_archetype_by_object_name (cp);	581	at_spell = find_archetype_by_object_name (cp);
540	if (!at_spell || at_spell->clone.type != SPELL)	582	if (!at_spell || at_spell->type != SPELL)
541	{	583	{
542	strcpy (spell_name, cp);	584	assign (spell_name, cp);
543	fsp = strchr (spell_name, ' ');	585	fsp = strchr (spell_name, ' ');
544	if (fsp)	586	if (fsp)
545	{	587	{
546	*fsp = 0;	588	*fsp = 0;
547	fsp++;	589	fsp++;
548	at_spell = archetype::find (spell_name);	590	at_spell = archetype::find (spell_name);
549		591
550	/* Got a spell, update the first string pointer */	592	/* Got a spell, update the first string pointer */
551	if (at_spell && at_spell->clone.type == SPELL)	593	if (at_spell && at_spell->type == SPELL)
552	bp2 = cp + strlen (spell_name) + 1;	594	bp2 = cp + strlen (spell_name) + 1;
553	else	595	else
554	at_spell = NULL;	596	at_spell = NULL;
555	}	597	}
556	}	598	}
…		…
558	/* OK - we didn't find a spell - presume the 'of'	600	/* OK - we didn't find a spell - presume the 'of'
559	* in this case means its an artifact.	601	* in this case means its an artifact.
560	*/	602	*/
561	if (!at_spell)	603	if (!at_spell)
562	{	604	{
563	if (find_artifactlist (at->clone.type) == NULL)	605	if (find_artifactlist (at->type) == NULL)
564	new_draw_info_format (NDI_UNIQUE, 0, op, "No artifact list for type %d\n", at->clone.type);	606	new_draw_info_format (NDI_UNIQUE, 0, op, "No artifact list for type %d\n", at->type);
565	else	607	else
566	{	608	{
567	art = find_artifactlist (at->clone.type)->items;	609	art = find_artifactlist (at->type)->items;
568		610
569	do	611	while (art)
570	{	612	{
571	if (!strcmp (art->item->name, cp))	613	if (!strcmp (&art->item->name, cp))
572	break;	614	break;
		615
573	art = art->next;	616	art = art->next;
574	}	617	}
575	while (art != NULL);
576		618
577	if (!art)	619	if (!art)
578	new_draw_info_format (NDI_UNIQUE, 0, op, "No such artifact ([%d] of %s)", at->clone.type, cp);	620	new_draw_info_format (NDI_UNIQUE, 0, op, "No such artifact ([%d] of %s)", at->type, cp);
579	}	621	}
580		622
581	LOG (llevDebug, "%s creates: (%d) (%d) (%s) of (%s)\n", &op->name, set_nrof ? nrof : 0, set_magic ? magic : 0, bp, cp);	623	LOG (llevDebug, "%s creates: (%d) (%d) (%s) of (%s)\n", &op->name, set_nrof ? nrof : 0, set_magic ? magic : 0, bp, cp);
582	}	624	}
583	} /* if cp */	625	} /* if cp */
584		626
585	if ((at->clone.type == ROD || at->clone.type == WAND || at->clone.type == SCROLL ||	627	if ((at->type == ROD || at->type == WAND || at->type == SCROLL ||
586	at->clone.type == HORN || at->clone.type == SPELLBOOK) && !at_spell)	628	at->type == HORN || at->type == SPELLBOOK) && !at_spell)
587	{	629	{
588	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	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);
589	return 1;	631	return 1;
590	}	632	}
591		633
592	/*	634	/*
593	* Rather than have two different blocks with a lot of similar code,	635	* Rather than have two different blocks with a lot of similar code,
594	* just create one object, do all the processing, and then determine	636	* just create one object, do all the processing, and then determine
595	* if that one object should be inserted or if we need to make copies.	637	* if that one object should be inserted or if we need to make copies.
596	*/	638	*/
597	tmp = arch_to_object (at);	639	tmp = at->instance ();
598
599	if (settings.real_wiz == FALSE)
600	SET_FLAG (tmp, FLAG_WAS_WIZ);
601		640
602	if (set_magic)	641	if (set_magic)
603	set_abs_magic (tmp, magic);	642	set_abs_magic (tmp, magic);
604		643
605	if (art)	644	if (art)
606	give_artifact_abilities (tmp, art->item);	645	give_artifact_abilities (tmp, art->item);
607		646
608	if (need_identify (tmp))	647	if (tmp->need_identify ())
609	{	648	{
610	SET_FLAG (tmp, FLAG_IDENTIFIED);	649	tmp->set_flag (FLAG_IDENTIFIED);
611	CLEAR_FLAG (tmp, FLAG_KNOWN_MAGICAL);	650	tmp->clr_flag (FLAG_KNOWN_MAGICAL);
612	}	651	}
613		652
614	/*	653	/*
615	* This entire block here tries to find variable pairings,	654	* This entire block here tries to find variable pairings,
616	* eg, 'hp 4' or the like. The mess here is that values	655	* eg, 'hp 4' or the like. The mess here is that values
…		…
685	new_draw_info_format (NDI_UNIQUE, 0, op, "(%s#%d)->%s", &tmp->name, tmp->count, bp2);	724	new_draw_info_format (NDI_UNIQUE, 0, op, "(%s#%d)->%s", &tmp->name, tmp->count, bp2);
686		725
687	bp2 = bp3 + 1;	726	bp2 = bp3 + 1;
688	}	727	}
689		728
690	if (at->clone.nrof)	729	if (at->nrof)
691	{	730	{
692	if (at_spell)	731	if (at_spell)
693	insert_ob_in_ob (arch_to_object (at_spell), tmp);	732	tmp->insert (at_spell->instance ());
694		733
695	tmp->x = op->x;	734	tmp->x = op->x;
696	tmp->y = op->y;	735	tmp->y = op->y;
		736	tmp->map = op->map;
697		737
698	if (set_nrof)	738	if (set_nrof)
699	tmp->nrof = nrof;	739	tmp->nrof = nrof;
700		740
701	tmp->map = op->map;	741	op->insert (tmp);
702
703	tmp = insert_ob_in_ob (tmp, op);
704	esrv_send_item (op, tmp);
705		742
706	/* Let's put this created item on stack so dm can access it easily. */	743	/* Let's put this created item on stack so dm can access it easily. */
707	dm_stack_push (op->contr, tmp->count);	744	dm_stack_push (op->contr, tmp->count);
708		745
709	return 1;	746	return 1;
710	}	747	}
711	else	748	else
712	{	749	{
713	for (i = 0; i < (set_nrof ? nrof : 1); i++)	750	for (i = 0; i < (set_nrof ? nrof : 1); i++)
714	{	751	{
715	archetype *atmp;
716	object *prev = 0, *head = 0;	752	object *prev = 0, *head = 0;
717		753
718	for (atmp = at; atmp; atmp = atmp->more)	754	for (archetype *atmp = at; atmp; atmp = (archetype *)atmp->more)
719	{	755	{
720	object *dup = arch_to_object (atmp);	756	object *dup = atmp->instance ();
721		757
722	if (at_spell)	758	if (at_spell)
723	insert_ob_in_ob (arch_to_object (at_spell), dup);	759	insert_ob_in_ob (at_spell->instance (), dup);
724		760
725	/*	761	/*
726	* The head is what contains all the important bits,	762	* The head is what contains all the important bits,
727	* so just copying it over should be fine.	763	* so just copying it over should be fine.
728	*/	764	*/
…		…
730	{	766	{
731	head = dup;	767	head = dup;
732	tmp->copy_to (dup);	768	tmp->copy_to (dup);
733	}	769	}
734		770
735	if (settings.real_wiz == FALSE)
736	SET_FLAG (dup, FLAG_WAS_WIZ);
737
738	dup->x = op->x + dup->arch->clone.x;	771	dup->x = op->x + dup->arch->x;
739	dup->y = op->y + dup->arch->clone.y;	772	dup->y = op->y + dup->arch->y;
740	dup->map = op->map;	773	dup->map = op->map;
741		774
742	if (head != dup)	775	if (head != dup)
743	{	776	{
744	dup->head = head;	777	dup->head = head;
…		…
746	}	779	}
747		780
748	prev = dup;	781	prev = dup;
749	}	782	}
750		783
751	if (QUERY_FLAG (head, FLAG_ALIVE))	784	if (head->flag [FLAG_ALIVE])
752	{	785	{
753	object *check = head;	786	object *check = head;
754	int size_x = 0;	787	int size_x = 0;
755	int size_y = 0;	788	int size_y = 0;
756		789
757	while (check)	790	while (check)
758	{	791	{
759	size_x = MAX (size_x, check->arch->clone.x);	792	size_x = max (size_x, check->arch->x);
760	size_y = MAX (size_y, check->arch->clone.y);	793	size_y = max (size_y, check->arch->y);
761	check = check->more;	794	check = check->more;
762	}	795	}
763		796
764	if (out_of_map (op->map, head->x + size_x, head->y + size_y))	797	if (out_of_map (op->map, head->x + size_x, head->y + size_y))
765	{	798	{
…		…
791	/* Wonder if we really want to push all of these, but since	824	/* Wonder if we really want to push all of these, but since
792	* things like rods have nrof 0, we want to cover those.	825	* things like rods have nrof 0, we want to cover those.
793	*/	826	*/
794	dm_stack_push (op->contr, head->count);	827	dm_stack_push (op->contr, head->count);
795		828
796	if (at->clone.randomitems != NULL && !at_spell)	829	if (at->randomitems && !at_spell)
797	create_treasure (at->clone.randomitems, head, GT_APPLY, op->map->difficulty, 0);	830	create_treasure (at->randomitems, head, GT_APPLY, op->map->difficulty, 0);
798
799	esrv_send_item (op, head);
800	}	831	}
801		832
802	/* free the one we used to copy */	833	/* free the one we used to copy */
803	tmp->destroy ();	834	tmp->destroy ();
804	}	835	}
…		…
811	*/	842	*/
812		843
813	int	844	int
814	command_inventory (object *op, char *params)	845	command_inventory (object *op, char *params)
815	{	846	{
		847	int i;
816	object *tmp;	848	object *tmp;
817	int i;
818		849
819	if (!params)	850	if (!params || !sscanf (params, "%d", &i) || !(tmp = find_object (i)))
820	{	851	{
821	inventory (op, NULL);	852	op->contr->failmsg ("Inventory of what object (nr)?");
822	return 0;	853	return 1;
823	}
824
825	if (!sscanf (params, "%d", &i) || (tmp = find_object (i)) == NULL)
826	{	854	}
827	new_draw_info (NDI_UNIQUE, 0, op, "Inventory of what object (nr)?");
828	return 1;
829	}
830		855
831	inventory (op, tmp);	856	op->contr->infobox (MSG_CHANNEL ("examine"), tmp->query_inventory (op));
		857
832	return 1;	858	return 1;
833	}	859	}
834		860
835	/* just show player's their skills for now. Dm's can	861	/* just show player's their skills for now. Dm's can
836	* already see skills w/ inventory command - b.t.	862	* already see skills w/ inventory command - b.t.
…		…
854		880
855	char *dump = dump_object (tmp);	881	char *dump = dump_object (tmp);
856	new_draw_info (NDI_UNIQUE, 0, op, dump);	882	new_draw_info (NDI_UNIQUE, 0, op, dump);
857	free (dump);	883	free (dump);
858		884
859	if (QUERY_FLAG (tmp, FLAG_OBJ_ORIGINAL))	885	if (tmp->flag [FLAG_OBJ_ORIGINAL])
860	new_draw_info (NDI_UNIQUE, 0, op, "Object is marked original");	886	new_draw_info (NDI_UNIQUE, 0, op, "Object is marked original");
861		887
862	return 1;
863	}
864
865	/**
866	* When DM is possessing a monster, flip aggression on and off, to allow
867	* better motion.
868	*/
869	int
870	command_mon_aggr (object *op, char *params)
871	{
872	if (op->enemy || !QUERY_FLAG (op, FLAG_UNAGGRESSIVE))
873	{
874	op->enemy = NULL;
875	SET_FLAG (op, FLAG_UNAGGRESSIVE);
876	new_draw_info (NDI_UNIQUE, 0, op, "Aggression turned OFF");
877	}
878	else
879	{
880	CLEAR_FLAG (op, FLAG_FRIENDLY);
881	CLEAR_FLAG (op, FLAG_UNAGGRESSIVE);
882	new_draw_info (NDI_UNIQUE, 0, op, "Aggression turned ON");
883	}
884
885	return 1;
886	}
887
888	/** DM can possess a monster. Basically, this tricks the client into thinking
889	* a given monster, is actually the player it controls. This allows a DM
890	* to inhabit a monster's body, and run around the game with it.
891	* This function is severely broken - it has tons of hardcoded values,
892	*/
893	int
894	command_possess (object *op, char *params)
895	{
896	object *victim, *curinv, *nextinv;
897	player *pl;
898	int i;
899	char buf[MAX_BUF];
900
901	victim = NULL;
902	if (params != NULL)
903	{
904	if (sscanf (params, "%d", &i))
905	victim = find_object (i);
906	else if (sscanf (params, "%s", buf))
907	victim = find_object_name (buf);
908	}
909	if (victim == NULL)
910	{
911	new_draw_info (NDI_UNIQUE, 0, op, "Patch what object (nr)?");
912	return 1;
913	}
914
915	if (victim == op)
916	{
917	new_draw_info (NDI_UNIQUE, 0, op, "As insane as you are, I cannot " "allow you to possess yourself.");
918	return 1;
919	}
920
921	/* clear out the old inventory */
922	curinv = op->inv;
923	while (curinv != NULL)
924	{
925	nextinv = curinv->below;
926	esrv_del_item (op->contr, curinv->count);
927	curinv = nextinv;
928	}
929
930	/* make the switch */
931	pl = op->contr;
932	victim->contr = pl;
933	pl->ob = victim;
934	victim->type = PLAYER;
935	SET_FLAG (victim, FLAG_WIZ);
936
937	/* send the inventory to the client */
938	curinv = victim->inv;
939	while (curinv != NULL)
940	{
941	nextinv = curinv->below;
942	esrv_send_item (victim, curinv);
943	curinv = nextinv;
944	}
945	/* basic patchup */
946	/* The use of hard coded values is terrible. Note
947	* that really, to be fair, this shouldn't get changed at
948	* all - if you are possessing a kobold, you should have the
949	* same limitations. As it is, as more body locations are added,
950	* this will give this player more locations than perhaps
951	* they should be allowed.
952	*/
953	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
954	if (i == 1 || i == 6 || i == 8 || i == 9)
955	victim->body_info[i] = 2;
956	else
957	victim->body_info[i] = 1;
958
959	esrv_new_player (pl, 80); /* just pick a wieght, we don't care */
960	esrv_send_inventory (victim, victim);
961
962	victim->update_stats ();
963
964	do_some_living (victim);
965	return 1;	888	return 1;
966	}	889	}
967		890
968	int	891	int
969	command_patch (object *op, char *params)	892	command_patch (object *op, char *params)
…		…
984	return 1;	907	return 1;
985	}	908	}
986		909
987	if ((arg2 = strchr (arg, ' ')))	910	if ((arg2 = strchr (arg, ' ')))
988	arg2++;	911	arg2++;
989	if (settings.real_wiz == FALSE)	912
990	SET_FLAG (tmp, FLAG_WAS_WIZ); /* To avoid cheating */
991	if (set_variable (tmp, arg) == -1)	913	if (set_variable (tmp, arg) == -1)
992	new_draw_info_format (NDI_UNIQUE, 0, op, "Unknown variable %s", arg);	914	new_draw_info_format (NDI_UNIQUE, 0, op, "Unknown variable %s", arg);
993	else	915	else
994	{
995	new_draw_info_format (NDI_UNIQUE, 0, op, "(%s#%d)->%s=%s", &tmp->name, tmp->count, arg, arg2);	916	new_draw_info_format (NDI_UNIQUE, 0, op, "(%s#%d)->%s=%s", &tmp->name, tmp->count, arg, arg2);
996	}
997		917
998	return 1;	918	return 1;
999	}	919	}
1000		920
1001	int	921	int
…		…
1015	{	935	{
1016	new_draw_info (NDI_UNIQUE, 0, op, "Unable to remove a player!");	936	new_draw_info (NDI_UNIQUE, 0, op, "Unable to remove a player!");
1017	return 1;	937	return 1;
1018	}	938	}
1019		939
1020	if (QUERY_FLAG (tmp, FLAG_REMOVED))	940	if (tmp->flag [FLAG_REMOVED])
1021	{	941	{
1022	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is already removed!", query_name (tmp));	942	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is already removed!", query_name (tmp));
1023	return 1;	943	return 1;
1024	}	944	}
1025		945
…		…
1050		970
1051	if (from != STACK_FROM_STACK)	971	if (from != STACK_FROM_STACK)
1052	/* Item is either stack top, or is a number thus is now stack top, let's remove it */	972	/* Item is either stack top, or is a number thus is now stack top, let's remove it */
1053	dm_stack_pop (op->contr);	973	dm_stack_pop (op->contr);
1054		974
1055	if (!QUERY_FLAG (tmp, FLAG_REMOVED))
1056	{
1057	new_draw_info (NDI_UNIQUE, 0, op, "Warning, item wasn't removed.");
1058	tmp->remove ();
1059	}
1060
1061	if (tmp->head)	975	if (tmp->head)
1062	tmp = tmp->head;	976	tmp = tmp->head;
1063		977
1064	tmp->destroy ();	978	tmp->destroy ();
1065	return 1;	979	return 1;
…		…
1070	*/	984	*/
1071	int	985	int
1072	command_addexp (object *op, char *params)	986	command_addexp (object *op, char *params)
1073	{	987	{
1074	char buf[MAX_BUF], skill[MAX_BUF];	988	char buf[MAX_BUF], skill[MAX_BUF];
1075	int i, q;	989	int q;
		990	long long i; // use sint64 and finally provide format specifiers for sint64 etc. via configure
1076	object *skillob = NULL;	991	object *skillob = NULL;
1077		992
1078	skill[0] = '\0';	993	skill[0] = '\0';
1079	if ((params == NULL) || (strlen (params) > MAX_BUF) || ((q = sscanf (params, "%s %d %s", buf, &i, skill)) < 2))	994	if ((params == NULL) || (strlen (params) > MAX_BUF) || ((q = sscanf (params, "%s %lld %[^\n]", buf, &i, skill)) < 2))
1080	{	995	{
1081	new_draw_info (NDI_UNIQUE, 0, op, "Usage: addexp <who> <how much> [<skill>].");	996	new_draw_info (NDI_UNIQUE, 0, op, "Usage: addexp <who> <how much> [<skill>].");
1082	return 1;	997	return 1;
1083	}	998	}
1084		999
…		…
1102		1017
1103	pl->ob->stats.exp += i;	1018	pl->ob->stats.exp += i;
1104	calc_perm_exp (pl->ob);	1019	calc_perm_exp (pl->ob);
1105	player_lvl_adj (pl->ob, NULL);	1020	player_lvl_adj (pl->ob, NULL);
1106		1021
1107	if (settings.real_wiz == FALSE)
1108	SET_FLAG (pl->ob, FLAG_WAS_WIZ);
1109
1110	return 1;	1022	return 1;
1111	}	1023	}
1112		1024
1113	new_draw_info (NDI_UNIQUE, 0, op, "No such player.");	1025	new_draw_info (NDI_UNIQUE, 0, op, "No such player.");
1114	return 1;	1026	return 1;
…		…
1134	new_draw_info (NDI_UNIQUE, 0, op, "Who?");	1046	new_draw_info (NDI_UNIQUE, 0, op, "Who?");
1135	return 1;	1047	return 1;
1136	}	1048	}
1137		1049
1138	for_all_players (pl)	1050	for_all_players (pl)
1139	if (!strcmp (pl->ob->name, thing))	1051	if (!strcmp (&pl->ob->name, thing))
1140	{	1052	{
1141	sprintf (buf, "Str : %-2d H.P. : %-4d MAX : %d", pl->ob->stats.Str, pl->ob->stats.hp, pl->ob->stats.maxhp);	1053	sprintf (buf, "Str : %-2d H.P. : %-4d MAX : %d", pl->ob->stats.Str, pl->ob->stats.hp, pl->ob->stats.maxhp);
1142	new_draw_info (NDI_UNIQUE, 0, op, buf);	1054	new_draw_info (NDI_UNIQUE, 0, op, buf);
1143	sprintf (buf, "Dex : %-2d S.P. : %-4d MAX : %d", pl->ob->stats.Dex, pl->ob->stats.sp, pl->ob->stats.maxsp);	1055	sprintf (buf, "Dex : %-2d S.P. : %-4d MAX : %d", pl->ob->stats.Dex, pl->ob->stats.sp, pl->ob->stats.maxsp);
1144	new_draw_info (NDI_UNIQUE, 0, op, buf);	1056	new_draw_info (NDI_UNIQUE, 0, op, buf);
…		…
1162	int	1074	int
1163	command_abil (object *op, char *params)	1075	command_abil (object *op, char *params)
1164	{	1076	{
1165	char thing[20], thing2[20];	1077	char thing[20], thing2[20];
1166	int iii;	1078	int iii;
1167	player *pl;
1168	char buf[MAX_BUF];	1079	char buf[MAX_BUF];
1169		1080
1170	iii = 0;	1081	iii = 0;
1171	thing[0] = '\0';	1082	thing[0] = '\0';
1172	thing2[0] = '\0';	1083	thing2[0] = '\0';
…		…
1188	return 1;	1099	return 1;
1189	}	1100	}
1190		1101
1191	for_all_players (pl)	1102	for_all_players (pl)
1192	{	1103	{
1193	if (!strcmp (pl->ob->name, thing))	1104	if (!strcmp (&pl->ob->name, thing))
1194	{	1105	{
1195	if (settings.real_wiz == FALSE)
1196	SET_FLAG (pl->ob, FLAG_WAS_WIZ);
1197	if (!strcmp ("str", thing2))
1198	pl->ob->stats.Str = iii, pl->orig_stats.Str = iii;	1106	if (!strcmp ("str", thing2)) pl->ob->stats.Str = iii, pl->orig_stats.Str = iii;
1199	if (!strcmp ("dex", thing2))
1200	pl->ob->stats.Dex = iii, pl->orig_stats.Dex = iii;	1107	if (!strcmp ("dex", thing2)) pl->ob->stats.Dex = iii, pl->orig_stats.Dex = iii;
1201	if (!strcmp ("con", thing2))
1202	pl->ob->stats.Con = iii, pl->orig_stats.Con = iii;	1108	if (!strcmp ("con", thing2)) pl->ob->stats.Con = iii, pl->orig_stats.Con = iii;
1203	if (!strcmp ("wis", thing2))
1204	pl->ob->stats.Wis = iii, pl->orig_stats.Wis = iii;	1109	if (!strcmp ("wis", thing2)) pl->ob->stats.Wis = iii, pl->orig_stats.Wis = iii;
1205	if (!strcmp ("cha", thing2))
1206	pl->ob->stats.Cha = iii, pl->orig_stats.Cha = iii;	1110	if (!strcmp ("cha", thing2)) pl->ob->stats.Cha = iii, pl->orig_stats.Cha = iii;
1207	if (!strcmp ("int", thing2))
1208	pl->ob->stats.Int = iii, pl->orig_stats.Int = iii;	1111	if (!strcmp ("int", thing2)) pl->ob->stats.Int = iii, pl->orig_stats.Int = iii;
1209	if (!strcmp ("pow", thing2))
1210	pl->ob->stats.Pow = iii, pl->orig_stats.Pow = iii;	1112	if (!strcmp ("pow", thing2)) pl->ob->stats.Pow = iii, pl->orig_stats.Pow = iii;
		1113
1211	sprintf (buf, "%s has been altered.", &pl->ob->name);	1114	sprintf (buf, "%s has been altered.", &pl->ob->name);
1212	new_draw_info (NDI_UNIQUE, 0, op, buf);	1115	new_draw_info (NDI_UNIQUE, 0, op, buf);
1213	pl->ob->update_stats ();	1116	pl->ob->update_stats ();
1214	return 1;	1117	return 1;
1215	}	1118	}
…		…
1219	return 1;	1122	return 1;
1220	}	1123	}
1221		1124
1222	int	1125	int
1223	command_nowiz (object *op, char *params)	1126	command_nowiz (object *op, char *params)
1224	{ /* 'noadm' is alias */	1127	{ /* 'nodm' is alias */
1225	CLEAR_FLAG (op, FLAG_WIZ);	1128	op->clr_flag (FLAG_WIZ);
1226	CLEAR_FLAG (op, FLAG_WIZPASS);	1129	op->clr_flag (FLAG_WIZPASS);
1227	CLEAR_FLAG (op, FLAG_WIZCAST);	1130	op->clr_flag (FLAG_WIZCAST);
		1131	op->clr_flag (FLAG_WIZLOOK);
		1132	op->contr->do_los = 1;
1228		1133
1229	if (settings.real_wiz == TRUE)
1230	CLEAR_FLAG (op, FLAG_WAS_WIZ);
1231	if (op->contr->hidden)	1134	if (op->contr->hidden)
1232	{	1135	{
1233	new_draw_info (NDI_UNIQUE, 0, op, "You are no longer hidden from other players");	1136	new_draw_info (NDI_UNIQUE, 0, op, "You are no longer hidden from other players");
1234	op->map->players++;	1137	op->map->players++;
1235	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s has entered the game.", &op->name);	1138	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s has entered the game.", &op->name);
1236	op->contr->hidden = 0;	1139	op->contr->hidden = 0;
1237	op->invisible = 1;	1140	op->invisible = 1;
1238	}	1141	}
1239	else	1142	else
1240	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master is gone..");	1143	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master is gone..");
		1144
1241	return 1;	1145	return 1;
1242	}	1146	}
1243		1147
1244	/**	1148	/**
1245	* object *op is trying to become dm.	1149	* object *op is trying to become dm.
…		…
1282	}	1186	}
1283	fclose (dmfile);	1187	fclose (dmfile);
1284	return (0);	1188	return (0);
1285	}	1189	}
1286		1190
1287	int	1191	static int
1288	do_wizard_dm (object *op, char *params, int silent)	1192	do_wizard_dm (object *op, char *params, int silent)
1289	{	1193	{
1290	if (!op->contr)	1194	if (!op->contr)
1291	return 0;	1195	return 0;
1292		1196
1293	if (QUERY_FLAG (op, FLAG_WIZ))	1197	if (op->flag [FLAG_WIZ])
1294	{	1198	{
1295	new_draw_info (NDI_UNIQUE, 0, op, "You are already the Dungeon Master!");	1199	new_draw_info (NDI_UNIQUE, 0, op, "You are already the Dungeon Master!");
1296	return 0;	1200	return 0;
1297	}	1201	}
1298		1202
1299	if (checkdm (op, op->name, (params ? params : "*"), op->contr->ns->host))	1203	if (checkdm (op, op->name, (params ? params : "*"), op->contr->ns->host))
1300	{	1204	{
1301	SET_FLAG (op, FLAG_WIZ);	1205	op->set_flag (FLAG_WIZ);
1302	SET_FLAG (op, FLAG_WAS_WIZ);	1206	op->set_flag (FLAG_WIZPASS);
1303	SET_FLAG (op, FLAG_WIZPASS);	1207	op->set_flag (FLAG_WIZCAST);
1304	SET_FLAG (op, FLAG_WIZCAST);	1208	op->set_flag (FLAG_WIZLOOK);
		1209	op->contr->do_los = 1;
		1210
1305	new_draw_info (NDI_UNIQUE, 0, op, "Ok, you are the Dungeon Master!");	1211	new_draw_info (NDI_UNIQUE, 0, op, "Ok, you are the Dungeon Master!");
1306	/*
1307	* Remove setting flying here - that won't work, because next
1308	* fix_player() is called that will get cleared - proper solution
1309	* is probably something like a wiz_force which gives that and any
1310	* other desired abilities.
1311	*/
1312	clear_los (op);
1313	op->contr->write_buf[0] = '\0';	1212	op->contr->write_buf[0] = '\0';
1314		1213
1315	if (!silent)	1214	if (!silent)
1316	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master has arrived!");	1215	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_LT_GREEN, 1, NULL, "The Dungeon Master has arrived!");
1317		1216
…		…
1344	command_invisible (object *op, char *params)	1243	command_invisible (object *op, char *params)
1345	{	1244	{
1346	if (op)	1245	if (op)
1347	{	1246	{
1348	op->invisible += 100;	1247	op->invisible += 100;
1349	update_object (op, UP_OBJ_FACE);	1248	update_object (op, UP_OBJ_CHANGE);
1350	new_draw_info (NDI_UNIQUE, 0, op, "You turn invisible.");	1249	new_draw_info (NDI_UNIQUE, 0, op, "You turn invisible.");
1351	}	1250	}
1352		1251
1353	return 0;	1252	return 0;
1354	}	1253	}
…		…
1357	* Returns spell object (from archetypes) by name.	1256	* Returns spell object (from archetypes) by name.
1358	* Returns NULL if 0 or more than one spell matches.	1257	* Returns NULL if 0 or more than one spell matches.
1359	* Used for wizard's learn spell/prayer.	1258	* Used for wizard's learn spell/prayer.
1360	*	1259	*
1361	* op is the player issuing the command.	1260	* op is the player issuing the command.
1362	*
1363	* Ignores archetypes "spelldirect_xxx" since these archetypes are not used
1364	* anymore (but may still be present in some player's inventories and thus
1365	* cannot be removed). We have to ignore them here since they have the same
1366	* name than other "spell_xxx" archetypes and would always conflict.
1367	*/	1261	*/
1368	static object *	1262	static object *
1369	get_spell_by_name (object *op, const char *spell_name)	1263	get_spell_by_name (object *op, shstr_cmp spell_name)
1370	{	1264	{
1371	archetype *ar;
1372	archetype *found;
1373	int conflict_found;
1374	size_t spell_name_length;
1375
1376	/* First check for full name matches. */	1265	/* First check for full name matches. */
1377	conflict_found = 0;	1266	int conflict_found = 0;
1378	found = NULL;	1267	archetype *found = 0;
1379	for (ar = first_archetype; ar != NULL; ar = ar->next)	1268
		1269	for_all_archetypes (at)
1380	{	1270	{
1381	if (ar->clone.type != SPELL)	1271	if (at->type != SPELL)
1382	continue;	1272	continue;
1383		1273
1384	if (strncmp (ar->name, "spelldirect_", 12) == 0)	1274	if (at->object::name != spell_name)
1385	continue;	1275	continue;
1386		1276
1387	if (strcmp (ar->clone.name, spell_name) != 0)
1388	continue;
1389
1390	if (found != NULL)	1277	if (found)
1391	{	1278	{
1392	if (!conflict_found)	1279	if (!conflict_found)
1393	{	1280	{
1394	conflict_found = 1;	1281	conflict_found = 1;
1395	new_draw_info_format (NDI_UNIQUE, 0, op, "More than one archetype matches the spell name %s:", spell_name);	1282	new_draw_info_format (NDI_UNIQUE, 0, op, "More than one archetype matches the spell name %s:", &spell_name);
1396	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &found->name);	1283	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &found->archname);
1397	}	1284	}
		1285
1398	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &ar->name);	1286	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &at->archname);
1399	continue;	1287	return 0;
1400	}	1288	}
1401		1289
1402	found = ar;	1290	found = at;
1403	}	1291	}
1404
1405	/* No match if more more than one archetype matches. */
1406	if (conflict_found)
1407	return NULL;
1408		1292
1409	/* Return if exactly one archetype matches. */	1293	/* Return if exactly one archetype matches. */
1410	if (found != NULL)	1294	if (found)
1411	return arch_to_object (found);	1295	return found->instance ();
1412
1413	/* No full match found: now check for partial matches. */
1414	spell_name_length = strlen (spell_name);
1415	conflict_found = 0;
1416	found = NULL;
1417	for (ar = first_archetype; ar != NULL; ar = ar->next)
1418	{
1419	if (ar->clone.type != SPELL)
1420	continue;
1421
1422	if (strncmp (ar->name, "spelldirect_", 12) == 0)
1423	continue;
1424
1425	if (strncmp (ar->clone.name, spell_name, spell_name_length) != 0)
1426	continue;
1427
1428	if (found != NULL)
1429	{
1430	if (!conflict_found)
1431	{
1432	conflict_found = 1;
1433	new_draw_info_format (NDI_UNIQUE, 0, op, "More than one spell matches %s:", spell_name);
1434	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &found->clone.name);
1435	}
1436	new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &ar->clone.name);
1437	continue;
1438	}
1439
1440	found = ar;
1441	}
1442
1443	/* No match if more more than one archetype matches. */
1444	if (conflict_found)
1445	return NULL;
1446
1447	/* Return if exactly one archetype matches. */
1448	if (found != NULL)
1449	return arch_to_object (found);
1450		1296
1451	/* No spell found: just print an error message. */	1297	/* No spell found: just print an error message. */
1452	new_draw_info_format (NDI_UNIQUE, 0, op, "The spell %s does not exist.", spell_name);	1298	new_draw_info_format (NDI_UNIQUE, 0, op, "The spell does not exist.");
		1299
1453	return NULL;	1300	return 0;
1454	}	1301	}
1455		1302
1456	static int	1303	static int
1457	command_learn_spell_or_prayer (object *op, char *params, int special_prayer)	1304	command_learn_spell_or_prayer (object *op, char *params, int special_prayer)
1458	{	1305	{
…		…
1510	new_draw_info_format (NDI_UNIQUE, 0, op, "You do not know the spell %s.", params);	1357	new_draw_info_format (NDI_UNIQUE, 0, op, "You do not know the spell %s.", params);
1511	return 0;	1358	return 0;
1512	}	1359	}
1513		1360
1514	do_forget_spell (op, spell->name);	1361	do_forget_spell (op, spell->name);
1515	return 1;
1516	}
1517
1518	/**
1519	* Lists all plugins currently loaded with their IDs and full names.
1520	*/
1521	int
1522	command_listplugins (object *op, char *params)
1523	{
1524	plugins_display_list (op);
1525	return 1;
1526	}
1527
1528	/**
1529	* Loads the given plugin. The DM specifies the name of the library to load (no
1530	* pathname is needed). Do not ever attempt to load the same plugin more than
1531	* once at a time, or bad things could happen.
1532	*/
1533	int
1534	command_loadplugin (object *op, char *params)
1535	{
1536	char buf[MAX_BUF];
1537
1538	if (params == NULL)
1539	{
1540	new_draw_info (NDI_UNIQUE, 0, op, "Load which plugin?");
1541	return 1;
1542	}
1543
1544	strcpy (buf, LIBDIR);
1545	strcat (buf, "/plugins/");
1546	strcat (buf, params);
1547	LOG (llevDebug, "Requested plugin file is %s\n", buf);
1548	if (plugins_init_plugin (buf) == 0)
1549	new_draw_info (NDI_UNIQUE, 0, op, "Plugin successfully loaded.");
1550	else
1551	new_draw_info (NDI_UNIQUE, 0, op, "Could not load plugin.");
1552	return 1;
1553	}
1554
1555	/**
1556	* Unloads the given plugin. The DM specified the ID of the library to unload.
1557	* Note that some things may behave strangely if the correct plugins are not
1558	* loaded.
1559	*/
1560	int
1561	command_unloadplugin (object *op, char *params)
1562	{
1563	if (params == NULL)
1564	{
1565	new_draw_info (NDI_UNIQUE, 0, op, "Remove which plugin?");
1566	return 1;
1567	}
1568
1569	if (plugins_remove_plugin (params) == 0)
1570	new_draw_info (NDI_UNIQUE, 0, op, "Plugin successfully removed.");
1571	else
1572	new_draw_info (NDI_UNIQUE, 0, op, "Could not remove plugin.");
1573	return 1;	1362	return 1;
1574	}	1363	}
1575		1364
1576	/**	1365	/**
1577	* A players wants to become DM and hide.	1366	* A players wants to become DM and hide.
…		…
1585	return 0;	1374	return 0;
1586		1375
1587	do_wizard_hide (op, 1);	1376	do_wizard_hide (op, 1);
1588		1377
1589	return 1;	1378	return 1;
1590	}
1591
1592	void
1593	dm_stack_pop (player *pl)
1594	{
1595	if (!pl->stack_items || !pl->stack_position)
1596	{
1597	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
1598	return;
1599	}
1600
1601	pl->stack_position--;
1602	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Popped item from stack, %d left.", pl->stack_position);
1603	}
1604
1605	/**
1606	* Get current stack top item for player.
1607	* Returns NULL if no stacked item.
1608	* If stacked item disappeared (freed), remove it.
1609	*
1610	* Ryo, august 2004
1611	*/
1612	object *
1613	dm_stack_peek (player *pl)
1614	{
1615	object *ob;
1616
1617	if (!pl->stack_position)
1618	{
1619	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
1620	return NULL;
1621	}
1622
1623	ob = find_object (pl->stack_items[pl->stack_position - 1]);
1624	if (!ob)
1625	{
1626	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Stacked item was removed!");
1627	dm_stack_pop (pl);
1628	return NULL;
1629	}
1630
1631	return ob;
1632	}
1633
1634	/**
1635	* Push specified item on player stack.
1636	* Inform player of position.
1637	* Initializes variables if needed.
1638	*/
1639	void
1640	dm_stack_push (player *pl, tag_t item)
1641	{
1642	if (!pl->stack_items)
1643	{
1644	pl->stack_items = (tag_t *) malloc (sizeof (tag_t) * STACK_SIZE);
1645	memset (pl->stack_items, 0, sizeof (tag_t) * STACK_SIZE);
1646	}
1647
1648	if (pl->stack_position == STACK_SIZE)
1649	{
1650	new_draw_info (NDI_UNIQUE, 0, pl->ob, "Item stack full!");
1651	return;
1652	}
1653
1654	pl->stack_items[pl->stack_position] = item;
1655	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Item stacked as %d.", pl->stack_position);
1656	pl->stack_position++;
1657	}
1658
1659	/**
1660	* Checks 'params' for object code.
1661	*
1662	* Can be:
1663	* * empty => get current object stack top for player
1664	* * number => get item with that tag, stack it for future use
1665	* * $number => get specified stack item
1666	* * "me" => player himself
1667	*
1668	* At function exit, params points to first non-object char
1669	*
1670	* 'from', if not NULL, contains at exit:
1671	* * STACK_FROM_NONE => object not found
1672	* * STACK_FROM_TOP => top item stack, may be NULL if stack was empty
1673	* * STACK_FROM_STACK => item from somewhere in the stack
1674	* * STACK_FROM_NUMBER => item by number, pushed on stack
1675	*
1676	* Ryo, august 2004
1677	*/
1678	object *
1679	get_dm_object (player *pl, char **params, int *from)
1680	{
1681	int item_tag, item_position;
1682	object *ob;
1683
1684	if (!pl)
1685	return NULL;
1686
1687	if (!params || !*params || **params == '\0')
1688	{
1689	if (from)
1690	*from = STACK_FROM_TOP;
1691	/* No parameter => get stack item */
1692	return dm_stack_peek (pl);
1693	}
1694
1695	/* Let's clean white spaces */
1696	while (**params == ' ')
1697	(*params)++;
1698
1699	/* Next case: number => item tag */
1700	if (sscanf (*params, "%d", &item_tag))
1701	{
1702	/* Move parameter to next item */
1703	while (isdigit (**params))
1704	(*params)++;
1705
1706	/* And skip blanks, too */
1707	while (**params == ' ')
1708	(*params)++;
1709
1710	/* Get item */
1711	ob = find_object (item_tag);
1712	if (!ob)
1713	{
1714	if (from)
1715	*from = STACK_FROM_NONE;
1716	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "No such item %d!", item_tag);
1717	return NULL;
1718	}
1719
1720	/* Got one, let's push it on stack */
1721	dm_stack_push (pl, item_tag);
1722	if (from)
1723	*from = STACK_FROM_NUMBER;
1724	return ob;
1725	}
1726
1727	/* Next case: $number => stack item */
1728	if (sscanf (*params, "$%d", &item_position))
1729	{
1730	/* Move parameter to next item */
1731	(*params)++;
1732
1733	while (isdigit (**params))
1734	(*params)++;
1735	while (**params == ' ')
1736	(*params)++;
1737
1738	if (item_position >= pl->stack_position)
1739	{
1740	if (from)
1741	*from = STACK_FROM_NONE;
1742	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "No such stack item %d!", item_position);
1743	return NULL;
1744	}
1745
1746	ob = find_object (pl->stack_items[item_position]);
1747	if (!ob)
1748	{
1749	if (from)
1750	*from = STACK_FROM_NONE;
1751	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Stack item %d was removed.", item_position);
1752	return NULL;
1753	}
1754
1755	if (from)
1756	*from = item_position < pl->stack_position - 1 ? STACK_FROM_STACK : STACK_FROM_TOP;
1757	return ob;
1758	}
1759
1760	/* Next case: 'me' => return pl->ob */
1761	if (!strncmp (*params, "me", 2))
1762	{
1763	if (from)
1764	*from = STACK_FROM_NUMBER;
1765	dm_stack_push (pl, pl->ob->count);
1766
1767	/* Skip to next token */
1768	(*params) += 2;
1769	while (**params == ' ')
1770	(*params)++;
1771
1772	return pl->ob;
1773	}
1774
1775	/* Last case: get stack top */
1776	if (from)
1777	*from = STACK_FROM_TOP;
1778	return dm_stack_peek (pl);
1779	}	1379	}
1780		1380
1781	/**	1381	/**
1782	* Pop the stack top.	1382	* Pop the stack top.
1783	*/	1383	*/
…		…
1843	}	1443	}
1844		1444
1845	int	1445	int
1846	command_insert_into (object *op, char *params)	1446	command_insert_into (object *op, char *params)
1847	{	1447	{
1848	object *left, *right, *inserted;	1448	object *left, *right;
1849	int left_from, right_from;	1449	int left_from, right_from;
1850		1450
1851	left = get_dm_object (op->contr, &params, &left_from);	1451	left = get_dm_object (op->contr, &params, &left_from);
1852	if (!left)	1452	if (!left)
1853	{	1453	{
…		…
1896	{	1496	{
1897	new_draw_info (NDI_UNIQUE, 0, op, "Can't insert a player into something!");	1497	new_draw_info (NDI_UNIQUE, 0, op, "Can't insert a player into something!");
1898	return 0;	1498	return 0;
1899	}	1499	}
1900		1500
1901	if (!QUERY_FLAG (right, FLAG_REMOVED))	1501	if (!right->flag [FLAG_REMOVED])
1902	right->remove ();	1502	right->remove ();
		1503
1903	inserted = insert_ob_in_ob (right, left);	1504	object *inserted = insert_ob_in_ob (right, left);
1904	if (left->type == PLAYER)
1905	if (inserted == right)
1906	esrv_send_item (left, right);
1907	else
1908	esrv_update_item (UPD_WEIGHT | UPD_NAME | UPD_NROF, left, inserted);
1909		1505
1910	new_draw_info_format (NDI_UNIQUE, 0, op, "Inserted %s in %s", query_name (inserted), query_name (left));	1506	new_draw_info_format (NDI_UNIQUE, 0, op, "Inserted %s in %s", query_name (inserted), query_name (left));
1911		1507
1912	return 0;	1508	return 0;
1913		1509

Diff Legend

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