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.5 by root, Thu Aug 31 17:54:15 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.5 2006/08/31 17:54:15 root 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) = add_string (name);
329 dummy->name = add_string(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) = add_string(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) = add_string(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#ifndef WIN32 1147 sprintf (buf, "Wis : %-2d EXP : %lld", pl->ob->stats.Wis, (long long) pl->ob->stats.exp);
1117 sprintf(buf, "Wis : %-2d EXP : %lld",
1118 pl->ob->stats.Wis, pl->ob->stats.exp);
1119#else
1120 sprintf(buf, "Wis : %-2d EXP : %I64d",
1121 pl->ob->stats.Wis, pl->ob->stats.exp);
1122#endif
1123 new_draw_info(NDI_UNIQUE, 0, op, buf); 1148 new_draw_info (NDI_UNIQUE, 0, op, buf);
1124 sprintf(buf, "Pow : %-2d Grace : %d", 1149 sprintf (buf, "Pow : %-2d Grace : %d", pl->ob->stats.Pow, pl->ob->stats.grace);
1125 pl->ob->stats.Pow, pl->ob->stats.grace);
1126 new_draw_info(NDI_UNIQUE, 0, op, buf); 1150 new_draw_info (NDI_UNIQUE, 0, op, buf);
1127 sprintf(buf, "Cha : %-2d Food : %d", 1151 sprintf (buf, "Cha : %-2d Food : %d", pl->ob->stats.Cha, pl->ob->stats.food);
1128 pl->ob->stats.Cha, pl->ob->stats.food);
1129 new_draw_info(NDI_UNIQUE, 0, op, buf); 1152 new_draw_info (NDI_UNIQUE, 0, op, buf);
1130 break; 1153 break;
1131 } 1154 }
1132 if (pl == NULL) 1155 if (pl == NULL)
1133 new_draw_info(NDI_UNIQUE, 0, op, "No such player.");
1134 return 1;
1135}
1136
1137int command_abil(object *op, char *params) {
1138 char thing[20], thing2[20];
1139 int iii;
1140 player *pl;
1141 char buf[MAX_BUF];
1142
1143 iii = 0;
1144 thing[0] = '\0';
1145 thing2[0] = '\0';
1146 if (params == NULL || !sscanf(params, "%s %s %d", thing, thing2, &iii) ||
1147 thing==NULL) {
1148 new_draw_info(NDI_UNIQUE, 0, op, "Who?");
1149 return 1;
1150 }
1151
1152 if (thing2 == NULL){
1153 new_draw_info(NDI_UNIQUE, 0, op, "You can't change that.");
1154 return 1;
1155 }
1156
1157 if (iii < MIN_STAT || iii > MAX_STAT) {
1158 new_draw_info(NDI_UNIQUE, 0, op, "Illegal range of stat.\n");
1159 return 1;
1160 }
1161
1162 for (pl = first_player; pl != NULL; pl = pl->next) {
1163 if (!strcmp(pl->ob->name, thing)) {
1164 if (settings.real_wiz == FALSE)
1165 SET_FLAG(pl->ob, FLAG_WAS_WIZ);
1166 if (!strcmp("str", thing2))
1167 pl->ob->stats.Str = iii, pl->orig_stats.Str = iii;
1168 if (!strcmp("dex", thing2))
1169 pl->ob->stats.Dex = iii, pl->orig_stats.Dex = iii;
1170 if (!strcmp("con", thing2))
1171 pl->ob->stats.Con = iii, pl->orig_stats.Con = iii;
1172 if (!strcmp("wis", thing2))
1173 pl->ob->stats.Wis = iii, pl->orig_stats.Wis = iii;
1174 if (!strcmp("cha", thing2))
1175 pl->ob->stats.Cha = iii, pl->orig_stats.Cha = iii;
1176 if (!strcmp("int", thing2))
1177 pl->ob->stats.Int = iii, pl->orig_stats.Int = iii;
1178 if (!strcmp("pow", thing2))
1179 pl->ob->stats.Pow = iii, pl->orig_stats.Pow = iii;
1180 sprintf(buf, "%s has been altered.", pl->ob->name);
1181 new_draw_info(NDI_UNIQUE, 0, op, buf);
1182 fix_player(pl->ob);
1183 return 1;
1184 }
1185 }
1186
1187 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?");
1188 return 1; 1174 return 1;
1189} 1175 }
1190 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
1191int command_reset (object *op, char *params) { 1221command_reset (object *op, char *params)
1192 mapstruct *m; 1222{
1223 maptile *m;
1193 object *dummy = NULL, *tmp = NULL; 1224 object *dummy = NULL, *tmp = NULL;
1194 1225
1195 if (params == NULL) { 1226 if (params == NULL)
1227 {
1196 new_draw_info(NDI_UNIQUE, 0, op, "Reset what map [name]?"); 1228 new_draw_info (NDI_UNIQUE, 0, op, "Reset what map [name]?");
1197 return 1; 1229 return 1;
1198 } 1230 }
1199 1231
1200 if (strcmp(params, ".") == 0) 1232 if (strcmp (params, ".") == 0)
1201 params = op->map->path; 1233 params = op->map->path;
1234
1202 m = has_been_loaded(params); 1235 m = has_been_loaded (params);
1203 if (m == NULL) { 1236 if (m == NULL)
1237 {
1204 new_draw_info(NDI_UNIQUE, 0, op, "No such map."); 1238 new_draw_info (NDI_UNIQUE, 0, op, "No such map.");
1205 return 1; 1239 return 1;
1206 } 1240 }
1207 1241
1208 if (m->in_memory != MAP_SWAPPED) { 1242 if (m->in_memory != MAP_SWAPPED)
1243 {
1209 if (m->in_memory != MAP_IN_MEMORY) { 1244 if (m->in_memory != MAP_IN_MEMORY)
1245 {
1210 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");
1211 return 0; 1247 return 0;
1212 } 1248 }
1213 1249
1214 /* 1250 /*
1215 * 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
1216 * players or wiz's. 1252 * players or wiz's.
1217 */ 1253 */
1218 if (op->map == m) { 1254 if (op->map == m)
1255 {
1219 dummy = get_object(); 1256 dummy = get_object ();
1220 dummy->map = NULL; 1257 dummy->map = NULL;
1221 EXIT_X(dummy) = op->x; 1258 EXIT_X (dummy) = op->x;
1222 EXIT_Y(dummy) = op->y; 1259 EXIT_Y (dummy) = op->y;
1223 EXIT_PATH(dummy) = add_string(op->map->path); 1260 EXIT_PATH (dummy) = op->map->path;
1224 remove_ob(op); 1261 remove_ob (op);
1225 op->map = NULL; 1262 op->map = NULL;
1226 tmp = op; 1263 tmp = op;
1227 } 1264 }
1228 swap_map(m); 1265 swap_map (m);
1229 } 1266 }
1230 1267
1231 if (m->in_memory == MAP_SWAPPED) { 1268 if (m->in_memory == MAP_SWAPPED)
1269 {
1232 LOG(llevDebug, "Resetting map %s.\n", m->path); 1270 LOG (llevDebug, "Resetting map %s.\n", m->path);
1233 1271
1234 /* setting this effectively causes an immediate reload */ 1272 /* setting this effectively causes an immediate reload */
1235 m->reset_time = 1; 1273 m->reset_time = 1;
1236 flush_old_maps(); 1274 flush_old_maps ();
1237 new_draw_info(NDI_UNIQUE, 0, op, "OK."); 1275 new_draw_info (NDI_UNIQUE, 0, op, "OK.");
1238 if (tmp) { 1276 if (tmp)
1277 {
1239 enter_exit(tmp, dummy); 1278 enter_exit (tmp, dummy);
1240 free_object(dummy); 1279 free_object (dummy);
1241 } 1280 }
1242 return 1; 1281 return 1;
1243 } else { 1282 }
1283 else
1284 {
1244 player *pl; 1285 player *pl;
1245 int playercount = 0; 1286 int playercount = 0;
1246 1287
1247 /* Need to re-insert player if swap failed for some reason */ 1288 /* Need to re-insert player if swap failed for some reason */
1248 if (tmp) { 1289 if (tmp)
1290 {
1249 insert_ob_in_map(op, m, NULL, 0); 1291 insert_ob_in_map (op, m, NULL, 0);
1250 free_object(dummy); 1292 free_object (dummy);
1251 } 1293 }
1252 1294
1253 new_draw_info(NDI_UNIQUE, 0, op,
1254 "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:");
1255 for (pl = first_player; pl != NULL; pl = pl->next) { 1296 for (pl = first_player; pl != NULL; pl = pl->next)
1297 {
1256 if (pl->ob->map == m && pl->ob != op) { 1298 if (pl->ob->map == m && pl->ob != op)
1299 {
1257 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);
1258 playercount++; 1301 playercount++;
1259 } 1302 }
1260 } 1303 }
1261 if (!playercount) 1304 if (!playercount)
1262 new_draw_info(NDI_UNIQUE, 0, op,
1263 "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.");
1264 return 1; 1306 return 1;
1265 } 1307 }
1266} 1308}
1267 1309
1268int command_nowiz(object *op, char *params) { /* 'noadm' is alias */ 1310int
1311command_nowiz (object *op, char *params)
1312{ /* 'noadm' is alias */
1269 CLEAR_FLAG(op, FLAG_WIZ); 1313 CLEAR_FLAG (op, FLAG_WIZ);
1270 CLEAR_FLAG(op, FLAG_WIZPASS); 1314 CLEAR_FLAG (op, FLAG_WIZPASS);
1271 CLEAR_FLAG(op, FLAG_WIZCAST); 1315 CLEAR_FLAG (op, FLAG_WIZCAST);
1272 1316
1273 if (settings.real_wiz == TRUE) 1317 if (settings.real_wiz == TRUE)
1274 CLEAR_FLAG(op, FLAG_WAS_WIZ); 1318 CLEAR_FLAG (op, FLAG_WAS_WIZ);
1275 if (op->contr->hidden) { 1319 if (op->contr->hidden)
1320 {
1276 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");
1277 op->map->players++; 1322 op->map->players++;
1278 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);
1279 "%s has entered the game.", op->name);
1280 op->contr->hidden = 0; 1324 op->contr->hidden = 0;
1281 op->invisible = 1; 1325 op->invisible = 1;
1326 }
1282 } else 1327 else
1283 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..");
1284 return 1; 1329 return 1;
1285} 1330}
1286 1331
1287/** 1332/**
1288 * object *op is trying to become dm. 1333 * object *op is trying to become dm.
1289 * 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
1290 * 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
1291 * character name. 1336 * character name.
1292 */ 1337 */
1338static int
1293static 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)
1294{ 1340{
1295 FILE *dmfile; 1341 FILE *dmfile;
1296 char buf[MAX_BUF]; 1342 char buf[MAX_BUF];
1297 char line_buf[160], name[160], passwd[160], host[160]; 1343 char line_buf[160], name[160], passwd[160], host[160];
1298 1344
1299#ifdef RESTRICTIVE_DM 1345#ifdef RESTRICTIVE_DM
1300 *pl_name = op->name ? op->name : "*"; 1346 *pl_name = op->name ? op->name : "*";
1301#endif 1347#endif
1302 1348
1303 sprintf(buf, "%s/%s", settings.confdir, DMFILE); 1349 sprintf (buf, "%s/%s", settings.confdir, DMFILE);
1304 if ((dmfile = fopen(buf, "r")) == NULL) { 1350 if ((dmfile = fopen (buf, "r")) == NULL)
1351 {
1305 LOG(llevDebug, "Could not find DM file.\n"); 1352 LOG (llevDebug, "Could not find DM file.\n");
1306 return 0; 1353 return 0;
1307 } 1354 }
1308 1355
1309 while (fgets(line_buf, 160, dmfile) != NULL) { 1356 while (fgets (line_buf, 160, dmfile) != NULL)
1357 {
1310 if (line_buf[0] == '#') 1358 if (line_buf[0] == '#')
1311 continue; 1359 continue;
1312 if (sscanf(line_buf, "%[^:]:%[^:]:%s\n", name, passwd, host) != 3) { 1360 if (sscanf (line_buf, "%[^:]:%[^:]:%s\n", name, passwd, host) != 3)
1361 {
1313 LOG(llevError, "Warning - malformed dm file entry: %s\n", line_buf); 1362 LOG (llevError, "Warning - malformed dm file entry: %s\n", line_buf);
1363 }
1314 } else if ((!strcmp(name, "*") || (pl_name && !strcmp(pl_name, name))) 1364 else if ((!strcmp (name, "*") || (pl_name && !strcmp (pl_name, name)))
1315 && (!strcmp(passwd, "*") || !strcmp(passwd, pl_passwd)) && 1365 && (!strcmp (passwd, "*") || !strcmp (passwd, pl_passwd)) && (!strcmp (host, "*") || !strcmp (host, pl_host)))
1316 (!strcmp(host, "*") || !strcmp(host, pl_host))) { 1366 {
1317 fclose(dmfile); 1367 fclose (dmfile);
1318 return (1); 1368 return (1);
1319 } 1369 }
1320 } 1370 }
1321 fclose(dmfile); 1371 fclose (dmfile);
1322 return (0); 1372 return (0);
1323} 1373}
1324 1374
1375int
1325int do_wizard_dm(object *op, char *params, int silent) { 1376do_wizard_dm (object *op, char *params, int silent)
1377{
1326 if (!op->contr) 1378 if (!op->contr)
1327 return 0; 1379 return 0;
1328 1380
1329 if (QUERY_FLAG(op, FLAG_WIZ)) { 1381 if (QUERY_FLAG (op, FLAG_WIZ))
1382 {
1330 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!");
1331 return 0; 1384 return 0;
1385 }
1386
1387 if (checkdm (op, op->name, (params ? params : "*"), op->contr->socket.host))
1332 } 1388 {
1333
1334 if (checkdm(op, op->name,
1335 (params ? params : "*"), op->contr->socket.host)) {
1336 SET_FLAG(op, FLAG_WIZ); 1389 SET_FLAG (op, FLAG_WIZ);
1337 SET_FLAG(op, FLAG_WAS_WIZ); 1390 SET_FLAG (op, FLAG_WAS_WIZ);
1338 SET_FLAG(op, FLAG_WIZPASS); 1391 SET_FLAG (op, FLAG_WIZPASS);
1339 SET_FLAG(op, FLAG_WIZCAST); 1392 SET_FLAG (op, FLAG_WIZCAST);
1340 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!");
1341 /* 1394 /*
1342 * Remove setting flying here - that won't work, because next 1395 * Remove setting flying here - that won't work, because next
1343 * fix_player() is called that will get cleared - proper solution 1396 * fix_player() is called that will get cleared - proper solution
1344 * 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
1345 * other desired abilities. 1398 * other desired abilities.
1346 */ 1399 */
1347 clear_los(op); 1400 clear_los (op);
1348 op->contr->write_buf[0] ='\0'; 1401 op->contr->write_buf[0] = '\0';
1349 1402
1350 if (!silent) 1403 if (!silent)
1351 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!");
1352 "The Dungeon Master has arrived!");
1353 1405
1354 return 1; 1406 return 1;
1355 } else { 1407 }
1408 else
1409 {
1356 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.");
1357 op->contr->write_buf[0] ='\0'; 1411 op->contr->write_buf[0] = '\0';
1358 return 0; 1412 return 0;
1359 } 1413 }
1360} 1414}
1361 1415
1362/* 1416/*
1363 * 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
1364 * - 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
1365 */ 1419 */
1420int
1366int command_dm(object *op, char *params) { 1421command_dm (object *op, char *params)
1422{
1367 if (!op->contr) 1423 if (!op->contr)
1368 return 0;
1369
1370 do_wizard_dm(op, params, 0);
1371
1372 return 1;
1373}
1374
1375int command_invisible(object *op, char *params) {
1376 if (op) {
1377 op->invisible += 100;
1378 update_object(op, UP_OBJ_FACE);
1379 new_draw_info(NDI_UNIQUE, 0, op, "You turn invisible.");
1380 }
1381
1382 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;
1383} 1442}
1384 1443
1385/** 1444/**
1386 * Returns spell object (from archetypes) by name. 1445 * Returns spell object (from archetypes) by name.
1387 * Returns NULL if 0 or more than one spell matches. 1446 * Returns NULL if 0 or more than one spell matches.
… …
1392 * Ignores archetypes "spelldirect_xxx" since these archetypes are not used 1451 * Ignores archetypes "spelldirect_xxx" since these archetypes are not used
1393 * 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
1394 * 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
1395 * name than other "spell_xxx" archetypes and would always conflict. 1454 * name than other "spell_xxx" archetypes and would always conflict.
1396 */ 1455 */
1456static object *
1397static object *get_spell_by_name(object *op, const char *spell_name) { 1457get_spell_by_name (object *op, const char *spell_name)
1458{
1398 archetype *ar; 1459 archetype *ar;
1399 archetype *found; 1460 archetype *found;
1400 int conflict_found; 1461 int conflict_found;
1401 size_t spell_name_length; 1462 size_t spell_name_length;
1402 1463
1403 /* First check for full name matches. */ 1464 /* First check for full name matches. */
1404 conflict_found = 0; 1465 conflict_found = 0;
1405 found = NULL; 1466 found = NULL;
1406 for (ar = first_archetype; ar != NULL; ar = ar->next) { 1467 for (ar = first_archetype; ar != NULL; ar = ar->next)
1468 {
1407 if (ar->clone.type != SPELL) 1469 if (ar->clone.type != SPELL)
1408 continue; 1470 continue;
1409 1471
1410 if (strncmp(ar->name, "spelldirect_", 12) == 0) 1472 if (strncmp (ar->name, "spelldirect_", 12) == 0)
1411 continue; 1473 continue;
1412 1474
1413 if (strcmp(ar->clone.name, spell_name) != 0) 1475 if (strcmp (ar->clone.name, spell_name) != 0)
1414 continue; 1476 continue;
1415 1477
1416 if (found != NULL) { 1478 if (found != NULL)
1479 {
1417 if (!conflict_found) { 1480 if (!conflict_found)
1481 {
1418 conflict_found = 1; 1482 conflict_found = 1;
1419 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);
1420 new_draw_info_format(NDI_UNIQUE, 0, op, "- %s", found->name); 1484 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &found->name);
1421 } 1485 }
1422 new_draw_info_format(NDI_UNIQUE, 0, op, "- %s", ar->name); 1486 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s", &ar->name);
1423 continue; 1487 continue;
1424 } 1488 }
1425 1489
1426 found = ar; 1490 found = ar;
1427 } 1491 }
1428 1492
1429 /* No match if more more than one archetype matches. */ 1493 /* No match if more more than one archetype matches. */
1430 if (conflict_found) 1494 if (conflict_found)
1431 return NULL; 1495 return NULL;
1432 1496
1433 /* Return if exactly one archetype matches. */ 1497 /* Return if exactly one archetype matches. */
1434 if (found != NULL) 1498 if (found != NULL)
1435 return arch_to_object(found); 1499 return arch_to_object (found);
1436 1500
1437 /* No full match found: now check for partial matches. */ 1501 /* No full match found: now check for partial matches. */
1438 spell_name_length = strlen(spell_name); 1502 spell_name_length = strlen (spell_name);
1439 conflict_found = 0; 1503 conflict_found = 0;
1440 found = NULL; 1504 found = NULL;
1441 for (ar = first_archetype; ar != NULL; ar = ar->next) { 1505 for (ar = first_archetype; ar != NULL; ar = ar->next)
1506 {
1442 if (ar->clone.type != SPELL) 1507 if (ar->clone.type != SPELL)
1443 continue; 1508 continue;
1444 1509
1445 if (strncmp(ar->name, "spelldirect_", 12) == 0) 1510 if (strncmp (ar->name, "spelldirect_", 12) == 0)
1446 continue; 1511 continue;
1447 1512
1448 if (strncmp(ar->clone.name, spell_name, spell_name_length) != 0) 1513 if (strncmp (ar->clone.name, spell_name, spell_name_length) != 0)
1449 continue; 1514 continue;
1450 1515
1451 if (found != NULL) { 1516 if (found != NULL)
1517 {
1452 if (!conflict_found) { 1518 if (!conflict_found)
1519 {
1453 conflict_found = 1; 1520 conflict_found = 1;
1454 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);
1455 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);
1456 } 1523 }
1457 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);
1458 continue; 1525 continue;
1459 } 1526 }
1460 1527
1461 found = ar; 1528 found = ar;
1462 } 1529 }
1463 1530
1464 /* No match if more more than one archetype matches. */ 1531 /* No match if more more than one archetype matches. */
1465 if (conflict_found) 1532 if (conflict_found)
1466 return NULL;
1467
1468 /* Return if exactly one archetype matches. */
1469 if (found != NULL)
1470 return arch_to_object(found);
1471
1472 /* No spell found: just print an error message. */
1473 new_draw_info_format(NDI_UNIQUE, 0, op, "The spell %s does not exist.", spell_name);
1474 return NULL; 1533 return NULL;
1475}
1476 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
1477static int command_learn_spell_or_prayer(object *op, char *params, 1545command_learn_spell_or_prayer (object *op, char *params, int special_prayer)
1478 int special_prayer) { 1546{
1479 object *tmp; 1547 object *tmp;
1480 1548
1481 if (op->contr == NULL || params == NULL) { 1549 if (op->contr == NULL || params == NULL)
1550 {
1482 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?");
1483 return 0; 1552 return 0;
1484 } 1553 }
1485 1554
1486 tmp = get_spell_by_name(op, params); 1555 tmp = get_spell_by_name (op, params);
1487 if (tmp == NULL) { 1556 if (tmp == NULL)
1557 {
1488 return 0; 1558 return 0;
1489 } 1559 }
1490 1560
1491 if (check_spell_known(op, tmp->name)) { 1561 if (check_spell_known (op, tmp->name))
1562 {
1492 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);
1493 return 0; 1564 return 0;
1494 } 1565 }
1495 1566
1496 do_learn_spell(op, tmp, special_prayer); 1567 do_learn_spell (op, tmp, special_prayer);
1497 free_object(tmp); 1568 free_object (tmp);
1498 return 1; 1569 return 1;
1499} 1570}
1500 1571
1572int
1501int command_learn_spell(object *op, char *params) { 1573command_learn_spell (object *op, char *params)
1574{
1502 return command_learn_spell_or_prayer(op, params, 0); 1575 return command_learn_spell_or_prayer (op, params, 0);
1503} 1576}
1504 1577
1578int
1505int command_learn_special_prayer(object *op, char *params) 1579command_learn_special_prayer (object *op, char *params)
1506{ 1580{
1507 return command_learn_spell_or_prayer(op, params, 1); 1581 return command_learn_spell_or_prayer (op, params, 1);
1508} 1582}
1509 1583
1584int
1510int command_forget_spell(object *op, char *params) 1585command_forget_spell (object *op, char *params)
1511{ 1586{
1512 object *spell; 1587 object *spell;
1513 1588
1514 if (op->contr == NULL || params == NULL) { 1589 if (op->contr == NULL || params == NULL)
1590 {
1515 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?");
1516 return 0; 1592 return 0;
1517 } 1593 }
1518 1594
1519 spell = lookup_spell_by_name(op, params); 1595 spell = lookup_spell_by_name (op, params);
1520 if (spell == NULL) { 1596 if (spell == NULL)
1597 {
1521 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);
1522 return 0; 1599 return 0;
1523 } 1600 }
1524 1601
1525 do_forget_spell(op, spell->name); 1602 do_forget_spell (op, spell->name);
1526 return 1; 1603 return 1;
1527} 1604}
1528 1605
1529/** 1606/**
1530 * Lists all plugins currently loaded with their IDs and full names. 1607 * Lists all plugins currently loaded with their IDs and full names.
1531 */ 1608 */
1609int
1532int command_listplugins(object *op, char *params) 1610command_listplugins (object *op, char *params)
1533{ 1611{
1534 plugins_display_list(op); 1612 plugins_display_list (op);
1535 return 1; 1613 return 1;
1536} 1614}
1537 1615
1538/** 1616/**
1539 * 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
1540 * 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
1541 * once at a time, or bad things could happen. 1619 * once at a time, or bad things could happen.
1542 */ 1620 */
1621int
1543int command_loadplugin(object *op, char *params) { 1622command_loadplugin (object *op, char *params)
1623{
1544 char buf[MAX_BUF]; 1624 char buf[MAX_BUF];
1545 1625
1546 if (params == NULL) { 1626 if (params == NULL)
1627 {
1547 new_draw_info(NDI_UNIQUE, 0, op, "Load which plugin?"); 1628 new_draw_info (NDI_UNIQUE, 0, op, "Load which plugin?");
1548 return 1; 1629 return 1;
1549 } 1630 }
1550 1631
1551 strcpy(buf, LIBDIR); 1632 strcpy (buf, LIBDIR);
1552 strcat(buf, "/plugins/"); 1633 strcat (buf, "/plugins/");
1553 strcat(buf, params); 1634 strcat (buf, params);
1554 LOG(llevDebug, "Requested plugin file is %s\n", buf); 1635 LOG (llevDebug, "Requested plugin file is %s\n", buf);
1555 if (plugins_init_plugin(buf) == 0) 1636 if (plugins_init_plugin (buf) == 0)
1556 new_draw_info(NDI_UNIQUE, 0, op, "Plugin successfully loaded."); 1637 new_draw_info (NDI_UNIQUE, 0, op, "Plugin successfully loaded.");
1557 else 1638 else
1558 new_draw_info(NDI_UNIQUE, 0, op, "Could not load plugin."); 1639 new_draw_info (NDI_UNIQUE, 0, op, "Could not load plugin.");
1559 return 1; 1640 return 1;
1560} 1641}
1561 1642
1562/** 1643/**
1563 * 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.
1564 * 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
1565 * loaded. 1646 * loaded.
1566 */ 1647 */
1648int
1567int command_unloadplugin(object *op, char *params) 1649command_unloadplugin (object *op, char *params)
1568{ 1650{
1569 if (params == NULL) { 1651 if (params == NULL)
1652 {
1570 new_draw_info(NDI_UNIQUE, 0, op, "Remove which plugin?"); 1653 new_draw_info (NDI_UNIQUE, 0, op, "Remove which plugin?");
1571 return 1; 1654 return 1;
1572 } 1655 }
1573 1656
1574 if (plugins_remove_plugin(params) == 0) 1657 if (plugins_remove_plugin (params) == 0)
1575 new_draw_info(NDI_UNIQUE, 0, op, "Plugin successfully removed."); 1658 new_draw_info (NDI_UNIQUE, 0, op, "Plugin successfully removed.");
1576 else 1659 else
1577 new_draw_info(NDI_UNIQUE, 0, op, "Could not remove plugin."); 1660 new_draw_info (NDI_UNIQUE, 0, op, "Could not remove plugin.");
1578 return 1; 1661 return 1;
1579} 1662}
1580 1663
1581/** 1664/**
1582 * A players wants to become DM and hide. 1665 * A players wants to become DM and hide.
1583 * Let's see if that's authorized. 1666 * Let's see if that's authorized.
1584 * Make sure to not tell anything to anyone. 1667 * Make sure to not tell anything to anyone.
1585 */ 1668 */
1669int
1586int command_dmhide(object *op, char *params) { 1670command_dmhide (object *op, char *params)
1671{
1587 if (!do_wizard_dm(op, params, 1)) 1672 if (!do_wizard_dm (op, params, 1))
1588 return 0; 1673 return 0;
1589 1674
1590 do_wizard_hide(op, 1); 1675 do_wizard_hide (op, 1);
1591 1676
1592 return 1; 1677 return 1;
1593} 1678}
1594 1679
1680void
1595void dm_stack_pop(player *pl) { 1681dm_stack_pop (player *pl)
1682{
1596 if (!pl->stack_items || !pl->stack_position) { 1683 if (!pl->stack_items || !pl->stack_position)
1684 {
1597 new_draw_info(NDI_UNIQUE, 0, pl->ob, "Empty stack!"); 1685 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
1598 return; 1686 return;
1599 } 1687 }
1600 1688
1601 pl->stack_position--; 1689 pl->stack_position--;
1602 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);
1603} 1691}
1604 1692
1605/** 1693/**
1606 * Get current stack top item for player. 1694 * Get current stack top item for player.
1607 * Returns NULL if no stacked item. 1695 * Returns NULL if no stacked item.
1608 * If stacked item disappeared (freed), remove it. 1696 * If stacked item disappeared (freed), remove it.
1609 * 1697 *
1610 * Ryo, august 2004 1698 * Ryo, august 2004
1611 */ 1699 */
1700object *
1612object *dm_stack_peek(player *pl) { 1701dm_stack_peek (player *pl)
1702{
1613 object* ob; 1703 object *ob;
1614 1704
1615 if (!pl->stack_position) { 1705 if (!pl->stack_position)
1706 {
1616 new_draw_info(NDI_UNIQUE, 0, pl->ob, "Empty stack!"); 1707 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Empty stack!");
1617 return NULL; 1708 return NULL;
1618 } 1709 }
1619 1710
1620 ob = find_object(pl->stack_items[pl->stack_position-1]); 1711 ob = find_object (pl->stack_items[pl->stack_position - 1]);
1621 if (!ob) { 1712 if (!ob)
1713 {
1622 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!");
1623 dm_stack_pop(pl); 1715 dm_stack_pop (pl);
1624 return NULL; 1716 return NULL;
1625 } 1717 }
1626 1718
1627 return ob; 1719 return ob;
1628} 1720}
1629 1721
1630/** 1722/**
1631 * Push specified item on player stack. 1723 * Push specified item on player stack.
1632 * Inform player of position. 1724 * Inform player of position.
1633 * Initializes variables if needed. 1725 * Initializes variables if needed.
1634 */ 1726 */
1727void
1635void dm_stack_push(player *pl, tag_t item) { 1728dm_stack_push (player *pl, tag_t item)
1729{
1636 if (!pl->stack_items) { 1730 if (!pl->stack_items)
1731 {
1637 pl->stack_items = (tag_t *)malloc(sizeof(tag_t)*STACK_SIZE); 1732 pl->stack_items = (tag_t *) malloc (sizeof (tag_t) * STACK_SIZE);
1638 memset(pl->stack_items, 0, sizeof(tag_t)*STACK_SIZE); 1733 memset (pl->stack_items, 0, sizeof (tag_t) * STACK_SIZE);
1639 } 1734 }
1640 1735
1641 if (pl->stack_position == STACK_SIZE) { 1736 if (pl->stack_position == STACK_SIZE)
1737 {
1642 new_draw_info(NDI_UNIQUE, 0, pl->ob, "Item stack full!"); 1738 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Item stack full!");
1643 return; 1739 return;
1644 } 1740 }
1645 1741
1646 pl->stack_items[pl->stack_position] = item; 1742 pl->stack_items[pl->stack_position] = item;
1647 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);
1648 pl->stack_position++; 1744 pl->stack_position++;
1649} 1745}
1650 1746
1651/** 1747/**
1652 * Checks 'params' for object code. 1748 * Checks 'params' for object code.
1653 * 1749 *
… …
1665 * * STACK_FROM_STACK => item from somewhere in the stack 1761 * * STACK_FROM_STACK => item from somewhere in the stack
1666 * * STACK_FROM_NUMBER => item by number, pushed on stack 1762 * * STACK_FROM_NUMBER => item by number, pushed on stack
1667 * 1763 *
1668 * Ryo, august 2004 1764 * Ryo, august 2004
1669 */ 1765 */
1766object *
1670object *get_dm_object(player *pl, char **params, int *from) { 1767get_dm_object (player *pl, char **params, int *from)
1768{
1671 int item_tag, item_position; 1769 int item_tag, item_position;
1672 object *ob; 1770 object *ob;
1673 1771
1674 if (!pl) 1772 if (!pl)
1675 return NULL; 1773 return NULL;
1676 1774
1677 if (!params || !*params || **params == '\0') { 1775 if (!params || !*params || **params == '\0')
1776 {
1678 if (from) 1777 if (from)
1679 *from = STACK_FROM_TOP; 1778 *from = STACK_FROM_TOP;
1680 /* No parameter => get stack item */ 1779 /* No parameter => get stack item */
1681 return dm_stack_peek(pl); 1780 return dm_stack_peek (pl);
1682 } 1781 }
1683 1782
1684 /* Let's clean white spaces */ 1783 /* Let's clean white spaces */
1685 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))
1686 (*params)++; 1792 (*params)++;
1687 1793
1688 /* Next case: number => item tag */
1689 if (sscanf(*params, "%d", &item_tag)) {
1690 /* Move parameter to next item */
1691 while (isdigit(**params))
1692 (*params)++;
1693
1694 /* And skip blanks, too */ 1794 /* And skip blanks, too */
1695 while (**params == ' ') 1795 while (**params == ' ')
1696 (*params)++;
1697
1698 /* Get item */
1699 ob = find_object(item_tag);
1700 if (!ob) {
1701 if (from)
1702 *from = STACK_FROM_NONE;
1703 new_draw_info_format(NDI_UNIQUE, 0, pl->ob, "No such item %d!", item_tag);
1704 return NULL;
1705 }
1706
1707 /* Got one, let's push it on stack */
1708 dm_stack_push(pl, item_tag);
1709 if (from)
1710 *from = STACK_FROM_NUMBER;
1711 return ob;
1712 }
1713
1714 /* Next case: $number => stack item */
1715 if (sscanf(*params, "$%d", &item_position)) {
1716 /* Move parameter to next item */
1717 (*params)++; 1796 (*params)++;
1718 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
1719 while (isdigit(**params)) 1821 while (isdigit (**params))
1720 (*params)++; 1822 (*params)++;
1721 while (**params == ' ') 1823 while (**params == ' ')
1722 (*params)++; 1824 (*params)++;
1723 1825
1724 if (item_position >= pl->stack_position) { 1826 if (item_position >= pl->stack_position)
1827 {
1725 if (from) 1828 if (from)
1726 *from = STACK_FROM_NONE; 1829 *from = STACK_FROM_NONE;
1727 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);
1728 return NULL; 1831 return NULL;
1729 } 1832 }
1730 1833
1731 ob = find_object(pl->stack_items[item_position]); 1834 ob = find_object (pl->stack_items[item_position]);
1732 if (!ob) { 1835 if (!ob)
1836 {
1733 if (from) 1837 if (from)
1734 *from = STACK_FROM_NONE; 1838 *from = STACK_FROM_NONE;
1735 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);
1736 return NULL; 1840 return NULL;
1737 } 1841 }
1738 1842
1739 if (from) 1843 if (from)
1740 *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;
1741 return ob; 1845 return ob;
1742 } 1846 }
1743 1847
1744 /* Next case: 'me' => return pl->ob */ 1848 /* Next case: 'me' => return pl->ob */
1745 if (!strncmp(*params, "me", 2)) { 1849 if (!strncmp (*params, "me", 2))
1850 {
1746 if (from) 1851 if (from)
1747 *from = STACK_FROM_NUMBER; 1852 *from = STACK_FROM_NUMBER;
1748 dm_stack_push(pl, pl->ob->count); 1853 dm_stack_push (pl, pl->ob->count);
1749 1854
1750 /* Skip to next token */ 1855 /* Skip to next token */
1751 (*params) += 2; 1856 (*params) += 2;
1752 while (**params == ' ') 1857 while (**params == ' ')
1753 (*params)++; 1858 (*params)++;
1754 1859
1755 return pl->ob; 1860 return pl->ob;
1756 } 1861 }
1757 1862
1758 /* Last case: get stack top */ 1863 /* Last case: get stack top */
1759 if (from) 1864 if (from)
1760 *from = STACK_FROM_TOP; 1865 *from = STACK_FROM_TOP;
1761 return dm_stack_peek(pl); 1866 return dm_stack_peek (pl);
1762} 1867}
1763 1868
1764/** 1869/**
1765 * Pop the stack top. 1870 * Pop the stack top.
1766 */ 1871 */
1872int
1767int command_stack_pop(object *op, char *params) { 1873command_stack_pop (object *op, char *params)
1874{
1768 dm_stack_pop(op->contr); 1875 dm_stack_pop (op->contr);
1769 return 0; 1876 return 0;
1770} 1877}
1771 1878
1772/** 1879/**
1773 * Push specified item on stack. 1880 * Push specified item on stack.
1774 */ 1881 */
1882int
1775int command_stack_push(object *op, char *params) { 1883command_stack_push (object *op, char *params)
1884{
1776 object *ob; 1885 object *ob;
1777 int from; 1886 int from;
1887
1778 ob = get_dm_object(op->contr, &params, &from); 1888 ob = get_dm_object (op->contr, &params, &from);
1779 1889
1780 if (ob && from != STACK_FROM_NUMBER) 1890 if (ob && from != STACK_FROM_NUMBER)
1781 /* Object was from stack, need to push it again */ 1891 /* Object was from stack, need to push it again */
1782 dm_stack_push(op->contr, ob->count); 1892 dm_stack_push (op->contr, ob->count);
1783 1893
1784 return 0; 1894 return 0;
1785} 1895}
1786 1896
1787/** 1897/**
1788 * Displays stack contents. 1898 * Displays stack contents.
1789 */ 1899 */
1900int
1790int command_stack_list(object *op, char *params) { 1901command_stack_list (object *op, char *params)
1902{
1791 int item; 1903 int item;
1792 object *display; 1904 object *display;
1793 player *pl = op->contr; 1905 player *pl = op->contr;
1794 1906
1795 new_draw_info(NDI_UNIQUE, 0, op, "Item stack contents:"); 1907 new_draw_info (NDI_UNIQUE, 0, op, "Item stack contents:");
1796 1908
1797 for (item = 0; item < pl->stack_position; item++) { 1909 for (item = 0; item < pl->stack_position; item++)
1910 {
1798 display = find_object(pl->stack_items[item]); 1911 display = find_object (pl->stack_items[item]);
1799 if (display) 1912 if (display)
1800 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);
1801 else 1914 else
1802 /* Item was freed */ 1915 /* Item was freed */
1803 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]);
1804 } 1917 }
1805 1918
1806 return 0; 1919 return 0;
1807} 1920}
1808 1921
1809/** 1922/**
1810 * Empty DM item stack. 1923 * Empty DM item stack.
1811 */ 1924 */
1925int
1812int command_stack_clear(object *op, char *params) { 1926command_stack_clear (object *op, char *params)
1927{
1813 op->contr->stack_position = 0; 1928 op->contr->stack_position = 0;
1814 new_draw_info(NDI_UNIQUE, 0, op, "Item stack cleared."); 1929 new_draw_info (NDI_UNIQUE, 0, op, "Item stack cleared.");
1815 return 0; 1930 return 0;
1816} 1931}
1817 1932
1933int
1818int command_insert_into(object* op, char *params) 1934command_insert_into (object *op, char *params)
1819{ 1935{
1820 object *left, *right, *inserted; 1936 object *left, *right, *inserted;
1821 const char *diff;
1822 int left_from, right_from; 1937 int left_from, right_from;
1823 1938
1824 left = get_dm_object(op->contr, &params, &left_from); 1939 left = get_dm_object (op->contr, &params, &left_from);
1825 if (!left) { 1940 if (!left)
1941 {
1826 new_draw_info(NDI_UNIQUE, 0, op, "Insert into what object?"); 1942 new_draw_info (NDI_UNIQUE, 0, op, "Insert into what object?");
1827 return 0; 1943 return 0;
1828 } 1944 }
1829 1945
1830 if (left_from == STACK_FROM_NUMBER) 1946 if (left_from == STACK_FROM_NUMBER)
1831 /* Item was stacked, remove it else right will be the same... */ 1947 /* Item was stacked, remove it else right will be the same... */
1832 dm_stack_pop(op->contr); 1948 dm_stack_pop (op->contr);
1833 1949
1834 right = get_dm_object(op->contr, &params, &right_from); 1950 right = get_dm_object (op->contr, &params, &right_from);
1835 1951
1836 if (!right) { 1952 if (!right)
1953 {
1837 new_draw_info(NDI_UNIQUE, 0, op, "Insert what item?"); 1954 new_draw_info (NDI_UNIQUE, 0, op, "Insert what item?");
1838 return 0; 1955 return 0;
1839 } 1956 }
1840 1957
1841 if (left_from == STACK_FROM_TOP && right_from == STACK_FROM_TOP) { 1958 if (left_from == STACK_FROM_TOP && right_from == STACK_FROM_TOP)
1959 {
1842 /* 1960 /*
1843 * Special case: both items were taken from stack top. 1961 * Special case: both items were taken from stack top.
1844 * 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.
1845 * See function description for why. 1963 * See function description for why.
1846 * Besides, can't insert an item into itself. 1964 * Besides, can't insert an item into itself.
1847 */ 1965 */
1848 if (op->contr->stack_position > 1) { 1966 if (op->contr->stack_position > 1)
1967 {
1849 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]);
1850 if (left) 1969 if (left)
1851 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)");
1852 else 1971 else
1853 /* Stupid case: item under top was freed, fallback to stack top */ 1972 /* Stupid case: item under top was freed, fallback to stack top */
1854 left = right; 1973 left = right;
1855 } 1974 }
1856 } 1975 }
1857 1976
1858 if (left == right) 1977 if (left == right)
1859 { 1978 {
1860 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!");
1861 return 0; 1980 return 0;
1862 } 1981 }
1863 1982
1864 if (right->type == PLAYER) 1983 if (right->type == PLAYER)
1865 { 1984 {
1866 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!");
1867 return 0; 1986 return 0;
1868 } 1987 }
1869 1988
1870 if (!QUERY_FLAG(right,FLAG_REMOVED)) 1989 if (!QUERY_FLAG (right, FLAG_REMOVED))
1871 remove_ob(right); 1990 remove_ob (right);
1872 inserted = insert_ob_in_ob(right,left); 1991 inserted = insert_ob_in_ob (right, left);
1873 if (left->type == PLAYER) 1992 if (left->type == PLAYER)
1874 if (inserted == right) 1993 if (inserted == right)
1875 esrv_send_item(left,right); 1994 esrv_send_item (left, right);
1876 else 1995 else
1877 esrv_update_item(UPD_WEIGHT|UPD_NAME|UPD_NROF,left,inserted); 1996 esrv_update_item (UPD_WEIGHT | UPD_NAME | UPD_NROF, left, inserted);
1878 1997
1879 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));
1880 1999
1881 return 0; 2000 return 0;
1882 2001
1883} 2002}

Diff Legend

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