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

Comparing deliantra/server/server/c_wiz.C (file contents):
Revision 1.2 by root, Thu Aug 24 13:13:49 2006 UTC vs.
Revision 1.13 by root, Fri Sep 15 23:31:34 2006 UTC

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

Diff Legend

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