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.53 by root, Fri Dec 22 16:03:21 2006 UTC vs.
Revision 1.96 by root, Mon Jan 8 19:25:53 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game
3 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version. 11 * (at your option) any later version.
11 12 *
12 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21 *
21 The author can be reached via e-mail to <crossfire@schmorp.de> 22 * The author can be reached via e-mail to <crossfire@schmorp.de>
22*/ 23 */
23 24
24#include <global.h> 25#include <global.h>
25#include <pwd.h> 26#include <pwd.h>
26#include <sproto.h> 27#include <sproto.h>
27#include <sounds.h> 28#include <sounds.h>
28#include <living.h> 29#include <living.h>
29#include <object.h> 30#include <object.h>
30#include <spells.h> 31#include <spells.h>
31#include <skills.h> 32#include <skills.h>
32 33
33#ifdef COZY_SERVER 34#include <algorithm>
34extern int same_party (partylist *a, partylist *b); 35#include <functional>
35#endif
36 36
37player * 37playervec players;
38find_player (const char *plname)
39{
40 player *pl;
41
42 for (pl = first_player; pl; pl = pl->next)
43 {
44 if (pl->obL && !strcmp (query_name (pl->ob), plname))
45 return pl;
46 };
47
48 return 0;
49}
50
51player *
52find_player_partial_name (const char *plname)
53{
54 player *pl;
55 player *found = NULL;
56 size_t namelen = strlen (plname);
57
58 for (pl = first_player; pl; pl = pl->next)
59 {
60 if ((size_t) strlen (pl->ob->name) < namelen)
61 continue;
62
63 if (!strcmp (pl->ob->name, plname))
64 return pl;
65
66 if (!strncasecmp (pl->ob->name, plname, namelen))
67 {
68 if (found)
69 return 0;
70
71 found = pl;
72 }
73 }
74
75 return found;
76}
77 38
78void 39void
79display_motd (const object *op) 40display_motd (const object *op)
80{ 41{
81 char buf[MAX_BUF]; 42 char buf[MAX_BUF];
… …
164 125
165 if (*buf == '%') 126 if (*buf == '%')
166 { /* send one news */ 127 { /* send one news */
167 if (size > 0) 128 if (size > 0)
168 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
169 strcpy (subject, buf + 1); 131 strcpy (subject, buf + 1);
170 strip_endline (subject); 132 strip_endline (subject);
171 size = 0; 133 size = 0;
172 news[0] = '\0'; 134 news[0] = '\0';
173 } 135 }
… …
186 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op, 148 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,
187 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);
188 close_and_delete (fp, comp); 150 close_and_delete (fp, comp);
189} 151}
190 152
191int
192playername_ok (const char *cp)
193{
194 /* Don't allow - or _ as first character in the name */
195 if (*cp == '-' || *cp == '_')
196 return 0;
197
198 for (; *cp != '\0'; cp++)
199 if (!((*cp >= 'a' && *cp <= 'z') || (*cp >= 'A' && *cp <= 'Z')) && *cp != '-' && *cp != '_')
200 return 0;
201
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 (0));
220 int i;
221
222 /* Clears basically the entire player structure except
223 * for next and socket.
224 */
225 p->clear ();
226
227 /* There are some elements we want initialized to non zero value -
228 * we deal with that below this point.
229 */
230 p->party = NULL;
231 p->outputs_sync = 16; /* Every 2 seconds */
232 p->outputs_count = 8; /* Keeps present behaviour */
233 p->unapply = unapply_nochoice;
234 p->Swap_First = -1;
235
236#ifdef AUTOSAVE
237 p->last_save_tick = 9999999;
238#endif
239
240 strcpy (p->savebed_map, first_map_path); /* Init. respawn position */
241
242 op->contr = p; /* this aren't yet in archetype */
243 p->ob = op;
244 op->speed_left = 0.5;
245 op->speed = 1.0;
246 op->direction = 5; /* So player faces south */
247 op->stats.wc = 2;
248 op->run_away = 25; /* Then we panick... */
249
250 {
251 int oldmon = p->ns->monitor_spells; // what a hack
252 p->ns->monitor_spells = 0; /* Needed because esrv_update_spells( ) gets called by roll_stats */
253 roll_stats (op);
254 p->ns->monitor_spells = oldmon;
255 }
256 p->ns->state = ST_ROLL_STAT;
257 clear_los (op);
258
259 p->gen_sp_armour = 10;
260 p->last_speed = -1;
261 p->shoottype = range_none;
262 p->bowtype = bow_normal;
263 p->petmode = pet_normal;
264 p->listening = 10;
265 p->usekeys = containers;
266 p->last_weapon_sp = -1;
267 p->peaceful = 1; /* default peaceful */
268 p->do_los = 1;
269 p->explore = 0;
270
271 assign (p->title, op->arch->clone.name);
272 op->race = op->arch->clone.race;
273
274 CLEAR_FLAG (op, FLAG_READY_SKILL);
275
276 /* we need to clear these to -1 and not zero - otherwise,
277 * if a player quits and starts a new character, we wont
278 * send new values to the client, as things like exp start
279 * at zero.
280 */
281 for (i = 0; i < NUM_SKILLS; i++)
282 {
283 p->last_skill_exp[i] = -1;
284 p->last_skill_ob[i] = NULL;
285 }
286
287 for (i = 0; i < NROFATTACKS; i++)
288 p->last_resist[i] = -1;
289
290 p->last_stats.exp = -1;
291 p->last_weight = (uint32) - 1;
292
293 p->ns->update_look = 0;
294 p->ns->look_position = 0;
295
296 return p;
297}
298
299/* This loads the first map an puts the player on it. */ 153/* This loads the first map an puts the player on it. */
300static void 154static void
301set_first_map (object *op) 155set_first_map (object *op)
302{ 156{
303 strcpy (op->contr->maplevel, first_map_path); 157 op->contr->maplevel = first_map_path;
304 op->x = -1; 158 op->x = -1;
305 op->y = -1; 159 op->y = -1;
160}
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;
306 enter_exit (op, 0); 170 ob->enter_exit (tmp);
307}
308 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
219 ns->update_look = 0;
220 ns->look_position = 0;
221
222 clear_los (ob);
223
224 ns->reset_stats ();
225
226 /* make sure he's a player -- needed because of class change. */
227 ob->type = PLAYER; // we are paranoid
228 ob->race = ob->arch->clone.race;
229
230 if (!legal_range (ob, shoottype))
231 shoottype = range_none;
232
233 ob->carrying = sum_weight (ob);
234 link_player_skills (ob);
235
236 CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER);
237
238 assign (title, ob->arch->clone.name);
239
240 /* can_use_shield is a new flag. However, the can_use.. seems to largely come
241 * from the class, and not race. I don't see any way to get the class information
242 * to then update this. I don't think this will actually break anything - anyone
243 * that can use armour should be able to use a shield. What this may 'break'
244 * are features new characters get, eg, if someone starts up with a Q, they
245 * should be able to use a shield. However, old Q's won't get that advantage.
246 */
247 if (QUERY_FLAG (ob, FLAG_USE_ARMOUR))
248 SET_FLAG (ob, FLAG_USE_SHIELD);
249
250 /* if it's a dragon player, set the correct title here */
251 if (is_dragon_pl (ob))
252 {
253 object *tmp, *abil = 0, *skin = 0;
254
255 shstr_cmp dragon_ability_force ("dragon_ability_force");
256 shstr_cmp dragon_skin_force ("dragon_skin_force");
257
258 for (tmp = ob->inv; tmp; tmp = tmp->below)
259 if (tmp->type == FORCE)
260 if (tmp->arch->name == dragon_ability_force)
261 abil = tmp;
262 else if (tmp->arch->name == dragon_skin_force)
263 skin = tmp;
264
265 set_dragon_name (ob, abil, skin);
266 }
267
268 new_draw_info (NDI_UNIQUE, 0, ob, "Welcome Back!");
269
270 esrv_new_player (this, ob->weight + ob->carrying);
271
272 ob->update_stats ();
273 ns->floorbox_update ();
274
275 esrv_send_inventory (ob, ob);
276 esrv_add_spells (this, 0);
277
278 activate ();
279
280 send_rules (ob);
281 send_news (ob);
282 display_motd (ob);
283
284 INVOKE_PLAYER (CONNECT, this);
285 INVOKE_PLAYER (LOGIN, this);
286}
287
288void
289player::disconnect ()
290{
291 if (ns)
292 {
293 if (active)
294 INVOKE_PLAYER (LOGOUT, this, ARG_INT (0));
295
296 INVOKE_PLAYER (DISCONNECT, this);
297
298 ns->pl = 0;
299 this->ns = 0;
300 }
301
302 deactivate ();
303}
304
305// the need for this function can be explained
306// by load_object not returning the object
307void
308player::set_object (object *op)
309{
310 ob = op;
311 ob->contr = this; /* this aren't yet in archetype */
312
313 ob->speed_left = 0.5;
314 ob->speed = 1.0;
315 ob->direction = 5; /* So player faces south */
316 ob->stats.wc = 2;
317 ob->run_away = 25; /* Then we panick... */
318
319 ob->roll_stats ();
320}
321
322player::player ()
323{
324 /* There are some elements we want initialised to non zero value -
325 * we deal with that below this point.
326 */
327 outputs_sync = 16; /* Every 2 seconds */
328 outputs_count = 8; /* Keeps present behaviour */
329 unapply = unapply_nochoice;
330
331 savebed_map = first_map_path; /* Init. respawn position */
332
333 gen_sp_armour = 10;
334 shoottype = range_none;
335 bowtype = bow_normal;
336 petmode = pet_normal;
337 listening = 10;
338 usekeys = containers;
339 peaceful = 1; /* default peaceful */
340 do_los = 1;
341}
342
343void
344player::do_destroy ()
345{
346 disconnect ();
347
348 attachable::do_destroy ();
349
350 if (ob)
351 {
352 ob->destroy_inv (false);
353 ob->destroy ();
354 }
355}
356
357player::~player ()
358{
359 /* Clear item stack */
360 free (stack_items);
361}
362
309/* Tries to add player on the connection passwd in ns. 363/* Tries to add player on the connection passed in ns.
310 * All we can really get in this is some settings like host and display 364 * All we can really get in this is some settings like host and display
311 * mode. 365 * mode.
312 */ 366 */
313 367player *
314int 368player::create ()
315add_player (client *ns)
316{ 369{
317 player *p = new player; 370 player *pl = new player;
318 371
319 p->ns = ns; 372 pl->set_object (arch_to_object (get_player_archetype (0)));
320 ns->pl = p;
321
322 p->next = first_player;
323 first_player = p;
324
325 p = get_player (p);
326
327 set_first_map (p->ob); 373 set_first_map (pl->ob);
328 374
329 CLEAR_FLAG (p->ob, FLAG_FRIENDLY);
330 add_friendly_object (p->ob);
331 send_rules (p->ob);
332 send_news (p->ob);
333 display_motd (p->ob);
334
335 get_name (p->ob);
336
337 return 0; 375 return pl;
338} 376}
339 377
340/* 378/*
341 * get_player_archetype() return next player archetype from archetype 379 * get_player_archetype() return next player archetype from archetype
342 * list. Not very efficient routine, but used only creating new players. 380 * list. Not very efficient routine, but used only creating new players.
… …
367 405
368object * 406object *
369get_nearest_player (object *mon) 407get_nearest_player (object *mon)
370{ 408{
371 object *op = NULL; 409 object *op = NULL;
372 player *pl = NULL;
373 objectlink *ol; 410 objectlink *ol;
374 unsigned lastdist; 411 unsigned lastdist;
375 rv_vector rv; 412 rv_vector rv;
376 413
377 for (ol = first_friendly_object, lastdist = 1000; ol != NULL; ol = ol->next) 414 for (ol = first_friendly_object, lastdist = 1000; ol; ol = ol->next)
378 { 415 {
379 /* We should not find free objects on this friendly list, but it 416 /* We should not find free objects on this friendly list, but it
380 * does periodically happen. Given that, lets deal with it. 417 * does periodically happen. Given that, lets deal with it.
381 * While unlikely, it is possible the next object on the friendly 418 * While unlikely, it is possible the next object on the friendly
382 * list is also free, so encapsulate this in a while loop. 419 * list is also free, so encapsulate this in a while loop.
… …
386 object *tmp = ol->ob; 423 object *tmp = ol->ob;
387 424
388 /* Can't do much more other than log the fact, because the object 425 /* Can't do much more other than log the fact, because the object
389 * itself will have been cleared. 426 * itself will have been cleared.
390 */ 427 */
391 LOG (llevDebug, "get_nearest_player: Found free/non friendly object on friendly list\n"); 428 LOG (llevDebug, "get_nearest_player: Found free/non friendly object '%s' on friendly list\n",
429 tmp->debug_desc ());
392 ol = ol->next; 430 ol = ol->next;
393 remove_friendly_object (tmp); 431 remove_friendly_object (tmp);
394 if (!ol) 432 if (!ol)
395 return op; 433 return op;
396 } 434 }
… …
409 { 447 {
410 op = ol->ob; 448 op = ol->ob;
411 lastdist = rv.distance; 449 lastdist = rv.distance;
412 } 450 }
413 } 451 }
414 for (pl = first_player; pl != NULL; pl = pl->next) 452
415 { 453 for_all_players (pl)
416 if (can_detect_enemy (mon, pl->ob, &rv)) 454 if (can_detect_enemy (mon, pl->ob, &rv))
417 {
418
419 if (lastdist > rv.distance) 455 if (lastdist > rv.distance)
420 { 456 {
421 op = pl->ob; 457 op = pl->ob;
422 lastdist = rv.distance; 458 lastdist = rv.distance;
423 } 459 }
424 } 460
425 }
426#if 0 461#if 0
427 LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)"); 462 LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)");
428#endif 463#endif
429 return op; 464 return op;
430} 465}
… …
448 * circling behaviour. Unfortunately, this function is also used to determined 483 * circling behaviour. Unfortunately, this function is also used to determined
449 * if the creature should cast a spell, so returning a direction in that case 484 * if the creature should cast a spell, so returning a direction in that case
450 * is probably not a good thing. 485 * is probably not a good thing.
451 */ 486 */
452#define MAX_SPACES 50 487#define MAX_SPACES 50
453
454 488
455/* 489/*
456 * Returns the direction to the player, if valid. Returns 0 otherwise. 490 * Returns the direction to the player, if valid. Returns 0 otherwise.
457 * modified to verify there is a path to the player. Does this by stepping towards 491 * modified to verify there is a path to the player. Does this by stepping towards
458 * player and if path is blocked then see if blockage is close enough to player that 492 * player and if path is blocked then see if blockage is close enough to player that
… …
697 /* Need to set up the skill pointers */ 731 /* Need to set up the skill pointers */
698 link_player_skills (pl); 732 link_player_skills (pl);
699} 733}
700 734
701void 735void
702get_name (object *op)
703{
704 op->contr->write_buf[0] = '\0';
705 op->contr->ns->state = ST_GET_NAME;
706 send_query (op->contr->ns, 0, "What is your name?\n:");
707}
708
709void
710get_password (object *op)
711{
712 op->contr->write_buf[0] = '\0';
713 op->contr->ns->state = ST_GET_PASSWORD;
714 send_query (op->contr->ns, CS_QUERY_HIDEINPUT, "What is your password?\n:");
715}
716
717void
718play_again (object *op)
719{
720 op->contr->ns->state = ST_PLAY_AGAIN;
721 op->chosen_skill = NULL;
722 send_query (op->contr->ns, CS_QUERY_SINGLECHAR, "Do you want to play again (a/q)?");
723 /* a bit of a hack, but there are various places early in th
724 * player creation process that a user can quit (eg, roll
725 * stats) that isn't removing the player. Taking a quick
726 * look, there are many places that call play_again without
727 * removing the player - it probably makes more sense
728 * to leave it to play_again to remove the object in all
729 * cases.
730 */
731 if (!QUERY_FLAG (op, FLAG_REMOVED))
732 op->remove ();
733
734 /* Need to set this to null - otherwise, it could point to garbage,
735 * and draw() doesn't check to see if the player is removed, only if
736 * the map is null or not swapped out.
737 */
738 op->map = NULL;
739}
740
741int
742receive_play_again (object *op, char key)
743{
744 if (key == 'q' || key == 'Q')
745 {
746 remove_friendly_object (op);
747 leave (op->contr, 0); /* ericserver will draw the message */
748 return 2;
749 }
750 else if (key == 'a' || key == 'A')
751 {
752 player *pl = op->contr;
753 shstr name = op->name;
754
755 op->contr = 0;
756 op->type = 0;
757 op->destroy (1);
758 pl = get_player (pl);
759 op = pl->ob;
760 add_friendly_object (op);
761 op->contr->password[0] = '~';
762 op->name = op->name_pl = 0;
763 /* Lets put a space in here */
764 new_draw_info (NDI_UNIQUE, 0, op, "\n");
765 get_name (op);
766 op->name = op->name_pl = name;
767 set_first_map (op);
768 }
769 else
770 /* user pressed something else so just ask again... */
771 play_again (op);
772
773 return 0;
774}
775
776void
777confirm_password (object *op)
778{
779
780 op->contr->write_buf[0] = '\0';
781 op->contr->ns->state = ST_CONFIRM_PASSWORD;
782 send_query (op->contr->ns, CS_QUERY_HIDEINPUT, "Please type your password again.\n:");
783}
784
785void
786get_party_password (object *op, partylist *party) 736get_party_password (object *op, partylist *party)
787{ 737{
788 if (party == NULL) 738 if (party == NULL)
789 { 739 {
790 LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name); 740 LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name);
791 return; 741 return;
792 } 742 }
743
793 op->contr->write_buf[0] = '\0'; 744 op->contr->write_buf[0] = '\0';
794 op->contr->ns->state = ST_GET_PARTY_PASSWORD; 745 op->contr->ns->state = ST_GET_PARTY_PASSWORD;
795 op->contr->party_to_join = party; 746 op->contr->party_to_join = party;
796 send_query (op->contr->ns, CS_QUERY_HIDEINPUT, "What is the password?\n:"); 747 send_query (op->contr->ns, CS_QUERY_HIDEINPUT, "What is the password?\n:");
797} 748}
798 749
799
800/* This rolls four 1-6 rolls and sums the best 3 of the 4. */ 750/* This rolls four 1-6 rolls and sums the best 3 of the 4. */
801int 751static int
802roll_stat (void) 752roll_stat (void)
803{ 753{
804 int a[4], i, j, k; 754 int a[4], i, j, k;
805 755
806 for (i = 0; i < 4; i++) 756 for (i = 0; i < 4; i++)
… …
809 for (i = 0, j = 0, k = 7; i < 4; i++) 759 for (i = 0, j = 0, k = 7; i < 4; i++)
810 if (a[i] < k) 760 if (a[i] < k)
811 k = a[i], j = i; 761 k = a[i], j = i;
812 762
813 for (i = 0, k = 0; i < 4; i++) 763 for (i = 0, k = 0; i < 4; i++)
814 {
815 if (i != j) 764 if (i != j)
816 k += a[i]; 765 k += a[i];
817 } 766
818 return k; 767 return k;
819} 768}
820 769
821void 770void
822roll_stats (object *op) 771object::roll_stats ()
823{ 772{
824 int sum = 0;
825 int i = 0, j = 0;
826 int statsort[7]; 773 int statsort [7];
827 774
828 do 775 for (;;)
829 {
830 op->stats.Str = roll_stat ();
831 op->stats.Dex = roll_stat ();
832 op->stats.Int = roll_stat ();
833 op->stats.Con = roll_stat ();
834 op->stats.Wis = roll_stat ();
835 op->stats.Pow = roll_stat ();
836 op->stats.Cha = roll_stat ();
837 sum = op->stats.Str + op->stats.Dex + op->stats.Int + op->stats.Con + op->stats.Wis + op->stats.Pow + op->stats.Cha;
838 } 776 {
839 while (sum < 82 || sum > 116); 777 int sum = 0;
778 for (int i = 7; i--; )
779 sum += statsort [i] = roll_stat ();
840 780
781 if (sum >= 82 && sum <= 116)
782 break;
783 }
784
841 /* Sort the stats so that rerolling is easier... */ 785 // Sort the stats so that rerolling is easier...
842 statsort[0] = op->stats.Str; 786 std::sort (statsort, statsort + 7, std::greater<int>());
843 statsort[1] = op->stats.Dex;
844 statsort[2] = op->stats.Int;
845 statsort[3] = op->stats.Con;
846 statsort[4] = op->stats.Wis;
847 statsort[5] = op->stats.Pow;
848 statsort[6] = op->stats.Cha;
849 787
850 /* a quick and dirty bubblesort? */
851 do
852 {
853 if (statsort[i] < statsort[i + 1])
854 {
855 j = statsort[i];
856 statsort[i] = statsort[i + 1];
857 statsort[i + 1] = j;
858 i = 0;
859 }
860 else
861 {
862 i++;
863 }
864 }
865 while (i < 6);
866
867 op->stats.Str = statsort[0]; 788 stats.Str = statsort[0];
868 op->stats.Dex = statsort[1]; 789 stats.Dex = statsort[1];
869 op->stats.Con = statsort[2]; 790 stats.Con = statsort[2];
870 op->stats.Int = statsort[3]; 791 stats.Int = statsort[3];
871 op->stats.Wis = statsort[4]; 792 stats.Wis = statsort[4];
872 op->stats.Pow = statsort[5]; 793 stats.Pow = statsort[5];
873 op->stats.Cha = statsort[6]; 794 stats.Cha = statsort[6];
874 795
875
876 op->contr->orig_stats.Str = op->stats.Str;
877 op->contr->orig_stats.Dex = op->stats.Dex;
878 op->contr->orig_stats.Int = op->stats.Int;
879 op->contr->orig_stats.Con = op->stats.Con;
880 op->contr->orig_stats.Wis = op->stats.Wis;
881 op->contr->orig_stats.Pow = op->stats.Pow;
882 op->contr->orig_stats.Cha = op->stats.Cha;
883
884 op->level = 1;
885 op->stats.exp = 0; 796 stats.exp = 0;
886 op->stats.ac = 0; 797 stats.ac = 0;
887 798
888 op->contr->levhp[1] = 9;
889 op->contr->levsp[1] = 6;
890 op->contr->levgrace[1] = 3;
891
892 fix_player (op);
893 op->stats.hp = op->stats.maxhp; 799 stats.hp = stats.maxhp;
894 op->stats.sp = op->stats.maxsp; 800 stats.sp = stats.maxsp;
895 op->stats.grace = op->stats.maxgrace; 801 stats.grace = stats.maxgrace;
802
803 if (contr)
804 {
805 contr->levhp[1] = 9;
806 contr->levsp[1] = 6;
807 contr->levgrace[1] = 3;
808
896 op->contr->orig_stats = op->stats; 809 contr->orig_stats = stats;
810 }
897} 811}
898 812
899void 813void
900Roll_Again (object *op) 814object::swap_stats (int a, int b)
901{ 815{
902 esrv_new_player (op->contr, 0); 816 int tmp = get_attr_value (&contr->orig_stats, a);
903 send_query (op->contr->ns, CS_QUERY_SINGLECHAR, 817 set_attr_value (&contr->orig_stats, a, get_attr_value (&contr->orig_stats, b));
904 "[y] to roll new stats [n] to use stats\n[1-7] [1-7] to swap stats.\nRoll again (y/n/1-7)? "); 818 set_attr_value (&contr->orig_stats, b, tmp);
905}
906 819
907void 820 stats.Str = contr->orig_stats.Str;
908Swap_Stat (object *op, int Swap_Second) 821 stats.Dex = contr->orig_stats.Dex;
822 stats.Con = contr->orig_stats.Con;
823 stats.Int = contr->orig_stats.Int;
824 stats.Wis = contr->orig_stats.Wis;
825 stats.Pow = contr->orig_stats.Pow;
826 stats.Cha = contr->orig_stats.Cha;
827
828 //TODO: the following code looks so borked and should, at the very least,
829 // be merged with the similar code in roll_stats
830 stats.ac = 0;
831
832 level = 1;
833 stats.exp = 0;
834 stats.ac = 0;
835
836 stats.hp = stats.maxhp;
837 stats.sp = stats.maxsp;
838 stats.grace = stats.maxgrace;
839
840 if (contr)
841 {
842 contr->levhp[1] = 9;
843 contr->levsp[1] = 6;
844 contr->levgrace[1] = 3;
845
846 contr->orig_stats = stats;
847 }
848}
849
850static void
851start_info (object *op)
909{ 852{
910 signed char tmp;
911 char buf[MAX_BUF]; 853 char buf[MAX_BUF];
912 854
913 if (op->contr->Swap_First == -1) 855 sprintf (buf, "Welcome to Crossfire v%s!", VERSION);
914 {
915 new_draw_info (NDI_UNIQUE, 0, op, "How the hell did you get here?!?!!!");
916 new_draw_info (NDI_UNIQUE, 0, op, "Error in Swap_Stat code,");
917 new_draw_info (NDI_UNIQUE, 0, op, "mail korg@rdt.monash.edu.au");
918 return;
919 }
920
921 tmp = get_attr_value (&op->contr->orig_stats, op->contr->Swap_First);
922
923 set_attr_value (&op->contr->orig_stats, op->contr->Swap_First, get_attr_value (&op->contr->orig_stats, Swap_Second));
924
925 set_attr_value (&op->contr->orig_stats, Swap_Second, tmp);
926
927 sprintf (buf, "%s done\n", short_stat_name[Swap_Second]);
928 new_draw_info (NDI_UNIQUE, 0, op, buf); 856 new_draw_info (NDI_UNIQUE, 0, op, buf);
929 op->stats.Str = op->contr->orig_stats.Str; 857 //new_draw_info (NDI_UNIQUE, 0, op, "Press `?' for help");
930 op->stats.Dex = op->contr->orig_stats.Dex;
931 op->stats.Con = op->contr->orig_stats.Con;
932 op->stats.Int = op->contr->orig_stats.Int;
933 op->stats.Wis = op->contr->orig_stats.Wis;
934 op->stats.Pow = op->contr->orig_stats.Pow;
935 op->stats.Cha = op->contr->orig_stats.Cha;
936 op->stats.ac = 0;
937
938 op->level = 1;
939 op->stats.exp = 0;
940 op->stats.ac = 0;
941
942 op->contr->levhp[1] = 9;
943 op->contr->levsp[1] = 6;
944 op->contr->levgrace[1] = 3;
945
946 fix_player (op);
947 op->stats.hp = op->stats.maxhp;
948 op->stats.sp = op->stats.maxsp;
949 op->stats.grace = op->stats.maxgrace;
950 op->contr->orig_stats = op->stats;
951 op->contr->Swap_First = -1;
952}
953
954
955/* This code has been greatly reduced, because with set_attr_value
956 * and get_attr_value, the stats can be accessed just numeric
957 * ids. stat_trans is a table that translate the number entered
958 * into the actual stat. It is needed because the order the stats
959 * are displayed in the stat window is not the same as how
960 * the number's access that stat. The table does that translation.
961 */
962int
963key_roll_stat (object *op, char key)
964{
965 int keynum = key - '0';
966 char buf[MAX_BUF];
967 static sint8 stat_trans[] = { -1, STR, DEX, CON, INT, WIS, POW, CHA };
968
969 if (keynum > 0 && keynum <= 7)
970 {
971 if (op->contr->Swap_First == -1)
972 {
973 op->contr->Swap_First = stat_trans[keynum];
974 sprintf (buf, "%s ->", short_stat_name[stat_trans[keynum]]);
975 new_draw_info (NDI_UNIQUE, 0, op, buf); 858 //new_draw_info (NDI_UNIQUE, 0, op, " ");
976 }
977 else
978 Swap_Stat (op, stat_trans[keynum]);
979
980 send_query (op->contr->ns, CS_QUERY_SINGLECHAR, "");
981 return 1;
982 }
983 switch (key)
984 {
985 case 'n':
986 case 'N':
987 {
988 SET_FLAG (op, FLAG_WIZ);
989 if (op->map == NULL)
990 {
991 LOG (llevError, "Map == NULL in state 2\n");
992 break;
993 }
994
995#if 0
996 /* So that enter_exit will put us at startx/starty */
997 op->x = -1;
998
999 enter_exit (op, NULL);
1000#endif
1001 SET_ANIMATION (op, 2); /* So player faces south */
1002 /* Enter exit adds a player otherwise */
1003 add_statbonus (op);
1004 send_query (op->contr->ns, CS_QUERY_SINGLECHAR,
1005 "Now choose a character.\nPress any key to change outlook.\nPress `d' when you're pleased.\n");
1006 op->contr->ns->state = ST_CHANGE_CLASS;
1007 if (op->msg)
1008 new_draw_info (NDI_BLUE, 0, op, op->msg);
1009 return 0;
1010 }
1011 case 'y':
1012 case 'Y':
1013 roll_stats (op);
1014 send_query (op->contr->ns, CS_QUERY_SINGLECHAR, "");
1015 return 1;
1016
1017 case 'q':
1018 case 'Q':
1019 play_again (op);
1020 return 1;
1021
1022 default:
1023 send_query (op->contr->ns, CS_QUERY_SINGLECHAR, "Yes, No, Quit or 1-6. Roll again?");
1024 return 0;
1025 }
1026 return 0;
1027} 859}
1028 860
1029/* This function takes the key that is passed, and does the 861/* This function takes the key that is passed, and does the
1030 * appropriate action with it (change race, or other things). 862 * appropriate action with it (change race, or other things).
1031 * The function name is for historical reasons - now we have 863 * The function name is for historical reasons - now we have
1032 * separate race and class; this actually changes the RACE, 864 * separate race and class; this actually changes the RACE,
1033 * not the class. 865 * not the class.
1034 */ 866 */
1035
1036int 867int
1037key_change_class (object *op, char key) 868key_change_class (object *op, char key)
1038{ 869{
1039 int tmp_loop; 870 int tmp_loop;
1040 871
1041 if (key == 'q' || key == 'Q')
1042 {
1043 op->remove ();
1044 play_again (op);
1045 return 0;
1046 }
1047 if (key == 'd' || key == 'D') 872 if (key == 'd' || key == 'D')
1048 { 873 {
1049 char buf[MAX_BUF]; 874 char buf[MAX_BUF];
1050 875
1051 /* this must before then initial items are given */ 876 /* this must before then initial items are given */
… …
1067 * to save here. 892 * to save here.
1068 */ 893 */
1069 sprintf (buf, "%s/%s/%s", settings.localdir, settings.playerdir, &op->name); 894 sprintf (buf, "%s/%s/%s", settings.localdir, settings.playerdir, &op->name);
1070 make_path_to_file (buf); 895 make_path_to_file (buf);
1071 896
1072#ifdef AUTOSAVE
1073 op->contr->last_save_tick = pticks;
1074#endif
1075 start_info (op); 897 start_info (op);
1076 CLEAR_FLAG (op, FLAG_WIZ); 898 CLEAR_FLAG (op, FLAG_WIZ);
1077 give_initial_items (op, op->randomitems); 899 give_initial_items (op, op->randomitems);
1078 link_player_skills (op); 900 link_player_skills (op);
1079 esrv_send_inventory (op, op); 901 esrv_send_inventory (op, op);
1080 fix_player (op); 902 op->update_stats ();
1081 903
1082 /* This moves the player to a different start map, if there 904 /* This moves the player to a different start map, if there
1083 * is one for this race 905 * is one for this race
1084 */ 906 */
1085 if (*first_map_ext_path) 907 if (*first_map_ext_path)
1086 { 908 {
1087 object *tmp; 909 object *tmp;
1088 char mapname[MAX_BUF]; 910 char mapname[MAX_BUF];
1089 911
1090 snprintf (mapname, MAX_BUF - 1, "%s/%s", first_map_ext_path, &op->arch->name); 912 snprintf (mapname, MAX_BUF - 1, "%s/%s", &first_map_ext_path, &op->arch->name);
1091 tmp = object::create (); 913 tmp = object::create ();
1092 EXIT_PATH (tmp) = mapname; 914 EXIT_PATH (tmp) = mapname;
1093 EXIT_X (tmp) = op->x; 915 EXIT_X (tmp) = op->x;
1094 EXIT_Y (tmp) = op->y; 916 EXIT_Y (tmp) = op->y;
1095 enter_exit (op, tmp); /* we don't really care if it succeeded; 917 op->enter_exit (tmp); /* we don't really care if it succeeded;
1096 * if the map isn't there, then stay on the 918 * if the map isn't there, then stay on the
1097 * default initial map */ 919 * default initial map */
1098 tmp->destroy (); 920 tmp->destroy ();
1099 } 921 }
1100 else 922 else
… …
1111 while (!tmp_loop) 933 while (!tmp_loop)
1112 { 934 {
1113 shstr name = op->name; 935 shstr name = op->name;
1114 int x = op->x, y = op->y; 936 int x = op->x, y = op->y;
1115 937
1116 remove_statbonus (op); 938 op->remove_statbonus ();
1117 op->remove (); 939 op->remove ();
1118 op->arch = get_player_archetype (op->arch); 940 op->arch = get_player_archetype (op->arch);
1119 op->arch->clone.copy_to (op); 941 op->arch->clone.copy_to (op);
1120 op->instantiate (); 942 op->instantiate ();
1121 op->stats = op->contr->orig_stats; 943 op->stats = op->contr->orig_stats;
… …
1123 op->x = x; 945 op->x = x;
1124 op->y = y; 946 op->y = y;
1125 SET_ANIMATION (op, 2); /* So player faces south */ 947 SET_ANIMATION (op, 2); /* So player faces south */
1126 insert_ob_in_map (op, op->map, op, 0); 948 insert_ob_in_map (op, op->map, op, 0);
1127 assign (op->contr->title, op->arch->clone.name); 949 assign (op->contr->title, op->arch->clone.name);
1128 add_statbonus (op); 950 op->add_statbonus ();
1129 tmp_loop = allowed_class (op); 951 tmp_loop = allowed_class (op);
1130 } 952 }
1131 953
1132 update_object (op, UP_OBJ_FACE); 954 update_object (op, UP_OBJ_FACE);
1133 esrv_update_item (UPD_FACE, op, op); 955 esrv_update_item (UPD_FACE, op, op);
1134 fix_player (op); 956 op->update_stats ();
1135 op->stats.hp = op->stats.maxhp; 957 op->stats.hp = op->stats.maxhp;
1136 op->stats.sp = op->stats.maxsp; 958 op->stats.sp = op->stats.maxsp;
1137 op->stats.grace = 0; 959 op->stats.grace = 0;
1138 960
1139 if (op->msg) 961 if (op->msg)
1140 new_draw_info (NDI_BLUE, 0, op, op->msg); 962 new_draw_info (NDI_BLUE, 0, op, op->msg);
1141 963
1142 send_query (op->contr->ns, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n"); 964 send_query (op->contr->ns, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n");
1143 return 0; 965 return 0;
1144}
1145
1146int
1147key_confirm_quit (object *op, char key)
1148{
1149 char buf[MAX_BUF];
1150
1151 if (key != 'y' && key != 'Y' && key != 'q' && key != 'Q')
1152 {
1153 op->contr->ns->state = ST_PLAYING;
1154 new_draw_info (NDI_UNIQUE, 0, op, "OK, continuing to play.");
1155 return 1;
1156 }
1157
1158 INVOKE_PLAYER (LOGOUT, op->contr);
1159 INVOKE_PLAYER (QUIT, op->contr);
1160
1161 terminate_all_pets (op);
1162 leave_map (op);
1163 op->direction = 0;
1164 new_draw_info_format (NDI_UNIQUE | NDI_ALL, 5, NULL, "%s quits the game.", &op->name);
1165
1166 strcpy (op->contr->killer, "quit");
1167 check_score (op);
1168 op->contr->party = NULL;
1169 if (settings.set_title == TRUE)
1170 op->contr->own_title[0] = '\0';
1171
1172 if (!QUERY_FLAG (op, FLAG_WAS_WIZ))
1173 {
1174 maptile *mp, *next;
1175
1176 /* We need to hunt for any per player unique maps in memory and
1177 * get rid of them. The trailing slash in the path is intentional,
1178 * so that players named 'Ab' won't match against players 'Abe' pathname
1179 */
1180 sprintf (buf, "%s/%s/%s/", settings.localdir, settings.playerdir, &op->name);
1181 for (mp = first_map; mp != NULL; mp = next)
1182 {
1183 next = mp->next;
1184 if (!strncmp (mp->path, buf, strlen (buf)))
1185 delete_map (mp);
1186 }
1187
1188 delete_character (op->name, 1);
1189 }
1190
1191 play_again (op);
1192 return 1;
1193} 966}
1194 967
1195void 968void
1196flee_player (object *op) 969flee_player (object *op)
1197{ 970{
… …
1334 sprintf (putstring, "item name: %s item type: %d weight/value: %d", 1107 sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1335 &tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1)))); 1108 &tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1336 else 1109 else
1337 sprintf (putstring, "item name: %s item type: %d weight/value: %d", 1110 sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1338 &tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1)))); 1111 &tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1112
1339 new_draw_info (NDI_UNIQUE, 0, op, putstring); 1113 new_draw_info (NDI_UNIQUE, 0, op, putstring);
1340
1341 sprintf (putstring, "...flags: ");
1342 for (k = 0; k < 4; k++)
1343 {
1344 for (j = 0; j < 32; j++)
1345 {
1346 if ((tmp->flags[k] >> j) & 0x01)
1347 {
1348 sprintf (tmpstr, "%d ", k * 32 + j);
1349 strcat (putstring, tmpstr);
1350 }
1351 }
1352 }
1353 new_draw_info (NDI_UNIQUE, 0, op, putstring);
1354
1355#if 0
1356 /* print the flags too */
1357 for (k = 0; k < 4; k++)
1358 {
1359 fprintf (stderr, "%d [%d] ", k, k * 32 + 31);
1360 for (j = 0; j < 32; j++)
1361 {
1362 fprintf (stderr, "%d", tmp->flags[k] >> (31 - j) & 0x01);
1363 if (!((j + 1) % 4))
1364 fprintf (stderr, " ");
1365 }
1366 fprintf (stderr, " [%d]\n", k * 32);
1367 }
1368#endif
1369 } 1114 }
1115
1370 /* philosophy: 1116 /* philosophy:
1371 * It's easy to grab an item type from a pile, as long as it's 1117 * It's easy to grab an item type from a pile, as long as it's
1372 * generic. This takes no game-time. For more detailed pickups 1118 * generic. This takes no game-time. For more detailed pickups
1373 * and selections, select-items shoul dbe used. This is a 1119 * and selections, select-items should be used. This is a
1374 * grab-as-you-run type mode that's really useful for arrows for 1120 * grab-as-you-run type mode that's really useful for arrows for
1375 * example. 1121 * example.
1376 * The drawback: right now it has no frontend, so you need to 1122 * The drawback: right now it has no frontend, so you need to
1377 * stick the bits you want into a calculator in hex mode and then 1123 * stick the bits you want into a calculator in hex mode and then
1378 * convert to decimal and then 'pickup <#> 1124 * convert to decimal and then 'pickup <#>
… …
1878 return 0; 1624 return 0;
1879 } 1625 }
1880 1626
1881 arrow->set_owner (op); 1627 arrow->set_owner (op);
1882 arrow->skill = bow->skill; 1628 arrow->skill = bow->skill;
1883
1884 arrow->direction = dir; 1629 arrow->direction = dir;
1885 arrow->x = sx;
1886 arrow->y = sy;
1887 1630
1888 if (op->type == PLAYER) 1631 if (op->type == PLAYER)
1889 { 1632 {
1890 op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed; 1633 op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed;
1891 fix_player (op); 1634 op->update_stats ();
1892 } 1635 }
1893 1636
1894 SET_ANIMATION (arrow, arrow->direction); 1637 SET_ANIMATION (arrow, arrow->direction);
1895 arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */ 1638 arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */
1896 arrow->stats.hp = arrow->stats.dam; 1639 arrow->stats.hp = arrow->stats.dam;
… …
1906 1649
1907 /* update the speed */ 1650 /* update the speed */
1908 arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ? 1651 arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ?
1909 0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 + (float) bow->stats.dam / 7.0; 1652 0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 + (float) bow->stats.dam / 7.0;
1910 1653
1911 if (arrow->speed < 1.0) 1654 arrow->set_speed (max (arrow->speed, 1.0));
1912 arrow->speed = 1.0;
1913 update_ob_speed (arrow);
1914 arrow->speed_left = 0; 1655 arrow->speed_left = 0;
1915 1656
1916 if (op->type == PLAYER) 1657 if (op->type == PLAYER)
1917 { 1658 {
1918 arrow->stats.wc = 20 - bow->magic - arrow->magic - 1659 arrow->stats.wc = 20 - bow->magic - arrow->magic -
… …
1931 arrow->attacktype |= bow->attacktype; 1672 arrow->attacktype |= bow->attacktype;
1932 1673
1933 if (bow->slaying) 1674 if (bow->slaying)
1934 arrow->slaying = bow->slaying; 1675 arrow->slaying = bow->slaying;
1935 1676
1936 arrow->map = m;
1937 arrow->move_type = MOVE_FLY_LOW; 1677 arrow->move_type = MOVE_FLY_LOW;
1938 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK; 1678 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
1939 1679
1940 play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW); 1680 play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW);
1941 insert_ob_in_map (arrow, m, op, 0); 1681 m->insert (arrow, sx, sy, op);
1942 1682
1943 if (!arrow->destroyed ()) 1683 if (!arrow->destroyed ())
1944 move_arrow (arrow); 1684 move_arrow (arrow);
1945 1685
1946 if (op->type == PLAYER) 1686 if (op->type == PLAYER)
… …
1972 } 1712 }
1973 else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw) 1713 else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw)
1974 { 1714 {
1975 if (!similar_direction (dir, op->contr->bowtype - bow_n + 1)) 1715 if (!similar_direction (dir, op->contr->bowtype - bow_n + 1))
1976 wcmod = -1; 1716 wcmod = -1;
1717
1977 ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y); 1718 ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y);
1978 } 1719 }
1979 else if (op->contr->bowtype == bow_threewide) 1720 else if (op->contr->bowtype == bow_threewide)
1980 { 1721 {
1981 ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y); 1722 ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);
… …
2051 1792
2052 if (item->arch) 1793 if (item->arch)
2053 { 1794 {
2054 CLEAR_FLAG (item, FLAG_ANIMATE); 1795 CLEAR_FLAG (item, FLAG_ANIMATE);
2055 item->face = item->arch->clone.face; 1796 item->face = item->arch->clone.face;
2056 item->speed = 0; 1797 item->set_speed (0);
2057 update_ob_speed (item);
2058 } 1798 }
1799
2059 if ((tmp = item->in_player ())) 1800 if ((tmp = item->in_player ()))
2060 esrv_update_item (UPD_ANIM, tmp, item); 1801 esrv_update_item (UPD_ANIM, tmp, item);
2061 } 1802 }
2062 } 1803 }
2063 else if (item->type == ROD || item->type == HORN) 1804 else if (item->type == ROD || item->type == HORN)
2064 {
2065 drain_rod_charge (item); 1805 drain_rod_charge (item);
2066 }
2067 } 1806 }
2068} 1807}
2069 1808
2070/* Received a fire command for the player - go and do it. 1809/* Received a fire command for the player - go and do it.
2071 */ 1810 */
… …
2110 { 1849 {
2111 if (op->type == PLAYER) 1850 if (op->type == PLAYER)
2112 new_draw_info (NDI_UNIQUE, 0, op, "You have no applicable skill to use."); 1851 new_draw_info (NDI_UNIQUE, 0, op, "You have no applicable skill to use.");
2113 return; 1852 return;
2114 } 1853 }
1854
2115 (void) do_skill (op, op, op->chosen_skill, dir, NULL); 1855 do_skill (op, op, op->chosen_skill, dir, NULL);
2116 return; 1856 return;
2117 case range_builder: 1857 case range_builder:
2118 apply_map_builder (op, dir); 1858 apply_map_builder (op, dir);
2119 return; 1859 return;
2120 default: 1860 default:
… …
2287 */ 2027 */
2288 if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny)) 2028 if ((op->contr->braced || !move_ob (op, dir, op)) && !out_of_map (op->map, nx, ny))
2289 { 2029 {
2290 if (OUT_OF_REAL_MAP (op->map, nx, ny)) 2030 if (OUT_OF_REAL_MAP (op->map, nx, ny))
2291 { 2031 {
2292 m = get_map_from_coord (op->map, &nx, &ny); 2032 m = op->map->xy_find (nx, ny);
2293 if (!m) 2033 if (!m)
2294 return; /* Don't think this should happen */ 2034 return; /* Don't think this should happen */
2295 } 2035 }
2296 else 2036 else
2297 m = op->map; 2037 m = op->map;
2298 2038
2299 if ((tmp = GET_MAP_OB (m, nx, ny)) == NULL) 2039 if (!(tmp = m->at (nx, ny).bot))
2300 {
2301 /* LOG(llevError,"player_move_attack: GET_MAP_OB returns NULL, but player can not move there.\n"); */
2302 return; 2040 return;
2303 }
2304 2041
2305 mon = 0; 2042 mon = 0;
2306 /* Go through all the objects, and find ones of interest. Only stop if 2043 /* Go through all the objects, and find ones of interest. Only stop if
2307 * we find a monster - that is something we know we want to attack. 2044 * we find a monster - that is something we know we want to attack.
2308 * if its a door or barrel (can roll) see if there may be monsters 2045 * if its a door or barrel (can roll) see if there may be monsters
… …
2361 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY))) 2098 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))
2362 { 2099 {
2363 /* If we're braced, we don't want to switch places with it */ 2100 /* If we're braced, we don't want to switch places with it */
2364 if (op->contr->braced) 2101 if (op->contr->braced)
2365 return; 2102 return;
2103
2366 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2104 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2367 (void) push_ob (mon, dir, op); 2105 (void) push_ob (mon, dir, op);
2368 if (op->contr->tmp_invis || op->hide) 2106 if (op->contr->tmp_invis || op->hide)
2369 make_visible (op); 2107 make_visible (op);
2108
2370 return; 2109 return;
2371 } 2110 }
2372 2111
2373 /* in certain circumstances, you shouldn't attack friendly 2112 /* in certain circumstances, you shouldn't attack friendly
2374 * creatures. Note that if you are braced, you can't push 2113 * creatures. Note that if you are braced, you can't push
… …
2388 !on_battleground)) 2127 !on_battleground))
2389 { 2128 {
2390 if (!op->contr->braced) 2129 if (!op->contr->braced)
2391 { 2130 {
2392 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2131 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2393 (void) push_ob (mon, dir, op); 2132 push_ob (mon, dir, op);
2394 } 2133 }
2395 else 2134 else
2396 new_draw_info (0, 0, op, "You withhold your attack"); 2135 new_draw_info (0, 0, op, "You withhold your attack");
2397 2136
2398 if (op->contr->tmp_invis || op->hide) 2137 if (op->contr->tmp_invis || op->hide)
… …
2413 * Way it works is like this: First, it must have some hit points 2152 * Way it works is like this: First, it must have some hit points
2414 * and be living. Then, it must be one of the following: 2153 * and be living. Then, it must be one of the following:
2415 * 1) Not a player, 2) A player, but of a different party. Note 2154 * 1) Not a player, 2) A player, but of a different party. Note
2416 * that party_number -1 is no party, so attacks can still happen. 2155 * that party_number -1 is no party, so attacks can still happen.
2417 */ 2156 */
2418
2419 else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) && 2157 else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&
2420 ((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party))) 2158 ((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party)))
2421 { 2159 {
2422 2160
2423 /* If the player hasn't hit something this tick, and does 2161 /* If the player hasn't hit something this tick, and does
… …
2457int 2195int
2458move_player (object *op, int dir) 2196move_player (object *op, int dir)
2459{ 2197{
2460 int pick; 2198 int pick;
2461 2199
2462 if (op->map == NULL || op->map->in_memory != MAP_IN_MEMORY) 2200 if (!op->map || op->map->in_memory != MAP_IN_MEMORY)
2463 return 0; 2201 return 0;
2464 2202
2465 /* Sanity check: make sure dir is valid */ 2203 /* Sanity check: make sure dir is valid */
2466 if ((dir < 0) || (dir >= 9)) 2204 if ((dir < 0) || (dir >= 9))
2467 { 2205 {
2468 LOG (llevError, "move_player: invalid direction %d\n", dir); 2206 LOG (llevError, "move_player: invalid direction %d\n", dir);
2469 return 0; 2207 return 0;
2470 } 2208 }
2471 2209
2472 /* peterm: added following line */ 2210 /* peterm: added following line */
2473 if (QUERY_FLAG (op, FLAG_CONFUSED) && dir) 2211 if (QUERY_FLAG (op, FLAG_CONFUSED) && dir)
2474 dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2); 2212 dir = absdir (dir + RANDOM () % 3 + RANDOM () % 3 - 2);
2475 2213
2476 op->facing = dir; 2214 op->facing = dir;
2477 2215
… …
2555 2293
2556 /* call this here - we also will call this in do_ericserver, but 2294 /* call this here - we also will call this in do_ericserver, but
2557 * the players time has been increased when doericserver has been 2295 * the players time has been increased when doericserver has been
2558 * called, so we recheck it here. 2296 * called, so we recheck it here.
2559 */ 2297 */
2560 //TODO: better than handling 8 commands, use some more intelligent rate-limiting 2298 if (op->contr->ns->handle_command ())
2561 for (int rep = 8; --rep && op->contr->ns->handle_command (); ) 2299 return 1;
2562 ;
2563 2300
2564 if (op->speed_left < 0) 2301 if (op->speed_left > 0)
2565 return 0; 2302 {
2566
2567 if (op->direction && (op->contr->run_on || op->contr->fire_on)) 2303 if (op->direction && (op->contr->run_on || op->contr->fire_on))
2568 { 2304 {
2569 /* All move commands take 1 tick, at least for now */ 2305 /* All move commands take 1 tick, at least for now */
2570 op->speed_left--; 2306 op->speed_left--;
2571 2307
2572 /* Instead of all the stuff below, let move_player take care 2308 /* Instead of all the stuff below, let move_player take care
2573 * of it. Also, some of the skill stuff is only put in 2309 * of it. Also, some of the skill stuff is only put in
2574 * there, as well as the confusion stuff. 2310 * there, as well as the confusion stuff.
2575 */ 2311 */
2576 move_player (op, op->direction); 2312 move_player (op, op->direction);
2577 if (op->speed_left > 0) 2313
2578 return 1; 2314 return op->speed_left > 0;
2579 else 2315 }
2580 return 0;
2581 } 2316 }
2582 2317
2583 return 0; 2318 return 0;
2584} 2319}
2585 2320
… …
2605 op->stats.hp = op->stats.maxhp; 2340 op->stats.hp = op->stats.maxhp;
2606 2341
2607 if (op->stats.food < 0) 2342 if (op->stats.food < 0)
2608 op->stats.food = 999; 2343 op->stats.food = 999;
2609 2344
2610 fix_player (op); 2345 op->update_stats ();
2611 return 1; 2346 return 1;
2612 } 2347 }
2613 2348
2614 LOG (llevError, "Error: LIFESAVE set without applied object.\n"); 2349 LOG (llevError, "Error: LIFESAVE set without applied object.\n");
2615 CLEAR_FLAG (op, FLAG_LIFESAVE); 2350 CLEAR_FLAG (op, FLAG_LIFESAVE);
… …
2627{ 2362{
2628 object *next; 2363 object *next;
2629 2364
2630 while (op) 2365 while (op)
2631 { 2366 {
2632 next = op->below; /* Make sure we have a good value, in case 2367 object *next = op->below; /* Make sure we have a good value, in case we remove object 'op' */
2633 * we remove object 'op' 2368
2634 */
2635 if (QUERY_FLAG (op, FLAG_UNPAID)) 2369 if (QUERY_FLAG (op, FLAG_UNPAID))
2636 { 2370 {
2637 op->remove ();
2638 op->x = env->x;
2639 op->y = env->y;
2640 if (env->type == PLAYER) 2371 if (env->type == PLAYER)
2641 esrv_del_item (env->contr, op->count); 2372 esrv_del_item (env->contr, op->count);
2642 insert_ob_in_map (op, env->map, NULL, 0); 2373
2374 op->insert_at (env);
2643 } 2375 }
2644 else if (op->inv) 2376 else if (op->inv)
2645 remove_unpaid_objects (op->inv, env); 2377 remove_unpaid_objects (op->inv, env);
2646 2378
2647 op = next; 2379 op = next;
2648 } 2380 }
2649} 2381}
2650
2651 2382
2652/* 2383/*
2653 * Returns pointer a static string containing gravestone text 2384 * Returns pointer a static string containing gravestone text
2654 * Moved from apply.c to player.c - player.c is what 2385 * Moved from apply.c to player.c - player.c is what
2655 * actually uses this function. player.c may not be quite the 2386 * actually uses this function. player.c may not be quite the
… …
2689 strncat (buf2, " ", 20 - strlen (buf) / 2); 2420 strncat (buf2, " ", 20 - strlen (buf) / 2);
2690 strcat (buf2, buf); 2421 strcat (buf2, buf);
2691 2422
2692 return buf2; 2423 return buf2;
2693} 2424}
2694
2695
2696 2425
2697void 2426void
2698do_some_living (object *op) 2427do_some_living (object *op)
2699{ 2428{
2700 int last_food = op->stats.food; 2429 int last_food = op->stats.food;
… …
2709 const int max_grace = 1; 2438 const int max_grace = 1;
2710 2439
2711 if (op->contr->outputs_sync) 2440 if (op->contr->outputs_sync)
2712 { 2441 {
2713 for (i = 0; i < NUM_OUTPUT_BUFS; i++) 2442 for (i = 0; i < NUM_OUTPUT_BUFS; i++)
2714 if (op->contr->outputs[i].buf != NULL && (op->contr->outputs[i].first_update + op->contr->outputs_sync) < (uint16) pticks) 2443 if (op->contr->outputs[i].buf && (op->contr->outputs[i].first_update + op->contr->outputs_sync) < (uint16) pticks)
2715 flush_output_element (op, &op->contr->outputs[i]); 2444 flush_output_element (op, &op->contr->outputs[i]);
2716 } 2445 }
2717 2446
2718 if (op->contr->ns->state == ST_PLAYING) 2447 if (op->contr->ns->state == ST_PLAYING)
2719 { 2448 {
2720
2721 /* these next three if clauses make it possible to SLOW DOWN 2449 /* these next three if clauses make it possible to SLOW DOWN
2722 hp/grace/spellpoint regeneration. */ 2450 hp/grace/spellpoint regeneration. */
2723 if (op->contr->gen_hp >= 0) 2451 if (op->contr->gen_hp >= 0)
2724 gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp; 2452 gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;
2725 else 2453 else
2726 { 2454 {
2727 gen_hp = op->stats.maxhp; 2455 gen_hp = op->stats.maxhp;
2728 rate_hp -= rate_hp / 2 * op->contr->gen_hp; 2456 rate_hp -= rate_hp / 2 * op->contr->gen_hp;
2729 } 2457 }
2458
2730 if (op->contr->gen_sp >= 0) 2459 if (op->contr->gen_sp >= 0)
2731 gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp; 2460 gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;
2732 else 2461 else
2733 { 2462 {
2734 gen_sp = op->stats.maxsp; 2463 gen_sp = op->stats.maxsp;
2735 rate_sp -= rate_sp / 2 * op->contr->gen_sp; 2464 rate_sp -= rate_sp / 2 * op->contr->gen_sp;
2736 } 2465 }
2466
2737 if (op->contr->gen_grace >= 0) 2467 if (op->contr->gen_grace >= 0)
2738 gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace; 2468 gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;
2739 else 2469 else
2740 { 2470 {
2741 gen_grace = op->stats.maxgrace; 2471 gen_grace = op->stats.maxgrace;
… …
2757 op->stats.food += op->contr->digestion; 2487 op->stats.food += op->contr->digestion;
2758 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH)) 2488 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2759 op->stats.food = last_food; 2489 op->stats.food = last_food;
2760 } 2490 }
2761 } 2491 }
2492
2762 if (max_sp > 1) 2493 if (max_sp > 1)
2763 { 2494 {
2764 over_sp = (gen_sp + 10) / rate_sp; 2495 over_sp = (gen_sp + 10) / rate_sp;
2765 if (over_sp > 0) 2496 if (over_sp > 0)
2766 { 2497 {
2767 if (op->stats.sp < op->stats.maxsp) 2498 if (op->stats.sp < op->stats.maxsp)
2768 { 2499 {
2769 op->stats.sp += over_sp > max_sp ? max_sp : over_sp; 2500 op->stats.sp += over_sp > max_sp ? max_sp : over_sp;
2501
2770 if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp)) 2502 if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp))
2771 op->stats.sp--; 2503 op->stats.sp--;
2504
2772 if (op->stats.sp > op->stats.maxsp) 2505 if (op->stats.sp > op->stats.maxsp)
2773 op->stats.sp = op->stats.maxsp; 2506 op->stats.sp = op->stats.maxsp;
2774 } 2507 }
2775 op->last_sp = 0; 2508 op->last_sp = 0;
2776 } 2509 }
2777 else 2510 else
2778 {
2779 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10); 2511 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2780 }
2781 } 2512 }
2782 else 2513 else
2783 {
2784 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);
2785 }
2786 } 2515 }
2787 2516
2788 /* Regenerate Grace */ 2517 /* Regenerate Grace */
2789 /* I altered this a little - maximum grace is ony achieved through prayer -b.t. */ 2518 /* I altered this a little - maximum grace is ony achieved through prayer -b.t. */
2790 if (--op->last_grace < 0) 2519 if (--op->last_grace < 0)
2791 { 2520 {
2792 if (op->stats.grace < op->stats.maxgrace / 2) 2521 if (op->stats.grace < op->stats.maxgrace / 2)
2793 op->stats.grace++; /* no penalty in food for regaining grace */ 2522 op->stats.grace++; /* no penalty in food for regaining grace */
2523
2794 if (max_grace > 1) 2524 if (max_grace > 1)
2795 { 2525 {
2796 over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace; 2526 over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;
2797 if (over_grace > 0) 2527 if (over_grace > 0)
2798 { 2528 {
… …
2826 op->stats.food += op->contr->digestion; 2556 op->stats.food += op->contr->digestion;
2827 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH)) 2557 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2828 op->stats.food = last_food; 2558 op->stats.food = last_food;
2829 } 2559 }
2830 } 2560 }
2561
2831 if (max_hp > 1) 2562 if (max_hp > 1)
2832 { 2563 {
2833 over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp; 2564 over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;
2834 if (over_hp > 0) 2565 if (over_hp > 0)
2835 { 2566 {
… …
2859 2590
2860 if (op->contr->gen_hp > 0) 2591 if (op->contr->gen_hp > 0)
2861 op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1); 2592 op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1);
2862 else 2593 else
2863 op->last_eat = 25 * (1 + bonus) / (penalty + 1); 2594 op->last_eat = 25 * (1 + bonus) / (penalty + 1);
2595
2864 /* dms do not consume food */ 2596 /* dms do not consume food */
2865 if (!QUERY_FLAG (op, FLAG_WIZ)) 2597 if (!QUERY_FLAG (op, FLAG_WIZ))
2866 op->stats.food--; 2598 op->stats.food--;
2867 } 2599 }
2868 }
2869 2600
2870 if (op->contr->ns->state == ST_PLAYING && op->stats.food < 0 && op->stats.hp >= 0) 2601 if (op->stats.food < 0 && op->stats.hp >= 0)
2871 { 2602 {
2872 object *tmp, *flesh = NULL; 2603 object *tmp, *flesh = 0;
2873 2604
2874 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 2605 for (tmp = op->inv; tmp; tmp = tmp->below)
2875 { 2606 {
2876 if (!QUERY_FLAG (tmp, FLAG_UNPAID)) 2607 if (!QUERY_FLAG (tmp, FLAG_UNPAID))
2877 {
2878 if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
2879 { 2608 {
2609 if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
2610 {
2880 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food."); 2611 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2881 manual_apply (op, tmp, 0); 2612 manual_apply (op, tmp, 0);
2882 if (op->stats.food >= 0 || op->stats.hp < 0) 2613 if (op->stats.food >= 0 || op->stats.hp < 0)
2883 break; 2614 break;
2884 } 2615 }
2885 else if (tmp->type == FLESH) 2616 else if (tmp->type == FLESH)
2886 flesh = tmp; 2617 flesh = tmp;
2887 } /* End if paid for object */ 2618 } /* End if paid for object */
2888 } /* end of for loop */ 2619 } /* end of for loop */
2620
2889 /* If player is still starving, it means they don't have any food, so 2621 /* If player is still starving, it means they don't have any food, so
2890 * eat flesh instead. 2622 * eat flesh instead.
2891 */ 2623 */
2892 if (op->stats.food < 0 && op->stats.hp >= 0 && flesh) 2624 if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)
2893 { 2625 {
2894 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food."); 2626 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2895 manual_apply (op, flesh, 0); 2627 manual_apply (op, flesh, 0);
2896 } 2628 }
2897 } /* end if player is starving */ 2629 }
2898 2630
2899 while (op->stats.food < 0 && op->stats.hp > 0) 2631 while (op->stats.food < 0 && op->stats.hp >= 0)
2900 op->stats.food++, op->stats.hp--; 2632 op->stats.food++, op->stats.hp--;
2901 2633
2902 if (!op->contr->ns->state && !QUERY_FLAG (op, FLAG_WIZ) && (op->stats.hp < 0 || op->stats.food < 0)) 2634 if (op->stats.hp < 0 && !QUERY_FLAG (op, FLAG_WIZ))
2903 kill_player (op); 2635 kill_player (op);
2636 }
2904} 2637}
2905
2906
2907 2638
2908/* If the player should die (lack of hp, food, etc), we call this. 2639/* If the player should die (lack of hp, food, etc), we call this.
2909 * op is the player in jeopardy. If the player can not be saved (not 2640 * op is the player in jeopardy. If the player can not be saved (not
2910 * permadeath, no lifesave), this will take care of removing the player 2641 * permadeath, no lifesave), this will take care of removing the player
2911 * file. 2642 * file.
… …
2941 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!"); 2672 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!");
2942 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life..."); 2673 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life...");
2943 2674
2944 /* restore player */ 2675 /* restore player */
2945 at = archetype::find ("poisoning"); 2676 at = archetype::find ("poisoning");
2946 tmp = present_arch_in_ob (at, op); 2677 if (object *tmp = present_arch_in_ob (at, op))
2947 if (tmp)
2948 { 2678 {
2949 tmp->destroy (); 2679 tmp->destroy ();
2950 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed"); 2680 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
2951 } 2681 }
2952 2682
2953 at = archetype::find ("confusion"); 2683 at = archetype::find ("confusion");
2954 tmp = present_arch_in_ob (at, op); 2684 if (object *tmp = present_arch_in_ob (at, op))
2955 if (tmp)
2956 { 2685 {
2957 tmp->destroy (); 2686 tmp->destroy ();
2958 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 2687 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
2959 } 2688 }
2960 2689
… …
2962 op->stats.hp = op->stats.maxhp; 2691 op->stats.hp = op->stats.maxhp;
2963 if (op->stats.food <= 0) 2692 if (op->stats.food <= 0)
2964 op->stats.food = 999; 2693 op->stats.food = 999;
2965 2694
2966 /* create a bodypart-trophy to make the winner happy */ 2695 /* create a bodypart-trophy to make the winner happy */
2967 tmp = arch_to_object (archetype::find ("finger")); 2696 if (object *tmp = arch_to_object (archetype::find ("finger")))
2968 if (tmp != NULL)
2969 { 2697 {
2970 sprintf (buf, "%s's finger", &op->name); 2698 sprintf (buf, "%s's finger", &op->name);
2971 tmp->name = buf; 2699 tmp->name = buf;
2972 sprintf (buf, " This finger has been cut off %s\n" 2700 sprintf (buf, " This finger has been cut off %s\n"
2973 " the %s, when he was defeated at\n level %d by %s.\n", 2701 " the %s, when he was defeated at\n level %d by %s.\n",
2974 &op->name, op->contr->title, (int) (op->level), op->contr->killer); 2702 &op->name, op->contr->title, (int) (op->level), op->contr->killer);
2975 tmp->msg = buf; 2703 tmp->msg = buf;
2976 tmp->value = 0, tmp->material = 0, tmp->type = 0; 2704 tmp->value = 0, tmp->material = 0, tmp->type = 0;
2977 tmp->materialname = NULL; 2705 tmp->materialname = NULL;
2978 tmp->x = op->x, tmp->y = op->y; 2706 tmp->insert_at (op, tmp);
2979 insert_ob_in_map (tmp, op->map, op, 0);
2980 } 2707 }
2981 2708
2982 /* teleport defeated player to new destination */ 2709 /* teleport defeated player to new destination */
2983 transfer_ob (op, x, y, 0, NULL); 2710 transfer_ob (op, x, y, 0, NULL);
2984 op->contr->braced = 0; 2711 op->contr->braced = 0;
… …
2989 2716
2990 command_kill_pets (op, 0); 2717 command_kill_pets (op, 0);
2991 2718
2992 if (op->stats.food < 0) 2719 if (op->stats.food < 0)
2993 { 2720 {
2994 if (op->contr->explore)
2995 {
2996 new_draw_info (NDI_UNIQUE, 0, op, "You would have starved, but you are");
2997 new_draw_info (NDI_UNIQUE, 0, op, "in explore mode, so...");
2998 op->stats.food = 999;
2999 return;
3000 }
3001 sprintf (buf, "%s starved to death.", &op->name); 2721 sprintf (buf, "%s starved to death.", &op->name);
3002 strcpy (op->contr->killer, "starvation"); 2722 strcpy (op->contr->killer, "starvation");
3003 } 2723 }
3004 else 2724 else
3005 {
3006 if (op->contr->explore)
3007 {
3008 new_draw_info (NDI_UNIQUE, 0, op, "You would have died, but you are");
3009 new_draw_info (NDI_UNIQUE, 0, op, "in explore mode, so...");
3010 op->stats.hp = op->stats.maxhp;
3011 return;
3012 }
3013 sprintf (buf, "%s died.", &op->name); 2725 sprintf (buf, "%s died.", &op->name);
3014 } 2726
3015 play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0); 2727 play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0);
3016 2728
3017 /* save the map location for corpse, gravestone */ 2729 /* save the map location for corpse, gravestone */
3018 x = op->x; 2730 x = op->x;
3019 y = op->y; 2731 y = op->y;
3020 map = op->map; 2732 map = op->map;
3021 2733
3022
3023 if (settings.not_permadeth == TRUE)
3024 {
3025 /* NOT_PERMADEATH code. This basically brings the character back to 2734 /* NOT_PERMADEATH code. This basically brings the character back to
3026 * life if they are dead - it takes some exp and a random stat. 2735 * life if they are dead - it takes some exp and a random stat.
3027 * See the config.h file for a little more in depth detail about this. 2736 * See the config.h file for a little more in depth detail about this.
3028 */ 2737 */
3029 2738
3030 /* Basically two ways to go - remove a stat permanently, or just 2739 /* Basically two ways to go - remove a stat permanently, or just
3031 * make it depletion. This bunch of code deals with that aspect 2740 * make it depletion. This bunch of code deals with that aspect
3032 * of death. 2741 * of death.
3033 */ 2742 */
3034#ifndef COZY_SERVER 2743#ifndef COZY_SERVER
3035 if (settings.balanced_stat_loss) 2744 if (settings.balanced_stat_loss)
3036 { 2745 {
3037 /* If stat loss is permanent, lose one stat only. */ 2746 /* If stat loss is permanent, lose one stat only. */
3038 /* Lower level chars don't lose as many stats because they suffer 2747 /* Lower level chars don't lose as many stats because they suffer
3039 more if they do. */ 2748 more if they do. */
3040 /* Higher level characters can afford things such as potions of 2749 /* Higher level characters can afford things such as potions of
3041 restoration, or better, stat potions. So we slug them that 2750 restoration, or better, stat potions. So we slug them that
3042 little bit harder. */ 2751 little bit harder. */
3043 /* GD */ 2752 /* GD */
3044 if (settings.stat_loss_on_death) 2753 if (settings.stat_loss_on_death)
3045 num_stats_lose = 1; 2754 num_stats_lose = 1;
3046 else
3047 num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
3048 }
3049 else 2755 else
3050 { 2756 num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
2757 }
2758 else
3051 num_stats_lose = 1; 2759 num_stats_lose = 1;
3052 } 2760
3053 lost_a_stat = 0; 2761 lost_a_stat = 0;
3054 2762
3055 for (z = 0; z < num_stats_lose; z++) 2763 for (z = 0; z < num_stats_lose; z++)
3056 { 2764 {
3057 i = RANDOM () % NUM_STATS; 2765 i = RANDOM () % NUM_STATS;
3058 2766
3059 if (settings.stat_loss_on_death) 2767 if (settings.stat_loss_on_death)
3060 { 2768 {
3061 /* Pick a random stat and take a point off it. Tell the player 2769 /* Pick a random stat and take a point off it. Tell the player
3062 * what he lost. 2770 * what he lost.
3063 */ 2771 */
3064 change_attr_value (&(op->stats), i, -1); 2772 change_attr_value (&(op->stats), i, -1);
3065 check_stat_bounds (&(op->stats)); 2773 check_stat_bounds (&(op->stats));
3066 change_attr_value (&(op->contr->orig_stats), i, -1); 2774 change_attr_value (&(op->contr->orig_stats), i, -1);
3067 check_stat_bounds (&(op->contr->orig_stats)); 2775 check_stat_bounds (&(op->contr->orig_stats));
3068 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]); 2776 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3069 lost_a_stat = 1; 2777 lost_a_stat = 1;
2778 }
2779 else
2780 {
2781 /* deplete a stat */
2782 archetype *deparch = archetype::find ("depletion");
2783 object *dep;
2784
2785 dep = present_arch_in_ob (deparch, op);
2786 if (!dep)
2787 {
2788 dep = arch_to_object (deparch);
2789 insert_ob_in_ob (dep, op);
3070 } 2790 }
3071 else 2791 lose_this_stat = 1;
2792 if (settings.balanced_stat_loss)
3072 { 2793 {
3073 /* deplete a stat */ 2794 /* GD */
3074 archetype *deparch = archetype::find ("depletion"); 2795 /* Get the stat that we're about to deplete. */
3075 object *dep; 2796 this_stat = get_attr_value (&(dep->stats), i);
3076 2797 if (this_stat < 0)
3077 dep = present_arch_in_ob (deparch, op);
3078 if (!dep)
3079 { 2798 {
3080 dep = arch_to_object (deparch); 2799 int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3081 insert_ob_in_ob (dep, op); 2800 int keep_chance = this_stat * this_stat;
3082 } 2801
3083 lose_this_stat = 1; 2802 /* Yes, I am paranoid. Sue me. */
3084 if (settings.balanced_stat_loss)
3085 {
3086 /* GD */
3087 /* Get the stat that we're about to deplete. */
3088 this_stat = get_attr_value (&(dep->stats), i);
3089 if (this_stat < 0) 2803 if (keep_chance < 1)
2804 keep_chance = 1;
2805
2806 /* There is a maximum depletion total per level. */
2807 if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3090 { 2808 {
3091 int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3092 int keep_chance = this_stat * this_stat;
3093
3094 /* Yes, I am paranoid. Sue me. */
3095 if (keep_chance < 1)
3096 keep_chance = 1;
3097
3098 /* There is a maximum depletion total per level. */
3099 if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3100 {
3101 lose_this_stat = 0; 2809 lose_this_stat = 0;
3102 /* Take loss chance vs keep chance to see if we 2810 /* Take loss chance vs keep chance to see if we
3103 retain the stat. */ 2811 retain the stat. */
3104 }
3105 else
3106 {
3107 if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3108 lose_this_stat = 0;
3109 /* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
3110 this_stat, keep_chance, loss_chance,
3111 lose_this_stat?"LOSE":"KEEP"); */
3112 }
3113 } 2812 }
3114 }
3115
3116 if (lose_this_stat)
3117 {
3118 this_stat = get_attr_value (&(dep->stats), i);
3119 /* We could try to do something clever like find another
3120 * stat to reduce if this fails. But chances are, if
3121 * stats have been depleted to -50, all are pretty low
3122 * and should be roughly the same, so it shouldn't make a
3123 * difference.
3124 */ 2813 else
3125 if (this_stat >= -50)
3126 { 2814 {
3127 change_attr_value (&(dep->stats), i, -1); 2815 if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3128 SET_FLAG (dep, FLAG_APPLIED);
3129 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3130 fix_player (op);
3131 lost_a_stat = 1; 2816 lose_this_stat = 0;
2817 /* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
2818 this_stat, keep_chance, loss_chance,
2819 lose_this_stat?"LOSE":"KEEP"); */
3132 } 2820 }
3133 } 2821 }
3134 } 2822 }
2823
2824 if (lose_this_stat)
2825 {
2826 this_stat = get_attr_value (&(dep->stats), i);
2827 /* We could try to do something clever like find another
2828 * stat to reduce if this fails. But chances are, if
2829 * stats have been depleted to -50, all are pretty low
2830 * and should be roughly the same, so it shouldn't make a
2831 * difference.
2832 */
2833 if (this_stat >= -50)
2834 {
2835 change_attr_value (&(dep->stats), i, -1);
2836 SET_FLAG (dep, FLAG_APPLIED);
2837 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
2838 op->update_stats ();
2839 lost_a_stat = 1;
2840 }
3135 } 2841 }
2842 }
2843 }
3136 /* If no stat lost, tell the player. */ 2844 /* If no stat lost, tell the player. */
3137 if (!lost_a_stat) 2845 if (!lost_a_stat)
3138 { 2846 {
3139 /* determine_god() seems to not work sometimes... why is this? 2847 /* determine_god() seems to not work sometimes... why is this?
3140 Should I be using something else? GD */ 2848 Should I be using something else? GD */
3141 const char *god = determine_god (op); 2849 const char *god = determine_god (op);
3142 2850
3143 if (god && (strcmp (god, "none"))) 2851 if (god && (strcmp (god, "none")))
3144 new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god); 2852 new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god);
3145 else 2853 else
3146 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you."); 2854 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you.");
3147 } 2855 }
3148#else 2856#else
3149 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely."); 2857 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");
3150#endif 2858#endif
3151 2859
3152 /* Put a gravestone up where the character 'almost' died. List the 2860 /* Put a gravestone up where the character 'almost' died. List the
3153 * exp loss on the stone. 2861 * exp loss on the stone.
3154 */ 2862 */
3155 tmp = arch_to_object (archetype::find ("gravestone")); 2863 tmp = arch_to_object (archetype::find ("gravestone"));
3156 sprintf (buf, "%s's gravestone", &op->name); 2864 sprintf (buf, "%s's gravestone", &op->name);
3157 tmp->name = buf; 2865 tmp->name = buf;
3158 sprintf (buf, "%s's gravestones", &op->name); 2866 sprintf (buf, "%s's gravestones", &op->name);
3159 tmp->name_pl = buf; 2867 tmp->name_pl = buf;
3160 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); 2868 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);
3161 tmp->msg = buf; 2869 tmp->msg = buf;
3162 tmp->x = op->x, tmp->y = op->y; 2870 tmp->x = op->x, tmp->y = op->y;
3163 insert_ob_in_map (tmp, op->map, NULL, 0); 2871 insert_ob_in_map (tmp, op->map, NULL, 0);
3164 2872
3165 /**************************************/ 2873 /**************************************/
3166 /* */ 2874 /* */
3167 /* Subtract the experience points, */ 2875 /* Subtract the experience points, */
3168 /* if we died cause of food, give us */ 2876 /* if we died cause of food, give us */
3169 /* food, and reset HP's... */ 2877 /* food, and reset HP's... */
3170 /* */ 2878 /* */
3171 /**************************************/ 2879 /**************************************/
3172 2880
3173 /* remove any poisoning and confusion the character may be suffering. */ 2881 /* remove any poisoning and confusion the character may be suffering. */
3174 /* restore player */ 2882 /* restore player */
3175 at = archetype::find ("poisoning"); 2883 at = archetype::find ("poisoning");
3176 tmp = present_arch_in_ob (at, op); 2884 tmp = present_arch_in_ob (at, op);
3177 2885
3178 if (tmp) 2886 if (tmp)
3179 { 2887 {
3180 tmp->destroy (); 2888 tmp->destroy ();
3181 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed"); 2889 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
3182 } 2890 }
3183 2891
3184 at = archetype::find ("confusion"); 2892 at = archetype::find ("confusion");
3185 tmp = present_arch_in_ob (at, op); 2893 tmp = present_arch_in_ob (at, op);
3186 if (tmp) 2894 if (tmp)
3187 { 2895 {
3188 tmp->destroy (); 2896 tmp->destroy ();
3189 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 2897 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
3190 } 2898 }
3191 2899
3192 cure_disease (op, 0); /* remove any disease */ 2900 cure_disease (op, 0); /* remove any disease */
3193 2901
3194 /*add_exp(op, (op->stats.exp * -0.20)); */ 2902 /*add_exp(op, (op->stats.exp * -0.20)); */
3195 apply_death_exp_penalty (op); 2903 apply_death_exp_penalty (op);
3196 if (op->stats.food < 100) 2904 if (op->stats.food < 100)
3197 op->stats.food = 900; 2905 op->stats.food = 900;
3198 op->stats.hp = op->stats.maxhp; 2906 op->stats.hp = op->stats.maxhp;
3199 op->stats.sp = MAX (op->stats.sp, op->stats.maxsp); 2907 op->stats.sp = MAX (op->stats.sp, op->stats.maxsp);
3200 op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace); 2908 op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace);
3201 2909
3202 /* 2910 /*
3203 * Check to see if the player is in a shop. IF so, then check to see if 2911 * Check to see if the player is in a shop. IF so, then check to see if
3204 * the player has any unpaid items. If so, remove them and put them back 2912 * the player has any unpaid items. If so, remove them and put them back
3205 * in the map. 2913 * in the map.
3206 */ 2914 */
3207 2915
3208 if (is_in_shop (op)) 2916 if (is_in_shop (op))
3209 remove_unpaid_objects (op->inv, op); 2917 remove_unpaid_objects (op->inv, op);
3210 2918
3211 /****************************************/ 2919 /****************************************/
3212 /* */ 2920 /* */
3213 /* Move player to his current respawn- */ 2921 /* Move player to his current respawn- */
3214 /* position (usually last savebed) */ 2922 /* position (usually last savebed) */
3215 /* */ 2923 /* */
3216 /****************************************/ 2924 /****************************************/
3217 2925
3218 enter_player_savebed (op); 2926 enter_player_savebed (op);
3219 2927
3220 /* Save the player before inserting the force to reduce
3221 * chance of abuse.
3222 */
3223 op->contr->braced = 0; 2928 op->contr->braced = 0;
3224 save_player (op, 1);
3225 2929
3226 /* it is possible that the player has blown something up 2930 /* it is possible that the player has blown something up
3227 * at his savebed location, and that can have long lasting 2931 * at his savebed location, and that can have long lasting
3228 * spell effects. So first see if there is a spell effect 2932 * spell effects. So first see if there is a spell effect
3229 * on the space that might harm the player. 2933 * on the space that might harm the player.
3230 */ 2934 */
3231 will_kill_again = 0; 2935 will_kill_again = 0;
3232 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above) 2936 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
3233 if (tmp->type == SPELL_EFFECT) 2937 if (tmp->type == SPELL_EFFECT)
3234 will_kill_again |= tmp->attacktype; 2938 will_kill_again |= tmp->attacktype;
3235 2939
3236 if (will_kill_again) 2940 if (will_kill_again)
3237 { 2941 {
3238 object *force; 2942 object *force;
3239 int at; 2943 int at;
3240 2944
3241 force = get_archetype (FORCE_NAME); 2945 force = get_archetype (FORCE_NAME);
3242 /* 50 ticks should be enough time for the spell to abate */ 2946 /* 50 ticks should be enough time for the spell to abate */
3243 force->speed = 0.1; 2947 force->speed = 0.1;
3244 force->speed_left = -5.0; 2948 force->speed_left = -5.0;
3245 SET_FLAG (force, FLAG_APPLIED); 2949 SET_FLAG (force, FLAG_APPLIED);
3246 for (at = 0; at < NROFATTACKS; at++) 2950 for (at = 0; at < NROFATTACKS; at++)
3247 if (will_kill_again & (1 << at)) 2951 if (will_kill_again & (1 << at))
3248 force->resist[at] = 100; 2952 force->resist[at] = 100;
3249 2953
3250 insert_ob_in_ob (force, op); 2954 insert_ob_in_ob (force, op);
3251 fix_player (op); 2955 op->update_stats ();
3252 2956
3253 } 2957 }
3254 2958
3255 new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED."); 2959 new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED.");
3256 return;
3257 } /* NOT_PERMADETH */
3258 else
3259 {
3260 /* If NOT_PERMADETH is set, then the rest of this is not reachable. This
3261 * should probably be embedded in an else statement.
3262 */
3263
3264 op->contr->party = NULL;
3265 if (settings.set_title == TRUE)
3266 op->contr->own_title[0] = '\0';
3267 new_draw_info (NDI_UNIQUE | NDI_ALL, 0, NULL, buf);
3268 check_score (op);
3269
3270 if (op->contr->ranges[range_golem])
3271 {
3272 remove_friendly_object (op->contr->ranges[range_golem]);
3273 op->contr->ranges[range_golem]->destroy ();
3274 op->contr->ranges[range_golem] = 0;
3275 }
3276
3277 loot_object (op); /* Remove some of the items for good */
3278 op->remove ();
3279 op->direction = 0;
3280
3281 if (!QUERY_FLAG (op, FLAG_WAS_WIZ) && op->stats.exp)
3282 {
3283 delete_character (op->name, 0);
3284 if (settings.resurrection == TRUE)
3285 {
3286 /* save playerfile sans equipment when player dies
3287 ** then save it as player.pl.dead so that future resurrection
3288 ** type spells will work on them nicely
3289 */
3290 delete_character (op->name, 0);
3291 op->stats.hp = op->stats.maxhp;
3292 op->stats.food = 999;
3293
3294 /* set the location of where the person will reappear when */
3295 /* maybe resurrection code should fix map also */
3296 strcpy (op->contr->maplevel, settings.emergency_mapname);
3297 if (op->map != NULL)
3298 op->map = NULL;
3299 op->x = settings.emergency_x;
3300 op->y = settings.emergency_y;
3301 save_player (op, 0);
3302 op->map = map;
3303 /* please see resurrection.c: peterm */
3304 dead_player (op);
3305 }
3306 else
3307 delete_character (op->name, 1);
3308 }
3309
3310 play_again (op);
3311
3312 /* peterm: added to create a corpse at deathsite. */
3313 tmp = arch_to_object (archetype::find ("corpse_pl"));
3314 sprintf (buf, "%s", &op->name);
3315 tmp->name = tmp->name_pl = buf;
3316 tmp->level = op->level;
3317 tmp->x = x;
3318 tmp->y = y;
3319 tmp->msg = gravestone_text (op);
3320 SET_FLAG (tmp, FLAG_UNIQUE);
3321 insert_ob_in_map (tmp, map, NULL, 0);
3322 }
3323} 2960}
3324
3325 2961
3326void 2962void
3327loot_object (object *op) 2963loot_object (object *op)
3328{ /* Grab and destroy some treasure */ 2964{ /* Grab and destroy some treasure */
3329 object *tmp, *tmp2, *next; 2965 object *tmp, *tmp2, *next;
3330 2966
3331 if (op->container) 2967 if (op->container)
3332 { /* close open sack first */
3333 esrv_apply_container (op, op->container); 2968 esrv_apply_container (op, op->container); /* close open sack first */
3334 }
3335 2969
3336 for (tmp = op->inv; tmp != NULL; tmp = next) 2970 for (tmp = op->inv; tmp; tmp = next)
3337 { 2971 {
3338 next = tmp->below; 2972 next = tmp->below;
2973
3339 if (tmp->invisible) 2974 if (tmp->invisible)
3340 continue; 2975 continue;
2976
3341 tmp->remove (); 2977 tmp->remove ();
3342 tmp->x = op->x, tmp->y = op->y; 2978 tmp->x = op->x, tmp->y = op->y;
3343 if (tmp->type == CONTAINER) 2979 if (tmp->type == CONTAINER)
3344 { /* empty container to ground */ 2980 { /* empty container to ground */
3345 loot_object (tmp); 2981 loot_object (tmp);
… …
3367 */ 3003 */
3368 3004
3369void 3005void
3370fix_weight (void) 3006fix_weight (void)
3371{ 3007{
3372 player *pl; 3008 for_all_players (pl)
3373
3374 for (pl = first_player; pl != NULL; pl = pl->next)
3375 { 3009 {
3376 int old = pl->ob->carrying, sum = sum_weight (pl->ob); 3010 int old = pl->ob->carrying, sum = sum_weight (pl->ob);
3377 3011
3378 if (old == sum) 3012 if (old == sum)
3379 continue; 3013 continue;
3380 fix_player (pl->ob); 3014 pl->ob->update_stats ();
3381 LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum); 3015 LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum);
3382 } 3016 }
3383} 3017}
3384 3018
3385void 3019void
3386fix_luck (void) 3020fix_luck (void)
3387{ 3021{
3388 player *pl; 3022 for_all_players (pl)
3389
3390 for (pl = first_player; pl != NULL; pl = pl->next)
3391 if (!pl->ob->contr->ns->state) 3023 if (!pl->ob->contr->ns->state)
3392 change_luck (pl->ob, 0); 3024 pl->ob->change_luck (0);
3393} 3025}
3394
3395 3026
3396/* cast_dust() - handles op throwing objects of type 'DUST'. 3027/* cast_dust() - handles op throwing objects of type 'DUST'.
3397 * This is much simpler in the new spell code - we basically 3028 * This is much simpler in the new spell code - we basically
3398 * just treat this as any other spell casting object. 3029 * just treat this as any other spell casting object.
3399 */ 3030 */
3400
3401void 3031void
3402cast_dust (object *op, object *throw_ob, int dir) 3032cast_dust (object *op, object *throw_ob, int dir)
3403{ 3033{
3404 object *skop, *spob; 3034 object *skop, *spob;
3405 3035
… …
3515 3145
3516 skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING); 3146 skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING);
3517 3147
3518 /* its *extremely* hard to run and sneak/hide at the same time! */ 3148 /* its *extremely* hard to run and sneak/hide at the same time! */
3519 if (op->type == PLAYER && op->contr->run_on) 3149 if (op->type == PLAYER && op->contr->run_on)
3520 {
3521 if (!skop || num >= skop->level) 3150 if (!skop || num >= skop->level)
3522 { 3151 {
3523 new_draw_info (NDI_UNIQUE, 0, op, "You ran too much! You are no longer hidden!"); 3152 new_draw_info (NDI_UNIQUE, 0, op, "You ran too much! You are no longer hidden!");
3524 make_visible (op); 3153 make_visible (op);
3525 return; 3154 return;
3526 } 3155 }
3527 else 3156 else
3528 num += 20; 3157 num += 20;
3529 } 3158
3530 num += op->map->difficulty; 3159 num += op->map->difficulty;
3531 hide = hideability (op); /* modify by terrain hidden level */ 3160 hide = hideability (op); /* modify by terrain hidden level */
3532 num -= hide; 3161 num -= hide;
3162
3533 if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0)) 3163 if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0))
3534 { 3164 {
3535 make_visible (op); 3165 make_visible (op);
3536 if (op->type == PLAYER) 3166 if (op->type == PLAYER)
3537 new_draw_info (NDI_UNIQUE, 0, op, "You moved out of hiding! You are visible!"); 3167 new_draw_info (NDI_UNIQUE, 0, op, "You moved out of hiding! You are visible!");
3538 } 3168 }
3539 else if (op->type == PLAYER && skop) 3169 else if (op->type == PLAYER && skop)
3540 {
3541 change_exp (op, calc_skill_exp (op, NULL, skop), skop->skill, 0); 3170 change_exp (op, calc_skill_exp (op, NULL, skop), skop->skill, 0);
3542 }
3543} 3171}
3544 3172
3545/* determine if who is standing near a hostile creature. */ 3173/* determine if who is standing near a hostile creature. */
3546 3174
3547int 3175int
… …
3614 if (pl->type != PLAYER) 3242 if (pl->type != PLAYER)
3615 { 3243 {
3616 LOG (llevError, "player_can_view() called for non-player object\n"); 3244 LOG (llevError, "player_can_view() called for non-player object\n");
3617 return -1; 3245 return -1;
3618 } 3246 }
3247
3619 if (!pl || !op) 3248 if (!pl || !op)
3620 return 0; 3249 return 0;
3621 3250
3622 if (op->head)
3623 {
3624 op = op->head; 3251 op = op->head_ ();
3625 } 3252
3626 get_rangevector (pl, op, &rv, 0x1); 3253 get_rangevector (pl, op, &rv, 0x1);
3627 3254
3628 /* starting with the 'head' part, lets loop 3255 /* starting with the 'head' part, lets loop
3629 * through the object and find if it has any 3256 * through the object and find if it has any
3630 * part that is in the los array but isnt on 3257 * part that is in the los array but isnt on
… …
3760 if (trlist == NULL || who->type != PLAYER) 3387 if (trlist == NULL || who->type != PLAYER)
3761 return; 3388 return;
3762 3389
3763 for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++); 3390 for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++);
3764 3391
3765 if (tr == NULL || tr->item == NULL) 3392 if (!tr || !tr->item)
3766 { 3393 {
3767 /* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */ 3394 /* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */
3768 return; 3395 return;
3769 } 3396 }
3770 3397
… …
3895 * not readied. 3522 * not readied.
3896 */ 3523 */
3897void 3524void
3898player_unready_range_ob (player *pl, object *ob) 3525player_unready_range_ob (player *pl, object *ob)
3899{ 3526{
3900 rangetype i;
3901
3902 for (i = (rangetype) 0; i < range_size; i = (rangetype) ((int) i + 1)) 3527 for (rangetype i = (rangetype) 0; i < range_size; i = (rangetype) ((int) i + 1))
3903 {
3904 if (pl->ranges[i] == ob) 3528 if (pl->ranges[i] == ob)
3905 { 3529 {
3906 pl->ranges[i] = NULL; 3530 pl->ranges[i] = 0;
3907 if (pl->shoottype == i) 3531 if (pl->shoottype == i)
3908 {
3909 pl->shoottype = range_none; 3532 pl->shoottype = range_none;
3910 }
3911 } 3533 }
3912 }
3913} 3534}

Diff Legend

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