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

Comparing deliantra/server/server/c_wiz.C (file contents):
Revision 1.2 by root, Thu Aug 24 13:13:49 2006 UTC vs.
Revision 1.18 by pippijn, Sat Dec 9 17:28:37 2006 UTC

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

Diff Legend

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