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

Comparing deliantra/server/server/player.C (file contents):
Revision 1.19 by root, Mon Sep 11 23:53:30 2006 UTC vs.
Revision 1.97 by root, Mon Jan 8 22:32:11 2007 UTC

1
2/* 1/*
3 * static char *rcsid_player_c = 2 * CrossFire, A Multiplayer game
4 * "$Id: player.C,v 1.19 2006/09/11 23:53:30 root Exp $"; 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 *
22 * The author can be reached via e-mail to <crossfire@schmorp.de>
5 */ 23 */
6 24
7/*
8 CrossFire, A Multiplayer game for X-windows
9
10 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen
12
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
27 The author can be reached via e-mail to crossfire-devel@real-time.com
28*/
29
30#include <global.h> 25#include <global.h>
31#ifndef WIN32 /* ---win32 remove headers */
32# include <pwd.h> 26#include <pwd.h>
33#endif
34#ifndef __CEXTRACT__
35# include <sproto.h> 27#include <sproto.h>
36#endif
37#include <sounds.h> 28#include <sounds.h>
38#include <living.h> 29#include <living.h>
39#include <object.h> 30#include <object.h>
40#include <spells.h> 31#include <spells.h>
41#include <skills.h> 32#include <skills.h>
42#include <newclient.h>
43 33
44#ifdef COZY_SERVER 34#include <algorithm>
45extern int same_party (partylist *a, partylist *b); 35#include <functional>
46#endif
47 36
48player * 37playervec players;
49find_player (const char *plname)
50{
51 player *pl;
52
53 for (pl = first_player; pl != NULL; pl = pl->next)
54 {
55 if (pl->ob != NULL && !strcmp (query_name (pl->ob), plname))
56 return pl;
57 };
58 return NULL;
59}
60
61player *
62find_player_partial_name (const char *plname)
63{
64 player *pl;
65 player *found = NULL;
66 size_t namelen = strlen (plname);
67
68 for (pl = first_player; pl != NULL; pl = pl->next)
69 {
70 if ((size_t) strlen (pl->ob->name) < namelen)
71 continue;
72
73 if (!strcmp (pl->ob->name, plname))
74 return pl;
75
76 if (!strncasecmp (pl->ob->name, plname, namelen))
77 {
78 if (found)
79 return NULL;
80
81 found = pl;
82 }
83 }
84 return found;
85}
86 38
87void 39void
88display_motd (const object *op) 40display_motd (const object *op)
89{ 41{
90 char buf[MAX_BUF]; 42 char buf[MAX_BUF];
… …
93 int comp; 45 int comp;
94 int size; 46 int size;
95 47
96 sprintf (buf, "%s/%s", settings.confdir, settings.motd); 48 sprintf (buf, "%s/%s", settings.confdir, settings.motd);
97 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL) 49 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
98 {
99 return; 50 return;
100 } 51
101 motd[0] = '\0'; 52 motd[0] = '\0';
102 size = 0; 53 size = 0;
54
103 while (fgets (buf, MAX_BUF, fp) != NULL) 55 while (fgets (buf, MAX_BUF, fp))
104 { 56 {
105 if (*buf == '#') 57 if (*buf == '#')
106 continue; 58 continue;
59
107 strncat (motd + size, buf, HUGE_BUF - size); 60 strncat (motd + size, buf, HUGE_BUF - size);
108 size += strlen (buf); 61 size += strlen (buf);
109 } 62 }
63
110 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_MOTD, MSG_SUBTYPE_NONE, motd, NULL); 64 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_MOTD, MSG_SUBTYPE_NONE, motd, NULL);
111 close_and_delete (fp, comp); 65 close_and_delete (fp, comp);
112} 66}
113 67
114void 68void
… …
120 int comp; 74 int comp;
121 int size; 75 int size;
122 76
123 sprintf (buf, "%s/%s", settings.confdir, settings.rules); 77 sprintf (buf, "%s/%s", settings.confdir, settings.rules);
124 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL) 78 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
125 {
126 return; 79 return;
127 } 80
128 rules[0] = '\0'; 81 rules[0] = '\0';
129 size = 0; 82 size = 0;
83
130 while (fgets (buf, MAX_BUF, fp) != NULL) 84 while (fgets (buf, MAX_BUF, fp))
131 { 85 {
132 if (*buf == '#') 86 if (*buf == '#')
133 continue; 87 continue;
88
134 if (size + strlen (buf) >= HUGE_BUF) 89 if (size + strlen (buf) >= HUGE_BUF)
135 { 90 {
136 LOG (llevDebug, "Warning, rules size is > %d bytes.\n", HUGE_BUF); 91 LOG (llevDebug, "Warning, rules size is > %d bytes.\n", HUGE_BUF);
137 break; 92 break;
138 } 93 }
94
139 strncat (rules + size, buf, HUGE_BUF - size); 95 strncat (rules + size, buf, HUGE_BUF - size);
140 size += strlen (buf); 96 size += strlen (buf);
141 } 97 }
98
142 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_RULES, rules, NULL); 99 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_RULES, rules, NULL);
143 close_and_delete (fp, comp); 100 close_and_delete (fp, comp);
144} 101}
145 102
146void 103void
… …
154 int size; 111 int size;
155 112
156 sprintf (buf, "%s/%s", settings.confdir, settings.news); 113 sprintf (buf, "%s/%s", settings.confdir, settings.news);
157 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL) 114 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
158 return; 115 return;
116
159 news[0] = '\0'; 117 news[0] = '\0';
160 subject[0] = '\0'; 118 subject[0] = '\0';
161 size = 0; 119 size = 0;
120
162 while (fgets (buf, MAX_BUF, fp) != NULL) 121 while (fgets (buf, MAX_BUF, fp) != NULL)
163 { 122 {
164 if (*buf == '#') 123 if (*buf == '#')
165 continue; 124 continue;
125
166 if (*buf == '%') 126 if (*buf == '%')
167 { /* send one news */ 127 { /* send one news */
168 if (size > 0) 128 if (size > 0)
169 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s", "%s\n%s", subject, news); /*send previously read news */ 129 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s", "%s\n%s", subject, news); /*send previously read news */
130
170 strcpy (subject, buf + 1); 131 strcpy (subject, buf + 1);
171 strip_endline (subject); 132 strip_endline (subject);
172 size = 0; 133 size = 0;
173 news[0] = '\0'; 134 news[0] = '\0';
174 } 135 }
… …
187 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op, 148 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,
188 MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s\n", "%s\n%s", subject, news); 149 MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s\n", "%s\n%s", subject, news);
189 close_and_delete (fp, comp); 150 close_and_delete (fp, comp);
190} 151}
191 152
192int
193playername_ok (const char *cp)
194{
195 /* Don't allow - or _ as first character in the name */
196 if (*cp == '-' || *cp == '_')
197 return 0;
198
199 for (; *cp != '\0'; cp++)
200 if (!((*cp >= 'a' && *cp <= 'z') || (*cp >= 'A' && *cp <= 'Z')) && *cp != '-' && *cp != '_')
201 return 0;
202 return 1;
203}
204
205/* This no longer sets the player map. Also, it now updates
206 * all the pointers so the caller doesn't need to do that.
207 * Caller is responsible for setting the correct map.
208 */
209
210/* Redo this to do both get_player_ob and get_player.
211 * Hopefully this will be less bugfree and simpler.
212 * Returns the player structure. If 'p' is null,
213 * we create a new one. Otherwise, we recycle
214 * the one that is passed.
215 */
216static player *
217get_player (player *p)
218{
219 object *op = arch_to_object (get_player_archetype (NULL));
220 int i;
221
222 if (!p)
223 {
224 p = new player;
225
226 /* This adds the player in the linked list. There is extra
227 * complexity here because we want to add the new player at the
228 * end of the list - there is in fact no compelling reason that
229 * that needs to be done except for things like output of
230 * 'who'.
231 */
232 player *tmp = first_player;
233
234 while (tmp != NULL && tmp->next != NULL)
235 tmp = tmp->next;
236 if (tmp != NULL)
237 tmp->next = p;
238 else
239 first_player = p;
240
241 p->next = NULL;
242 }
243
244 /* Clears basically the entire player structure except
245 * for next and socket.
246 */
247 p->clear ();
248
249 /* There are some elements we want initialized to non zero value -
250 * we deal with that below this point.
251 */
252 p->party = NULL;
253 p->outputs_sync = 16; /* Every 2 seconds */
254 p->outputs_count = 8; /* Keeps present behaviour */
255 p->unapply = unapply_nochoice;
256 p->Swap_First = -1;
257
258#ifdef AUTOSAVE
259 p->last_save_tick = 9999999;
260#endif
261
262 strcpy (p->savebed_map, first_map_path); /* Init. respawn position */
263
264 op->contr = p; /* this aren't yet in archetype */
265 p->ob = op;
266 op->speed_left = 0.5;
267 op->speed = 1.0;
268 op->direction = 5; /* So player faces south */
269 op->stats.wc = 2;
270 op->run_away = 25; /* Then we panick... */
271 p->socket.monitor_spells = 0; /* Needed because esrv_update_spells( ) gets called by roll_stats */
272
273 roll_stats (op);
274 p->state = ST_ROLL_STAT;
275 clear_los (op);
276
277 p->gen_sp_armour = 10;
278 p->last_speed = -1;
279 p->shoottype = range_none;
280 p->bowtype = bow_normal;
281 p->petmode = pet_normal;
282 p->listening = 10;
283 p->usekeys = containers;
284 p->last_weapon_sp = -1;
285 p->peaceful = 1; /* default peaceful */
286 p->do_los = 1;
287 p->explore = 0;
288 p->no_shout = 0; /* default can shout */
289
290 strncpy (p->title, op->arch->clone.name, sizeof (p->title) - 1);
291 p->title[sizeof (p->title) - 1] = '\0';
292 op->race = op->arch->clone.race;
293
294 CLEAR_FLAG (op, FLAG_READY_SKILL);
295
296 /* we need to clear these to -1 and not zero - otherwise,
297 * if a player quits and starts a new character, we wont
298 * send new values to the client, as things like exp start
299 * at zero.
300 */
301 for (i = 0; i < NUM_SKILLS; i++)
302 {
303 p->last_skill_exp[i] = -1;
304 p->last_skill_ob[i] = NULL;
305 }
306 for (i = 0; i < NROFATTACKS; i++)
307 {
308 p->last_resist[i] = -1;
309 }
310 p->last_stats.exp = -1;
311 p->last_weight = (uint32) - 1;
312
313 p->socket.update_look = 0;
314 p->socket.look_position = 0;
315 return p;
316}
317
318/* This loads the first map an puts the player on it. */ 153/* This loads the first map an puts the player on it. */
319static void 154static void
320set_first_map (object *op) 155set_first_map (object *op)
321{ 156{
322 strcpy (op->contr->maplevel, first_map_path); 157 op->contr->maplevel = first_map_path;
323 op->x = -1; 158 op->x = -1;
324 op->y = -1; 159 op->y = -1;
325 enter_exit (op, NULL);
326} 160}
327 161
162void
163player::enter_map ()
164{
165 object *tmp = object::create ();
166
167 EXIT_PATH (tmp) = maplevel;
168 EXIT_X (tmp) = ob->x;
169 EXIT_Y (tmp) = ob->y;
170 ob->enter_exit (tmp);
171
172 tmp->destroy ();
173}
174
175void
176player::activate ()
177{
178 if (active)
179 return;
180
181 players.insert (this);
182 ob->remove ();
183 ob->map = 0;
184 ob->activate_recursive ();
185 CLEAR_FLAG (ob, FLAG_FRIENDLY);
186 add_friendly_object (ob);
187 enter_map ();
188}
189
190void
191player::deactivate ()
192{
193 if (!active)
194 return;
195
196 terminate_all_pets (ob);
197 remove_friendly_object (ob);
198 ob->deactivate_recursive ();
199 ob->remove ();
200 ob->map = 0;
201
202 // for weird reasons, this is often "ob", keeping a circular reference
203 ranges [range_skill] = 0;
204
205 players.erase (this);
206}
207
208// connect the player with a specific client
209// also changed, rationalises, and fixes some incorrect settings
210void
211player::connect (client *ns)
212{
213 this->ns = ns;
214 ns->pl = this;
215
216 run_on = 0;
217 fire_on = 0;
218 ob->container = 0; //TODO: client-specific
219
220 ns->update_look = 0;
221 ns->look_position = 0;
222
223 clear_los (ob);
224
225 ns->reset_stats ();
226
227 /* make sure he's a player -- needed because of class change. */
228 ob->type = PLAYER; // we are paranoid
229 ob->race = ob->arch->clone.race;
230
231 if (!legal_range (ob, shoottype))
232 shoottype = range_none;
233
234 ob->carrying = sum_weight (ob);
235 link_player_skills (ob);
236
237 CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER);
238
239 assign (title, ob->arch->clone.name);
240
241 /* can_use_shield is a new flag. However, the can_use.. seems to largely come
242 * from the class, and not race. I don't see any way to get the class information
243 * to then update this. I don't think this will actually break anything - anyone
244 * that can use armour should be able to use a shield. What this may 'break'
245 * are features new characters get, eg, if someone starts up with a Q, they
246 * should be able to use a shield. However, old Q's won't get that advantage.
247 */
248 if (QUERY_FLAG (ob, FLAG_USE_ARMOUR))
249 SET_FLAG (ob, FLAG_USE_SHIELD);
250
251 /* if it's a dragon player, set the correct title here */
252 if (is_dragon_pl (ob))
253 {
254 object *tmp, *abil = 0, *skin = 0;
255
256 shstr_cmp dragon_ability_force ("dragon_ability_force");
257 shstr_cmp dragon_skin_force ("dragon_skin_force");
258
259 for (tmp = ob->inv; tmp; tmp = tmp->below)
260 if (tmp->type == FORCE)
261 if (tmp->arch->name == dragon_ability_force)
262 abil = tmp;
263 else if (tmp->arch->name == dragon_skin_force)
264 skin = tmp;
265
266 set_dragon_name (ob, abil, skin);
267 }
268
269 new_draw_info (NDI_UNIQUE, 0, ob, "Welcome Back!");
270
271 esrv_new_player (this, ob->weight + ob->carrying);
272
273 ob->update_stats ();
274 ns->floorbox_update ();
275
276 esrv_send_inventory (ob, ob);
277 esrv_add_spells (this, 0);
278
279 activate ();
280
281 send_rules (ob);
282 send_news (ob);
283 display_motd (ob);
284
285 INVOKE_PLAYER (CONNECT, this);
286 INVOKE_PLAYER (LOGIN, this);
287}
288
289void
290player::disconnect ()
291{
292 if (ns)
293 {
294 if (active)
295 INVOKE_PLAYER (LOGOUT, this, ARG_INT (0));
296
297 INVOKE_PLAYER (DISCONNECT, this);
298
299 ns->reset_stats ();
300 ns->pl = 0;
301 this->ns = 0;
302 }
303
304 ob->container = 0; //TODO: client-specific
305 deactivate ();
306}
307
308// the need for this function can be explained
309// by load_object not returning the object
310void
311player::set_object (object *op)
312{
313 ob = op;
314 ob->contr = this; /* this aren't yet in archetype */
315
316 ob->speed_left = 0.5;
317 ob->speed = 1.0;
318 ob->direction = 5; /* So player faces south */
319 ob->stats.wc = 2;
320 ob->run_away = 25; /* Then we panick... */
321
322 ob->roll_stats ();
323}
324
325player::player ()
326{
327 /* There are some elements we want initialised to non zero value -
328 * we deal with that below this point.
329 */
330 outputs_sync = 16; /* Every 2 seconds */
331 outputs_count = 8; /* Keeps present behaviour */
332 unapply = unapply_nochoice;
333
334 savebed_map = first_map_path; /* Init. respawn position */
335
336 gen_sp_armour = 10;
337 shoottype = range_none;
338 bowtype = bow_normal;
339 petmode = pet_normal;
340 listening = 10;
341 usekeys = containers;
342 peaceful = 1; /* default peaceful */
343 do_los = 1;
344}
345
346void
347player::do_destroy ()
348{
349 disconnect ();
350
351 attachable::do_destroy ();
352
353 if (ob)
354 {
355 ob->destroy_inv (false);
356 ob->destroy ();
357 }
358}
359
360player::~player ()
361{
362 /* Clear item stack */
363 free (stack_items);
364}
365
328/* Tries to add player on the connection passwd in ns. 366/* Tries to add player on the connection passed in ns.
329 * All we can really get in this is some settings like host and display 367 * All we can really get in this is some settings like host and display
330 * mode. 368 * mode.
331 */ 369 */
332
333int
334add_player (NewSocket * ns)
335{
336 player *p; 370player *
371player::create ()
372{
373 player *pl = new player;
337 374
338 p = get_player (NULL); 375 pl->set_object (arch_to_object (get_player_archetype (0)));
339 p->socket = *ns;
340 p->socket.faces_sent = (uint8 *) malloc (p->socket.faces_sent_len * sizeof (*p->socket.faces_sent));
341 if (p->socket.faces_sent == NULL)
342 fatal (OUT_OF_MEMORY);
343 memcpy (p->socket.faces_sent, ns->faces_sent, p->socket.faces_sent_len * sizeof (*p->socket.faces_sent));
344 /* Needed because the socket we just copied over needs to be cleared.
345 * Note that this can result in a client reset if there is partial data
346 * on the uncoming socket.
347 */
348 p->socket.inbuf.len = 0;
349 set_first_map (p->ob); 376 set_first_map (pl->ob);
350 377
351 CLEAR_FLAG (p->ob, FLAG_FRIENDLY);
352 add_friendly_object (p->ob);
353 send_rules (p->ob);
354 send_news (p->ob);
355 display_motd (p->ob);
356 get_name (p->ob);
357 return 0; 378 return pl;
358} 379}
359 380
360/* 381/*
361 * get_player_archetype() return next player archetype from archetype 382 * get_player_archetype() return next player archetype from archetype
362 * list. Not very efficient routine, but used only creating new players. 383 * list. Not very efficient routine, but used only creating new players.
… …
371 { 392 {
372 if (at == NULL || at->next == NULL) 393 if (at == NULL || at->next == NULL)
373 at = first_archetype; 394 at = first_archetype;
374 else 395 else
375 at = at->next; 396 at = at->next;
397
376 if (at->clone.type == PLAYER) 398 if (at->clone.type == PLAYER)
377 return at; 399 return at;
400
378 if (at == start) 401 if (at == start)
379 { 402 {
380 LOG (llevError, "No Player archetypes\n"); 403 LOG (llevError, "No Player archetypes\n");
381 exit (-1); 404 exit (-1);
382 } 405 }
383 } 406 }
384} 407}
385 408
386
387object * 409object *
388get_nearest_player (object *mon) 410get_nearest_player (object *mon)
389{ 411{
390 object *op = NULL; 412 object *op = NULL;
391 player *pl = NULL;
392 objectlink *ol; 413 objectlink *ol;
393 unsigned lastdist; 414 unsigned lastdist;
394 rv_vector rv; 415 rv_vector rv;
395 416
396 for (ol = first_friendly_object, lastdist = 1000; ol != NULL; ol = ol->next) 417 for (ol = first_friendly_object, lastdist = 1000; ol; ol = ol->next)
397 { 418 {
398 /* We should not find free objects on this friendly list, but it 419 /* We should not find free objects on this friendly list, but it
399 * does periodically happen. Given that, lets deal with it. 420 * does periodically happen. Given that, lets deal with it.
400 * While unlikely, it is possible the next object on the friendly 421 * While unlikely, it is possible the next object on the friendly
401 * list is also free, so encapsulate this in a while loop. 422 * list is also free, so encapsulate this in a while loop.
… …
405 object *tmp = ol->ob; 426 object *tmp = ol->ob;
406 427
407 /* Can't do much more other than log the fact, because the object 428 /* Can't do much more other than log the fact, because the object
408 * itself will have been cleared. 429 * itself will have been cleared.
409 */ 430 */
410 LOG (llevDebug, "get_nearest_player: Found free/non friendly object on friendly list\n"); 431 LOG (llevDebug, "get_nearest_player: Found free/non friendly object '%s' on friendly list\n",
432 tmp->debug_desc ());
411 ol = ol->next; 433 ol = ol->next;
412 remove_friendly_object (tmp); 434 remove_friendly_object (tmp);
413 if (!ol) 435 if (!ol)
414 return op; 436 return op;
415 } 437 }
… …
428 { 450 {
429 op = ol->ob; 451 op = ol->ob;
430 lastdist = rv.distance; 452 lastdist = rv.distance;
431 } 453 }
432 } 454 }
433 for (pl = first_player; pl != NULL; pl = pl->next) 455
434 { 456 for_all_players (pl)
435 if (can_detect_enemy (mon, pl->ob, &rv)) 457 if (can_detect_enemy (mon, pl->ob, &rv))
436 {
437
438 if (lastdist > rv.distance) 458 if (lastdist > rv.distance)
439 { 459 {
440 op = pl->ob; 460 op = pl->ob;
441 lastdist = rv.distance; 461 lastdist = rv.distance;
442 } 462 }
443 } 463
444 }
445#if 0 464#if 0
446 LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)"); 465 LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)");
447#endif 466#endif
448 return op; 467 return op;
449} 468}
… …
467 * circling behaviour. Unfortunately, this function is also used to determined 486 * circling behaviour. Unfortunately, this function is also used to determined
468 * if the creature should cast a spell, so returning a direction in that case 487 * if the creature should cast a spell, so returning a direction in that case
469 * is probably not a good thing. 488 * is probably not a good thing.
470 */ 489 */
471#define MAX_SPACES 50 490#define MAX_SPACES 50
472
473 491
474/* 492/*
475 * Returns the direction to the player, if valid. Returns 0 otherwise. 493 * Returns the direction to the player, if valid. Returns 0 otherwise.
476 * modified to verify there is a path to the player. Does this by stepping towards 494 * modified to verify there is a path to the player. Does this by stepping towards
477 * player and if path is blocked then see if blockage is close enough to player that 495 * player and if path is blocked then see if blockage is close enough to player that
… …
496path_to_player (object *mon, object *pl, unsigned mindiff) 514path_to_player (object *mon, object *pl, unsigned mindiff)
497{ 515{
498 rv_vector rv; 516 rv_vector rv;
499 sint16 x, y; 517 sint16 x, y;
500 int lastx, lasty, dir, i, diff, firstdir = 0, lastdir, max = MAX_SPACES, mflags, blocked; 518 int lastx, lasty, dir, i, diff, firstdir = 0, lastdir, max = MAX_SPACES, mflags, blocked;
501 mapstruct *m, *lastmap; 519 maptile *m, *lastmap;
502 520
503 get_rangevector (mon, pl, &rv, 0); 521 get_rangevector (mon, pl, &rv, 0);
504 522
505 if (rv.distance < mindiff) 523 if (rv.distance < mindiff)
506 return 0; 524 return 0;
… …
650 (op->type == ARMOUR || op->type == BOOTS || 668 (op->type == ARMOUR || op->type == BOOTS ||
651 op->type == CLOAK || op->type == HELMET || 669 op->type == CLOAK || op->type == HELMET ||
652 op->type == SHIELD || op->type == GLOVES || 670 op->type == SHIELD || op->type == GLOVES ||
653 op->type == BRACERS || op->type == GIRDLE)) || (!QUERY_FLAG (pl, FLAG_USE_WEAPON) && op->type == WEAPON)) 671 op->type == BRACERS || op->type == GIRDLE)) || (!QUERY_FLAG (pl, FLAG_USE_WEAPON) && op->type == WEAPON))
654 { 672 {
655 remove_ob (op); 673 op->destroy ();
656 free_object (op);
657 continue; 674 continue;
658 } 675 }
659 } 676 }
660 677
661 /* This really needs to be better - we should really give 678 /* This really needs to be better - we should really give
… …
672 if (tmp->type == op->type && tmp->name == op->name) 689 if (tmp->type == op->type && tmp->name == op->name)
673 break; 690 break;
674 691
675 if (tmp) 692 if (tmp)
676 { 693 {
677 remove_ob (op); 694 op->destroy ();
678 free_object (op);
679 LOG (llevError, "give_initial_items: Removing duplicate object %s\n", &tmp->name); 695 LOG (llevError, "give_initial_items: Removing duplicate object %s\n", &tmp->name);
680 continue; 696 continue;
681 } 697 }
698
682 if (op->nrof > 1) 699 if (op->nrof > 1)
683 op->nrof = 1; 700 op->nrof = 1;
684 } 701 }
685 702
686 if (op->type == SPELLBOOK && op->inv) 703 if (op->type == SPELLBOOK && op->inv)
… …
698 CLEAR_FLAG (op, FLAG_CURSED); 715 CLEAR_FLAG (op, FLAG_CURSED);
699 CLEAR_FLAG (op, FLAG_DAMNED); 716 CLEAR_FLAG (op, FLAG_DAMNED);
700 } 717 }
701 if (op->type == SPELL) 718 if (op->type == SPELL)
702 { 719 {
703 remove_ob (op); 720 op->destroy ();
704 free_object (op);
705 continue; 721 continue;
706 } 722 }
707 else if (op->type == SKILL) 723 else if (op->type == SKILL)
708 { 724 {
709 SET_FLAG (op, FLAG_CAN_USE_SKILL); 725 SET_FLAG (op, FLAG_CAN_USE_SKILL);
… …
718 /* Need to set up the skill pointers */ 734 /* Need to set up the skill pointers */
719 link_player_skills (pl); 735 link_player_skills (pl);
720} 736}
721 737
722void 738void
723get_name (object *op)
724{
725 op->contr->write_buf[0] = '\0';
726 op->contr->state = ST_GET_NAME;
727 send_query (&op->contr->socket, 0, "What is your name?\n:");
728}
729
730void
731get_password (object *op)
732{
733 op->contr->write_buf[0] = '\0';
734 op->contr->state = ST_GET_PASSWORD;
735 send_query (&op->contr->socket, CS_QUERY_HIDEINPUT, "What is your password?\n:");
736}
737
738void
739play_again (object *op)
740{
741 op->contr->state = ST_PLAY_AGAIN;
742 op->chosen_skill = NULL;
743 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Do you want to play again (a/q)?");
744 /* a bit of a hack, but there are various places early in th
745 * player creation process that a user can quit (eg, roll
746 * stats) that isn't removing the player. Taking a quick
747 * look, there are many places that call play_again without
748 * removing the player - it probably makes more sense
749 * to leave it to play_again to remove the object in all
750 * cases.
751 */
752 if (!QUERY_FLAG (op, FLAG_REMOVED))
753 remove_ob (op);
754 /* Need to set this to null - otherwise, it could point to garbage,
755 * and draw() doesn't check to see if the player is removed, only if
756 * the map is null or not swapped out.
757 */
758 op->map = NULL;
759}
760
761int
762receive_play_again (object *op, char key)
763{
764 if (key == 'q' || key == 'Q')
765 {
766 remove_friendly_object (op);
767 leave (op->contr, 0); /* ericserver will draw the message */
768 return 2;
769 }
770 else if (key == 'a' || key == 'A')
771 {
772 player *pl = op->contr;
773 shstr name = op->name;
774
775 op->contr = 0;
776 op->type = 0;
777 op->free (1);
778 pl = get_player (pl);
779 op = pl->ob;
780 add_friendly_object (op);
781 op->contr->password[0] = '~';
782 op->name = op->name_pl = 0;
783 /* Lets put a space in here */
784 new_draw_info (NDI_UNIQUE, 0, op, "\n");
785 get_name (op);
786 op->name = op->name_pl = name;
787 set_first_map (op);
788 }
789 else
790 /* user pressed something else so just ask again... */
791 play_again (op);
792
793 return 0;
794}
795
796void
797confirm_password (object *op)
798{
799
800 op->contr->write_buf[0] = '\0';
801 op->contr->state = ST_CONFIRM_PASSWORD;
802 send_query (&op->contr->socket, CS_QUERY_HIDEINPUT, "Please type your password again.\n:");
803}
804
805void
806get_party_password (object *op, partylist *party) 739get_party_password (object *op, partylist *party)
807{ 740{
808 if (party == NULL) 741 if (party == NULL)
809 { 742 {
810 LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name); 743 LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name);
811 return; 744 return;
812 } 745 }
746
813 op->contr->write_buf[0] = '\0'; 747 op->contr->write_buf[0] = '\0';
814 op->contr->state = ST_GET_PARTY_PASSWORD; 748 op->contr->ns->state = ST_GET_PARTY_PASSWORD;
815 op->contr->party_to_join = party; 749 op->contr->party_to_join = party;
816 send_query (&op->contr->socket, CS_QUERY_HIDEINPUT, "What is the password?\n:"); 750 send_query (op->contr->ns, CS_QUERY_HIDEINPUT, "What is the password?\n:");
817} 751}
818
819 752
820/* This rolls four 1-6 rolls and sums the best 3 of the 4. */ 753/* This rolls four 1-6 rolls and sums the best 3 of the 4. */
821int 754static int
822roll_stat (void) 755roll_stat (void)
823{ 756{
824 int a[4], i, j, k; 757 int a[4], i, j, k;
825 758
826 for (i = 0; i < 4; i++) 759 for (i = 0; i < 4; i++)
… …
829 for (i = 0, j = 0, k = 7; i < 4; i++) 762 for (i = 0, j = 0, k = 7; i < 4; i++)
830 if (a[i] < k) 763 if (a[i] < k)
831 k = a[i], j = i; 764 k = a[i], j = i;
832 765
833 for (i = 0, k = 0; i < 4; i++) 766 for (i = 0, k = 0; i < 4; i++)
834 {
835 if (i != j) 767 if (i != j)
836 k += a[i]; 768 k += a[i];
837 } 769
838 return k; 770 return k;
839} 771}
840 772
841void 773void
842roll_stats (object *op) 774object::roll_stats ()
843{ 775{
844 int sum = 0;
845 int i = 0, j = 0;
846 int statsort[7]; 776 int statsort [7];
847 777
848 do 778 for (;;)
849 {
850 op->stats.Str = roll_stat ();
851 op->stats.Dex = roll_stat ();
852 op->stats.Int = roll_stat ();
853 op->stats.Con = roll_stat ();
854 op->stats.Wis = roll_stat ();
855 op->stats.Pow = roll_stat ();
856 op->stats.Cha = roll_stat ();
857 sum = op->stats.Str + op->stats.Dex + op->stats.Int + op->stats.Con + op->stats.Wis + op->stats.Pow + op->stats.Cha;
858 } 779 {
859 while (sum < 82 || sum > 116); 780 int sum = 0;
781 for (int i = 7; i--; )
782 sum += statsort [i] = roll_stat ();
860 783
784 if (sum >= 82 && sum <= 116)
785 break;
786 }
787
861 /* Sort the stats so that rerolling is easier... */ 788 // Sort the stats so that rerolling is easier...
862 statsort[0] = op->stats.Str; 789 std::sort (statsort, statsort + 7, std::greater<int>());
863 statsort[1] = op->stats.Dex;
864 statsort[2] = op->stats.Int;
865 statsort[3] = op->stats.Con;
866 statsort[4] = op->stats.Wis;
867 statsort[5] = op->stats.Pow;
868 statsort[6] = op->stats.Cha;
869 790
870 /* a quick and dirty bubblesort? */
871 do
872 {
873 if (statsort[i] < statsort[i + 1])
874 {
875 j = statsort[i];
876 statsort[i] = statsort[i + 1];
877 statsort[i + 1] = j;
878 i = 0;
879 }
880 else
881 {
882 i++;
883 }
884 }
885 while (i < 6);
886
887 op->stats.Str = statsort[0]; 791 stats.Str = statsort[0];
888 op->stats.Dex = statsort[1]; 792 stats.Dex = statsort[1];
889 op->stats.Con = statsort[2]; 793 stats.Con = statsort[2];
890 op->stats.Int = statsort[3]; 794 stats.Int = statsort[3];
891 op->stats.Wis = statsort[4]; 795 stats.Wis = statsort[4];
892 op->stats.Pow = statsort[5]; 796 stats.Pow = statsort[5];
893 op->stats.Cha = statsort[6]; 797 stats.Cha = statsort[6];
894 798
895
896 op->contr->orig_stats.Str = op->stats.Str;
897 op->contr->orig_stats.Dex = op->stats.Dex;
898 op->contr->orig_stats.Int = op->stats.Int;
899 op->contr->orig_stats.Con = op->stats.Con;
900 op->contr->orig_stats.Wis = op->stats.Wis;
901 op->contr->orig_stats.Pow = op->stats.Pow;
902 op->contr->orig_stats.Cha = op->stats.Cha;
903
904 op->level = 1;
905 op->stats.exp = 0; 799 stats.exp = 0;
906 op->stats.ac = 0; 800 stats.ac = 0;
907 801
908 op->contr->levhp[1] = 9;
909 op->contr->levsp[1] = 6;
910 op->contr->levgrace[1] = 3;
911
912 fix_player (op);
913 op->stats.hp = op->stats.maxhp; 802 stats.hp = stats.maxhp;
914 op->stats.sp = op->stats.maxsp; 803 stats.sp = stats.maxsp;
915 op->stats.grace = op->stats.maxgrace; 804 stats.grace = stats.maxgrace;
805
806 if (contr)
807 {
808 contr->levhp[1] = 9;
809 contr->levsp[1] = 6;
810 contr->levgrace[1] = 3;
811
916 op->contr->orig_stats = op->stats; 812 contr->orig_stats = stats;
813 }
917} 814}
918 815
919void 816void
920Roll_Again (object *op) 817object::swap_stats (int a, int b)
921{ 818{
922 esrv_new_player (op->contr, 0); 819 int tmp = get_attr_value (&contr->orig_stats, a);
923 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, 820 set_attr_value (&contr->orig_stats, a, get_attr_value (&contr->orig_stats, b));
924 "[y] to roll new stats [n] to use stats\n[1-7] [1-7] to swap stats.\nRoll again (y/n/1-7)? "); 821 set_attr_value (&contr->orig_stats, b, tmp);
925}
926 822
927void 823 stats.Str = contr->orig_stats.Str;
928Swap_Stat (object *op, int Swap_Second) 824 stats.Dex = contr->orig_stats.Dex;
825 stats.Con = contr->orig_stats.Con;
826 stats.Int = contr->orig_stats.Int;
827 stats.Wis = contr->orig_stats.Wis;
828 stats.Pow = contr->orig_stats.Pow;
829 stats.Cha = contr->orig_stats.Cha;
830
831 //TODO: the following code looks so borked and should, at the very least,
832 // be merged with the similar code in roll_stats
833 stats.ac = 0;
834
835 level = 1;
836 stats.exp = 0;
837 stats.ac = 0;
838
839 stats.hp = stats.maxhp;
840 stats.sp = stats.maxsp;
841 stats.grace = stats.maxgrace;
842
843 if (contr)
844 {
845 contr->levhp[1] = 9;
846 contr->levsp[1] = 6;
847 contr->levgrace[1] = 3;
848
849 contr->orig_stats = stats;
850 }
851}
852
853static void
854start_info (object *op)
929{ 855{
930 signed char tmp;
931 char buf[MAX_BUF]; 856 char buf[MAX_BUF];
932 857
933 if (op->contr->Swap_First == -1) 858 sprintf (buf, "Welcome to Crossfire v%s!", VERSION);
934 {
935 new_draw_info (NDI_UNIQUE, 0, op, "How the hell did you get here?!?!!!");
936 new_draw_info (NDI_UNIQUE, 0, op, "Error in Swap_Stat code,");
937 new_draw_info (NDI_UNIQUE, 0, op, "mail korg@rdt.monash.edu.au");
938 return;
939 }
940
941 tmp = get_attr_value (&op->contr->orig_stats, op->contr->Swap_First);
942
943 set_attr_value (&op->contr->orig_stats, op->contr->Swap_First, get_attr_value (&op->contr->orig_stats, Swap_Second));
944
945 set_attr_value (&op->contr->orig_stats, Swap_Second, tmp);
946
947 sprintf (buf, "%s done\n", short_stat_name[Swap_Second]);
948 new_draw_info (NDI_UNIQUE, 0, op, buf); 859 new_draw_info (NDI_UNIQUE, 0, op, buf);
949 op->stats.Str = op->contr->orig_stats.Str; 860 //new_draw_info (NDI_UNIQUE, 0, op, "Press `?' for help");
950 op->stats.Dex = op->contr->orig_stats.Dex;
951 op->stats.Con = op->contr->orig_stats.Con;
952 op->stats.Int = op->contr->orig_stats.Int;
953 op->stats.Wis = op->contr->orig_stats.Wis;
954 op->stats.Pow = op->contr->orig_stats.Pow;
955 op->stats.Cha = op->contr->orig_stats.Cha;
956 op->stats.ac = 0;
957
958 op->level = 1;
959 op->stats.exp = 0;
960 op->stats.ac = 0;
961
962 op->contr->levhp[1] = 9;
963 op->contr->levsp[1] = 6;
964 op->contr->levgrace[1] = 3;
965
966 fix_player (op);
967 op->stats.hp = op->stats.maxhp;
968 op->stats.sp = op->stats.maxsp;
969 op->stats.grace = op->stats.maxgrace;
970 op->contr->orig_stats = op->stats;
971 op->contr->Swap_First = -1;
972}
973
974
975/* This code has been greatly reduced, because with set_attr_value
976 * and get_attr_value, the stats can be accessed just numeric
977 * ids. stat_trans is a table that translate the number entered
978 * into the actual stat. It is needed because the order the stats
979 * are displayed in the stat window is not the same as how
980 * the number's access that stat. The table does that translation.
981 */
982int
983key_roll_stat (object *op, char key)
984{
985 int keynum = key - '0';
986 char buf[MAX_BUF];
987 static sint8 stat_trans[] = { -1, STR, DEX, CON, INT, WIS, POW, CHA };
988
989 if (keynum > 0 && keynum <= 7)
990 {
991 if (op->contr->Swap_First == -1)
992 {
993 op->contr->Swap_First = stat_trans[keynum];
994 sprintf (buf, "%s ->", short_stat_name[stat_trans[keynum]]);
995 new_draw_info (NDI_UNIQUE, 0, op, buf); 861 //new_draw_info (NDI_UNIQUE, 0, op, " ");
996 }
997 else
998 Swap_Stat (op, stat_trans[keynum]);
999
1000 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "");
1001 return 1;
1002 }
1003 switch (key)
1004 {
1005 case 'n':
1006 case 'N':
1007 {
1008 SET_FLAG (op, FLAG_WIZ);
1009 if (op->map == NULL)
1010 {
1011 LOG (llevError, "Map == NULL in state 2\n");
1012 break;
1013 }
1014
1015#if 0
1016 /* So that enter_exit will put us at startx/starty */
1017 op->x = -1;
1018
1019 enter_exit (op, NULL);
1020#endif
1021 SET_ANIMATION (op, 2); /* So player faces south */
1022 /* Enter exit adds a player otherwise */
1023 add_statbonus (op);
1024 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR,
1025 "Now choose a character.\nPress any key to change outlook.\nPress `d' when you're pleased.\n");
1026 op->contr->state = ST_CHANGE_CLASS;
1027 if (op->msg)
1028 new_draw_info (NDI_BLUE, 0, op, op->msg);
1029 return 0;
1030 }
1031 case 'y':
1032 case 'Y':
1033 roll_stats (op);
1034 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "");
1035 return 1;
1036
1037 case 'q':
1038 case 'Q':
1039 play_again (op);
1040 return 1;
1041
1042 default:
1043 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Yes, No, Quit or 1-6. Roll again?");
1044 return 0;
1045 }
1046 return 0;
1047} 862}
1048 863
1049/* This function takes the key that is passed, and does the 864/* This function takes the key that is passed, and does the
1050 * appropriate action with it (change race, or other things). 865 * appropriate action with it (change race, or other things).
1051 * The function name is for historical reasons - now we have 866 * The function name is for historical reasons - now we have
1052 * separate race and class; this actually changes the RACE, 867 * separate race and class; this actually changes the RACE,
1053 * not the class. 868 * not the class.
1054 */ 869 */
1055
1056int 870int
1057key_change_class (object *op, char key) 871key_change_class (object *op, char key)
1058{ 872{
1059 int tmp_loop; 873 int tmp_loop;
1060 874
1061 if (key == 'q' || key == 'Q')
1062 {
1063 remove_ob (op);
1064 play_again (op);
1065 return 0;
1066 }
1067 if (key == 'd' || key == 'D') 875 if (key == 'd' || key == 'D')
1068 { 876 {
1069 char buf[MAX_BUF]; 877 char buf[MAX_BUF];
1070 878
1071 /* this must before then initial items are given */ 879 /* this must before then initial items are given */
1072 esrv_new_player (op->contr, op->weight + op->carrying); 880 esrv_new_player (op->contr, op->weight + op->carrying);
881
1073 create_treasure (find_treasurelist ("starting_wealth"), op, 0, 0, 0); 882 treasurelist *tl = find_treasurelist ("starting_wealth");
883 if (tl)
884 create_treasure (tl, op, 0, 0, 0);
1074 885
1075 INVOKE_PLAYER (BIRTH, op->contr); 886 INVOKE_PLAYER (BIRTH, op->contr);
1076 INVOKE_PLAYER (LOGIN, op->contr); 887 INVOKE_PLAYER (LOGIN, op->contr);
1077 888
1078 op->contr->state = ST_PLAYING; 889 op->contr->ns->state = ST_PLAYING;
1079 890
1080 if (op->msg) 891 if (op->msg)
1081 op->msg = NULL; 892 op->msg = NULL;
1082 893
1083 /* We create this now because some of the unique maps will need it 894 /* We create this now because some of the unique maps will need it
1084 * to save here. 895 * to save here.
1085 */ 896 */
1086 sprintf (buf, "%s/%s/%s", settings.localdir, settings.playerdir, &op->name); 897 sprintf (buf, "%s/%s/%s", settings.localdir, settings.playerdir, &op->name);
1087 make_path_to_file (buf); 898 make_path_to_file (buf);
1088 899
1089#ifdef AUTOSAVE
1090 op->contr->last_save_tick = pticks;
1091#endif
1092 start_info (op); 900 start_info (op);
1093 CLEAR_FLAG (op, FLAG_WIZ); 901 CLEAR_FLAG (op, FLAG_WIZ);
1094 give_initial_items (op, op->randomitems); 902 give_initial_items (op, op->randomitems);
1095 link_player_skills (op); 903 link_player_skills (op);
1096 esrv_send_inventory (op, op); 904 esrv_send_inventory (op, op);
1097 fix_player (op); 905 op->update_stats ();
1098 906
1099 /* This moves the player to a different start map, if there 907 /* This moves the player to a different start map, if there
1100 * is one for this race 908 * is one for this race
1101 */ 909 */
1102 if (*first_map_ext_path) 910 if (*first_map_ext_path)
1103 { 911 {
1104 object *tmp; 912 object *tmp;
1105 char mapname[MAX_BUF]; 913 char mapname[MAX_BUF];
1106 914
1107 snprintf (mapname, MAX_BUF - 1, "%s/%s", first_map_ext_path, &op->arch->name); 915 snprintf (mapname, MAX_BUF - 1, "%s/%s", &first_map_ext_path, &op->arch->name);
1108 tmp = get_object (); 916 tmp = object::create ();
1109 EXIT_PATH (tmp) = mapname; 917 EXIT_PATH (tmp) = mapname;
1110 EXIT_X (tmp) = op->x; 918 EXIT_X (tmp) = op->x;
1111 EXIT_Y (tmp) = op->y; 919 EXIT_Y (tmp) = op->y;
1112 enter_exit (op, tmp); /* we don't really care if it succeeded; 920 op->enter_exit (tmp); /* we don't really care if it succeeded;
1113 * if the map isn't there, then stay on the 921 * if the map isn't there, then stay on the
1114 * default initial map */ 922 * default initial map */
1115 free_object (tmp); 923 tmp->destroy ();
1116 } 924 }
1117 else 925 else
1118 {
1119 LOG (llevDebug, "first_map_ext_path not set\n"); 926 LOG (llevDebug, "first_map_ext_path not set\n");
1120 } 927
1121 return 0; 928 return 0;
1122 } 929 }
1123 930
1124 /* Following actually changes the race - this is the default command 931 /* Following actually changes the race - this is the default command
1125 * if we don't match with one of the options above. 932 * if we don't match with one of the options above.
… …
1129 while (!tmp_loop) 936 while (!tmp_loop)
1130 { 937 {
1131 shstr name = op->name; 938 shstr name = op->name;
1132 int x = op->x, y = op->y; 939 int x = op->x, y = op->y;
1133 940
1134 remove_statbonus (op); 941 op->remove_statbonus ();
1135 remove_ob (op); 942 op->remove ();
1136 op->arch = get_player_archetype (op->arch); 943 op->arch = get_player_archetype (op->arch);
1137 copy_object (&op->arch->clone, op); 944 op->arch->clone.copy_to (op);
1138 op->instantiate (); 945 op->instantiate ();
1139 op->stats = op->contr->orig_stats; 946 op->stats = op->contr->orig_stats;
1140 op->name = op->name_pl = name; 947 op->name = op->name_pl = name;
1141 op->x = x; 948 op->x = x;
1142 op->y = y; 949 op->y = y;
1143 SET_ANIMATION (op, 2); /* So player faces south */ 950 SET_ANIMATION (op, 2); /* So player faces south */
1144 insert_ob_in_map (op, op->map, op, 0); 951 insert_ob_in_map (op, op->map, op, 0);
1145 strncpy (op->contr->title, op->arch->clone.name, sizeof (op->contr->title) - 1); 952 assign (op->contr->title, op->arch->clone.name);
1146 op->contr->title[sizeof (op->contr->title) - 1] = '\0';
1147 add_statbonus (op); 953 op->add_statbonus ();
1148 tmp_loop = allowed_class (op); 954 tmp_loop = allowed_class (op);
1149 } 955 }
1150 956
1151 update_object (op, UP_OBJ_FACE); 957 update_object (op, UP_OBJ_FACE);
1152 esrv_update_item (UPD_FACE, op, op); 958 esrv_update_item (UPD_FACE, op, op);
1153 fix_player (op); 959 op->update_stats ();
1154 op->stats.hp = op->stats.maxhp; 960 op->stats.hp = op->stats.maxhp;
1155 op->stats.sp = op->stats.maxsp; 961 op->stats.sp = op->stats.maxsp;
1156 op->stats.grace = 0; 962 op->stats.grace = 0;
963
1157 if (op->msg) 964 if (op->msg)
1158 new_draw_info (NDI_BLUE, 0, op, op->msg); 965 new_draw_info (NDI_BLUE, 0, op, op->msg);
966
1159 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n"); 967 send_query (op->contr->ns, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n");
1160 return 0; 968 return 0;
1161}
1162
1163int
1164key_confirm_quit (object *op, char key)
1165{
1166 char buf[MAX_BUF];
1167
1168 if (key != 'y' && key != 'Y' && key != 'q' && key != 'Q')
1169 {
1170 op->contr->state = ST_PLAYING;
1171 new_draw_info (NDI_UNIQUE, 0, op, "OK, continuing to play.");
1172 return 1;
1173 }
1174
1175 INVOKE_PLAYER (LOGOUT, op->contr);
1176 INVOKE_PLAYER (QUIT, op->contr);
1177
1178 terminate_all_pets (op);
1179 leave_map (op);
1180 op->direction = 0;
1181 new_draw_info_format (NDI_UNIQUE | NDI_ALL, 5, NULL, "%s quits the game.", &op->name);
1182
1183 strcpy (op->contr->killer, "quit");
1184 check_score (op);
1185 op->contr->party = NULL;
1186 if (settings.set_title == TRUE)
1187 op->contr->own_title[0] = '\0';
1188
1189 if (!QUERY_FLAG (op, FLAG_WAS_WIZ))
1190 {
1191 mapstruct *mp, *next;
1192
1193 /* We need to hunt for any per player unique maps in memory and
1194 * get rid of them. The trailing slash in the path is intentional,
1195 * so that players named 'Ab' won't match against players 'Abe' pathname
1196 */
1197 sprintf (buf, "%s/%s/%s/", settings.localdir, settings.playerdir, &op->name);
1198 for (mp = first_map; mp != NULL; mp = next)
1199 {
1200 next = mp->next;
1201 if (!strncmp (mp->path, buf, strlen (buf)))
1202 delete_map (mp);
1203 }
1204
1205 delete_character (op->name, 1);
1206 }
1207
1208 play_again (op);
1209 return 1;
1210} 969}
1211 970
1212void 971void
1213flee_player (object *op) 972flee_player (object *op)
1214{ 973{
… …
1244 { 1003 {
1245 op->enemy = NULL; 1004 op->enemy = NULL;
1246 CLEAR_FLAG (op, FLAG_SCARED); 1005 CLEAR_FLAG (op, FLAG_SCARED);
1247 return; 1006 return;
1248 } 1007 }
1008
1249 get_rangevector (op, op->enemy, &rv, 0); 1009 get_rangevector (op, op->enemy, &rv, 0);
1250 1010
1251 dir = absdir (4 + rv.direction); 1011 dir = absdir (4 + rv.direction);
1252 for (diff = 0; diff < 3; diff++) 1012 for (diff = 0; diff < 3; diff++)
1253 { 1013 {
1254 int m = 1 - (RANDOM () & 2); 1014 int m = 1 - (RANDOM () & 2);
1255 1015
1256 if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op))) 1016 if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op)))
1257 {
1258 return; 1017 return;
1259 }
1260 } 1018 }
1019
1261 /* Cornered, get rid of scared */ 1020 /* Cornered, get rid of scared */
1262 CLEAR_FLAG (op, FLAG_SCARED); 1021 CLEAR_FLAG (op, FLAG_SCARED);
1263 op->enemy = NULL; 1022 op->enemy = NULL;
1264} 1023}
1265 1024
… …
1270 */ 1029 */
1271int 1030int
1272check_pick (object *op) 1031check_pick (object *op)
1273{ 1032{
1274 object *tmp, *next; 1033 object *tmp, *next;
1275 tag_t next_tag = 0, op_tag;
1276 int stop = 0; 1034 int stop = 0;
1277 int j, k, wvratio; 1035 int j, k, wvratio;
1278 char putstring[128], tmpstr[16]; 1036 char putstring[128], tmpstr[16];
1279 1037
1280
1281 /* if you're flying, you cna't pick up anything */ 1038 /* if you're flying, you cna't pick up anything */
1282 if (op->move_type & MOVE_FLYING) 1039 if (op->move_type & MOVE_FLYING)
1283 return 1; 1040 return 1;
1284 1041
1285 op_tag = op->count;
1286
1287 next = op->below; 1042 next = op->below;
1288 if (next)
1289 next_tag = next->count;
1290 1043
1291 /* loop while there are items on the floor that are not marked as 1044 /* loop while there are items on the floor that are not marked as
1292 * destroyed */ 1045 * destroyed */
1293 while (next && !was_destroyed (next, next_tag)) 1046 while (next && !next->destroyed ())
1294 { 1047 {
1295 tmp = next; 1048 tmp = next;
1296 next = tmp->below; 1049 next = tmp->below;
1297 if (next)
1298 next_tag = next->count;
1299 1050
1300 if (was_destroyed (op, op_tag)) 1051 if (op->destroyed ())
1301 return 0; 1052 return 0;
1302 1053
1303 if (!can_pick (op, tmp)) 1054 if (!can_pick (op, tmp))
1304 continue; 1055 continue;
1305 1056
… …
1313 /* high not bit set? We're using the old autopickup model */ 1064 /* high not bit set? We're using the old autopickup model */
1314 if (!(op->contr->mode & PU_NEWMODE)) 1065 if (!(op->contr->mode & PU_NEWMODE))
1315 { 1066 {
1316 switch (op->contr->mode) 1067 switch (op->contr->mode)
1317 { 1068 {
1318 case 0: 1069 case 0:
1319 return 1; /* don't pick up */ 1070 return 1; /* don't pick up */
1320 case 1: 1071 case 1:
1072 pick_up (op, tmp);
1073 return 1;
1074 case 2:
1075 pick_up (op, tmp);
1076 return 0;
1077 case 3:
1078 return 0; /* stop before pickup */
1079 case 4:
1080 pick_up (op, tmp);
1081 break;
1082 case 5:
1083 pick_up (op, tmp);
1084 stop = 1;
1085 break;
1086 case 6:
1087 if (QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED))
1321 pick_up (op, tmp); 1088 pick_up (op, tmp);
1322 return 1; 1089 break;
1090
1323 case 2: 1091 case 7:
1092 if (tmp->type == MONEY || tmp->type == GEM)
1324 pick_up (op, tmp); 1093 pick_up (op, tmp);
1325 return 0; 1094 break;
1326 case 3: 1095
1327 return 0; /* stop before pickup */ 1096 default:
1328 case 4: 1097 /* use value density */
1098 if (!QUERY_FLAG (tmp, FLAG_UNPAID)
1099 && (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))) >= op->contr->mode)
1329 pick_up (op, tmp); 1100 pick_up (op, tmp);
1330 break;
1331 case 5:
1332 pick_up (op, tmp);
1333 stop = 1;
1334 break;
1335 case 6:
1336 if (QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED))
1337 pick_up (op, tmp);
1338 break;
1339
1340 case 7:
1341 if (tmp->type == MONEY || tmp->type == GEM)
1342 pick_up (op, tmp);
1343 break;
1344
1345 default:
1346 /* use value density */
1347 if (!QUERY_FLAG (tmp, FLAG_UNPAID)
1348 && (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))) >= op->contr->mode)
1349 pick_up (op, tmp);
1350 } 1101 }
1351 } 1102 }
1352 else 1103 else
1353 { /* old model */ 1104 { /* old model */
1354 /* NEW pickup handling */ 1105 /* NEW pickup handling */
… …
1359 sprintf (putstring, "item name: %s item type: %d weight/value: %d", 1110 sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1360 &tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1)))); 1111 &tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1361 else 1112 else
1362 sprintf (putstring, "item name: %s item type: %d weight/value: %d", 1113 sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1363 &tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1)))); 1114 &tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1115
1364 new_draw_info (NDI_UNIQUE, 0, op, putstring); 1116 new_draw_info (NDI_UNIQUE, 0, op, putstring);
1365
1366 sprintf (putstring, "...flags: ");
1367 for (k = 0; k < 4; k++)
1368 {
1369 for (j = 0; j < 32; j++)
1370 {
1371 if ((tmp->flags[k] >> j) & 0x01)
1372 {
1373 sprintf (tmpstr, "%d ", k * 32 + j);
1374 strcat (putstring, tmpstr);
1375 }
1376 }
1377 }
1378 new_draw_info (NDI_UNIQUE, 0, op, putstring);
1379
1380#if 0
1381 /* print the flags too */
1382 for (k = 0; k < 4; k++)
1383 {
1384 fprintf (stderr, "%d [%d] ", k, k * 32 + 31);
1385 for (j = 0; j < 32; j++)
1386 {
1387 fprintf (stderr, "%d", tmp->flags[k] >> (31 - j) & 0x01);
1388 if (!((j + 1) % 4))
1389 fprintf (stderr, " ");
1390 }
1391 fprintf (stderr, " [%d]\n", k * 32);
1392 }
1393#endif
1394 } 1117 }
1118
1395 /* philosophy: 1119 /* philosophy:
1396 * It's easy to grab an item type from a pile, as long as it's 1120 * It's easy to grab an item type from a pile, as long as it's
1397 * generic. This takes no game-time. For more detailed pickups 1121 * generic. This takes no game-time. For more detailed pickups
1398 * and selections, select-items shoul dbe used. This is a 1122 * and selections, select-items should be used. This is a
1399 * grab-as-you-run type mode that's really useful for arrows for 1123 * grab-as-you-run type mode that's really useful for arrows for
1400 * example. 1124 * example.
1401 * The drawback: right now it has no frontend, so you need to 1125 * The drawback: right now it has no frontend, so you need to
1402 * stick the bits you want into a calculator in hex mode and then 1126 * stick the bits you want into a calculator in hex mode and then
1403 * convert to decimal and then 'pickup <#> 1127 * convert to decimal and then 'pickup <#>
… …
1437 /* question: don't pick up known-poisonous stuff? */ 1161 /* question: don't pick up known-poisonous stuff? */
1438 if (op->contr->mode & PU_FOOD) 1162 if (op->contr->mode & PU_FOOD)
1439 if (tmp->type == FOOD) 1163 if (tmp->type == FOOD)
1440 { 1164 {
1441 pick_up (op, tmp); 1165 pick_up (op, tmp);
1442 if (0)
1443 fprintf (stderr, "FOOD\n");
1444 continue; 1166 continue;
1445 } 1167 }
1168
1446 if (op->contr->mode & PU_DRINK) 1169 if (op->contr->mode & PU_DRINK)
1447 if (tmp->type == DRINK || (tmp->type == POISON && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED))) 1170 if (tmp->type == DRINK || (tmp->type == POISON && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED)))
1448 { 1171 {
1449 pick_up (op, tmp); 1172 pick_up (op, tmp);
1450 if (0)
1451 fprintf (stderr, "DRINK\n");
1452 continue; 1173 continue;
1453 } 1174 }
1454 1175
1455 if (op->contr->mode & PU_POTION) 1176 if (op->contr->mode & PU_POTION)
1456 if (tmp->type == POTION) 1177 if (tmp->type == POTION)
1457 { 1178 {
1458 pick_up (op, tmp); 1179 pick_up (op, tmp);
1459 if (0)
1460 fprintf (stderr, "POTION\n");
1461 continue; 1180 continue;
1462 } 1181 }
1463 1182
1464 /* spellbooks, skillscrolls and normal books/scrolls */ 1183 /* spellbooks, skillscrolls and normal books/scrolls */
1465 if (op->contr->mode & PU_SPELLBOOK) 1184 if (op->contr->mode & PU_SPELLBOOK)
1466 if (tmp->type == SPELLBOOK) 1185 if (tmp->type == SPELLBOOK)
1467 { 1186 {
1468 pick_up (op, tmp); 1187 pick_up (op, tmp);
1469 if (0)
1470 fprintf (stderr, "SPELLBOOK\n");
1471 continue; 1188 continue;
1472 } 1189 }
1190
1473 if (op->contr->mode & PU_SKILLSCROLL) 1191 if (op->contr->mode & PU_SKILLSCROLL)
1474 if (tmp->type == SKILLSCROLL) 1192 if (tmp->type == SKILLSCROLL)
1475 { 1193 {
1476 pick_up (op, tmp); 1194 pick_up (op, tmp);
1477 if (0)
1478 fprintf (stderr, "SKILLSCROLL\n");
1479 continue; 1195 continue;
1480 } 1196 }
1197
1481 if (op->contr->mode & PU_READABLES) 1198 if (op->contr->mode & PU_READABLES)
1482 if (tmp->type == BOOK || tmp->type == SCROLL) 1199 if (tmp->type == BOOK || tmp->type == SCROLL)
1483 { 1200 {
1484 pick_up (op, tmp); 1201 pick_up (op, tmp);
1485 if (0)
1486 fprintf (stderr, "READABLES\n");
1487 continue; 1202 continue;
1488 } 1203 }
1489 1204
1490 /* wands/staves/rods/horns */ 1205 /* wands/staves/rods/horns */
1491 if (op->contr->mode & PU_MAGIC_DEVICE) 1206 if (op->contr->mode & PU_MAGIC_DEVICE)
1492 if (tmp->type == WAND || tmp->type == ROD || tmp->type == HORN) 1207 if (tmp->type == WAND || tmp->type == ROD || tmp->type == HORN)
1493 { 1208 {
1494 pick_up (op, tmp); 1209 pick_up (op, tmp);
1495 if (0)
1496 fprintf (stderr, "MAGIC_DEVICE\n");
1497 continue; 1210 continue;
1498 } 1211 }
1499 1212
1500 /* pick up all magical items */ 1213 /* pick up all magical items */
1501 if (op->contr->mode & PU_MAGICAL) 1214 if (op->contr->mode & PU_MAGICAL)
1502 if (QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED)) 1215 if (QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED))
1503 { 1216 {
1504 pick_up (op, tmp); 1217 pick_up (op, tmp);
1505 if (0)
1506 fprintf (stderr, "MAGICAL\n");
1507 continue; 1218 continue;
1508 } 1219 }
1509 1220
1510 if (op->contr->mode & PU_VALUABLES) 1221 if (op->contr->mode & PU_VALUABLES)
1511 { 1222 {
1512 if (tmp->type == MONEY || tmp->type == GEM) 1223 if (tmp->type == MONEY || tmp->type == GEM)
1513 { 1224 {
1514 pick_up (op, tmp); 1225 pick_up (op, tmp);
1515 if (0)
1516 fprintf (stderr, "MONEY/GEM\n");
1517 continue; 1226 continue;
1518 } 1227 }
1519 } 1228 }
1520 1229
1521 /* rings & amulets - talismans seems to be typed AMULET */ 1230 /* rings & amulets - talismans seems to be typed AMULET */
1522 if (op->contr->mode & PU_JEWELS) 1231 if (op->contr->mode & PU_JEWELS)
1523 if (tmp->type == RING || tmp->type == AMULET) 1232 if (tmp->type == RING || tmp->type == AMULET)
1524 { 1233 {
1525 pick_up (op, tmp); 1234 pick_up (op, tmp);
1235 continue;
1526 if (0) 1236 }
1527 fprintf (stderr, "JEWELS\n"); 1237
1238 /* we don't forget dragon food */
1239 if (op->contr->mode & PU_FLESH)
1240 if (tmp->type == FLESH)
1241 {
1242 pick_up (op, tmp);
1528 continue; 1243 continue;
1529 } 1244 }
1530 1245
1531 /* bows and arrows. Bows are good for selling! */ 1246 /* bows and arrows. Bows are good for selling! */
1532 if (op->contr->mode & PU_BOW) 1247 if (op->contr->mode & PU_BOW)
1533 if (tmp->type == BOW) 1248 if (tmp->type == BOW)
1534 { 1249 {
1535 pick_up (op, tmp); 1250 pick_up (op, tmp);
1536 if (0)
1537 fprintf (stderr, "BOW\n");
1538 continue; 1251 continue;
1539 } 1252 }
1253
1540 if (op->contr->mode & PU_ARROW) 1254 if (op->contr->mode & PU_ARROW)
1541 if (tmp->type == ARROW) 1255 if (tmp->type == ARROW)
1542 { 1256 {
1543 pick_up (op, tmp); 1257 pick_up (op, tmp);
1544 if (0)
1545 fprintf (stderr, "ARROW\n");
1546 continue; 1258 continue;
1547 } 1259 }
1548 1260
1549 /* all kinds of armor etc. */ 1261 /* all kinds of armor etc. */
1550 if (op->contr->mode & PU_ARMOUR) 1262 if (op->contr->mode & PU_ARMOUR)
1551 if (tmp->type == ARMOUR) 1263 if (tmp->type == ARMOUR)
1552 { 1264 {
1553 pick_up (op, tmp); 1265 pick_up (op, tmp);
1554 if (0)
1555 fprintf (stderr, "ARMOUR\n");
1556 continue; 1266 continue;
1557 } 1267 }
1268
1558 if (op->contr->mode & PU_HELMET) 1269 if (op->contr->mode & PU_HELMET)
1559 if (tmp->type == HELMET) 1270 if (tmp->type == HELMET)
1560 { 1271 {
1561 pick_up (op, tmp); 1272 pick_up (op, tmp);
1562 if (0)
1563 fprintf (stderr, "HELMET\n");
1564 continue; 1273 continue;
1565 } 1274 }
1275
1566 if (op->contr->mode & PU_SHIELD) 1276 if (op->contr->mode & PU_SHIELD)
1567 if (tmp->type == SHIELD) 1277 if (tmp->type == SHIELD)
1568 { 1278 {
1569 pick_up (op, tmp); 1279 pick_up (op, tmp);
1570 if (0)
1571 fprintf (stderr, "SHIELD\n");
1572 continue; 1280 continue;
1573 } 1281 }
1282
1574 if (op->contr->mode & PU_BOOTS) 1283 if (op->contr->mode & PU_BOOTS)
1575 if (tmp->type == BOOTS) 1284 if (tmp->type == BOOTS)
1576 { 1285 {
1577 pick_up (op, tmp); 1286 pick_up (op, tmp);
1578 if (0)
1579 fprintf (stderr, "BOOTS\n");
1580 continue; 1287 continue;
1581 } 1288 }
1289
1582 if (op->contr->mode & PU_GLOVES) 1290 if (op->contr->mode & PU_GLOVES)
1583 if (tmp->type == GLOVES) 1291 if (tmp->type == GLOVES)
1584 { 1292 {
1585 pick_up (op, tmp); 1293 pick_up (op, tmp);
1586 if (0)
1587 fprintf (stderr, "GLOVES\n");
1588 continue; 1294 continue;
1589 } 1295 }
1296
1590 if (op->contr->mode & PU_CLOAK) 1297 if (op->contr->mode & PU_CLOAK)
1591 if (tmp->type == CLOAK) 1298 if (tmp->type == CLOAK)
1592 { 1299 {
1593 pick_up (op, tmp); 1300 pick_up (op, tmp);
1594 if (0)
1595 fprintf (stderr, "GLOVES\n");
1596 continue; 1301 continue;
1597 } 1302 }
1598 1303
1599 /* hoping to catch throwing daggers here */ 1304 /* hoping to catch throwing daggers here */
1600 if (op->contr->mode & PU_MISSILEWEAPON) 1305 if (op->contr->mode & PU_MISSILEWEAPON)
1601 if (tmp->type == WEAPON && QUERY_FLAG (tmp, FLAG_IS_THROWN)) 1306 if (tmp->type == WEAPON && QUERY_FLAG (tmp, FLAG_IS_THROWN))
1602 { 1307 {
1603 pick_up (op, tmp); 1308 pick_up (op, tmp);
1604 if (0)
1605 fprintf (stderr, "MISSILEWEAPON\n");
1606 continue; 1309 continue;
1607 } 1310 }
1608 1311
1609 /* careful: chairs and tables are weapons! */ 1312 /* careful: chairs and tables are weapons! */
1610 if (op->contr->mode & PU_ALLWEAPON) 1313 if (op->contr->mode & PU_ALLWEAPON)
… …
1613 { 1316 {
1614 if (strstr (tmp->name, "table") == NULL && strstr (tmp->arch->name, "table") == NULL && 1317 if (strstr (tmp->name, "table") == NULL && strstr (tmp->arch->name, "table") == NULL &&
1615 strstr (tmp->name, "chair") && strstr (tmp->arch->name, "chair") == NULL) 1318 strstr (tmp->name, "chair") && strstr (tmp->arch->name, "chair") == NULL)
1616 { 1319 {
1617 pick_up (op, tmp); 1320 pick_up (op, tmp);
1618 if (0)
1619 fprintf (stderr, "WEAPON\n");
1620 continue; 1321 continue;
1621 } 1322 }
1622 } 1323 }
1324
1623 if (tmp->type == WEAPON && tmp->name == NULL) 1325 if (tmp->type == WEAPON && tmp->name == NULL)
1624 { 1326 {
1625 if (strstr (tmp->arch->name, "table") == NULL && strstr (tmp->arch->name, "chair") == NULL) 1327 if (strstr (tmp->arch->name, "table") == NULL && strstr (tmp->arch->name, "chair") == NULL)
1626 { 1328 {
1627 pick_up (op, tmp); 1329 pick_up (op, tmp);
1628 if (0)
1629 fprintf (stderr, "WEAPON\n");
1630 continue; 1330 continue;
1631 } 1331 }
1632 } 1332 }
1633 } 1333 }
1634 1334
1635 /* misc stuff that's useful */ 1335 /* misc stuff that's useful */
1636 if (op->contr->mode & PU_KEY) 1336 if (op->contr->mode & PU_KEY)
1637 if (tmp->type == KEY || tmp->type == SPECIAL_KEY) 1337 if (tmp->type == KEY || tmp->type == SPECIAL_KEY)
1638 { 1338 {
1639 pick_up (op, tmp); 1339 pick_up (op, tmp);
1640 if (0)
1641 fprintf (stderr, "KEY\n");
1642 continue; 1340 continue;
1643 } 1341 }
1644 1342
1645 /* any of the last 4 bits set means we use the ratio for value 1343 /* any of the last 4 bits set means we use the ratio for value
1646 * pickups */ 1344 * pickups */
… …
1668 continue; 1366 continue;
1669 } 1367 }
1670 } 1368 }
1671 } /* the new pickup model */ 1369 } /* the new pickup model */
1672 } 1370 }
1371
1673 return !stop; 1372 return !stop;
1674} 1373}
1675 1374
1676/* 1375/*
1677 * Find an arrow in the inventory and after that 1376 * Find an arrow in the inventory and after that
… …
1776 1475
1777object * 1476object *
1778pick_arrow_target (object *op, const char *type, int dir) 1477pick_arrow_target (object *op, const char *type, int dir)
1779{ 1478{
1780 object *tmp = NULL; 1479 object *tmp = NULL;
1781 mapstruct *m; 1480 maptile *m;
1782 int i, mflags, found, number; 1481 int i, mflags, found, number;
1783 sint16 x, y; 1482 sint16 x, y;
1784 1483
1785 if (op->map == NULL) 1484 if (op->map == NULL)
1786 return find_arrow (op, type); 1485 return find_arrow (op, type);
… …
1846 */ 1545 */
1847int 1546int
1848fire_bow (object *op, object *part, object *arrow, int dir, int wc_mod, sint16 sx, sint16 sy) 1547fire_bow (object *op, object *part, object *arrow, int dir, int wc_mod, sint16 sx, sint16 sy)
1849{ 1548{
1850 object *left, *bow; 1549 object *left, *bow;
1851 tag_t left_tag, tag;
1852 int bowspeed, mflags; 1550 int bowspeed, mflags;
1853 mapstruct *m; 1551 maptile *m;
1854 1552
1855 if (!dir) 1553 if (!dir)
1856 { 1554 {
1857 new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!"); 1555 new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");
1858 return 0; 1556 return 0;
1859 } 1557 }
1558
1860 if (op->type == PLAYER) 1559 if (op->type == PLAYER)
1861 bow = op->contr->ranges[range_bow]; 1560 bow = op->contr->ranges[range_bow];
1862 else 1561 else
1863 { 1562 {
1864 for (bow = op->inv; bow; bow = bow->below) 1563 for (bow = op->inv; bow; bow = bow->below)
… …
1872 { 1571 {
1873 LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name); 1572 LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);
1874 return 0; 1573 return 0;
1875 } 1574 }
1876 } 1575 }
1576
1877 if (!bow->race || !bow->skill) 1577 if (!bow->race || !bow->skill)
1878 { 1578 {
1879 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name); 1579 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name);
1880 return 0; 1580 return 0;
1881 } 1581 }
… …
1883 bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex]; 1583 bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex];
1884 1584
1885 /* penalize ROF for bestarrow */ 1585 /* penalize ROF for bestarrow */
1886 if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow) 1586 if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow)
1887 bowspeed -= dex_bonus[op->stats.Dex] + 5; 1587 bowspeed -= dex_bonus[op->stats.Dex] + 5;
1588
1888 if (bowspeed < 1) 1589 if (bowspeed < 1)
1889 bowspeed = 1; 1590 bowspeed = 1;
1890 1591
1891 if (arrow == NULL) 1592 if (arrow == NULL)
1892 { 1593 {
… …
1898 else 1599 else
1899 CLEAR_FLAG (op, FLAG_READY_BOW); 1600 CLEAR_FLAG (op, FLAG_READY_BOW);
1900 return 0; 1601 return 0;
1901 } 1602 }
1902 } 1603 }
1604
1903 mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy); 1605 mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);
1904 if (mflags & P_OUT_OF_MAP) 1606 if (mflags & P_OUT_OF_MAP)
1905 {
1906 return 0; 1607 return 0;
1907 } 1608
1908 if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW) 1609 if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)
1909 { 1610 {
1910 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 1611 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1911 return 0; 1612 return 0;
1912 } 1613 }
1913 1614
1914 /* this should not happen, but sometimes does */ 1615 /* this should not happen, but sometimes does */
1915 if (arrow->nrof == 0) 1616 if (arrow->nrof == 0)
1916 { 1617 {
1917 remove_ob (arrow); 1618 arrow->destroy ();
1918 free_object (arrow);
1919 return 0; 1619 return 0;
1920 } 1620 }
1921 1621
1922 left = arrow; /* these are arrows left to the player */ 1622 left = arrow; /* these are arrows left to the player */
1923 left_tag = left->count;
1924 arrow = get_split_ob (arrow, 1); 1623 arrow = get_split_ob (arrow, 1);
1925 if (arrow == NULL) 1624 if (!arrow)
1926 { 1625 {
1927 new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race); 1626 new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);
1928 return 0; 1627 return 0;
1929 } 1628 }
1930 set_owner (arrow, op); 1629
1630 arrow->set_owner (op);
1931 arrow->skill = bow->skill; 1631 arrow->skill = bow->skill;
1932
1933 arrow->direction = dir; 1632 arrow->direction = dir;
1934 arrow->x = sx;
1935 arrow->y = sy;
1936 1633
1937 if (op->type == PLAYER) 1634 if (op->type == PLAYER)
1938 { 1635 {
1939 op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed; 1636 op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed;
1940 fix_player (op); 1637 op->update_stats ();
1941 } 1638 }
1942 1639
1943 SET_ANIMATION (arrow, arrow->direction); 1640 SET_ANIMATION (arrow, arrow->direction);
1944 arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */ 1641 arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */
1945 arrow->stats.hp = arrow->stats.dam; 1642 arrow->stats.hp = arrow->stats.dam;
1946 arrow->stats.grace = arrow->attacktype; 1643 arrow->stats.grace = arrow->attacktype;
1947 if (arrow->slaying != NULL) 1644 if (arrow->slaying != NULL)
1948 arrow->spellarg = strdup_local (arrow->slaying); 1645 arrow->spellarg = strdup (arrow->slaying);
1949 1646
1950 /* Note that this was different for monsters - they got their level 1647 /* Note that this was different for monsters - they got their level
1951 * added to the damage. I think the strength bonus is more proper. 1648 * added to the damage. I think the strength bonus is more proper.
1952 */ 1649 */
1953 1650
… …
1955 1652
1956 /* update the speed */ 1653 /* update the speed */
1957 arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ? 1654 arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ?
1958 0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 + (float) bow->stats.dam / 7.0; 1655 0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 + (float) bow->stats.dam / 7.0;
1959 1656
1960 if (arrow->speed < 1.0) 1657 arrow->set_speed (max (arrow->speed, 1.0));
1961 arrow->speed = 1.0;
1962 update_ob_speed (arrow);
1963 arrow->speed_left = 0; 1658 arrow->speed_left = 0;
1964 1659
1965 if (op->type == PLAYER) 1660 if (op->type == PLAYER)
1966 { 1661 {
1967 arrow->stats.wc = 20 - bow->magic - arrow->magic - 1662 arrow->stats.wc = 20 - bow->magic - arrow->magic -
… …
1971 arrow->level = op->chosen_skill ? op->chosen_skill->level : op->level; 1666 arrow->level = op->chosen_skill ? op->chosen_skill->level : op->level;
1972 } 1667 }
1973 else 1668 else
1974 { 1669 {
1975 arrow->stats.wc = op->stats.wc - bow->magic - arrow->magic - arrow->stats.wc + wc_mod; 1670 arrow->stats.wc = op->stats.wc - bow->magic - arrow->magic - arrow->stats.wc + wc_mod;
1976
1977 arrow->level = op->level; 1671 arrow->level = op->level;
1978 } 1672 }
1673
1979 if (arrow->attacktype == AT_PHYSICAL) 1674 if (arrow->attacktype == AT_PHYSICAL)
1980 arrow->attacktype |= bow->attacktype; 1675 arrow->attacktype |= bow->attacktype;
1676
1981 if (bow->slaying != NULL) 1677 if (bow->slaying)
1982 arrow->slaying = bow->slaying; 1678 arrow->slaying = bow->slaying;
1983 1679
1984 arrow->map = m;
1985 arrow->move_type = MOVE_FLY_LOW; 1680 arrow->move_type = MOVE_FLY_LOW;
1986 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK; 1681 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
1987 1682
1988 play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW); 1683 play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW);
1989 tag = arrow->count; 1684 m->insert (arrow, sx, sy, op);
1990 insert_ob_in_map (arrow, m, op, 0);
1991 1685
1992 if (!was_destroyed (arrow, tag)) 1686 if (!arrow->destroyed ())
1993 move_arrow (arrow); 1687 move_arrow (arrow);
1994 1688
1995 if (op->type == PLAYER) 1689 if (op->type == PLAYER)
1996 { 1690 {
1997 if (was_destroyed (left, left_tag)) 1691 if (left->destroyed ())
1998 esrv_del_item (op->contr, left_tag); 1692 esrv_del_item (op->contr, left->count);
1999 else 1693 else
2000 esrv_send_item (op, left); 1694 esrv_send_item (op, left);
2001 } 1695 }
1696
2002 return 1; 1697 return 1;
2003} 1698}
2004 1699
2005/* Special fire code for players - this takes into 1700/* Special fire code for players - this takes into
2006 * account the special fire modes players can have 1701 * account the special fire modes players can have
… …
2020 } 1715 }
2021 else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw) 1716 else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw)
2022 { 1717 {
2023 if (!similar_direction (dir, op->contr->bowtype - bow_n + 1)) 1718 if (!similar_direction (dir, op->contr->bowtype - bow_n + 1))
2024 wcmod = -1; 1719 wcmod = -1;
1720
2025 ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y); 1721 ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y);
2026 } 1722 }
2027 else if (op->contr->bowtype == bow_threewide) 1723 else if (op->contr->bowtype == bow_threewide)
2028 { 1724 {
2029 ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y); 1725 ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);
… …
2099 1795
2100 if (item->arch) 1796 if (item->arch)
2101 { 1797 {
2102 CLEAR_FLAG (item, FLAG_ANIMATE); 1798 CLEAR_FLAG (item, FLAG_ANIMATE);
2103 item->face = item->arch->clone.face; 1799 item->face = item->arch->clone.face;
2104 item->speed = 0; 1800 item->set_speed (0);
2105 update_ob_speed (item);
2106 } 1801 }
1802
2107 if ((tmp = is_player_inv (item))) 1803 if ((tmp = item->in_player ()))
2108 esrv_update_item (UPD_ANIM, tmp, item); 1804 esrv_update_item (UPD_ANIM, tmp, item);
2109 } 1805 }
2110 } 1806 }
2111 else if (item->type == ROD || item->type == HORN) 1807 else if (item->type == ROD || item->type == HORN)
2112 {
2113 drain_rod_charge (item); 1808 drain_rod_charge (item);
2114 }
2115 } 1809 }
2116} 1810}
2117 1811
2118/* Received a fire command for the player - go and do it. 1812/* Received a fire command for the player - go and do it.
2119 */ 1813 */
… …
2126 if (action_makes_visible (op)) 1820 if (action_makes_visible (op))
2127 make_visible (op); 1821 make_visible (op);
2128 1822
2129 switch (op->contr->shoottype) 1823 switch (op->contr->shoottype)
2130 { 1824 {
2131 case range_none: 1825 case range_none:
2132 return; 1826 return;
2133 1827
2134 case range_bow: 1828 case range_bow:
2135 player_fire_bow (op, dir); 1829 player_fire_bow (op, dir);
2136 return; 1830 return;
2137 1831
2138 case range_magic: /* Casting spells */ 1832 case range_magic: /* Casting spells */
2139 spellcost = (cast_spell (op, op, dir, op->contr->ranges[range_magic], op->contr->spellparam[0] ? op->contr->spellparam : NULL)); 1833 spellcost = (cast_spell (op, op, dir, op->contr->ranges[range_magic], op->contr->spellparam[0] ? op->contr->spellparam : 0));
2140 return; 1834 return;
2141 1835
2142 case range_misc: 1836 case range_misc:
2143 fire_misc_object (op, dir); 1837 fire_misc_object (op, dir);
2144 return; 1838 return;
2145 1839
2146 case range_golem: /* Control summoned monsters from scrolls */ 1840 case range_golem: /* Control summoned monsters from scrolls */
2147 if (op->contr->ranges[range_golem] == NULL || op->contr->golem_count != op->contr->ranges[range_golem]->count) 1841 if (QUERY_FLAG (op->contr->ranges[range_golem], FLAG_REMOVED))
2148 { 1842 {
2149 op->contr->ranges[range_golem] = NULL; 1843 op->contr->ranges[range_golem] = 0;
2150 op->contr->shoottype = range_none; 1844 op->contr->shoottype = range_none;
2151 op->contr->golem_count = 0;
2152 } 1845 }
2153 else 1846 else
2154 control_golem (op->contr->ranges[range_golem], dir); 1847 control_golem (op->contr->ranges[range_golem], dir);
2155 return; 1848 return;
2156 1849
2157 case range_skill: 1850 case range_skill:
2158 if (!op->chosen_skill) 1851 if (!op->chosen_skill)
2159 { 1852 {
2160 if (op->type == PLAYER) 1853 if (op->type == PLAYER)
2161 new_draw_info (NDI_UNIQUE, 0, op, "You have no applicable skill to use."); 1854 new_draw_info (NDI_UNIQUE, 0, op, "You have no applicable skill to use.");
2162 return; 1855 return;
2163 } 1856 }
1857
2164 (void) do_skill (op, op, op->chosen_skill, dir, NULL); 1858 do_skill (op, op, op->chosen_skill, dir, NULL);
2165 return; 1859 return;
2166 case range_builder: 1860 case range_builder:
2167 apply_map_builder (op, dir); 1861 apply_map_builder (op, dir);
2168 return; 1862 return;
2169 default: 1863 default:
2170 new_draw_info (NDI_UNIQUE, 0, op, "Illegal shoot type."); 1864 new_draw_info (NDI_UNIQUE, 0, op, "Illegal shoot type.");
2171 return; 1865 return;
2172 } 1866 }
2173} 1867}
2174 1868
2175 1869
2176 1870
… …
2263 * 0 otherwise 1957 * 0 otherwise
2264 */ 1958 */
2265static int 1959static int
2266player_attack_door (object *op, object *door) 1960player_attack_door (object *op, object *door)
2267{ 1961{
2268
2269 /* If its a door, try to find a use a key. If we do destroy the door, 1962 /* If its a door, try to find a use a key. If we do destroy the door,
2270 * might as well return immediately as there is nothing more to do - 1963 * might as well return immediately as there is nothing more to do -
2271 * otherwise, we fall through to the rest of the code. 1964 * otherwise, we fall through to the rest of the code.
2272 */ 1965 */
2273 object *key = find_key (op, op, door); 1966 object *key = find_key (op, op, door);
… …
2311 * It should keep the code cleaner. 2004 * It should keep the code cleaner.
2312 * When this is called, the players direction has been updated 2005 * When this is called, the players direction has been updated
2313 * (taking into account confusion.) The player is also actually 2006 * (taking into account confusion.) The player is also actually
2314 * going to try and move (not fire weapons). 2007 * going to try and move (not fire weapons).
2315 */ 2008 */
2316
2317void 2009void
2318move_player_attack (object *op, int dir) 2010move_player_attack (object *op, int dir)
2319{ 2011{
2320 object *tmp, *mon; 2012 object *tmp, *mon;
2321 sint16 nx, ny; 2013 sint16 nx, ny;
2322 int on_battleground; 2014 int on_battleground;
2323 mapstruct *m; 2015 maptile *m;
2324 2016
2325 nx = freearr_x[dir] + op->x; 2017 nx = freearr_x[dir] + op->x;
2326 ny = freearr_y[dir] + op->y; 2018 ny = freearr_y[dir] + op->y;
2327 2019
2328 on_battleground = op_on_battleground (op, NULL, NULL); 2020 on_battleground = op_on_battleground (op, 0, 0);
2329 2021
2330 /* If braced, or can't move to the square, and it is not out of the 2022 /* If braced, or can't move to the square, and it is not out of the
2331 * map, attack it. Note order of if statement is important - don't 2023 * map, attack it. Note order of if statement is important - don't
2332 * want to be calling move_ob if braced, because move_ob will move the 2024 * want to be calling move_ob if braced, because move_ob will move the
2333 * player. This is a pretty nasty hack, because if we could 2025 * player. This is a pretty nasty hack, because if we could
… …
2338 */ 2030 */
2339 if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny)) 2031 if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny))
2340 { 2032 {
2341 if (OUT_OF_REAL_MAP (op->map, nx, ny)) 2033 if (OUT_OF_REAL_MAP (op->map, nx, ny))
2342 { 2034 {
2343 m = get_map_from_coord (op->map, &nx, &ny); 2035 m = op->map->xy_find (nx, ny);
2344 if (!m) 2036 if (!m)
2345 return; /* Don't think this should happen */ 2037 return; /* Don't think this should happen */
2346 } 2038 }
2347 else 2039 else
2348 m = op->map; 2040 m = op->map;
2349 2041
2350 if ((tmp = get_map_ob (m, nx, ny)) == NULL) 2042 if (!(tmp = m->at (nx, ny).bot))
2351 {
2352 /* LOG(llevError,"player_move_attack: get_map_ob returns NULL, but player can not more there.\n"); */
2353 return; 2043 return;
2354 }
2355 2044
2356 mon = NULL; 2045 mon = 0;
2357 /* Go through all the objects, and find ones of interest. Only stop if 2046 /* Go through all the objects, and find ones of interest. Only stop if
2358 * we find a monster - that is something we know we want to attack. 2047 * we find a monster - that is something we know we want to attack.
2359 * if its a door or barrel (can roll) see if there may be monsters 2048 * if its a door or barrel (can roll) see if there may be monsters
2360 * on the space 2049 * on the space
2361 */ 2050 */
2362 while (tmp != NULL) 2051 while (tmp)
2363 { 2052 {
2364 if (tmp == op) 2053 if (tmp == op)
2365 { 2054 {
2366 tmp = tmp->above; 2055 tmp = tmp->above;
2367 continue; 2056 continue;
2368 } 2057 }
2058
2369 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 2059 if (QUERY_FLAG (tmp, FLAG_ALIVE))
2370 { 2060 {
2371 mon = tmp; 2061 mon = tmp;
2372 break; 2062 break;
2373 } 2063 }
2064
2374 if (tmp->type == LOCKED_DOOR || QUERY_FLAG (tmp, FLAG_CAN_ROLL)) 2065 if (tmp->type == LOCKED_DOOR || QUERY_FLAG (tmp, FLAG_CAN_ROLL))
2375 mon = tmp; 2066 mon = tmp;
2067
2376 tmp = tmp->above; 2068 tmp = tmp->above;
2377 } 2069 }
2378 2070
2379 if (mon == NULL) /* This happens anytime the player tries to move */ 2071 if (!mon) /* This happens anytime the player tries to move */
2380 return; /* into a wall */ 2072 return; /* into a wall */
2381 2073
2382 if (mon->head != NULL) 2074 if (mon->head)
2383 mon = mon->head; 2075 mon = mon->head;
2384 2076
2385 if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR)) 2077 if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))
2386 if (player_attack_door (op, mon)) 2078 if (player_attack_door (op, mon))
2387 return; 2079 return;
… …
2399 * player owns it and it is either friendly or unagressive. 2091 * player owns it and it is either friendly or unagressive.
2400 */ 2092 */
2401 if ((op->type == PLAYER) 2093 if ((op->type == PLAYER)
2402#if COZY_SERVER 2094#if COZY_SERVER
2403 && 2095 &&
2404 ((get_owner (mon) && get_owner (mon)->contr 2096 ((mon->owner && mon->owner->contr
2405 && same_party (get_owner (mon)->contr->party, op->contr->party)) || get_owner (mon) == op) 2097 && same_party (mon->owner->contr->party, op->contr->party)) || mon->owner == op)
2406#else 2098#else
2407 && get_owner (mon) == op 2099 && mon->owner == op
2408#endif 2100#endif
2409 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY))) 2101 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))
2410 { 2102 {
2411 /* If we're braced, we don't want to switch places with it */ 2103 /* If we're braced, we don't want to switch places with it */
2412 if (op->contr->braced) 2104 if (op->contr->braced)
2413 return; 2105 return;
2106
2414 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2107 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2415 (void) push_ob (mon, dir, op); 2108 (void) push_ob (mon, dir, op);
2416 if (op->contr->tmp_invis || op->hide) 2109 if (op->contr->tmp_invis || op->hide)
2417 make_visible (op); 2110 make_visible (op);
2111
2418 return; 2112 return;
2419 } 2113 }
2420 2114
2421 /* in certain circumstances, you shouldn't attack friendly 2115 /* in certain circumstances, you shouldn't attack friendly
2422 * creatures. Note that if you are braced, you can't push 2116 * creatures. Note that if you are braced, you can't push
… …
2424 * attack them either. 2118 * attack them either.
2425 */ 2119 */
2426 if ((mon->type == PLAYER || mon->enemy != op) && 2120 if ((mon->type == PLAYER || mon->enemy != op) &&
2427 (mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && ( 2121 (mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && (
2428#ifdef PROHIBIT_PLAYERKILL 2122#ifdef PROHIBIT_PLAYERKILL
2429 (op->contr->peaceful 2123 (op->contr->peaceful
2430 || (mon->type == PLAYER 2124 || (mon->type == PLAYER
2431 && mon->contr-> 2125 && mon->contr->
2432 peaceful)) && 2126 peaceful)) &&
2433#else 2127#else
2434 op->contr->peaceful && 2128 op->contr->peaceful &&
2435#endif 2129#endif
2436 !on_battleground)) 2130 !on_battleground))
2437 { 2131 {
2438 if (!op->contr->braced) 2132 if (!op->contr->braced)
2439 { 2133 {
2440 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2134 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2441 (void) push_ob (mon, dir, op); 2135 push_ob (mon, dir, op);
2442 } 2136 }
2443 else 2137 else
2444 {
2445 new_draw_info (0, 0, op, "You withhold your attack"); 2138 new_draw_info (0, 0, op, "You withhold your attack");
2446 } 2139
2447 if (op->contr->tmp_invis || op->hide) 2140 if (op->contr->tmp_invis || op->hide)
2448 make_visible (op); 2141 make_visible (op);
2449 } 2142 }
2450 2143
2451 /* If the object is a boulder or other rollable object, then 2144 /* If the object is a boulder or other rollable object, then
… …
2462 * Way it works is like this: First, it must have some hit points 2155 * Way it works is like this: First, it must have some hit points
2463 * and be living. Then, it must be one of the following: 2156 * and be living. Then, it must be one of the following:
2464 * 1) Not a player, 2) A player, but of a different party. Note 2157 * 1) Not a player, 2) A player, but of a different party. Note
2465 * that party_number -1 is no party, so attacks can still happen. 2158 * that party_number -1 is no party, so attacks can still happen.
2466 */ 2159 */
2467
2468 else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) && 2160 else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&
2469 ((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party))) 2161 ((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party)))
2470 { 2162 {
2471 2163
2472 /* If the player hasn't hit something this tick, and does 2164 /* If the player hasn't hit something this tick, and does
… …
2479 op->speed_left += op->speed / op->contr->weapon_sp; 2171 op->speed_left += op->speed / op->contr->weapon_sp;
2480 2172
2481 op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */ 2173 op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */
2482 } 2174 }
2483 2175
2484 skill_attack (mon, op, 0, NULL, NULL); 2176 skill_attack (mon, op, 0, 0, 0);
2485 2177
2486 /* If attacking another player, that player gets automatic 2178 /* If attacking another player, that player gets automatic
2487 * hitback, and doesn't loose luck either. 2179 * hitback, and doesn't loose luck either.
2488 * Disable hitback on the battleground or if the target is 2180 * Disable hitback on the battleground or if the target is
2489 * the wiz. 2181 * the wiz.
… …
2491 if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ)) 2183 if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ))
2492 { 2184 {
2493 short luck = mon->stats.luck; 2185 short luck = mon->stats.luck;
2494 2186
2495 mon->contr->has_hit = 1; 2187 mon->contr->has_hit = 1;
2496 skill_attack (op, mon, 0, NULL, NULL); 2188 skill_attack (op, mon, 0, 0, 0);
2497 mon->stats.luck = luck; 2189 mon->stats.luck = luck;
2498 } 2190 }
2191
2499 if (action_makes_visible (op)) 2192 if (action_makes_visible (op))
2500 make_visible (op); 2193 make_visible (op);
2501 } 2194 }
2502 } /* if player should attack something */ 2195 } /* if player should attack something */
2503} 2196}
… …
2505int 2198int
2506move_player (object *op, int dir) 2199move_player (object *op, int dir)
2507{ 2200{
2508 int pick; 2201 int pick;
2509 2202
2510 if (op->map == NULL || op->map->in_memory != MAP_IN_MEMORY) 2203 if (!op->map || op->map->in_memory != MAP_IN_MEMORY)
2511 return 0; 2204 return 0;
2512 2205
2513 /* Sanity check: make sure dir is valid */ 2206 /* Sanity check: make sure dir is valid */
2514 if ((dir < 0) || (dir >= 9)) 2207 if ((dir < 0) || (dir >= 9))
2515 { 2208 {
2516 LOG (llevError, "move_player: invalid direction %d\n", dir); 2209 LOG (llevError, "move_player: invalid direction %d\n", dir);
2517 return 0; 2210 return 0;
2518 } 2211 }
2519 2212
2520 /* peterm: added following line */ 2213 /* peterm: added following line */
2521 if (QUERY_FLAG (op, FLAG_CONFUSED) && dir) 2214 if (QUERY_FLAG (op, FLAG_CONFUSED) && dir)
2522 dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2); 2215 dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);
2523 2216
2524 op->facing = dir; 2217 op->facing = dir;
2525 2218
… …
2538 2231
2539 /* Add special check for newcs players and fire on - this way, the 2232 /* Add special check for newcs players and fire on - this way, the
2540 * server can handle repeat firing. 2233 * server can handle repeat firing.
2541 */ 2234 */
2542 if (op->contr->fire_on || (op->contr->run_on && pick != 0)) 2235 if (op->contr->fire_on || (op->contr->run_on && pick != 0))
2543 {
2544 op->direction = dir; 2236 op->direction = dir;
2545 }
2546 else 2237 else
2547 {
2548 op->direction = 0; 2238 op->direction = 0;
2549 } 2239
2550 /* Update how the player looks. Use the facing, so direction may 2240 /* Update how the player looks. Use the facing, so direction may
2551 * get reset to zero. This allows for full animation capabilities 2241 * get reset to zero. This allows for full animation capabilities
2552 * for players. 2242 * for players.
2553 */ 2243 */
2554 animate_object (op, op->facing); 2244 animate_object (op, op->facing);
… …
2599 /* I've been seeing crashes where the golem has been destroyed, but 2289 /* I've been seeing crashes where the golem has been destroyed, but
2600 * the player object still points to the defunct golem. The code that 2290 * the player object still points to the defunct golem. The code that
2601 * destroys the golem looks correct, and it doesn't always happen, so 2291 * destroys the golem looks correct, and it doesn't always happen, so
2602 * put this in a a workaround to clean up the golem pointer. 2292 * put this in a a workaround to clean up the golem pointer.
2603 */ 2293 */
2604 if (op->contr->ranges[range_golem] &&
2605 ((op->contr->golem_count != op->contr->ranges[range_golem]->count) || QUERY_FLAG (op->contr->ranges[range_golem], FLAG_REMOVED))) 2294 if (op->contr->ranges[range_golem] && QUERY_FLAG (op->contr->ranges[range_golem], FLAG_REMOVED))
2606 {
2607 op->contr->ranges[range_golem] = NULL; 2295 op->contr->ranges[range_golem] = 0;
2608 op->contr->golem_count = 0;
2609 }
2610 2296
2611 /* call this here - we also will call this in do_ericserver, but 2297 /* call this here - we also will call this in do_ericserver, but
2612 * the players time has been increased when doericserver has been 2298 * the players time has been increased when doericserver has been
2613 * called, so we recheck it here. 2299 * called, so we recheck it here.
2614 */ 2300 */
2615 HandleClient (&op->contr->socket, op->contr); 2301 if (op->contr->ns->handle_command ())
2302 return 1;
2303
2616 if (op->speed_left < 0) 2304 if (op->speed_left > 0)
2617 return 0; 2305 {
2618
2619 if (op->direction && (op->contr->run_on || op->contr->fire_on)) 2306 if (op->direction && (op->contr->run_on || op->contr->fire_on))
2620 { 2307 {
2621 /* All move commands take 1 tick, at least for now */ 2308 /* All move commands take 1 tick, at least for now */
2622 op->speed_left--; 2309 op->speed_left--;
2623 2310
2624 /* Instead of all the stuff below, let move_player take care 2311 /* Instead of all the stuff below, let move_player take care
2625 * of it. Also, some of the skill stuff is only put in 2312 * of it. Also, some of the skill stuff is only put in
2626 * there, as well as the confusion stuff. 2313 * there, as well as the confusion stuff.
2627 */ 2314 */
2628 move_player (op, op->direction); 2315 move_player (op, op->direction);
2629 if (op->speed_left > 0) 2316
2630 return 1; 2317 return op->speed_left > 0;
2631 else 2318 }
2632 return 0;
2633 } 2319 }
2320
2634 return 0; 2321 return 0;
2635} 2322}
2636 2323
2637int 2324int
2638save_life (object *op) 2325save_life (object *op)
2639{ 2326{
2640 object *tmp;
2641
2642 if (!QUERY_FLAG (op, FLAG_LIFESAVE)) 2327 if (!QUERY_FLAG (op, FLAG_LIFESAVE))
2643 return 0; 2328 return 0;
2644 2329
2645 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 2330 for (object *tmp = op->inv; tmp; tmp = tmp->below)
2646 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE)) 2331 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE))
2647 { 2332 {
2648 play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE); 2333 play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE);
2649 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp)); 2334 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp));
2335
2650 if (op->contr) 2336 if (op->contr)
2651 esrv_del_item (op->contr, tmp->count); 2337 esrv_del_item (op->contr, tmp->count);
2652 remove_ob (tmp); 2338
2653 free_object (tmp); 2339 tmp->destroy ();
2654 CLEAR_FLAG (op, FLAG_LIFESAVE); 2340 CLEAR_FLAG (op, FLAG_LIFESAVE);
2341
2655 if (op->stats.hp < 0) 2342 if (op->stats.hp < 0)
2656 op->stats.hp = op->stats.maxhp; 2343 op->stats.hp = op->stats.maxhp;
2344
2657 if (op->stats.food < 0) 2345 if (op->stats.food < 0)
2658 op->stats.food = 999; 2346 op->stats.food = 999;
2659 fix_player (op); 2347
2348 op->update_stats ();
2660 return 1; 2349 return 1;
2661 } 2350 }
2351
2662 LOG (llevError, "Error: LIFESAVE set without applied object.\n"); 2352 LOG (llevError, "Error: LIFESAVE set without applied object.\n");
2663 CLEAR_FLAG (op, FLAG_LIFESAVE); 2353 CLEAR_FLAG (op, FLAG_LIFESAVE);
2664 enter_player_savebed (op); /* bring him home. */ 2354 enter_player_savebed (op); /* bring him home. */
2665 return 0; 2355 return 0;
2666} 2356}
… …
2675{ 2365{
2676 object *next; 2366 object *next;
2677 2367
2678 while (op) 2368 while (op)
2679 { 2369 {
2680 next = op->below; /* Make sure we have a good value, in case 2370 object *next = op->below; /* Make sure we have a good value, in case we remove object 'op' */
2681 * we remove object 'op' 2371
2682 */
2683 if (QUERY_FLAG (op, FLAG_UNPAID)) 2372 if (QUERY_FLAG (op, FLAG_UNPAID))
2684 { 2373 {
2685 remove_ob (op);
2686 op->x = env->x;
2687 op->y = env->y;
2688 if (env->type == PLAYER) 2374 if (env->type == PLAYER)
2689 esrv_del_item (env->contr, op->count); 2375 esrv_del_item (env->contr, op->count);
2690 insert_ob_in_map (op, env->map, NULL, 0); 2376
2377 op->insert_at (env);
2691 } 2378 }
2692 else if (op->inv) 2379 else if (op->inv)
2693 remove_unpaid_objects (op->inv, env); 2380 remove_unpaid_objects (op->inv, env);
2381
2694 op = next; 2382 op = next;
2695 } 2383 }
2696} 2384}
2697
2698 2385
2699/* 2386/*
2700 * Returns pointer a static string containing gravestone text 2387 * Returns pointer a static string containing gravestone text
2701 * Moved from apply.c to player.c - player.c is what 2388 * Moved from apply.c to player.c - player.c is what
2702 * actually uses this function. player.c may not be quite the 2389 * actually uses this function. player.c may not be quite the
… …
2713 strcpy (buf2, " R.I.P.\n\n"); 2400 strcpy (buf2, " R.I.P.\n\n");
2714 if (op->type == PLAYER) 2401 if (op->type == PLAYER)
2715 sprintf (buf, "%s the %s\n", &op->name, op->contr->title); 2402 sprintf (buf, "%s the %s\n", &op->name, op->contr->title);
2716 else 2403 else
2717 sprintf (buf, "%s\n", &op->name); 2404 sprintf (buf, "%s\n", &op->name);
2405
2718 strncat (buf2, " ", 20 - strlen (buf) / 2); 2406 strncat (buf2, " ", 20 - strlen (buf) / 2);
2719 strcat (buf2, buf); 2407 strcat (buf2, buf);
2720 if (op->type == PLAYER) 2408 if (op->type == PLAYER)
2721 sprintf (buf, "who was in level %d when killed\n", op->level); 2409 sprintf (buf, "who was in level %d when killed\n", op->level);
2722 else 2410 else
2723 sprintf (buf, "who was in level %d when died.\n\n", op->level); 2411 sprintf (buf, "who was in level %d when died.\n\n", op->level);
2412
2724 strncat (buf2, " ", 20 - strlen (buf) / 2); 2413 strncat (buf2, " ", 20 - strlen (buf) / 2);
2725 strcat (buf2, buf); 2414 strcat (buf2, buf);
2726 if (op->type == PLAYER) 2415 if (op->type == PLAYER)
2727 { 2416 {
2728 sprintf (buf, "by %s.\n\n", op->contr->killer); 2417 sprintf (buf, "by %s.\n\n", op->contr->killer);
2729 strncat (buf2, " ", 21 - strlen (buf) / 2); 2418 strncat (buf2, " ", 21 - strlen (buf) / 2);
2730 strcat (buf2, buf); 2419 strcat (buf2, buf);
2731 } 2420 }
2421
2732 strftime (buf, MAX_BUF, "%b %d %Y\n", localtime (&now)); 2422 strftime (buf, MAX_BUF, "%b %d %Y\n", localtime (&now));
2733 strncat (buf2, " ", 20 - strlen (buf) / 2); 2423 strncat (buf2, " ", 20 - strlen (buf) / 2);
2734 strcat (buf2, buf); 2424 strcat (buf2, buf);
2425
2735 return buf2; 2426 return buf2;
2736} 2427}
2737
2738
2739 2428
2740void 2429void
2741do_some_living (object *op) 2430do_some_living (object *op)
2742{ 2431{
2743 int last_food = op->stats.food; 2432 int last_food = op->stats.food;
… …
2752 const int max_grace = 1; 2441 const int max_grace = 1;
2753 2442
2754 if (op->contr->outputs_sync) 2443 if (op->contr->outputs_sync)
2755 { 2444 {
2756 for (i = 0; i < NUM_OUTPUT_BUFS; i++) 2445 for (i = 0; i < NUM_OUTPUT_BUFS; i++)
2757 if (op->contr->outputs[i].buf != NULL && (op->contr->outputs[i].first_update + op->contr->outputs_sync) < (uint16) pticks) 2446 if (op->contr->outputs[i].buf && (op->contr->outputs[i].first_update + op->contr->outputs_sync) < (uint16) pticks)
2758 flush_output_element (op, &op->contr->outputs[i]); 2447 flush_output_element (op, &op->contr->outputs[i]);
2759 } 2448 }
2760 2449
2761 if (op->contr->state == ST_PLAYING) 2450 if (op->contr->ns->state == ST_PLAYING)
2762 { 2451 {
2763
2764 /* these next three if clauses make it possible to SLOW DOWN 2452 /* these next three if clauses make it possible to SLOW DOWN
2765 hp/grace/spellpoint regeneration. */ 2453 hp/grace/spellpoint regeneration. */
2766 if (op->contr->gen_hp >= 0) 2454 if (op->contr->gen_hp >= 0)
2767 gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp; 2455 gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;
2768 else 2456 else
2769 { 2457 {
2770 gen_hp = op->stats.maxhp; 2458 gen_hp = op->stats.maxhp;
2771 rate_hp -= rate_hp / 2 * op->contr->gen_hp; 2459 rate_hp -= rate_hp / 2 * op->contr->gen_hp;
2772 } 2460 }
2461
2773 if (op->contr->gen_sp >= 0) 2462 if (op->contr->gen_sp >= 0)
2774 gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp; 2463 gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;
2775 else 2464 else
2776 { 2465 {
2777 gen_sp = op->stats.maxsp; 2466 gen_sp = op->stats.maxsp;
2778 rate_sp -= rate_sp / 2 * op->contr->gen_sp; 2467 rate_sp -= rate_sp / 2 * op->contr->gen_sp;
2779 } 2468 }
2469
2780 if (op->contr->gen_grace >= 0) 2470 if (op->contr->gen_grace >= 0)
2781 gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace; 2471 gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;
2782 else 2472 else
2783 { 2473 {
2784 gen_grace = op->stats.maxgrace; 2474 gen_grace = op->stats.maxgrace;
… …
2800 op->stats.food += op->contr->digestion; 2490 op->stats.food += op->contr->digestion;
2801 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH)) 2491 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2802 op->stats.food = last_food; 2492 op->stats.food = last_food;
2803 } 2493 }
2804 } 2494 }
2495
2805 if (max_sp > 1) 2496 if (max_sp > 1)
2806 { 2497 {
2807 over_sp = (gen_sp + 10) / rate_sp; 2498 over_sp = (gen_sp + 10) / rate_sp;
2808 if (over_sp > 0) 2499 if (over_sp > 0)
2809 { 2500 {
2810 if (op->stats.sp < op->stats.maxsp) 2501 if (op->stats.sp < op->stats.maxsp)
2811 { 2502 {
2812 op->stats.sp += over_sp > max_sp ? max_sp : over_sp; 2503 op->stats.sp += over_sp > max_sp ? max_sp : over_sp;
2504
2813 if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp)) 2505 if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp))
2814 op->stats.sp--; 2506 op->stats.sp--;
2507
2815 if (op->stats.sp > op->stats.maxsp) 2508 if (op->stats.sp > op->stats.maxsp)
2816 op->stats.sp = op->stats.maxsp; 2509 op->stats.sp = op->stats.maxsp;
2817 } 2510 }
2818 op->last_sp = 0; 2511 op->last_sp = 0;
2819 } 2512 }
2820 else 2513 else
2821 {
2822 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10); 2514 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2823 }
2824 } 2515 }
2825 else 2516 else
2826 {
2827 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10); 2517 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2828 }
2829 } 2518 }
2830 2519
2831 /* Regenerate Grace */ 2520 /* Regenerate Grace */
2832 /* I altered this a little - maximum grace is ony achieved through prayer -b.t. */ 2521 /* I altered this a little - maximum grace is ony achieved through prayer -b.t. */
2833 if (--op->last_grace < 0) 2522 if (--op->last_grace < 0)
2834 { 2523 {
2835 if (op->stats.grace < op->stats.maxgrace / 2) 2524 if (op->stats.grace < op->stats.maxgrace / 2)
2836 op->stats.grace++; /* no penalty in food for regaining grace */ 2525 op->stats.grace++; /* no penalty in food for regaining grace */
2526
2837 if (max_grace > 1) 2527 if (max_grace > 1)
2838 { 2528 {
2839 over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace; 2529 over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;
2840 if (over_grace > 0) 2530 if (over_grace > 0)
2841 { 2531 {
… …
2869 op->stats.food += op->contr->digestion; 2559 op->stats.food += op->contr->digestion;
2870 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH)) 2560 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2871 op->stats.food = last_food; 2561 op->stats.food = last_food;
2872 } 2562 }
2873 } 2563 }
2564
2874 if (max_hp > 1) 2565 if (max_hp > 1)
2875 { 2566 {
2876 over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp; 2567 over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;
2877 if (over_hp > 0) 2568 if (over_hp > 0)
2878 { 2569 {
… …
2902 2593
2903 if (op->contr->gen_hp > 0) 2594 if (op->contr->gen_hp > 0)
2904 op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1); 2595 op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1);
2905 else 2596 else
2906 op->last_eat = 25 * (1 + bonus) / (penalty + 1); 2597 op->last_eat = 25 * (1 + bonus) / (penalty + 1);
2598
2907 /* dms do not consume food */ 2599 /* dms do not consume food */
2908 if (!QUERY_FLAG (op, FLAG_WIZ)) 2600 if (!QUERY_FLAG (op, FLAG_WIZ))
2909 op->stats.food--; 2601 op->stats.food--;
2910 } 2602 }
2911 }
2912 2603
2913 if (op->contr->state == ST_PLAYING && op->stats.food < 0 && op->stats.hp >= 0) 2604 if (op->stats.food < 0 && op->stats.hp >= 0)
2914 { 2605 {
2915 object *tmp, *flesh = NULL; 2606 object *tmp, *flesh = 0;
2916 2607
2917 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 2608 for (tmp = op->inv; tmp; tmp = tmp->below)
2918 { 2609 {
2919 if (!QUERY_FLAG (tmp, FLAG_UNPAID)) 2610 if (!QUERY_FLAG (tmp, FLAG_UNPAID))
2920 {
2921 if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
2922 { 2611 {
2612 if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
2613 {
2923 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food."); 2614 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2924 manual_apply (op, tmp, 0); 2615 manual_apply (op, tmp, 0);
2925 if (op->stats.food >= 0 || op->stats.hp < 0) 2616 if (op->stats.food >= 0 || op->stats.hp < 0)
2926 break; 2617 break;
2927 } 2618 }
2928 else if (tmp->type == FLESH) 2619 else if (tmp->type == FLESH)
2929 flesh = tmp; 2620 flesh = tmp;
2930 } /* End if paid for object */ 2621 } /* End if paid for object */
2931 } /* end of for loop */ 2622 } /* end of for loop */
2623
2932 /* If player is still starving, it means they don't have any food, so 2624 /* If player is still starving, it means they don't have any food, so
2933 * eat flesh instead. 2625 * eat flesh instead.
2934 */ 2626 */
2935 if (op->stats.food < 0 && op->stats.hp >= 0 && flesh) 2627 if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)
2936 { 2628 {
2937 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food."); 2629 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2938 manual_apply (op, flesh, 0); 2630 manual_apply (op, flesh, 0);
2939 } 2631 }
2940 } /* end if player is starving */ 2632 }
2941 2633
2942 while (op->stats.food < 0 && op->stats.hp > 0) 2634 while (op->stats.food < 0 && op->stats.hp >= 0)
2943 op->stats.food++, op->stats.hp--; 2635 op->stats.food++, op->stats.hp--;
2944 2636
2945 if (!op->contr->state && !QUERY_FLAG (op, FLAG_WIZ) && (op->stats.hp < 0 || op->stats.food < 0)) 2637 if (op->stats.hp < 0 && !QUERY_FLAG (op, FLAG_WIZ))
2946 kill_player (op); 2638 kill_player (op);
2639 }
2947} 2640}
2948
2949
2950 2641
2951/* If the player should die (lack of hp, food, etc), we call this. 2642/* If the player should die (lack of hp, food, etc), we call this.
2952 * op is the player in jeopardy. If the player can not be saved (not 2643 * op is the player in jeopardy. If the player can not be saved (not
2953 * permadeath, no lifesave), this will take care of removing the player 2644 * permadeath, no lifesave), this will take care of removing the player
2954 * file. 2645 * file.
… …
2958{ 2649{
2959 char buf[MAX_BUF]; 2650 char buf[MAX_BUF];
2960 int x, y; 2651 int x, y;
2961 2652
2962 //int i; 2653 //int i;
2963 mapstruct *map; /* this is for resurrection */ 2654 maptile *map; /* this is for resurrection */
2964 2655
2965 /* int z; 2656 /* int z;
2966 int num_stats_lose; 2657 int num_stats_lose;
2967 int lost_a_stat; 2658 int lost_a_stat;
2968 int lose_this_stat; 2659 int lose_this_stat;
… …
2983 { 2674 {
2984 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!"); 2675 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!");
2985 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life..."); 2676 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life...");
2986 2677
2987 /* restore player */ 2678 /* restore player */
2988 at = find_archetype ("poisoning"); 2679 at = archetype::find ("poisoning");
2989 tmp = present_arch_in_ob (at, op); 2680 if (object *tmp = present_arch_in_ob (at, op))
2990 if (tmp)
2991 { 2681 {
2992 remove_ob (tmp); 2682 tmp->destroy ();
2993 free_object (tmp);
2994 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed"); 2683 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
2995 } 2684 }
2996 2685
2997 at = find_archetype ("confusion"); 2686 at = archetype::find ("confusion");
2998 tmp = present_arch_in_ob (at, op); 2687 if (object *tmp = present_arch_in_ob (at, op))
2999 if (tmp)
3000 { 2688 {
3001 remove_ob (tmp); 2689 tmp->destroy ();
3002 free_object (tmp);
3003 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 2690 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
3004 } 2691 }
3005 2692
3006 cure_disease (op, 0); /* remove any disease */ 2693 cure_disease (op, 0); /* remove any disease */
3007 op->stats.hp = op->stats.maxhp; 2694 op->stats.hp = op->stats.maxhp;
3008 if (op->stats.food <= 0) 2695 if (op->stats.food <= 0)
3009 op->stats.food = 999; 2696 op->stats.food = 999;
3010 2697
3011 /* create a bodypart-trophy to make the winner happy */ 2698 /* create a bodypart-trophy to make the winner happy */
3012 tmp = arch_to_object (find_archetype ("finger")); 2699 if (object *tmp = arch_to_object (archetype::find ("finger")))
3013 if (tmp != NULL)
3014 { 2700 {
3015 sprintf (buf, "%s's finger", &op->name); 2701 sprintf (buf, "%s's finger", &op->name);
3016 tmp->name = buf; 2702 tmp->name = buf;
3017 sprintf (buf, " This finger has been cut off %s\n" 2703 sprintf (buf, " This finger has been cut off %s\n"
3018 " the %s, when he was defeated at\n level %d by %s.\n", 2704 " the %s, when he was defeated at\n level %d by %s.\n",
3019 &op->name, op->contr->title, (int) (op->level), op->contr->killer); 2705 &op->name, op->contr->title, (int) (op->level), op->contr->killer);
3020 tmp->msg = buf; 2706 tmp->msg = buf;
3021 tmp->value = 0, tmp->material = 0, tmp->type = 0; 2707 tmp->value = 0, tmp->material = 0, tmp->type = 0;
3022 tmp->materialname = NULL; 2708 tmp->materialname = NULL;
3023 tmp->x = op->x, tmp->y = op->y; 2709 tmp->insert_at (op, tmp);
3024 insert_ob_in_map (tmp, op->map, op, 0);
3025 } 2710 }
3026 2711
3027 /* teleport defeated player to new destination */ 2712 /* teleport defeated player to new destination */
3028 transfer_ob (op, x, y, 0, NULL); 2713 transfer_ob (op, x, y, 0, NULL);
3029 op->contr->braced = 0; 2714 op->contr->braced = 0;
… …
3034 2719
3035 command_kill_pets (op, 0); 2720 command_kill_pets (op, 0);
3036 2721
3037 if (op->stats.food < 0) 2722 if (op->stats.food < 0)
3038 { 2723 {
3039 if (op->contr->explore)
3040 {
3041 new_draw_info (NDI_UNIQUE, 0, op, "You would have starved, but you are");
3042 new_draw_info (NDI_UNIQUE, 0, op, "in explore mode, so...");
3043 op->stats.food = 999;
3044 return;
3045 }
3046 sprintf (buf, "%s starved to death.", &op->name); 2724 sprintf (buf, "%s starved to death.", &op->name);
3047 strcpy (op->contr->killer, "starvation"); 2725 strcpy (op->contr->killer, "starvation");
3048 } 2726 }
3049 else 2727 else
3050 {
3051 if (op->contr->explore)
3052 {
3053 new_draw_info (NDI_UNIQUE, 0, op, "You would have died, but you are");
3054 new_draw_info (NDI_UNIQUE, 0, op, "in explore mode, so...");
3055 op->stats.hp = op->stats.maxhp;
3056 return;
3057 }
3058 sprintf (buf, "%s died.", &op->name); 2728 sprintf (buf, "%s died.", &op->name);
3059 } 2729
3060 play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0); 2730 play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0);
3061 2731
3062 /* save the map location for corpse, gravestone */ 2732 /* save the map location for corpse, gravestone */
3063 x = op->x; 2733 x = op->x;
3064 y = op->y; 2734 y = op->y;
3065 map = op->map; 2735 map = op->map;
3066 2736
3067
3068 if (settings.not_permadeth == TRUE)
3069 {
3070 /* NOT_PERMADEATH code. This basically brings the character back to 2737 /* NOT_PERMADEATH code. This basically brings the character back to
3071 * life if they are dead - it takes some exp and a random stat. 2738 * life if they are dead - it takes some exp and a random stat.
3072 * See the config.h file for a little more in depth detail about this. 2739 * See the config.h file for a little more in depth detail about this.
3073 */ 2740 */
3074 2741
3075 /* Basically two ways to go - remove a stat permanently, or just 2742 /* Basically two ways to go - remove a stat permanently, or just
3076 * make it depletion. This bunch of code deals with that aspect 2743 * make it depletion. This bunch of code deals with that aspect
3077 * of death. 2744 * of death.
3078 */ 2745 */
3079#ifndef COZY_SERVER 2746#ifndef COZY_SERVER
3080 if (settings.balanced_stat_loss) 2747 if (settings.balanced_stat_loss)
3081 { 2748 {
3082 /* If stat loss is permanent, lose one stat only. */ 2749 /* If stat loss is permanent, lose one stat only. */
3083 /* Lower level chars don't lose as many stats because they suffer 2750 /* Lower level chars don't lose as many stats because they suffer
3084 more if they do. */ 2751 more if they do. */
3085 /* Higher level characters can afford things such as potions of 2752 /* Higher level characters can afford things such as potions of
3086 restoration, or better, stat potions. So we slug them that 2753 restoration, or better, stat potions. So we slug them that
3087 little bit harder. */ 2754 little bit harder. */
3088 /* GD */ 2755 /* GD */
3089 if (settings.stat_loss_on_death) 2756 if (settings.stat_loss_on_death)
3090 num_stats_lose = 1; 2757 num_stats_lose = 1;
3091 else
3092 num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
3093 }
3094 else 2758 else
3095 { 2759 num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
2760 }
2761 else
3096 num_stats_lose = 1; 2762 num_stats_lose = 1;
3097 } 2763
3098 lost_a_stat = 0; 2764 lost_a_stat = 0;
3099 2765
3100 for (z = 0; z < num_stats_lose; z++) 2766 for (z = 0; z < num_stats_lose; z++)
3101 { 2767 {
3102 i = RANDOM () % NUM_STATS; 2768 i = RANDOM () % NUM_STATS;
3103 2769
3104 if (settings.stat_loss_on_death) 2770 if (settings.stat_loss_on_death)
3105 { 2771 {
3106 /* Pick a random stat and take a point off it. Tell the player 2772 /* Pick a random stat and take a point off it. Tell the player
3107 * what he lost. 2773 * what he lost.
3108 */ 2774 */
3109 change_attr_value (&(op->stats), i, -1); 2775 change_attr_value (&(op->stats), i, -1);
3110 check_stat_bounds (&(op->stats)); 2776 check_stat_bounds (&(op->stats));
3111 change_attr_value (&(op->contr->orig_stats), i, -1); 2777 change_attr_value (&(op->contr->orig_stats), i, -1);
3112 check_stat_bounds (&(op->contr->orig_stats)); 2778 check_stat_bounds (&(op->contr->orig_stats));
3113 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]); 2779 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3114 lost_a_stat = 1; 2780 lost_a_stat = 1;
2781 }
2782 else
2783 {
2784 /* deplete a stat */
2785 archetype *deparch = archetype::find ("depletion");
2786 object *dep;
2787
2788 dep = present_arch_in_ob (deparch, op);
2789 if (!dep)
2790 {
2791 dep = arch_to_object (deparch);
2792 insert_ob_in_ob (dep, op);
3115 } 2793 }
3116 else 2794 lose_this_stat = 1;
2795 if (settings.balanced_stat_loss)
3117 { 2796 {
3118 /* deplete a stat */ 2797 /* GD */
3119 archetype *deparch = find_archetype ("depletion"); 2798 /* Get the stat that we're about to deplete. */
3120 object *dep; 2799 this_stat = get_attr_value (&(dep->stats), i);
3121 2800 if (this_stat < 0)
3122 dep = present_arch_in_ob (deparch, op);
3123 if (!dep)
3124 { 2801 {
3125 dep = arch_to_object (deparch); 2802 int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3126 insert_ob_in_ob (dep, op); 2803 int keep_chance = this_stat * this_stat;
3127 } 2804
3128 lose_this_stat = 1; 2805 /* Yes, I am paranoid. Sue me. */
3129 if (settings.balanced_stat_loss)
3130 {
3131 /* GD */
3132 /* Get the stat that we're about to deplete. */
3133 this_stat = get_attr_value (&(dep->stats), i);
3134 if (this_stat < 0) 2806 if (keep_chance < 1)
2807 keep_chance = 1;
2808
2809 /* There is a maximum depletion total per level. */
2810 if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3135 { 2811 {
3136 int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3137 int keep_chance = this_stat * this_stat;
3138
3139 /* Yes, I am paranoid. Sue me. */
3140 if (keep_chance < 1)
3141 keep_chance = 1;
3142
3143 /* There is a maximum depletion total per level. */
3144 if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3145 {
3146 lose_this_stat = 0; 2812 lose_this_stat = 0;
3147 /* Take loss chance vs keep chance to see if we 2813 /* Take loss chance vs keep chance to see if we
3148 retain the stat. */ 2814 retain the stat. */
3149 }
3150 else
3151 {
3152 if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3153 lose_this_stat = 0;
3154 /* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
3155 this_stat, keep_chance, loss_chance,
3156 lose_this_stat?"LOSE":"KEEP"); */
3157 }
3158 } 2815 }
3159 }
3160
3161 if (lose_this_stat)
3162 {
3163 this_stat = get_attr_value (&(dep->stats), i);
3164 /* We could try to do something clever like find another
3165 * stat to reduce if this fails. But chances are, if
3166 * stats have been depleted to -50, all are pretty low
3167 * and should be roughly the same, so it shouldn't make a
3168 * difference.
3169 */ 2816 else
3170 if (this_stat >= -50)
3171 { 2817 {
3172 change_attr_value (&(dep->stats), i, -1); 2818 if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3173 SET_FLAG (dep, FLAG_APPLIED);
3174 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3175 fix_player (op);
3176 lost_a_stat = 1; 2819 lose_this_stat = 0;
2820 /* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
2821 this_stat, keep_chance, loss_chance,
2822 lose_this_stat?"LOSE":"KEEP"); */
3177 } 2823 }
3178 } 2824 }
3179 } 2825 }
2826
2827 if (lose_this_stat)
2828 {
2829 this_stat = get_attr_value (&(dep->stats), i);
2830 /* We could try to do something clever like find another
2831 * stat to reduce if this fails. But chances are, if
2832 * stats have been depleted to -50, all are pretty low
2833 * and should be roughly the same, so it shouldn't make a
2834 * difference.
2835 */
2836 if (this_stat >= -50)
2837 {
2838 change_attr_value (&(dep->stats), i, -1);
2839 SET_FLAG (dep, FLAG_APPLIED);
2840 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
2841 op->update_stats ();
2842 lost_a_stat = 1;
2843 }
3180 } 2844 }
2845 }
2846 }
3181 /* If no stat lost, tell the player. */ 2847 /* If no stat lost, tell the player. */
3182 if (!lost_a_stat) 2848 if (!lost_a_stat)
3183 { 2849 {
3184 /* determine_god() seems to not work sometimes... why is this? 2850 /* determine_god() seems to not work sometimes... why is this?
3185 Should I be using something else? GD */ 2851 Should I be using something else? GD */
3186 const char *god = determine_god (op); 2852 const char *god = determine_god (op);
3187 2853
3188 if (god && (strcmp (god, "none"))) 2854 if (god && (strcmp (god, "none")))
3189 new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief " "moment you feel the holy presence of %s protecting" " you.", god); 2855 new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god);
3190 else 2856 else
3191 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you."); 2857 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you.");
3192 } 2858 }
2859#else
2860 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");
3193#endif 2861#endif
3194 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");
3195 2862
3196 /* Put a gravestone up where the character 'almost' died. List the 2863 /* Put a gravestone up where the character 'almost' died. List the
3197 * exp loss on the stone. 2864 * exp loss on the stone.
3198 */ 2865 */
3199 tmp = arch_to_object (find_archetype ("gravestone")); 2866 tmp = arch_to_object (archetype::find ("gravestone"));
3200 sprintf (buf, "%s's gravestone", &op->name); 2867 sprintf (buf, "%s's gravestone", &op->name);
3201 tmp->name = buf; 2868 tmp->name = buf;
3202 sprintf (buf, "%s's gravestones", &op->name); 2869 sprintf (buf, "%s's gravestones", &op->name);
3203 tmp->name_pl = buf; 2870 tmp->name_pl = buf;
3204 sprintf (buf, "RIP\nHere rests the hero %s the %s,\n" "who was killed\n" "by %s.\n", &op->name, op->contr->title, op->contr->killer); 2871 sprintf (buf, "RIP\nHere rests the hero %s the %s,\n" "who was killed\n" "by %s.\n", &op->name, op->contr->title, op->contr->killer);
3205 tmp->msg = buf; 2872 tmp->msg = buf;
3206 tmp->x = op->x, tmp->y = op->y; 2873 tmp->x = op->x, tmp->y = op->y;
3207 insert_ob_in_map (tmp, op->map, NULL, 0); 2874 insert_ob_in_map (tmp, op->map, NULL, 0);
3208 2875
3209 /**************************************/ 2876 /**************************************/
3210 /* */ 2877 /* */
3211 /* Subtract the experience points, */ 2878 /* Subtract the experience points, */
3212 /* if we died cause of food, give us */ 2879 /* if we died cause of food, give us */
3213 /* food, and reset HP's... */ 2880 /* food, and reset HP's... */
3214 /* */ 2881 /* */
3215
3216 /**************************************/ 2882 /**************************************/
3217 2883
3218 /* remove any poisoning and confusion the character may be suffering. */ 2884 /* remove any poisoning and confusion the character may be suffering. */
3219 /* restore player */ 2885 /* restore player */
3220 at = find_archetype ("poisoning"); 2886 at = archetype::find ("poisoning");
3221 tmp = present_arch_in_ob (at, op); 2887 tmp = present_arch_in_ob (at, op);
2888
3222 if (tmp) 2889 if (tmp)
3223 { 2890 {
3224 remove_ob (tmp); 2891 tmp->destroy ();
3225 free_object (tmp);
3226 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed"); 2892 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
3227 } 2893 }
3228 2894
3229 at = find_archetype ("confusion"); 2895 at = archetype::find ("confusion");
3230 tmp = present_arch_in_ob (at, op); 2896 tmp = present_arch_in_ob (at, op);
3231 if (tmp) 2897 if (tmp)
3232 { 2898 {
3233 remove_ob (tmp); 2899 tmp->destroy ();
3234 free_object (tmp);
3235 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 2900 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
3236 } 2901 }
2902
3237 cure_disease (op, 0); /* remove any disease */ 2903 cure_disease (op, 0); /* remove any disease */
3238 2904
3239 /*add_exp(op, (op->stats.exp * -0.20)); */ 2905 /*add_exp(op, (op->stats.exp * -0.20)); */
3240 apply_death_exp_penalty (op); 2906 apply_death_exp_penalty (op);
3241 if (op->stats.food < 100) 2907 if (op->stats.food < 100)
3242 op->stats.food = 900; 2908 op->stats.food = 900;
3243 op->stats.hp = op->stats.maxhp; 2909 op->stats.hp = op->stats.maxhp;
3244 op->stats.sp = MAX (op->stats.sp, op->stats.maxsp); 2910 op->stats.sp = MAX (op->stats.sp, op->stats.maxsp);
3245 op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace); 2911 op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace);
3246 2912
3247 /* 2913 /*
3248 * Check to see if the player is in a shop. IF so, then check to see if 2914 * Check to see if the player is in a shop. IF so, then check to see if
3249 * the player has any unpaid items. If so, remove them and put them back 2915 * the player has any unpaid items. If so, remove them and put them back
3250 * in the map. 2916 * in the map.
3251 */ 2917 */
3252 2918
3253 if (is_in_shop (op)) 2919 if (is_in_shop (op))
3254 remove_unpaid_objects (op->inv, op); 2920 remove_unpaid_objects (op->inv, op);
3255 2921
3256 /****************************************/ 2922 /****************************************/
3257 /* */ 2923 /* */
3258 /* Move player to his current respawn- */ 2924 /* Move player to his current respawn- */
3259 /* position (usually last savebed) */ 2925 /* position (usually last savebed) */
3260 /* */ 2926 /* */
3261
3262 /****************************************/ 2927 /****************************************/
3263 2928
3264 enter_player_savebed (op); 2929 enter_player_savebed (op);
3265 2930
3266 /* Save the player before inserting the force to reduce
3267 * chance of abuse.
3268 */
3269 op->contr->braced = 0; 2931 op->contr->braced = 0;
3270 save_player (op, 1);
3271 2932
3272 /* it is possible that the player has blown something up 2933 /* it is possible that the player has blown something up
3273 * at his savebed location, and that can have long lasting 2934 * at his savebed location, and that can have long lasting
3274 * spell effects. So first see if there is a spell effect 2935 * spell effects. So first see if there is a spell effect
3275 * on the space that might harm the player. 2936 * on the space that might harm the player.
3276 */ 2937 */
3277 will_kill_again = 0; 2938 will_kill_again = 0;
3278 for (tmp = get_map_ob (op->map, op->x, op->y); tmp; tmp = tmp->above) 2939 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
3279 {
3280 if (tmp->type == SPELL_EFFECT) 2940 if (tmp->type == SPELL_EFFECT)
3281 will_kill_again |= tmp->attacktype; 2941 will_kill_again |= tmp->attacktype;
3282 } 2942
3283 if (will_kill_again) 2943 if (will_kill_again)
3284 { 2944 {
3285 object *force; 2945 object *force;
3286 int at; 2946 int at;
3287 2947
3288 force = get_archetype (FORCE_NAME); 2948 force = get_archetype (FORCE_NAME);
3289 /* 50 ticks should be enough time for the spell to abate */ 2949 /* 50 ticks should be enough time for the spell to abate */
3290 force->speed = 0.1; 2950 force->speed = 0.1;
3291 force->speed_left = -5.0; 2951 force->speed_left = -5.0;
3292 SET_FLAG (force, FLAG_APPLIED); 2952 SET_FLAG (force, FLAG_APPLIED);
3293 for (at = 0; at < NROFATTACKS; at++) 2953 for (at = 0; at < NROFATTACKS; at++)
3294 {
3295 if (will_kill_again & (1 << at)) 2954 if (will_kill_again & (1 << at))
3296 force->resist[at] = 100; 2955 force->resist[at] = 100;
3297 } 2956
3298 insert_ob_in_ob (force, op); 2957 insert_ob_in_ob (force, op);
3299 fix_player (op); 2958 op->update_stats ();
3300 2959
3301 } 2960 }
3302 2961
3303 new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED."); 2962 new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED.");
3304 return;
3305 } /* NOT_PERMADETH */
3306 else
3307 {
3308 /* If NOT_PERMADETH is set, then the rest of this is not reachable. This
3309 * should probably be embedded in an else statement.
3310 */
3311
3312 op->contr->party = NULL;
3313 if (settings.set_title == TRUE)
3314 op->contr->own_title[0] = '\0';
3315 new_draw_info (NDI_UNIQUE | NDI_ALL, 0, NULL, buf);
3316 check_score (op);
3317 if (op->contr->ranges[range_golem] != NULL)
3318 {
3319 remove_friendly_object (op->contr->ranges[range_golem]);
3320 remove_ob (op->contr->ranges[range_golem]);
3321 free_object (op->contr->ranges[range_golem]);
3322 op->contr->ranges[range_golem] = NULL;
3323 op->contr->golem_count = 0;
3324 }
3325 loot_object (op); /* Remove some of the items for good */
3326 remove_ob (op);
3327 op->direction = 0;
3328
3329 if (!QUERY_FLAG (op, FLAG_WAS_WIZ) && op->stats.exp)
3330 {
3331 delete_character (op->name, 0);
3332 if (settings.resurrection == TRUE)
3333 {
3334 /* save playerfile sans equipment when player dies
3335 ** then save it as player.pl.dead so that future resurrection
3336 ** type spells will work on them nicely
3337 */
3338 delete_character (op->name, 0);
3339 op->stats.hp = op->stats.maxhp;
3340 op->stats.food = 999;
3341
3342 /* set the location of where the person will reappear when */
3343 /* maybe resurrection code should fix map also */
3344 strcpy (op->contr->maplevel, settings.emergency_mapname);
3345 if (op->map != NULL)
3346 op->map = NULL;
3347 op->x = settings.emergency_x;
3348 op->y = settings.emergency_y;
3349 save_player (op, 0);
3350 op->map = map;
3351 /* please see resurrection.c: peterm */
3352 dead_player (op);
3353 }
3354 else
3355 delete_character (op->name, 1);
3356 }
3357
3358 play_again (op);
3359
3360 /* peterm: added to create a corpse at deathsite. */
3361 tmp = arch_to_object (find_archetype ("corpse_pl"));
3362 sprintf (buf, "%s", &op->name);
3363 tmp->name = tmp->name_pl = buf;
3364 tmp->level = op->level;
3365 tmp->x = x;
3366 tmp->y = y;
3367 tmp->msg = gravestone_text (op);
3368 SET_FLAG (tmp, FLAG_UNIQUE);
3369 insert_ob_in_map (tmp, map, NULL, 0);
3370 }
3371} 2963}
3372
3373 2964
3374void 2965void
3375loot_object (object *op) 2966loot_object (object *op)
3376{ /* Grab and destroy some treasure */ 2967{ /* Grab and destroy some treasure */
3377 object *tmp, *tmp2, *next; 2968 object *tmp, *tmp2, *next;
3378 2969
3379 if (op->container) 2970 if (op->container)
3380 { /* close open sack first */
3381 esrv_apply_container (op, op->container); 2971 esrv_apply_container (op, op->container); /* close open sack first */
3382 }
3383 2972
3384 for (tmp = op->inv; tmp != NULL; tmp = next) 2973 for (tmp = op->inv; tmp; tmp = next)
3385 { 2974 {
3386 next = tmp->below; 2975 next = tmp->below;
3387 if (tmp->type == EXPERIENCE || tmp->invisible) 2976
2977 if (tmp->invisible)
3388 continue; 2978 continue;
3389 remove_ob (tmp); 2979
2980 tmp->remove ();
3390 tmp->x = op->x, tmp->y = op->y; 2981 tmp->x = op->x, tmp->y = op->y;
3391 if (tmp->type == CONTAINER) 2982 if (tmp->type == CONTAINER)
3392 { /* empty container to ground */ 2983 { /* empty container to ground */
3393 loot_object (tmp); 2984 loot_object (tmp);
3394 } 2985 }
3395 if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(RANDOM () % 3))) 2986 if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(RANDOM () % 3)))
3396 { 2987 {
3397 if (tmp->nrof > 1) 2988 if (tmp->nrof > 1)
3398 { 2989 {
3399 tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1)); 2990 tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1));
3400 free_object (tmp2); 2991 tmp2->destroy ();
3401 insert_ob_in_map (tmp, op->map, NULL, 0); 2992 insert_ob_in_map (tmp, op->map, NULL, 0);
3402 } 2993 }
3403 else 2994 else
3404 free_object (tmp); 2995 tmp->destroy ();
3405 } 2996 }
3406 else 2997 else
3407 insert_ob_in_map (tmp, op->map, NULL, 0); 2998 insert_ob_in_map (tmp, op->map, NULL, 0);
3408 } 2999 }
3409} 3000}
… …
3415 */ 3006 */
3416 3007
3417void 3008void
3418fix_weight (void) 3009fix_weight (void)
3419{ 3010{
3420 player *pl; 3011 for_all_players (pl)
3421
3422 for (pl = first_player; pl != NULL; pl = pl->next)
3423 { 3012 {
3424 int old = pl->ob->carrying, sum = sum_weight (pl->ob); 3013 int old = pl->ob->carrying, sum = sum_weight (pl->ob);
3425 3014
3426 if (old == sum) 3015 if (old == sum)
3427 continue; 3016 continue;
3428 fix_player (pl->ob); 3017 pl->ob->update_stats ();
3429 LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum); 3018 LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum);
3430 } 3019 }
3431} 3020}
3432 3021
3433void 3022void
3434fix_luck (void) 3023fix_luck (void)
3435{ 3024{
3436 player *pl; 3025 for_all_players (pl)
3437
3438 for (pl = first_player; pl != NULL; pl = pl->next)
3439 if (!pl->ob->contr->state) 3026 if (!pl->ob->contr->ns->state)
3440 change_luck (pl->ob, 0); 3027 pl->ob->change_luck (0);
3441} 3028}
3442
3443 3029
3444/* cast_dust() - handles op throwing objects of type 'DUST'. 3030/* cast_dust() - handles op throwing objects of type 'DUST'.
3445 * This is much simpler in the new spell code - we basically 3031 * This is much simpler in the new spell code - we basically
3446 * just treat this as any other spell casting object. 3032 * just treat this as any other spell casting object.
3447 */ 3033 */
3448
3449void 3034void
3450cast_dust (object *op, object *throw_ob, int dir) 3035cast_dust (object *op, object *throw_ob, int dir)
3451{ 3036{
3452 object *skop, *spob; 3037 object *skop, *spob;
3453 3038
… …
3474 if (op->type == PLAYER) 3059 if (op->type == PLAYER)
3475 new_draw_info_format (NDI_UNIQUE, 0, op, "You cast %s.", &spob->name); 3060 new_draw_info_format (NDI_UNIQUE, 0, op, "You cast %s.", &spob->name);
3476 3061
3477 cast_spell (op, throw_ob, dir, spob, NULL); 3062 cast_spell (op, throw_ob, dir, spob, NULL);
3478 3063
3479 if (!QUERY_FLAG (throw_ob, FLAG_REMOVED)) 3064 throw_ob->destroy ();
3480 remove_ob (throw_ob);
3481 free_object (throw_ob);
3482} 3065}
3483 3066
3484void 3067void
3485make_visible (object *op) 3068make_visible (object *op)
3486{ 3069{
… …
3500 object *tmp = NULL; 3083 object *tmp = NULL;
3501 3084
3502 if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD)) 3085 if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))
3503 return 1; 3086 return 1;
3504 3087
3505 if (op->type == PLAYER)
3506 for (tmp = op->inv; tmp; tmp = tmp->below)
3507 if (tmp->type == EXPERIENCE && tmp->stats.Wis)
3508 if (QUERY_FLAG (tmp, FLAG_UNDEAD))
3509 return 1;
3510 return 0; 3088 return 0;
3511} 3089}
3512 3090
3513/* look at the surrounding terrain to determine 3091/* look at the surrounding terrain to determine
3514 * the hideability of this object. Positive levels 3092 * the hideability of this object. Positive levels
… …
3570 3148
3571 skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING); 3149 skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING);
3572 3150
3573 /* its *extremely* hard to run and sneak/hide at the same time! */ 3151 /* its *extremely* hard to run and sneak/hide at the same time! */
3574 if (op->type == PLAYER && op->contr->run_on) 3152 if (op->type == PLAYER && op->contr->run_on)
3575 {
3576 if (!skop || num >= skop->level) 3153 if (!skop || num >= skop->level)
3577 { 3154 {
3578 new_draw_info (NDI_UNIQUE, 0, op, "You ran too much! You are no longer hidden!"); 3155 new_draw_info (NDI_UNIQUE, 0, op, "You ran too much! You are no longer hidden!");
3579 make_visible (op); 3156 make_visible (op);
3580 return; 3157 return;
3581 } 3158 }
3582 else 3159 else
3583 num += 20; 3160 num += 20;
3584 } 3161
3585 num += op->map->difficulty; 3162 num += op->map->difficulty;
3586 hide = hideability (op); /* modify by terrain hidden level */ 3163 hide = hideability (op); /* modify by terrain hidden level */
3587 num -= hide; 3164 num -= hide;
3165
3588 if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0)) 3166 if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0))
3589 { 3167 {
3590 make_visible (op); 3168 make_visible (op);
3591 if (op->type == PLAYER) 3169 if (op->type == PLAYER)
3592 new_draw_info (NDI_UNIQUE, 0, op, "You moved out of hiding! You are visible!"); 3170 new_draw_info (NDI_UNIQUE, 0, op, "You moved out of hiding! You are visible!");
3593 } 3171 }
3594 else if (op->type == PLAYER && skop) 3172 else if (op->type == PLAYER && skop)
3595 {
3596 change_exp (op, calc_skill_exp (op, NULL, skop), skop->skill, 0); 3173 change_exp (op, calc_skill_exp (op, NULL, skop), skop->skill, 0);
3597 }
3598} 3174}
3599 3175
3600/* determine if who is standing near a hostile creature. */ 3176/* determine if who is standing near a hostile creature. */
3601 3177
3602int 3178int
3603stand_near_hostile (object *who) 3179stand_near_hostile (object *who)
3604{ 3180{
3605 object *tmp = NULL; 3181 object *tmp = NULL;
3606 int i, friendly = 0, player = 0, mflags; 3182 int i, friendly = 0, player = 0, mflags;
3607 mapstruct *m; 3183 maptile *m;
3608 sint16 x, y; 3184 sint16 x, y;
3609 3185
3610 if (!who) 3186 if (!who)
3611 return 0; 3187 return 0;
3612 3188
… …
3629 if (mflags & P_OUT_OF_MAP) 3205 if (mflags & P_OUT_OF_MAP)
3630 continue; 3206 continue;
3631 if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y))) 3207 if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y)))
3632 continue; 3208 continue;
3633 3209
3634 for (tmp = get_map_ob (m, x, y); tmp; tmp = tmp->above) 3210 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
3635 { 3211 {
3636 if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE)) 3212 if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))
3637 return 1; 3213 return 1;
3638 else if (tmp->type == PLAYER) 3214 else if (tmp->type == PLAYER)
3639 { 3215 {
… …
3669 if (pl->type != PLAYER) 3245 if (pl->type != PLAYER)
3670 { 3246 {
3671 LOG (llevError, "player_can_view() called for non-player object\n"); 3247 LOG (llevError, "player_can_view() called for non-player object\n");
3672 return -1; 3248 return -1;
3673 } 3249 }
3250
3674 if (!pl || !op) 3251 if (!pl || !op)
3675 return 0; 3252 return 0;
3676 3253
3677 if (op->head)
3678 {
3679 op = op->head; 3254 op = op->head_ ();
3680 } 3255
3681 get_rangevector (pl, op, &rv, 0x1); 3256 get_rangevector (pl, op, &rv, 0x1);
3682 3257
3683 /* starting with the 'head' part, lets loop 3258 /* starting with the 'head' part, lets loop
3684 * through the object and find if it has any 3259 * through the object and find if it has any
3685 * part that is in the los array but isnt on 3260 * part that is in the los array but isnt on
… …
3693 3268
3694 /* only the viewable area the player sees is updated by LOS 3269 /* only the viewable area the player sees is updated by LOS
3695 * code, so we need to restrict ourselves to that range of values 3270 * code, so we need to restrict ourselves to that range of values
3696 * for any meaningful values. 3271 * for any meaningful values.
3697 */ 3272 */
3698 if (FABS (dx) <= (pl->contr->socket.mapx / 2) && 3273 if (FABS (dx) <= (pl->contr->ns->mapx / 2) &&
3699 FABS (dy) <= (pl->contr->socket.mapy / 2) && 3274 FABS (dy) <= (pl->contr->ns->mapy / 2) &&
3700 !pl->contr->blocked_los[dx + (pl->contr->socket.mapx / 2)][dy + (pl->contr->socket.mapy / 2)]) 3275 !pl->contr->blocked_los[dx + (pl->contr->ns->mapx / 2)][dy + (pl->contr->ns->mapy / 2)])
3701 return 1; 3276 return 1;
3702 op = op->more; 3277 op = op->more;
3703 } 3278 }
3704 return 0; 3279 return 0;
3705} 3280}
… …
3815 if (trlist == NULL || who->type != PLAYER) 3390 if (trlist == NULL || who->type != PLAYER)
3816 return; 3391 return;
3817 3392
3818 for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++); 3393 for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++);
3819 3394
3820 if (tr == NULL || tr->item == NULL) 3395 if (!tr || !tr->item)
3821 { 3396 {
3822 /* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */ 3397 /* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */
3823 return; 3398 return;
3824 } 3399 }
3825 3400
… …
3891 { 3466 {
3892 /* forces in the treasurelist can alter the player's stats */ 3467 /* forces in the treasurelist can alter the player's stats */
3893 object *skin; 3468 object *skin;
3894 3469
3895 /* first get the dragon skin force */ 3470 /* first get the dragon skin force */
3471 shstr_cmp dragon_skin_force ("dragon_skin_force");
3896 for (skin = who->inv; skin != NULL && strcmp (skin->arch->name, "dragon_skin_force") != 0; skin = skin->below); 3472 for (skin = who->inv; skin && !(skin->arch->name == dragon_skin_force); skin = skin->below)
3473 ;
3474
3897 if (skin == NULL) 3475 if (!skin)
3898 return; 3476 return;
3899 3477
3900 /* adding new spellpath attunements */ 3478 /* adding new spellpath attunements */
3901 if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned)) 3479 if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned))
3902 { 3480 {
… …
3947 * not readied. 3525 * not readied.
3948 */ 3526 */
3949void 3527void
3950player_unready_range_ob (player *pl, object *ob) 3528player_unready_range_ob (player *pl, object *ob)
3951{ 3529{
3952 rangetype i;
3953
3954 for (i = (rangetype) 0; i < range_size; i = (rangetype) ((int) i + 1)) 3530 for (rangetype i = (rangetype) 0; i < range_size; i = (rangetype) ((int) i + 1))
3955 {
3956 if (pl->ranges[i] == ob) 3531 if (pl->ranges[i] == ob)
3957 { 3532 {
3958 pl->ranges[i] = NULL; 3533 pl->ranges[i] = 0;
3959 if (pl->shoottype == i) 3534 if (pl->shoottype == i)
3960 {
3961 pl->shoottype = range_none; 3535 pl->shoottype = range_none;
3962 }
3963 } 3536 }
3964 }
3965} 3537}

Diff Legend

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