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

Comparing deliantra/server/server/c_wiz.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:04 2006 UTC vs.
Revision 1.61 by root, Sat Dec 20 02:32:31 2008 UTC

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

Diff Legend

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