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

Comparing deliantra/server/server/c_wiz.C (file contents):
Revision 1.6 by root, Sun Sep 3 00:18:42 2006 UTC vs.
Revision 1.32 by pippijn, Mon Jan 15 21:06:20 2007 UTC

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

Diff Legend

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