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

Comparing deliantra/server/server/c_wiz.C (file contents):
Revision 1.2 by root, Thu Aug 24 13:13:49 2006 UTC vs.
Revision 1.48 by root, Tue Jun 5 13:05:02 2007 UTC

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

Diff Legend

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