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

Diff Legend

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