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.7 by pippijn, Thu Sep 7 10:01:57 2006 UTC vs.
Revision 1.28 by root, Sat Dec 30 10:16:11 2006 UTC

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

Diff Legend

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