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.4 by root, Tue Aug 29 08:01:37 2006 UTC vs.
Revision 1.25 by root, Thu Dec 21 23:37:06 2006 UTC

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

Diff Legend

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