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

Diff Legend

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