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

Comparing deliantra/server/server/c_wiz.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:04 2006 UTC vs.
Revision 1.25 by root, Thu Dec 21 23:37:06 2006 UTC

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

Diff Legend

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