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.1 by elmex, Sun Aug 13 17:16:04 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.1 2006/08/13 17:16:04 elmex 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}
1123
1124int command_speed(object *op, char *params) {
1125 int i;
1126
1127 if (params == NULL || !sscanf(params, "%d", &i)) {
1128 sprintf(errmsg, "Current speed is %ld", max_time);
1129 new_draw_info(NDI_UNIQUE, 0, op, errmsg);
1130 return 1;
1131 }
1132
1133 set_max_time(i);
1134 reset_sleep();
1135 new_draw_info(NDI_UNIQUE, 0, op, "The speed is changed.");
1136 return 1;
1137} 1208}
1138 1209
1139/**************************************************************************/ 1210/**************************************************************************/
1211
1140/* Mods made by Tyler Van Gorder, May 10-13, 1992. */ 1212/* Mods made by Tyler Van Gorder, May 10-13, 1992. */
1213
1141/* CSUChico : tvangod@cscihp.ecst.csuchico.edu */ 1214/* CSUChico : tvangod@cscihp.ecst.csuchico.edu */
1215
1142/**************************************************************************/ 1216/**************************************************************************/
1143 1217
1218int
1144int command_stats(object *op, char *params) { 1219command_stats (object *op, char *params)
1220{
1145 char thing[20]; 1221 char thing[20];
1146 player *pl; 1222 player *pl;
1147 char buf[MAX_BUF]; 1223 char buf[MAX_BUF];
1148 1224
1149 thing[0] = '\0'; 1225 thing[0] = '\0';
1150 if (params == NULL || !sscanf(params, "%s", thing) || thing == NULL) { 1226 if (params == NULL || !sscanf (params, "%s", thing) || thing == NULL)
1227 {
1151 new_draw_info(NDI_UNIQUE, 0, op, "Who?"); 1228 new_draw_info (NDI_UNIQUE, 0, op, "Who?");
1152 return 1; 1229 return 1;
1153 } 1230 }
1154 1231
1155 for (pl = first_player; pl != NULL; pl = pl->next) 1232 for (pl = first_player; pl != NULL; pl = pl->next)
1156 if (!strcmp(pl->ob->name, thing)) { 1233 if (!strcmp (pl->ob->name, thing))
1157 sprintf(buf, "Str : %-2d H.P. : %-4d MAX : %d", 1234 {
1158 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);
1159 new_draw_info(NDI_UNIQUE, 0, op, buf); 1236 new_draw_info (NDI_UNIQUE, 0, op, buf);
1160 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);
1161 pl->ob->stats.Dex, pl->ob->stats.sp, pl->ob->stats.maxsp);
1162 new_draw_info(NDI_UNIQUE, 0, op, buf); 1238 new_draw_info (NDI_UNIQUE, 0, op, buf);
1163 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);
1164 pl->ob->stats.Con, pl->ob->stats.ac, pl->ob->stats.wc) ;
1165 new_draw_info(NDI_UNIQUE, 0, op, buf); 1240 new_draw_info (NDI_UNIQUE, 0, op, buf);
1166 sprintf(buf, "Int : %-2d Damage : %d", 1241 sprintf (buf, "Int : %-2d Damage : %d", pl->ob->stats.Int, pl->ob->stats.dam);
1167 pl->ob->stats.Int, pl->ob->stats.dam);
1168 new_draw_info(NDI_UNIQUE, 0, op, buf); 1242 new_draw_info (NDI_UNIQUE, 0, op, buf);
1169#ifndef WIN32 1243 sprintf (buf, "Wis : %-2d EXP : %lld", pl->ob->stats.Wis, (long long) pl->ob->stats.exp);
1170 sprintf(buf, "Wis : %-2d EXP : %lld",
1171 pl->ob->stats.Wis, pl->ob->stats.exp);
1172#else
1173 sprintf(buf, "Wis : %-2d EXP : %I64d",
1174 pl->ob->stats.Wis, pl->ob->stats.exp);
1175#endif
1176 new_draw_info(NDI_UNIQUE, 0, op, buf); 1244 new_draw_info (NDI_UNIQUE, 0, op, buf);
1177 sprintf(buf, "Pow : %-2d Grace : %d", 1245 sprintf (buf, "Pow : %-2d Grace : %d", pl->ob->stats.Pow, pl->ob->stats.grace);
1178 pl->ob->stats.Pow, pl->ob->stats.grace);
1179 new_draw_info(NDI_UNIQUE, 0, op, buf); 1246 new_draw_info (NDI_UNIQUE, 0, op, buf);
1180 sprintf(buf, "Cha : %-2d Food : %d", 1247 sprintf (buf, "Cha : %-2d Food : %d", pl->ob->stats.Cha, pl->ob->stats.food);
1181 pl->ob->stats.Cha, pl->ob->stats.food);
1182 new_draw_info(NDI_UNIQUE, 0, op, buf); 1248 new_draw_info (NDI_UNIQUE, 0, op, buf);
1183 break; 1249 break;
1184 } 1250 }
1185 if (pl == NULL) 1251 if (pl == NULL)
1186 new_draw_info(NDI_UNIQUE, 0, op, "No such player.");
1187 return 1;
1188}
1189
1190int command_abil(object *op, char *params) {
1191 char thing[20], thing2[20];
1192 int iii;
1193 player *pl;
1194 char buf[MAX_BUF];
1195
1196 iii = 0;
1197 thing[0] = '\0';
1198 thing2[0] = '\0';
1199 if (params == NULL || !sscanf(params, "%s %s %d", thing, thing2, &iii) ||
1200 thing==NULL) {
1201 new_draw_info(NDI_UNIQUE, 0, op, "Who?");
1202 return 1;
1203 }
1204
1205 if (thing2 == NULL){
1206 new_draw_info(NDI_UNIQUE, 0, op, "You can't change that.");
1207 return 1;
1208 }
1209
1210 if (iii < MIN_STAT || iii > MAX_STAT) {
1211 new_draw_info(NDI_UNIQUE, 0, op, "Illegal range of stat.\n");
1212 return 1;
1213 }
1214
1215 for (pl = first_player; pl != NULL; pl = pl->next) {
1216 if (!strcmp(pl->ob->name, thing)) {
1217 if (settings.real_wiz == FALSE)
1218 SET_FLAG(pl->ob, FLAG_WAS_WIZ);
1219 if (!strcmp("str", thing2))
1220 pl->ob->stats.Str = iii, pl->orig_stats.Str = iii;
1221 if (!strcmp("dex", thing2))
1222 pl->ob->stats.Dex = iii, pl->orig_stats.Dex = iii;
1223 if (!strcmp("con", thing2))
1224 pl->ob->stats.Con = iii, pl->orig_stats.Con = iii;
1225 if (!strcmp("wis", thing2))
1226 pl->ob->stats.Wis = iii, pl->orig_stats.Wis = iii;
1227 if (!strcmp("cha", thing2))
1228 pl->ob->stats.Cha = iii, pl->orig_stats.Cha = iii;
1229 if (!strcmp("int", thing2))
1230 pl->ob->stats.Int = iii, pl->orig_stats.Int = iii;
1231 if (!strcmp("pow", thing2))
1232 pl->ob->stats.Pow = iii, pl->orig_stats.Pow = iii;
1233 sprintf(buf, "%s has been altered.", pl->ob->name);
1234 new_draw_info(NDI_UNIQUE, 0, op, buf);
1235 fix_player(pl->ob);
1236 return 1;
1237 }
1238 }
1239
1240 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?");
1241 return 1; 1270 return 1;
1242} 1271 }
1243 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
1244int command_reset (object *op, char *params) { 1317command_reset (object *op, char *params)
1318{
1245 mapstruct *m; 1319 mapstruct *m;
1246 object *dummy = NULL, *tmp = NULL; 1320 object *dummy = NULL, *tmp = NULL;
1247 1321
1248 if (params == NULL) { 1322 if (params == NULL)
1323 {
1249 new_draw_info(NDI_UNIQUE, 0, op, "Reset what map [name]?"); 1324 new_draw_info (NDI_UNIQUE, 0, op, "Reset what map [name]?");
1250 return 1; 1325 return 1;
1251 } 1326 }
1252 1327
1253 if (strcmp(params, ".") == 0) 1328 if (strcmp (params, ".") == 0)
1254 params = op->map->path; 1329 params = op->map->path;
1255 m = has_been_loaded(params); 1330 m = has_been_loaded (params);
1256 if (m == NULL) { 1331 if (m == NULL)
1332 {
1257 new_draw_info(NDI_UNIQUE, 0, op, "No such map."); 1333 new_draw_info (NDI_UNIQUE, 0, op, "No such map.");
1258 return 1; 1334 return 1;
1259 } 1335 }
1260 1336
1261 if (m->in_memory != MAP_SWAPPED) { 1337 if (m->in_memory != MAP_SWAPPED)
1338 {
1262 if (m->in_memory != MAP_IN_MEMORY) { 1339 if (m->in_memory != MAP_IN_MEMORY)
1340 {
1263 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");
1264 return 0; 1342 return 0;
1265 } 1343 }
1266 1344
1267 /* 1345 /*
1268 * 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
1269 * players or wiz's. 1347 * players or wiz's.
1270 */ 1348 */
1271 if (op->map == m) { 1349 if (op->map == m)
1350 {
1272 dummy = get_object(); 1351 dummy = get_object ();
1273 dummy->map = NULL; 1352 dummy->map = NULL;
1274 EXIT_X(dummy) = op->x; 1353 EXIT_X (dummy) = op->x;
1275 EXIT_Y(dummy) = op->y; 1354 EXIT_Y (dummy) = op->y;
1276 EXIT_PATH(dummy) = add_string(op->map->path); 1355 EXIT_PATH (dummy) = op->map->path;
1277 remove_ob(op); 1356 remove_ob (op);
1278 op->map = NULL; 1357 op->map = NULL;
1279 tmp = op; 1358 tmp = op;
1280 } 1359 }
1281 swap_map(m); 1360 swap_map (m);
1282 } 1361 }
1283 1362
1284 if (m->in_memory == MAP_SWAPPED) { 1363 if (m->in_memory == MAP_SWAPPED)
1364 {
1285 LOG(llevDebug, "Resetting map %s.\n", m->path); 1365 LOG (llevDebug, "Resetting map %s.\n", m->path);
1286 1366
1287 /* setting this effectively causes an immediate reload */ 1367 /* setting this effectively causes an immediate reload */
1288 m->reset_time = 1; 1368 m->reset_time = 1;
1289 flush_old_maps(); 1369 flush_old_maps ();
1290 new_draw_info(NDI_UNIQUE, 0, op, "OK."); 1370 new_draw_info (NDI_UNIQUE, 0, op, "OK.");
1291 if (tmp) { 1371 if (tmp)
1372 {
1292 enter_exit(tmp, dummy); 1373 enter_exit (tmp, dummy);
1293 free_object(dummy); 1374 free_object (dummy);
1294 } 1375 }
1295 return 1; 1376 return 1;
1296 } else { 1377 }
1378 else
1379 {
1297 player *pl; 1380 player *pl;
1298 int playercount = 0; 1381 int playercount = 0;
1299 1382
1300 /* Need to re-insert player if swap failed for some reason */ 1383 /* Need to re-insert player if swap failed for some reason */
1301 if (tmp) { 1384 if (tmp)
1385 {
1302 insert_ob_in_map(op, m, NULL, 0); 1386 insert_ob_in_map (op, m, NULL, 0);
1303 free_object(dummy); 1387 free_object (dummy);
1304 } 1388 }
1305 1389
1306 new_draw_info(NDI_UNIQUE, 0, op,
1307 "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:");
1308 for (pl = first_player; pl != NULL; pl = pl->next) { 1391 for (pl = first_player; pl != NULL; pl = pl->next)
1392 {
1309 if (pl->ob->map == m && pl->ob != op) { 1393 if (pl->ob->map == m && pl->ob != op)
1394 {
1310 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);
1311 playercount++; 1396 playercount++;
1312 } 1397 }
1313 } 1398 }
1314 if (!playercount) 1399 if (!playercount)
1315 new_draw_info(NDI_UNIQUE, 0, op,
1316 "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.");
1317 return 1; 1401 return 1;
1318 } 1402 }
1319} 1403}
1320 1404
1321int command_nowiz(object *op, char *params) { /* 'noadm' is alias */ 1405int
1406command_nowiz (object *op, char *params)
1407{ /* 'noadm' is alias */
1322 CLEAR_FLAG(op, FLAG_WIZ); 1408 CLEAR_FLAG (op, FLAG_WIZ);
1323 CLEAR_FLAG(op, FLAG_WIZPASS); 1409 CLEAR_FLAG (op, FLAG_WIZPASS);
1324 CLEAR_FLAG(op, FLAG_WIZCAST); 1410 CLEAR_FLAG (op, FLAG_WIZCAST);
1325 1411
1326 if (settings.real_wiz == TRUE) 1412 if (settings.real_wiz == TRUE)
1327 CLEAR_FLAG(op, FLAG_WAS_WIZ); 1413 CLEAR_FLAG (op, FLAG_WAS_WIZ);
1328 if (op->contr->hidden) { 1414 if (op->contr->hidden)
1415 {
1329 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");
1330 op->map->players++; 1417 op->map->players++;
1331 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);
1332 "%s has entered the game.", op->name);
1333 op->contr->hidden = 0; 1419 op->contr->hidden = 0;
1334 op->invisible = 1; 1420 op->invisible = 1;
1421 }
1335 } else 1422 else
1336 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..");
1337 return 1; 1424 return 1;
1338} 1425}
1339 1426
1340/** 1427/**
1341 * object *op is trying to become dm. 1428 * object *op is trying to become dm.
1342 * 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
1343 * 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
1344 * character name. 1431 * character name.
1345 */ 1432 */
1433static int
1346static 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)
1347{ 1435{
1348 FILE *dmfile; 1436 FILE *dmfile;
1349 char buf[MAX_BUF]; 1437 char buf[MAX_BUF];
1350 char line_buf[160], name[160], passwd[160], host[160]; 1438 char line_buf[160], name[160], passwd[160], host[160];
1351 1439
1352#ifdef RESTRICTIVE_DM 1440#ifdef RESTRICTIVE_DM
1353 *pl_name = op->name ? op->name : "*"; 1441 *pl_name = op->name ? op->name : "*";
1354#endif 1442#endif
1355 1443
1356 sprintf(buf, "%s/%s", settings.confdir, DMFILE); 1444 sprintf (buf, "%s/%s", settings.confdir, DMFILE);
1357 if ((dmfile = fopen(buf, "r")) == NULL) { 1445 if ((dmfile = fopen (buf, "r")) == NULL)
1446 {
1358 LOG(llevDebug, "Could not find DM file.\n"); 1447 LOG (llevDebug, "Could not find DM file.\n");
1359 return 0; 1448 return 0;
1360 } 1449 }
1361 1450
1362 while (fgets(line_buf, 160, dmfile) != NULL) { 1451 while (fgets (line_buf, 160, dmfile) != NULL)
1452 {
1363 if (line_buf[0] == '#') 1453 if (line_buf[0] == '#')
1364 continue; 1454 continue;
1365 if (sscanf(line_buf, "%[^:]:%[^:]:%s\n", name, passwd, host) != 3) { 1455 if (sscanf (line_buf, "%[^:]:%[^:]:%s\n", name, passwd, host) != 3)
1456 {
1366 LOG(llevError, "Warning - malformed dm file entry: %s\n", line_buf); 1457 LOG (llevError, "Warning - malformed dm file entry: %s\n", line_buf);
1458 }
1367 } else if ((!strcmp(name, "*") || (pl_name && !strcmp(pl_name, name))) 1459 else if ((!strcmp (name, "*") || (pl_name && !strcmp (pl_name, name)))
1368 && (!strcmp(passwd, "*") || !strcmp(passwd, pl_passwd)) && 1460 && (!strcmp (passwd, "*") || !strcmp (passwd, pl_passwd)) && (!strcmp (host, "*") || !strcmp (host, pl_host)))
1369 (!strcmp(host, "*") || !strcmp(host, pl_host))) { 1461 {
1370 fclose(dmfile); 1462 fclose (dmfile);
1371 return (1); 1463 return (1);
1372 } 1464 }
1373 } 1465 }
1374 fclose(dmfile); 1466 fclose (dmfile);
1375 return (0); 1467 return (0);
1376} 1468}
1377 1469
1470int
1378int do_wizard_dm(object *op, char *params, int silent) { 1471do_wizard_dm (object *op, char *params, int silent)
1472{
1379 if (!op->contr) 1473 if (!op->contr)
1380 return 0; 1474 return 0;
1381 1475
1382 if (QUERY_FLAG(op, FLAG_WIZ)) { 1476 if (QUERY_FLAG (op, FLAG_WIZ))
1477 {
1383 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!");
1384 return 0; 1479 return 0;
1480 }
1481
1482 if (checkdm (op, op->name, (params ? params : "*"), op->contr->socket.host))
1385 } 1483 {
1386
1387 if (checkdm(op, op->name,
1388 (params ? params : "*"), op->contr->socket.host)) {
1389 SET_FLAG(op, FLAG_WIZ); 1484 SET_FLAG (op, FLAG_WIZ);
1390 SET_FLAG(op, FLAG_WAS_WIZ); 1485 SET_FLAG (op, FLAG_WAS_WIZ);
1391 SET_FLAG(op, FLAG_WIZPASS); 1486 SET_FLAG (op, FLAG_WIZPASS);
1392 SET_FLAG(op, FLAG_WIZCAST); 1487 SET_FLAG (op, FLAG_WIZCAST);
1393 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!");
1394 /* 1489 /*
1395 * Remove setting flying here - that won't work, because next 1490 * Remove setting flying here - that won't work, because next
1396 * fix_player() is called that will get cleared - proper solution 1491 * fix_player() is called that will get cleared - proper solution
1397 * 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
1398 * other desired abilities. 1493 * other desired abilities.
1399 */ 1494 */
1400 clear_los(op); 1495 clear_los (op);
1401 op->contr->write_buf[0] ='\0'; 1496 op->contr->write_buf[0] = '\0';
1402 1497
1403 if (!silent) 1498 if (!silent)
1404 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!");
1405 "The Dungeon Master has arrived!");
1406 1500
1407 return 1; 1501 return 1;
1408 } else { 1502 }
1503 else
1504 {
1409 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.");
1410 op->contr->write_buf[0] ='\0'; 1506 op->contr->write_buf[0] = '\0';
1411 return 0; 1507 return 0;
1412 } 1508 }
1413} 1509}
1414 1510
1415/* 1511/*
1416 * 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
1417 * - 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
1418 */ 1514 */
1515int
1419int command_dm(object *op, char *params) { 1516command_dm (object *op, char *params)
1517{
1420 if (!op->contr) 1518 if (!op->contr)
1421 return 0;
1422
1423 do_wizard_dm(op, params, 0);
1424
1425 return 1;
1426}
1427
1428int command_invisible(object *op, char *params) {
1429 if (op) {
1430 op->invisible += 100;
1431 update_object(op, UP_OBJ_FACE);
1432 new_draw_info(NDI_UNIQUE, 0, op, "You turn invisible.");
1433 }
1434
1435 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;
1436} 1537}
1437 1538
1438/** 1539/**
1439 * Returns spell object (from archetypes) by name. 1540 * Returns spell object (from archetypes) by name.
1440 * Returns NULL if 0 or more than one spell matches. 1541 * Returns NULL if 0 or more than one spell matches.
… …
1445 * Ignores archetypes "spelldirect_xxx" since these archetypes are not used 1546 * Ignores archetypes "spelldirect_xxx" since these archetypes are not used
1446 * 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
1447 * 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
1448 * name than other "spell_xxx" archetypes and would always conflict. 1549 * name than other "spell_xxx" archetypes and would always conflict.
1449 */ 1550 */
1551static object *
1450static object *get_spell_by_name(object *op, const char *spell_name) { 1552get_spell_by_name (object *op, const char *spell_name)
1553{
1451 archetype *ar; 1554 archetype *ar;
1452 archetype *found; 1555 archetype *found;
1453 int conflict_found; 1556 int conflict_found;
1454 size_t spell_name_length; 1557 size_t spell_name_length;
1455 1558
1456 /* First check for full name matches. */ 1559 /* First check for full name matches. */
1457 conflict_found = 0; 1560 conflict_found = 0;
1458 found = NULL; 1561 found = NULL;
1459 for (ar = first_archetype; ar != NULL; ar = ar->next) { 1562 for (ar = first_archetype; ar != NULL; ar = ar->next)
1563 {
1460 if (ar->clone.type != SPELL) 1564 if (ar->clone.type != SPELL)
1461 continue; 1565 continue;
1462 1566
1463 if (strncmp(ar->name, "spelldirect_", 12) == 0) 1567 if (strncmp (ar->name, "spelldirect_", 12) == 0)
1464 continue; 1568 continue;
1465 1569
1466 if (strcmp(ar->clone.name, spell_name) != 0) 1570 if (strcmp (ar->clone.name, spell_name) != 0)
1467 continue; 1571 continue;
1468 1572
1469 if (found != NULL) { 1573 if (found != NULL)
1574 {
1470 if (!conflict_found) { 1575 if (!conflict_found)
1576 {
1471 conflict_found = 1; 1577 conflict_found = 1;
1472 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);
1473 new_draw_info_format(NDI_UNIQUE, 0, op, "- %s", found->name); 1579 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &found->name);
1474 } 1580 }
1475 new_draw_info_format(NDI_UNIQUE, 0, op, "- %s", ar->name); 1581 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &ar->name);
1476 continue; 1582 continue;
1477 } 1583 }
1478 1584
1479 found = ar; 1585 found = ar;
1480 } 1586 }
1481 1587
1482 /* No match if more more than one archetype matches. */ 1588 /* No match if more more than one archetype matches. */
1483 if (conflict_found) 1589 if (conflict_found)
1484 return NULL; 1590 return NULL;
1485 1591
1486 /* Return if exactly one archetype matches. */ 1592 /* Return if exactly one archetype matches. */
1487 if (found != NULL) 1593 if (found != NULL)
1488 return arch_to_object(found); 1594 return arch_to_object (found);
1489 1595
1490 /* No full match found: now check for partial matches. */ 1596 /* No full match found: now check for partial matches. */
1491 spell_name_length = strlen(spell_name); 1597 spell_name_length = strlen (spell_name);
1492 conflict_found = 0; 1598 conflict_found = 0;
1493 found = NULL; 1599 found = NULL;
1494 for (ar = first_archetype; ar != NULL; ar = ar->next) { 1600 for (ar = first_archetype; ar != NULL; ar = ar->next)
1601 {
1495 if (ar->clone.type != SPELL) 1602 if (ar->clone.type != SPELL)
1496 continue; 1603 continue;
1497 1604
1498 if (strncmp(ar->name, "spelldirect_", 12) == 0) 1605 if (strncmp (ar->name, "spelldirect_", 12) == 0)
1499 continue; 1606 continue;
1500 1607
1501 if (strncmp(ar->clone.name, spell_name, spell_name_length) != 0) 1608 if (strncmp (ar->clone.name, spell_name, spell_name_length) != 0)
1502 continue; 1609 continue;
1503 1610
1504 if (found != NULL) { 1611 if (found != NULL)
1612 {
1505 if (!conflict_found) { 1613 if (!conflict_found)
1614 {
1506 conflict_found = 1; 1615 conflict_found = 1;
1507 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);
1508 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);
1509 } 1618 }
1510 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);
1511 continue; 1620 continue;
1512 } 1621 }
1513 1622
1514 found = ar; 1623 found = ar;
1515 } 1624 }
1516 1625
1517 /* No match if more more than one archetype matches. */ 1626 /* No match if more more than one archetype matches. */
1518 if (conflict_found) 1627 if (conflict_found)
1519 return NULL;
1520
1521 /* Return if exactly one archetype matches. */
1522 if (found != NULL)
1523 return arch_to_object(found);
1524
1525 /* No spell found: just print an error message. */
1526 new_draw_info_format(NDI_UNIQUE, 0, op, "The spell %s does not exist.", spell_name);
1527 return NULL; 1628 return NULL;
1528}
1529 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
1530static int command_learn_spell_or_prayer(object *op, char *params, 1640command_learn_spell_or_prayer (object *op, char *params, int special_prayer)
1531 int special_prayer) { 1641{
1532 object *tmp; 1642 object *tmp;
1533 1643
1534 if (op->contr == NULL || params == NULL) { 1644 if (op->contr == NULL || params == NULL)
1645 {
1535 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?");
1536 return 0; 1647 return 0;
1537 } 1648 }
1538 1649
1539 tmp = get_spell_by_name(op, params); 1650 tmp = get_spell_by_name (op, params);
1540 if (tmp == NULL) { 1651 if (tmp == NULL)
1652 {
1541 return 0; 1653 return 0;
1542 } 1654 }
1543 1655
1544 if (check_spell_known(op, tmp->name)) { 1656 if (check_spell_known (op, tmp->name))
1657 {
1545 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);
1546 return 0; 1659 return 0;
1547 } 1660 }
1548 1661
1549 do_learn_spell(op, tmp, special_prayer); 1662 do_learn_spell (op, tmp, special_prayer);
1550 free_object(tmp); 1663 free_object (tmp);
1551 return 1; 1664 return 1;
1552} 1665}
1553 1666
1667int
1554int command_learn_spell(object *op, char *params) { 1668command_learn_spell (object *op, char *params)
1669{
1555 return command_learn_spell_or_prayer(op, params, 0); 1670 return command_learn_spell_or_prayer (op, params, 0);
1556} 1671}
1557 1672
1673int
1558int command_learn_special_prayer(object *op, char *params) 1674command_learn_special_prayer (object *op, char *params)
1559{ 1675{
1560 return command_learn_spell_or_prayer(op, params, 1); 1676 return command_learn_spell_or_prayer (op, params, 1);
1561} 1677}
1562 1678
1679int
1563int command_forget_spell(object *op, char *params) 1680command_forget_spell (object *op, char *params)
1564{ 1681{
1565 object *spell; 1682 object *spell;
1566 1683
1567 if (op->contr == NULL || params == NULL) { 1684 if (op->contr == NULL || params == NULL)
1685 {
1568 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?");
1569 return 0; 1687 return 0;
1570 } 1688 }
1571 1689
1572 spell = lookup_spell_by_name(op, params); 1690 spell = lookup_spell_by_name (op, params);
1573 if (spell == NULL) { 1691 if (spell == NULL)
1692 {
1574 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);
1575 return 0; 1694 return 0;
1576 } 1695 }
1577 1696
1578 do_forget_spell(op, spell->name); 1697 do_forget_spell (op, spell->name);
1579 return 1; 1698 return 1;
1580} 1699}
1581 1700
1582/** 1701/**
1583 * Lists all plugins currently loaded with their IDs and full names. 1702 * Lists all plugins currently loaded with their IDs and full names.
1584 */ 1703 */
1704int
1585int command_listplugins(object *op, char *params) 1705command_listplugins (object *op, char *params)
1586{ 1706{
1587 plugins_display_list(op); 1707 plugins_display_list (op);
1588 return 1; 1708 return 1;
1589} 1709}
1590 1710
1591/** 1711/**
1592 * 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
1593 * 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
1594 * once at a time, or bad things could happen. 1714 * once at a time, or bad things could happen.
1595 */ 1715 */
1716int
1596int command_loadplugin(object *op, char *params) { 1717command_loadplugin (object *op, char *params)
1718{
1597 char buf[MAX_BUF]; 1719 char buf[MAX_BUF];
1598 1720
1599 if (params == NULL) { 1721 if (params == NULL)
1722 {
1600 new_draw_info(NDI_UNIQUE, 0, op, "Load which plugin?"); 1723 new_draw_info (NDI_UNIQUE, 0, op, "Load which plugin?");
1601 return 1; 1724 return 1;
1602 } 1725 }
1603 1726
1604 strcpy(buf, LIBDIR); 1727 strcpy (buf, LIBDIR);
1605 strcat(buf, "/plugins/"); 1728 strcat (buf, "/plugins/");
1606 strcat(buf, params); 1729 strcat (buf, params);
1607 LOG(llevDebug, "Requested plugin file is %s\n", buf); 1730 LOG (llevDebug, "Requested plugin file is %s\n", buf);
1608 if (plugins_init_plugin(buf) == 0) 1731 if (plugins_init_plugin (buf) == 0)
1609 new_draw_info(NDI_UNIQUE, 0, op, "Plugin successfully loaded."); 1732 new_draw_info (NDI_UNIQUE, 0, op, "Plugin successfully loaded.");
1610 else 1733 else
1611 new_draw_info(NDI_UNIQUE, 0, op, "Could not load plugin."); 1734 new_draw_info (NDI_UNIQUE, 0, op, "Could not load plugin.");
1612 return 1; 1735 return 1;
1613} 1736}
1614 1737
1615/** 1738/**
1616 * 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.
1617 * 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
1618 * loaded. 1741 * loaded.
1619 */ 1742 */
1743int
1620int command_unloadplugin(object *op, char *params) 1744command_unloadplugin (object *op, char *params)
1621{ 1745{
1622 if (params == NULL) { 1746 if (params == NULL)
1747 {
1623 new_draw_info(NDI_UNIQUE, 0, op, "Remove which plugin?"); 1748 new_draw_info (NDI_UNIQUE, 0, op, "Remove which plugin?");
1624 return 1; 1749 return 1;
1625 } 1750 }
1626 1751
1627 if (plugins_remove_plugin(params) == 0) 1752 if (plugins_remove_plugin (params) == 0)
1628 new_draw_info(NDI_UNIQUE, 0, op, "Plugin successfully removed."); 1753 new_draw_info (NDI_UNIQUE, 0, op, "Plugin successfully removed.");
1629 else 1754 else
1630 new_draw_info(NDI_UNIQUE, 0, op, "Could not remove plugin."); 1755 new_draw_info (NDI_UNIQUE, 0, op, "Could not remove plugin.");
1631 return 1; 1756 return 1;
1632} 1757}
1633 1758
1634/** 1759/**
1635 * A players wants to become DM and hide. 1760 * A players wants to become DM and hide.
1636 * Let's see if that's authorized. 1761 * Let's see if that's authorized.
1637 * Make sure to not tell anything to anyone. 1762 * Make sure to not tell anything to anyone.
1638 */ 1763 */
1764int
1639int command_dmhide(object *op, char *params) { 1765command_dmhide (object *op, char *params)
1766{
1640 if (!do_wizard_dm(op, params, 1)) 1767 if (!do_wizard_dm (op, params, 1))
1641 return 0; 1768 return 0;
1642 1769
1643 do_wizard_hide(op, 1); 1770 do_wizard_hide (op, 1);
1644 1771
1645 return 1; 1772 return 1;
1646} 1773}
1647 1774
1775void
1648void dm_stack_pop(player *pl) { 1776dm_stack_pop (player *pl)
1777{
1649 if (!pl->stack_items || !pl->stack_position) { 1778 if (!pl->stack_items || !pl->stack_position)
1779 {
1650 new_draw_info(NDI_UNIQUE, 0, pl->ob, "Empty stack!"); 1780 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
1651 return; 1781 return;
1652 } 1782 }
1653 1783
1654 pl->stack_position--; 1784 pl->stack_position--;
1655 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);
1656} 1786}
1657 1787
1658/** 1788/**
1659 * Get current stack top item for player. 1789 * Get current stack top item for player.
1660 * Returns NULL if no stacked item. 1790 * Returns NULL if no stacked item.
1661 * If stacked item disappeared (freed), remove it. 1791 * If stacked item disappeared (freed), remove it.
1662 * 1792 *
1663 * Ryo, august 2004 1793 * Ryo, august 2004
1664 */ 1794 */
1795object *
1665object *dm_stack_peek(player *pl) { 1796dm_stack_peek (player *pl)
1797{
1666 object* ob; 1798 object *ob;
1667 1799
1668 if (!pl->stack_position) { 1800 if (!pl->stack_position)
1801 {
1669 new_draw_info(NDI_UNIQUE, 0, pl->ob, "Empty stack!"); 1802 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
1670 return NULL; 1803 return NULL;
1671 } 1804 }
1672 1805
1673 ob = find_object(pl->stack_items[pl->stack_position-1]); 1806 ob = find_object (pl->stack_items[pl->stack_position - 1]);
1674 if (!ob) { 1807 if (!ob)
1808 {
1675 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!");
1676 dm_stack_pop(pl); 1810 dm_stack_pop (pl);
1677 return NULL; 1811 return NULL;
1678 } 1812 }
1679 1813
1680 return ob; 1814 return ob;
1681} 1815}
1682 1816
1683/** 1817/**
1684 * Push specified item on player stack. 1818 * Push specified item on player stack.
1685 * Inform player of position. 1819 * Inform player of position.
1686 * Initializes variables if needed. 1820 * Initializes variables if needed.
1687 */ 1821 */
1822void
1688void dm_stack_push(player *pl, tag_t item) { 1823dm_stack_push (player *pl, tag_t item)
1824{
1689 if (!pl->stack_items) { 1825 if (!pl->stack_items)
1826 {
1690 pl->stack_items = (tag_t *)malloc(sizeof(tag_t)*STACK_SIZE); 1827 pl->stack_items = (tag_t *) malloc (sizeof (tag_t) * STACK_SIZE);
1691 memset(pl->stack_items, 0, sizeof(tag_t)*STACK_SIZE); 1828 memset (pl->stack_items, 0, sizeof (tag_t) * STACK_SIZE);
1692 } 1829 }
1693 1830
1694 if (pl->stack_position == STACK_SIZE) { 1831 if (pl->stack_position == STACK_SIZE)
1832 {
1695 new_draw_info(NDI_UNIQUE, 0, pl->ob, "Item stack full!"); 1833 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Item stack full!");
1696 return; 1834 return;
1697 } 1835 }
1698 1836
1699 pl->stack_items[pl->stack_position] = item; 1837 pl->stack_items[pl->stack_position] = item;
1700 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);
1701 pl->stack_position++; 1839 pl->stack_position++;
1702} 1840}
1703 1841
1704/** 1842/**
1705 * Checks 'params' for object code. 1843 * Checks 'params' for object code.
1706 * 1844 *
… …
1718 * * STACK_FROM_STACK => item from somewhere in the stack 1856 * * STACK_FROM_STACK => item from somewhere in the stack
1719 * * STACK_FROM_NUMBER => item by number, pushed on stack 1857 * * STACK_FROM_NUMBER => item by number, pushed on stack
1720 * 1858 *
1721 * Ryo, august 2004 1859 * Ryo, august 2004
1722 */ 1860 */
1861object *
1723object *get_dm_object(player *pl, char **params, int *from) { 1862get_dm_object (player *pl, char **params, int *from)
1863{
1724 int item_tag, item_position; 1864 int item_tag, item_position;
1725 object *ob; 1865 object *ob;
1726 1866
1727 if (!pl) 1867 if (!pl)
1728 return NULL; 1868 return NULL;
1729 1869
1730 if (!params || !*params || **params == '\0') { 1870 if (!params || !*params || **params == '\0')
1871 {
1731 if (from) 1872 if (from)
1732 *from = STACK_FROM_TOP; 1873 *from = STACK_FROM_TOP;
1733 /* No parameter => get stack item */ 1874 /* No parameter => get stack item */
1734 return dm_stack_peek(pl); 1875 return dm_stack_peek (pl);
1735 } 1876 }
1736 1877
1737 /* Let's clean white spaces */ 1878 /* Let's clean white spaces */
1738 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))
1739 (*params)++; 1887 (*params)++;
1740 1888
1741 /* Next case: number => item tag */
1742 if (sscanf(*params, "%d", &item_tag)) {
1743 /* Move parameter to next item */
1744 while (isdigit(**params))
1745 (*params)++;
1746
1747 /* And skip blanks, too */ 1889 /* And skip blanks, too */
1748 while (**params == ' ') 1890 while (**params == ' ')
1749 (*params)++;
1750
1751 /* Get item */
1752 ob = find_object(item_tag);
1753 if (!ob) {
1754 if (from)
1755 *from = STACK_FROM_NONE;
1756 new_draw_info_format(NDI_UNIQUE, 0, pl->ob, "No such item %d!", item_tag);
1757 return NULL;
1758 }
1759
1760 /* Got one, let's push it on stack */
1761 dm_stack_push(pl, item_tag);
1762 if (from)
1763 *from = STACK_FROM_NUMBER;
1764 return ob;
1765 }
1766
1767 /* Next case: $number => stack item */
1768 if (sscanf(*params, "$%d", &item_position)) {
1769 /* Move parameter to next item */
1770 (*params)++; 1891 (*params)++;
1771 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
1772 while (isdigit(**params)) 1916 while (isdigit (**params))
1773 (*params)++; 1917 (*params)++;
1774 while (**params == ' ') 1918 while (**params == ' ')
1775 (*params)++; 1919 (*params)++;
1776 1920
1777 if (item_position >= pl->stack_position) { 1921 if (item_position >= pl->stack_position)
1922 {
1778 if (from) 1923 if (from)
1779 *from = STACK_FROM_NONE; 1924 *from = STACK_FROM_NONE;
1780 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);
1781 return NULL; 1926 return NULL;
1782 } 1927 }
1783 1928
1784 ob = find_object(pl->stack_items[item_position]); 1929 ob = find_object (pl->stack_items[item_position]);
1785 if (!ob) { 1930 if (!ob)
1931 {
1786 if (from) 1932 if (from)
1787 *from = STACK_FROM_NONE; 1933 *from = STACK_FROM_NONE;
1788 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);
1789 return NULL; 1935 return NULL;
1790 } 1936 }
1791 1937
1792 if (from) 1938 if (from)
1793 *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;
1794 return ob; 1940 return ob;
1795 } 1941 }
1796 1942
1797 /* Next case: 'me' => return pl->ob */ 1943 /* Next case: 'me' => return pl->ob */
1798 if (!strncmp(*params, "me", 2)) { 1944 if (!strncmp (*params, "me", 2))
1945 {
1799 if (from) 1946 if (from)
1800 *from = STACK_FROM_NUMBER; 1947 *from = STACK_FROM_NUMBER;
1801 dm_stack_push(pl, pl->ob->count); 1948 dm_stack_push (pl, pl->ob->count);
1802 1949
1803 /* Skip to next token */ 1950 /* Skip to next token */
1804 (*params) += 2; 1951 (*params) += 2;
1805 while (**params == ' ') 1952 while (**params == ' ')
1806 (*params)++; 1953 (*params)++;
1807 1954
1808 return pl->ob; 1955 return pl->ob;
1809 } 1956 }
1810 1957
1811 /* Last case: get stack top */ 1958 /* Last case: get stack top */
1812 if (from) 1959 if (from)
1813 *from = STACK_FROM_TOP; 1960 *from = STACK_FROM_TOP;
1814 return dm_stack_peek(pl); 1961 return dm_stack_peek (pl);
1815} 1962}
1816 1963
1817/** 1964/**
1818 * Pop the stack top. 1965 * Pop the stack top.
1819 */ 1966 */
1967int
1820int command_stack_pop(object *op, char *params) { 1968command_stack_pop (object *op, char *params)
1969{
1821 dm_stack_pop(op->contr); 1970 dm_stack_pop (op->contr);
1822 return 0; 1971 return 0;
1823} 1972}
1824 1973
1825/** 1974/**
1826 * Push specified item on stack. 1975 * Push specified item on stack.
1827 */ 1976 */
1977int
1828int command_stack_push(object *op, char *params) { 1978command_stack_push (object *op, char *params)
1979{
1829 object *ob; 1980 object *ob;
1830 int from; 1981 int from;
1982
1831 ob = get_dm_object(op->contr, &params, &from); 1983 ob = get_dm_object (op->contr, &params, &from);
1832 1984
1833 if (ob && from != STACK_FROM_NUMBER) 1985 if (ob && from != STACK_FROM_NUMBER)
1834 /* Object was from stack, need to push it again */ 1986 /* Object was from stack, need to push it again */
1835 dm_stack_push(op->contr, ob->count); 1987 dm_stack_push (op->contr, ob->count);
1836 1988
1837 return 0; 1989 return 0;
1838} 1990}
1839 1991
1840/** 1992/**
1841 * Displays stack contents. 1993 * Displays stack contents.
1842 */ 1994 */
1995int
1843int command_stack_list(object *op, char *params) { 1996command_stack_list (object *op, char *params)
1997{
1844 int item; 1998 int item;
1845 object *display; 1999 object *display;
1846 player *pl = op->contr; 2000 player *pl = op->contr;
1847 2001
1848 new_draw_info(NDI_UNIQUE, 0, op, "Item stack contents:"); 2002 new_draw_info (NDI_UNIQUE, 0, op, "Item stack contents:");
1849 2003
1850 for (item = 0; item < pl->stack_position; item++) { 2004 for (item = 0; item < pl->stack_position; item++)
2005 {
1851 display = find_object(pl->stack_items[item]); 2006 display = find_object (pl->stack_items[item]);
1852 if (display) 2007 if (display)
1853 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);
1854 else 2009 else
1855 /* Item was freed */ 2010 /* Item was freed */
1856 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]);
1857 } 2012 }
1858 2013
1859 return 0; 2014 return 0;
1860} 2015}
1861 2016
1862/** 2017/**
1863 * Empty DM item stack. 2018 * Empty DM item stack.
1864 */ 2019 */
2020int
1865int command_stack_clear(object *op, char *params) { 2021command_stack_clear (object *op, char *params)
2022{
1866 op->contr->stack_position = 0; 2023 op->contr->stack_position = 0;
1867 new_draw_info(NDI_UNIQUE, 0, op, "Item stack cleared."); 2024 new_draw_info (NDI_UNIQUE, 0, op, "Item stack cleared.");
1868 return 0; 2025 return 0;
1869} 2026}
1870 2027
1871/** 2028int
1872 * Get a diff of specified items.
1873 * Second item is compared to first, and differences displayed.
1874 * Note: get_ob_diff works the opposite way (first compared to 2nd),
1875 * but it's easier with stack functions to do it this way, so you can do:
1876 * * stack_push <base>
1877 * * stack_push <object to be compared>
1878 * * diff
1879 * * patch xxx <---- applies to object compared to base, easier :)
1880 *
1881 * Ryo, august 2004
1882 */
1883int command_diff(object *op, char *params) { 2029command_insert_into (object *op, char *params)
2030{
1884 object *left, *right, *top; 2031 object *left, *right, *inserted;
1885 const char *diff;
1886 int left_from, right_from; 2032 int left_from, right_from;
1887 2033
1888 top = NULL;
1889
1890 left = get_dm_object(op->contr, &params, &left_from); 2034 left = get_dm_object (op->contr, &params, &left_from);
1891 if (!left) { 2035 if (!left)
1892 new_draw_info(NDI_UNIQUE, 0, op, "Compare to what item?");
1893 return 0;
1894 } 2036 {
1895
1896 if (left_from == STACK_FROM_NUMBER)
1897 /* Item was stacked, remove it else right will be the same... */
1898 dm_stack_pop(op->contr);
1899
1900 right = get_dm_object(op->contr, &params, &right_from);
1901
1902 if (!right) {
1903 new_draw_info(NDI_UNIQUE, 0, op, "Compare what item?");
1904 return 0;
1905 }
1906
1907 new_draw_info(NDI_UNIQUE, 0, op, "Item difference:");
1908
1909 if (left_from == STACK_FROM_TOP && right_from == STACK_FROM_TOP) {
1910 /*
1911 * Special case: both items were taken from stack top.
1912 * Override the behaviour, taking left as item just below top, if exists.
1913 * See function description for why.
1914 * Besides, if we don't do anything, compare an item to itself, not really useful.
1915 */
1916 if (op->contr->stack_position > 1) {
1917 left = find_object(op->contr->stack_items[op->contr->stack_position-2]);
1918 if (left)
1919 new_draw_info(NDI_UNIQUE, 0, op, "(Note: first item taken from undertop)");
1920 else
1921 /* Stupid case: item under top was freed, fallback to stack top */
1922 left = right;
1923 }
1924 }
1925
1926 diff = get_ob_diff(left, right);
1927
1928 if (!diff) {
1929 new_draw_info(NDI_UNIQUE, 0, op, "Objects are the same.");
1930 return 0;
1931 }
1932
1933 new_draw_info(NDI_UNIQUE, 0, op, diff);
1934 return 0;
1935}
1936
1937int command_insert_into(object* op, char *params)
1938{
1939 object *left, *right, *inserted;
1940 const char *diff;
1941 int left_from, right_from;
1942
1943 left = get_dm_object(op->contr, &params, &left_from);
1944 if (!left) {
1945 new_draw_info(NDI_UNIQUE, 0, op, "Insert into what object?"); 2037 new_draw_info (NDI_UNIQUE, 0, op, "Insert into what object?");
1946 return 0; 2038 return 0;
1947 } 2039 }
1948 2040
1949 if (left_from == STACK_FROM_NUMBER) 2041 if (left_from == STACK_FROM_NUMBER)
1950 /* Item was stacked, remove it else right will be the same... */ 2042 /* Item was stacked, remove it else right will be the same... */
1951 dm_stack_pop(op->contr); 2043 dm_stack_pop (op->contr);
1952 2044
1953 right = get_dm_object(op->contr, &params, &right_from); 2045 right = get_dm_object (op->contr, &params, &right_from);
1954 2046
1955 if (!right) { 2047 if (!right)
2048 {
1956 new_draw_info(NDI_UNIQUE, 0, op, "Insert what item?"); 2049 new_draw_info (NDI_UNIQUE, 0, op, "Insert what item?");
1957 return 0; 2050 return 0;
1958 } 2051 }
1959 2052
1960 if (left_from == STACK_FROM_TOP && right_from == STACK_FROM_TOP) { 2053 if (left_from == STACK_FROM_TOP && right_from == STACK_FROM_TOP)
2054 {
1961 /* 2055 /*
1962 * Special case: both items were taken from stack top. 2056 * Special case: both items were taken from stack top.
1963 * 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.
1964 * See function description for why. 2058 * See function description for why.
1965 * Besides, can't insert an item into itself. 2059 * Besides, can't insert an item into itself.
1966 */ 2060 */
1967 if (op->contr->stack_position > 1) { 2061 if (op->contr->stack_position > 1)
2062 {
1968 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]);
1969 if (left) 2064 if (left)
1970 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)");
1971 else 2066 else
1972 /* Stupid case: item under top was freed, fallback to stack top */ 2067 /* Stupid case: item under top was freed, fallback to stack top */
1973 left = right; 2068 left = right;
1974 } 2069 }
1975 } 2070 }
1976 2071
1977 if (left == right) 2072 if (left == right)
1978 { 2073 {
1979 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!");
1980 return 0; 2075 return 0;
1981 } 2076 }
1982 2077
1983 if (right->type == PLAYER) 2078 if (right->type == PLAYER)
1984 { 2079 {
1985 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!");
1986 return 0; 2081 return 0;
1987 } 2082 }
1988 2083
1989 if (!QUERY_FLAG(right,FLAG_REMOVED)) 2084 if (!QUERY_FLAG (right, FLAG_REMOVED))
1990 remove_ob(right); 2085 remove_ob (right);
1991 inserted = insert_ob_in_ob(right,left); 2086 inserted = insert_ob_in_ob (right, left);
1992 if (left->type == PLAYER) 2087 if (left->type == PLAYER)
1993 if (inserted == right) 2088 if (inserted == right)
1994 esrv_send_item(left,right); 2089 esrv_send_item (left, right);
1995 else 2090 else
1996 esrv_update_item(UPD_WEIGHT|UPD_NAME|UPD_NROF,left,inserted); 2091 esrv_update_item (UPD_WEIGHT | UPD_NAME | UPD_NROF, left, inserted);
1997 2092
1998 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));
1999 2094
2000 return 0; 2095 return 0;
2001 2096
2002} 2097}

Diff Legend

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