ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/player.C
Revision: 1.232
Committed: Sat Oct 3 20:11:12 2009 UTC (14 years, 8 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.231: +14 -16 lines
Log Message:
*** empty log message ***

File Contents

# Content
1 /*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 *
8 * Deliantra 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 3 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, see <http://www.gnu.org/licenses/>.
20 *
21 * The authors can be reached via e-mail to <support@deliantra.net>
22 */
23
24 #include <global.h>
25 #include <sproto.h>
26 #include <sounds.h>
27 #include <living.h>
28 #include <object.h>
29 #include <spells.h>
30 #include <skills.h>
31
32 #include <algorithm>
33 #include <functional>
34
35 playervec players;
36
37 void
38 display_motd (const object *op)
39 {
40 char buf[MAX_BUF];
41 char motd[HUGE_BUF];
42 FILE *fp;
43 int comp;
44 int size;
45
46 sprintf (buf, "%s/%s", settings.confdir, settings.motd);
47 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
48 return;
49
50 motd[0] = '\0';
51 size = 0;
52
53 while (fgets (buf, MAX_BUF, fp))
54 {
55 if (*buf == '#')
56 continue;
57
58 strncat (motd + size, buf, HUGE_BUF - size);
59 size += strlen (buf);
60 }
61
62 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_MOTD, MSG_SUBTYPE_NONE, motd, NULL);
63 close_and_delete (fp, comp);
64 }
65
66 void
67 send_rules (const object *op)
68 {
69 char buf[MAX_BUF];
70 char rules[HUGE_BUF];
71 FILE *fp;
72 int comp;
73 int size;
74
75 sprintf (buf, "%s/%s", settings.confdir, settings.rules);
76 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
77 return;
78
79 rules[0] = '\0';
80 size = 0;
81
82 while (fgets (buf, MAX_BUF, fp))
83 {
84 if (*buf == '#')
85 continue;
86
87 if (size + strlen (buf) >= HUGE_BUF)
88 {
89 LOG (llevDebug, "Warning, rules size is > %d bytes.\n", HUGE_BUF);
90 break;
91 }
92
93 strncat (rules + size, buf, HUGE_BUF - size);
94 size += strlen (buf);
95 }
96
97 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_RULES, rules, NULL);
98 close_and_delete (fp, comp);
99 }
100
101 void
102 send_news (const object *op)
103 {
104 char buf[MAX_BUF];
105 char news[HUGE_BUF];
106 char subject[MAX_BUF];
107 FILE *fp;
108 int comp;
109 int size;
110
111 sprintf (buf, "%s/%s", settings.confdir, settings.news);
112 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
113 return;
114
115 news[0] = '\0';
116 subject[0] = '\0';
117 size = 0;
118
119 while (fgets (buf, MAX_BUF, fp))
120 {
121 if (*buf == '#')
122 continue;
123
124 if (*buf == '%')
125 { /* send one news */
126 if (size > 0)
127 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,
128 MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS,
129 "INFORMATION: %s\n%s", (char *)"%s\n%s",
130 subject, news); /*send previously read news */
131
132 strcpy (subject, buf + 1);
133 strip_endline (subject);
134 size = 0;
135 news[0] = '\0';
136 }
137 else
138 {
139 if (size + strlen (buf) >= HUGE_BUF)
140 {
141 LOG (llevDebug, "Warning, one news item has size > %d bytes.\n", HUGE_BUF);
142 break;
143 }
144 strncat (news + size, buf, HUGE_BUF - size);
145 size += strlen (buf);
146 }
147 }
148
149 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,
150 MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s\n", (char *)"%s\n%s", subject, news);
151 close_and_delete (fp, comp);
152 }
153
154 /* This loads the first map an puts the player on it. */
155 static void
156 set_first_map (object *op)
157 {
158 op->contr->maplevel = first_map_path;
159 op->x = -1;
160 op->y = -1;
161 }
162
163 void
164 player::activate ()
165 {
166 if (active)
167 return;
168
169 players.insert (this);
170 ob->remove ();
171 ob->map = 0;
172 ob->activate_recursive ();
173 CLEAR_FLAG (ob, FLAG_FRIENDLY);
174 add_friendly_object (ob);
175 }
176
177 void
178 player::deactivate ()
179 {
180 if (!active)
181 return;
182
183 terminate_all_pets (ob);
184 remove_friendly_object (ob);
185 ob->deactivate_recursive ();
186
187 if (ob->map)
188 maplevel = ob->map->path;
189
190 ob->remove ();
191 ob->enemy = 0; // sometimes keeps an extra refcount on itself
192 ob->map = 0;
193 party = 0;
194
195 combat_ob = ranged_ob = 0; //TODO, should be special marker, non-refcounted, not this
196
197 players.erase (this);
198 }
199
200 // connect the player with a specific client
201 // also changes, rationalises, and fixes some incorrect settings
202 void
203 player::connect (client *ns)
204 {
205 this->ns = ns;
206 ns->pl = this;
207
208 run_on = 0;
209 fire_on = 0;
210 ob->close_container (); //TODO: client-specific
211
212 ns->update_look = 0;
213 ns->look_position = 0;
214
215 clear_los ();
216
217 ns->reset_stats ();
218
219 /* make sure he's a player -- needed because of class change. */
220 ob->type = PLAYER; // we are paranoid
221 ob->race = ob->arch->race;
222
223 ob->update_weight ();
224 link_skills ();
225
226 CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER);
227
228 assign (title, ob->arch->object::name);
229
230 /* if it's a dragon player, set the correct title here */
231 if (is_dragon_pl (ob))
232 {
233 object *tmp, *abil = 0, *skin = 0;
234
235 for (tmp = ob->inv; tmp; tmp = tmp->below)
236 if (tmp->type == FORCE)
237 if (tmp->arch->archname == shstr_dragon_ability_force)
238 abil = tmp;
239 else if (tmp->arch->archname == shstr_dragon_skin_force)
240 skin = tmp;
241
242 set_dragon_name (ob, abil, skin);
243 }
244
245 new_draw_info (NDI_UNIQUE, 0, ob, "Welcome Back!");
246
247 esrv_new_player (this);
248
249 ob->update_stats ();
250
251 ns->floorbox_update ();
252 esrv_send_inventory (ob, ob);
253 esrv_add_spells (this, 0);
254
255 activate ();
256
257 send_rules (ob);
258 send_news (ob);
259 display_motd (ob);
260
261 INVOKE_PLAYER (CONNECT, this);
262 INVOKE_PLAYER (LOGIN, this);
263 }
264
265 void
266 player::disconnect ()
267 {
268 if (ob)
269 {
270 ob->close_container (); //TODO: client-specific
271 ob->drop_unpaid_items ();
272 }
273
274 if (ns)
275 {
276 if (active)
277 INVOKE_PLAYER (LOGOUT, this, ARG_INT (0));
278
279 INVOKE_PLAYER (DISCONNECT, this);
280
281 ns->reset_stats ();
282 ns->pl = 0;
283 ns = 0;
284 }
285
286 observe = ob;
287
288 deactivate ();
289 }
290
291 // the need for this function can be explained
292 // by load_object not returning the object
293 void
294 player::set_object (object *op)
295 {
296 ob = observe = op;
297 ob->contr = this; /* this aren't yet in archetype */
298
299 ob->speed = 1.0f;
300 ob->speed_left = 0.5f;
301
302 ob->direction = 5; /* So player faces south */
303
304 ob->flag [FLAG_READY_WEAPON] = false;
305 ob->flag [FLAG_READY_SKILL] = false;
306 ob->flag [FLAG_READY_BOW] = false;
307
308 for (object *op = ob->inv; op; op = op->below)
309 if (op->flag [FLAG_APPLIED])
310 switch (op->type)
311 {
312 case SKILL:
313 ob->flag [FLAG_APPLIED] = false;
314 break;
315
316 case WAND:
317 case ROD:
318 case HORN:
319 case BOW:
320 ranged_ob = op;
321 break;
322
323 case WEAPON:
324 combat_ob = op;
325 break;
326 }
327
328 ob->change_weapon (combat_ob ? combat_ob : ranged_ob);
329 ob->deactivate (); // change_weapon activates, fix this better
330 }
331
332 void
333 player::set_observe (object *op)
334 {
335 observe = op ? op : ob;
336 do_los = 1;
337 }
338
339 player::player ()
340 {
341 /* There are some elements we want initialised to non zero value -
342 * we deal with that below this point.
343 */
344 outputs_sync = 4;
345 outputs_count = 4;
346 unapply = unapply_nochoice;
347
348 savebed_map = first_map_path; /* Init. respawn position */
349
350 gen_sp_armour = 10;
351 bowtype = bow_normal;
352 petmode = pet_normal;
353 usekeys = containers;
354 peaceful = 1; /* default peaceful */
355 do_los = 1;
356
357 weapon_sp = 1.0f;
358 weapon_sp_left = 0.5f;
359 }
360
361 void
362 player::do_destroy ()
363 {
364 disconnect ();
365
366 attachable::do_destroy ();
367
368 if (ob)
369 {
370 ob->destroy_inv (false);
371 ob->destroy ();
372 }
373
374 ob = observe = 0;
375 }
376
377 player::~player ()
378 {
379 /* Clear item stack */
380 free (stack_items);
381 }
382
383 /* Tries to add player on the connection passed in ns.
384 * All we can really get in this is some settings like host and display
385 * mode.
386 */
387 player *
388 player::create ()
389 {
390 player *pl = new player;
391
392 pl->set_object (arch_to_object (get_player_archetype (0)));
393
394 pl->ob->roll_stats ();
395 pl->ob->stats.wc = 2;
396 pl->ob->run_away = 25; /* Then we panick... */
397
398 set_first_map (pl->ob);
399
400 return pl;
401 }
402
403 /*
404 * get_player_archetype() return next player archetype from archetype
405 * list. Not very efficient routine, but used only creating new players.
406 * Note: there MUST be at least one player archetype!
407 */
408 archetype *
409 get_player_archetype (archetype *at)
410 {
411 // archetypes could have been reloaded
412 archetype *nat = at ? archetype::find (at->archname) : archetypes [0];
413
414 if (!nat)
415 return at;
416
417 archvec::iterator i = archetypes.find (nat);
418
419 for (;;)
420 {
421 if (++i == archetypes.end ())
422 i = archetypes.begin ();
423 else if (*i == at)
424 cleanup ("not a single player archetype found");
425
426 if ((*i)->type == PLAYER)
427 return *i;
428 }
429 }
430
431 object *
432 get_nearest_player (object *mon)
433 {
434 object *op = NULL;
435 objectlink *ol;
436 unsigned lastdist;
437 rv_vector rv;
438
439 for (ol = first_friendly_object, lastdist = 1000; ol; ol = ol->next)
440 {
441 if (!can_detect_enemy (mon, ol->ob, &rv))
442 continue;
443
444 if (lastdist > rv.distance)
445 {
446 op = ol->ob;
447 lastdist = rv.distance;
448 }
449 }
450
451 for_all_players (pl)
452 if (can_detect_enemy (mon, pl->ob, &rv))
453 if (lastdist > rv.distance)
454 {
455 op = pl->ob;
456 lastdist = rv.distance;
457 }
458
459 #if 0
460 LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)");
461 #endif
462 return op;
463 }
464
465 /* I believe this can safely go to 2, 3 is questionable, 4 will likely
466 * result in a monster paths backtracking. It basically determines how large a
467 * detour a monster will take from the direction path when looking
468 * for a path to the player. The values are in the amount of direction
469 * the deviation is
470 */
471 #define DETOUR_AMOUNT 2
472
473 /* This is used to prevent infinite loops. Consider a case where the
474 * player is in a chamber (with gate closed), and monsters are outside.
475 * with DETOUR_AMOUNT==2, the function will turn each corner, trying to
476 * find a path into the chamber. This is a good thing, but since there
477 * is no real path, it will just keep circling the chamber for
478 * ever (this could be a nice effect for monsters, but not for the function
479 * to get stuck in. I think for the monsters, if max is reached and
480 * we return the first direction the creature could move would result in the
481 * circling behaviour. Unfortunately, this function is also used to determined
482 * if the creature should cast a spell, so returning a direction in that case
483 * is probably not a good thing.
484 */
485 #define MAX_SPACES 50
486
487 /*
488 * Returns the direction to the player, if valid. Returns 0 otherwise.
489 * modified to verify there is a path to the player. Does this by stepping towards
490 * player and if path is blocked then see if blockage is close enough to player that
491 * direction to player is changed (ie zig or zag). Continue zig zag until either
492 * reach player or path is blocked. Thus, will only return true if there is a free
493 * path to player. Though path may not be a straight line. Note that it will find
494 * player hiding along a corridor at right angles to the corridor with the monster.
495 *
496 * Modified by MSW 2001-08-06 to handle tiled maps. Various notes:
497 * 1) With DETOUR_AMOUNT being 2, it should still go and find players hiding
498 * down corriders.
499 * 2) I think the old code was broken if the first direction the monster
500 * should move was blocked - the code would store the first direction without
501 * verifying that the player can actually move in that direction. The new
502 * code does not store anything in firstdir until we have verified that the
503 * monster can in fact move one space in that direction.
504 * 3) I'm not sure how good this code will be for moving multipart monsters,
505 * since only simple checks to blocked are being called, which could mean the monster
506 * is blocking itself.
507 */
508 int
509 path_to_player (object *mon, object *pl, unsigned mindiff)
510 {
511 rv_vector rv;
512 sint16 x, y;
513 int lastx, lasty, dir, i, diff, firstdir = 0, lastdir, max = MAX_SPACES, mflags, blocked;
514 maptile *m, *lastmap;
515
516 get_rangevector (mon, pl, &rv, 0);
517
518 if (rv.distance < mindiff)
519 return 0;
520
521 x = mon->x;
522 y = mon->y;
523 m = mon->map;
524 dir = rv.direction;
525 lastdir = firstdir = rv.direction; /* perhaps we stand next to pl, init firstdir too */
526 diff = ::max (abs (rv.distance_x), abs (rv.distance_y));
527
528 /* If we can't solve it within the search distance, return now. */
529 if (diff > max)
530 return 0;
531
532 while (diff > 1 && max > 0)
533 {
534 lastx = x;
535 lasty = y;
536 lastmap = m;
537 x = lastx + freearr_x[dir];
538 y = lasty + freearr_y[dir];
539
540 mflags = get_map_flags (m, &m, x, y, &x, &y);
541 blocked = (mflags & P_OUT_OF_MAP) ? MOVE_ALL : GET_MAP_MOVE_BLOCK (m, x, y);
542
543 /* Space is blocked - try changing direction a little */
544 if ((mflags & P_OUT_OF_MAP) || ((OB_TYPE_MOVE_BLOCK (mon, blocked) || (mflags & P_BLOCKSVIEW))
545 && (m == mon->map && blocked_link (mon, m, x, y))))
546 {
547 /* recalculate direction from last good location. Possible
548 * we were not traversing ideal location before.
549 */
550 get_rangevector_from_mapcoord (lastmap, lastx, lasty, pl, &rv, 0);
551 if (rv.direction != dir)
552 {
553 /* OK - says direction should be different - lets reset the
554 * the values so it will try again.
555 */
556 x = lastx;
557 y = lasty;
558 m = lastmap;
559 dir = firstdir = rv.direction;
560 }
561 else
562 {
563 /* direct path is blocked - try taking a side step to
564 * either the left or right.
565 * Note increase the values in the loop below to be
566 * more than -1/1 respectively will mean the monster takes
567 * bigger detour. Have to be careful about these values getting
568 * too big (3 or maybe 4 or higher) as the monster may just try
569 * stepping back and forth
570 */
571 for (i = -DETOUR_AMOUNT; i <= DETOUR_AMOUNT; i++)
572 {
573 if (i == 0)
574 continue; /* already did this, so skip it */
575 /* Use lastdir here - otherwise,
576 * since the direction that the creature should move in
577 * may change, you could get infinite loops.
578 * ie, player is northwest, but monster can only
579 * move west, so it does that. It goes some distance,
580 * gets blocked, finds that it should move north,
581 * can't do that, but now finds it can move east, and
582 * gets back to its original point. lastdir contains
583 * the last direction the creature has successfully
584 * moved.
585 */
586
587 x = lastx + freearr_x[absdir (lastdir + i)];
588 y = lasty + freearr_y[absdir (lastdir + i)];
589 m = lastmap;
590 mflags = get_map_flags (m, &m, x, y, &x, &y);
591 if (mflags & P_OUT_OF_MAP)
592 continue;
593 blocked = GET_MAP_MOVE_BLOCK (m, x, y);
594 if (OB_TYPE_MOVE_BLOCK (mon, blocked))
595 continue;
596 if (mflags & P_BLOCKSVIEW)
597 continue;
598
599 if (m == mon->map && blocked_link (mon, m, x, y))
600 break;
601 }
602 /* go through entire loop without finding a valid
603 * sidestep to take - thus, no valid path.
604 */
605 if (i == (DETOUR_AMOUNT + 1))
606 return 0;
607 diff--;
608 lastdir = dir;
609 max--;
610 if (!firstdir)
611 firstdir = dir + i;
612 } /* else check alternate directions */
613 } /* if blocked */
614 else
615 {
616 /* we moved towards creature, so diff is less */
617 diff--;
618 max--;
619 lastdir = dir;
620 if (!firstdir)
621 firstdir = dir;
622 }
623
624 if (diff <= 1)
625 {
626 /* Recalculate diff (distance) because we may not have actually
627 * headed toward player for entire distance.
628 */
629 get_rangevector_from_mapcoord (m, x, y, pl, &rv, 0);
630 diff = ::max (abs (rv.distance_x), abs (rv.distance_y));
631 }
632
633 if (diff > max)
634 return 0;
635 }
636
637 /* If we reached the max, didn't find a direction in time */
638 if (!max)
639 return 0;
640
641 return firstdir;
642 }
643
644 void
645 give_initial_items (object *pl, treasurelist *items)
646 {
647 if (pl->randomitems)
648 create_treasure (items, pl, GT_STARTEQUIP | GT_ONLY_GOOD, 1, 0);
649
650 for (object *next, *op = pl->inv; op; op = next)
651 {
652 next = op->below;
653
654 /* Forces get applied per default, unless they have the
655 * flag "neutral" set. Sorry but I can't think of a better way
656 */
657 if (op->type == FORCE && !QUERY_FLAG (op, FLAG_NEUTRAL))
658 SET_FLAG (op, FLAG_APPLIED);
659
660 /* we never give weapons/armour if these cannot be used
661 * by this player due to race restrictions
662 */
663 if (pl->type == PLAYER)
664 {
665 if ((!QUERY_FLAG (pl, FLAG_USE_ARMOUR)
666 &&
667 (op->type == ARMOUR || op->type == BOOTS
668 || op->type == CLOAK || op->type == HELMET
669 || op->type == SHIELD || op->type == GLOVES
670 || op->type == BRACERS || op->type == GIRDLE))
671 || (!QUERY_FLAG (pl, FLAG_USE_WEAPON) && op->type == WEAPON))
672 {
673 op->destroy ();
674 continue;
675 }
676 }
677
678 /* Here we remove duplicated skills (as duplicated spell objects have
679 * _very_ confusing effects for players), which could for instance be
680 * generated by bad treasurelists. - elmex
681 */
682 if (op->type == SKILL)
683 {
684 for (object *tmp = op->below; tmp; tmp = tmp->below)
685 if (tmp->type == op->type && tmp->name == op->name)
686 {
687 op->destroy ();
688 LOG (llevError,
689 "give_initial_items: Removing duplicate skill %s\n", &tmp->name);
690 break;
691 }
692
693 if (op->nrof > 1)
694 op->nrof = 1;
695 }
696
697 if (op->type == SPELLBOOK && op->inv)
698 CLEAR_FLAG (op->inv, FLAG_STARTEQUIP);
699
700 /* Give starting characters identified, uncursed, and undamned
701 * items. Just don't identify gold or silver, or it won't be
702 * merged properly.
703 */
704 if (need_identify (op))
705 {
706 SET_FLAG (op, FLAG_IDENTIFIED);
707 CLEAR_FLAG (op, FLAG_CURSED);
708 CLEAR_FLAG (op, FLAG_DAMNED);
709 }
710
711 if (op->type == SPELL)
712 {
713 op->destroy ();
714 continue;
715 }
716 else if (op->type == SKILL)
717 {
718 SET_FLAG (op, FLAG_CAN_USE_SKILL);
719 op->stats.exp = 0;
720 op->level = 1;
721 }
722 else /* lock all 'normal items by default */
723 SET_FLAG (op, FLAG_INV_LOCKED);
724 } /* for loop of objects in player inv */
725
726 /* Need to set up the skill pointers */
727 pl->contr->link_skills ();
728 }
729
730 void
731 get_party_password (object *op, partylist *party)
732 {
733 if (party == NULL)
734 {
735 LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name);
736 return;
737 }
738
739 op->contr->write_buf[0] = '\0';
740 op->contr->ns->state = ST_GET_PARTY_PASSWORD;
741 op->contr->party_to_join = party;
742 send_query (op->contr->ns, CS_QUERY_HIDEINPUT, "What is the password?\n:");
743 }
744
745 /* This rolls four 1-6 rolls and sums the best 3 of the 4. */
746 static int
747 roll_stat (void)
748 {
749 int a[4], i, j, k;
750
751 for (i = 0; i < 4; i++)
752 a[i] = (int) rndm (6) + 1;
753
754 for (i = 0, j = 0, k = 7; i < 4; i++)
755 if (a[i] < k)
756 k = a[i], j = i;
757
758 for (i = 0, k = 0; i < 4; i++)
759 if (i != j)
760 k += a[i];
761
762 return k;
763 }
764
765 void
766 object::roll_stats ()
767 {
768 int statsort [NUM_STATS];
769
770 for (;;)
771 {
772 int sum = 0;
773 for (int i = NUM_STATS; i--; )
774 sum += statsort [i] = roll_stat ();
775
776 if (sum >= 82 && sum <= 116)
777 break;
778 }
779
780 // Sort the stats so that rerolling is easier...
781 std::sort (statsort, statsort + NUM_STATS, std::greater<int>());
782
783 for (int i = 0; i < NUM_STATS; ++i)
784 stats.stat (i) = statsort [i];
785
786 stats.exp = 0;
787 stats.ac = 0;
788
789 stats.hp = stats.maxhp;
790 stats.sp = stats.maxsp;
791 stats.grace = stats.maxgrace;
792
793 if (contr)
794 {
795 contr->levhp[1] = 9;
796 contr->levsp[1] = 6;
797 contr->levgrace[1] = 3;
798
799 contr->orig_stats = stats;
800 }
801 }
802
803 void
804 object::swap_stats (int a, int b)
805 {
806 swap (contr->orig_stats.stat (a), contr->orig_stats.stat (b));
807
808 for (int i = 0; i < NUM_STATS; ++i)
809 stats.stat (i) = contr->orig_stats.stat (i);
810
811 //TODO: the following code looks so borked and should, at the very least,
812 // be merged with the similar code in roll_stats
813 stats.ac = 0;
814
815 level = 1;
816 stats.exp = 0;
817 stats.ac = 0;
818
819 stats.hp = stats.maxhp;
820 stats.sp = stats.maxsp;
821 stats.grace = stats.maxgrace;
822
823 if (contr)
824 {
825 contr->levhp[1] = 9;
826 contr->levsp[1] = 6;
827 contr->levgrace[1] = 3;
828
829 contr->orig_stats = stats;
830 }
831 }
832
833 static void
834 start_info (object *op)
835 {
836 char buf[MAX_BUF];
837
838 sprintf (buf, "Welcome to Deliantra v%s!", VERSION);
839 new_draw_info (NDI_UNIQUE, 0, op, buf);
840 }
841
842 /* This function takes the key that is passed, and does the
843 * appropriate action with it (change race, or other things).
844 * The function name is for historical reasons - now we have
845 * separate race and class; this actually changes the RACE,
846 * not the class.
847 */
848 void
849 player::chargen_race_done ()
850 {
851 /* this must before then initial items are given */
852 esrv_new_player (ob->contr);
853
854 treasurelist *tl = treasurelist::find ("starting_wealth");
855 if (tl)
856 create_treasure (tl, ob, 0, 0, 0);
857
858 INVOKE_PLAYER (BIRTH, ob->contr);
859 INVOKE_PLAYER (LOGIN, ob->contr);
860
861 ob->contr->ns->state = ST_PLAYING;
862
863 if (ob->msg)
864 ob->msg = 0;
865
866 start_info (ob);
867 CLEAR_FLAG (ob, FLAG_WIZ);
868 give_initial_items (ob, ob->randomitems);
869 esrv_send_inventory (ob, ob);
870 ob->update_stats ();
871
872 /* This moves the player to a different start map, if there
873 * is one for this race
874 */
875 if (*first_map_ext_path)
876 ob->player_goto (format ("%s/%s", &first_map_ext_path, &ob->arch->archname), ob->x, ob->y);
877 else
878 LOG (llevDebug, "first_map_ext_path not set\n");
879 }
880
881 void
882 player::chargen_race_next ()
883 {
884 /* Following actually changes the race - this is the default command
885 * if we don't match with one of the options above.
886 */
887
888 do
889 {
890 shstr name = ob->name;
891 int x = ob->x, y = ob->y;
892
893 ob->remove_statbonus ();
894 ob->remove ();
895 ob->arch = get_player_archetype (ob->arch);
896 ob->arch->copy_to (ob);
897 ob->instantiate ();
898 ob->stats = ob->contr->orig_stats;
899 ob->name = ob->name_pl = name;
900 ob->x = x;
901 ob->y = y;
902 SET_ANIMATION (ob, 2); /* So player faces south */
903 insert_ob_in_map (ob, ob->map, ob, 0);
904 assign (ob->contr->title, ob->arch->object::name);
905 ob->add_statbonus ();
906 }
907 while (!allowed_class (ob));
908
909 update_object (ob, UP_OBJ_FACE);
910 esrv_update_item (UPD_FACE, ob, ob);
911 ob->update_stats ();
912 ob->stats.hp = ob->stats.maxhp;
913 ob->stats.sp = ob->stats.maxsp;
914 ob->stats.grace = 0;
915 }
916
917 void
918 flee_player (object *op)
919 {
920 int dir, diff;
921 rv_vector rv;
922
923 if (op->stats.hp < 0)
924 {
925 LOG (llevDebug, "Fleeing player is dead.\n");
926 CLEAR_FLAG (op, FLAG_SCARED);
927 return;
928 }
929
930 if (!op->enemy)
931 {
932 LOG (llevDebug, "Fleeing player had no enemy.\n");
933 CLEAR_FLAG (op, FLAG_SCARED);
934 return;
935 }
936
937 if (!(random_roll (0, 4, op, PREFER_LOW)) && did_make_save (op, op->level, 0))
938 {
939 op->enemy = NULL;
940 CLEAR_FLAG (op, FLAG_SCARED);
941 return;
942 }
943
944 get_rangevector (op, op->enemy, &rv, 0);
945
946 dir = absdir (4 + rv.direction);
947 for (diff = 0; diff < 3; diff++)
948 {
949 int m = 1 - rndm (2) * 2;
950
951 if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op)))
952 return;
953 }
954
955 /* Cornered, get rid of scared */
956 CLEAR_FLAG (op, FLAG_SCARED);
957 op->enemy = NULL;
958 }
959
960 /* check_pick sees if there is stuff to be picked up/picks up stuff.
961 * It returns 1 if the player should keep on moving, 0 if he should
962 * stop.
963 */
964 int
965 check_pick (object *op)
966 {
967 object *tmp, *next;
968 int stop = 0;
969 int wvratio;
970
971 /* if you're flying, you cna't pick up anything */
972 if (op->move_type & MOVE_FLYING)
973 return 1;
974
975 next = op->below;
976
977 int cnt = MAX_ITEM_PER_DROP;
978 #define CHK_PICK_PICKUP do { pick_up (op, tmp); cnt--; } while (0)
979
980 /* loop while there are items on the floor that are not marked as
981 * destroyed */
982 while (next && !next->destroyed ())
983 {
984 tmp = next;
985 next = tmp->below;
986
987 if (cnt <= 0)
988 {
989 op->failmsg ("Couldn't pickup all items at once.");
990 return 0;
991 }
992
993 if (op->destroyed ())
994 return 0;
995
996 if (!can_pick (op, tmp))
997 continue;
998
999 if (op->contr->search_str[0] != '\0' && settings.search_items == TRUE)
1000 {
1001 if (item_matched_string (op, tmp, op->contr->search_str))
1002 CHK_PICK_PICKUP;
1003
1004 continue;
1005 }
1006
1007 /* pickup handling */
1008 if (op->contr->mode & PU_DEBUG)
1009 {
1010 /* some debugging code to figure out item information */
1011 const char *str = tmp->name
1012 ? format ("item name: %s item type: %d weight/value: %d",
1013 &tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))))
1014 : format ("item name: %s item type: %d weight/value: %d",
1015 &tmp->arch->archname, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1016
1017 new_draw_info (NDI_UNIQUE, 0, op, str);
1018 }
1019
1020 if (op->contr->mode & PU_INHIBIT)
1021 return 1;
1022
1023 if (!(op->contr->mode & PU_ENABLE)) // TODO: fix client
1024 return 1;
1025
1026 /* philosophy:
1027 * It's easy to grab an item type from a pile, as long as it's
1028 * generic. This takes no game-time. For more detailed pickups
1029 * and selections, select-items should be used. This is a
1030 * grab-as-you-run type mode that's really useful for arrows for
1031 * example.
1032 * The drawback: right now it has no frontend, so you need to
1033 * stick the bits you want into a calculator in hex mode and then
1034 * convert to decimal and then 'pickup <#>
1035 */
1036
1037 /* the first two modes are exclusive: if NOTHING we return, if
1038 * STOP then we stop. All the rest are applied sequentially,
1039 * meaning if any test passes, the item gets picked up. */
1040
1041 /* if mode is set to pick nothing up, return */
1042 if (op->contr->mode == PU_NOTHING)
1043 return 1;
1044
1045 /* if mode is set to stop when encountering objects, return */
1046 /* take STOP before INHIBIT since it doesn't actually pick
1047 * anything up */
1048 if (op->contr->mode & PU_STOP)
1049 return 0;
1050
1051 /* useful for going into stores and not losing your settings... */
1052 /* and for battles wher you don't want to get loaded down while
1053 * fighting */
1054 if (op->contr->mode & PU_INHIBIT)
1055 return 1;
1056
1057 /* prevent us from turning into auto-thieves :) */
1058 if (QUERY_FLAG (tmp, FLAG_UNPAID))
1059 continue;
1060
1061 /* ignore known cursed objects */
1062 if (QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && op->contr->mode & PU_NOT_CURSED)
1063 continue;
1064
1065 /* all food and drink if desired */
1066 /* question: don't pick up known-poisonous stuff? */
1067 if (op->contr->mode & PU_FOOD)
1068 if (tmp->type == FOOD)
1069 {
1070 CHK_PICK_PICKUP;
1071 continue;
1072 }
1073
1074 if (op->contr->mode & PU_DRINK)
1075 if (tmp->type == DRINK || (tmp->type == POISON && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED)))
1076 {
1077 CHK_PICK_PICKUP;
1078 continue;
1079 }
1080
1081 if (op->contr->mode & PU_POTION)
1082 if (tmp->type == POTION)
1083 {
1084 CHK_PICK_PICKUP;
1085 continue;
1086 }
1087
1088 /* spellbooks, skillscrolls and normal books/scrolls */
1089 if (op->contr->mode & PU_SPELLBOOK)
1090 if (tmp->type == SPELLBOOK)
1091 {
1092 CHK_PICK_PICKUP;
1093 continue;
1094 }
1095
1096 if (op->contr->mode & PU_SKILLSCROLL)
1097 if (tmp->type == SKILLSCROLL)
1098 {
1099 CHK_PICK_PICKUP;
1100 continue;
1101 }
1102
1103 if (op->contr->mode & PU_READABLES)
1104 if (tmp->type == BOOK || tmp->type == SCROLL || tmp->type == INSCRIBABLE)
1105 {
1106 CHK_PICK_PICKUP;
1107 continue;
1108 }
1109
1110 /* wands/staves/rods/horns */
1111 if (op->contr->mode & PU_MAGIC_DEVICE)
1112 if (tmp->type == WAND || tmp->type == ROD || tmp->type == HORN)
1113 {
1114 CHK_PICK_PICKUP;
1115 continue;
1116 }
1117
1118 /* pick up all magical items */
1119 if (op->contr->mode & PU_MAGICAL)
1120 if (QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED))
1121 {
1122 CHK_PICK_PICKUP;
1123 continue;
1124 }
1125
1126 if (op->contr->mode & PU_VALUABLES)
1127 {
1128 if (tmp->type == MONEY || tmp->type == GEM)
1129 {
1130 CHK_PICK_PICKUP;
1131 continue;
1132 }
1133 }
1134
1135 /* rings & amulets - talismans seems to be typed AMULET */
1136 if (op->contr->mode & PU_JEWELS)
1137 if (tmp->type == RING || tmp->type == AMULET)
1138 {
1139 CHK_PICK_PICKUP;
1140 continue;
1141 }
1142
1143 /* we don't forget dragon food */
1144 if (op->contr->mode & PU_FLESH)
1145 if (tmp->type == FLESH)
1146 {
1147 CHK_PICK_PICKUP;
1148 continue;
1149 }
1150
1151 /* bows and arrows. Bows are good for selling! */
1152 if (op->contr->mode & PU_BOW)
1153 if (tmp->type == BOW)
1154 {
1155 CHK_PICK_PICKUP;
1156 continue;
1157 }
1158
1159 if (op->contr->mode & PU_ARROW)
1160 if (tmp->type == ARROW)
1161 {
1162 CHK_PICK_PICKUP;
1163 continue;
1164 }
1165
1166 /* all kinds of armor etc. */
1167 if (op->contr->mode & PU_ARMOUR)
1168 if (tmp->type == ARMOUR)
1169 {
1170 CHK_PICK_PICKUP;
1171 continue;
1172 }
1173
1174 if (op->contr->mode & PU_HELMET)
1175 if (tmp->type == HELMET)
1176 {
1177 CHK_PICK_PICKUP;
1178 continue;
1179 }
1180
1181 if (op->contr->mode & PU_SHIELD)
1182 if (tmp->type == SHIELD)
1183 {
1184 CHK_PICK_PICKUP;
1185 continue;
1186 }
1187
1188 if (op->contr->mode & PU_BOOTS)
1189 if (tmp->type == BOOTS)
1190 {
1191 CHK_PICK_PICKUP;
1192 continue;
1193 }
1194
1195 if (op->contr->mode & PU_GLOVES)
1196 if (tmp->type == GLOVES)
1197 {
1198 CHK_PICK_PICKUP;
1199 continue;
1200 }
1201
1202 if (op->contr->mode & PU_CLOAK)
1203 if (tmp->type == CLOAK)
1204 {
1205 CHK_PICK_PICKUP;
1206 continue;
1207 }
1208
1209 /* hoping to catch throwing daggers here */
1210 if (op->contr->mode & PU_MISSILEWEAPON)
1211 if (tmp->type == WEAPON && QUERY_FLAG (tmp, FLAG_IS_THROWN))
1212 {
1213 CHK_PICK_PICKUP;
1214 continue;
1215 }
1216
1217 /* careful: chairs and tables are weapons! */
1218 if (op->contr->mode & PU_ALLWEAPON)
1219 {
1220 if (tmp->type == WEAPON)
1221 if (!tmp->arch->archname.contains ("table") && !tmp->arch->archname.contains ("chair"))
1222 {
1223 CHK_PICK_PICKUP;
1224 continue;
1225 }
1226 }
1227
1228 /* misc stuff that's useful */
1229 if (op->contr->mode & PU_KEY)
1230 if (tmp->type == KEY || tmp->type == SPECIAL_KEY)
1231 {
1232 CHK_PICK_PICKUP;
1233 continue;
1234 }
1235
1236 /* any of the last 4 bits set means we use the ratio for value
1237 * pickups */
1238 if (op->contr->mode & PU_RATIO)
1239 {
1240 /* use value density to decide what else to grab */
1241 /* >=7 was >= op->contr->mode */
1242 /* >=7 is the old standard setting. Now we take the last 4 bits
1243 */
1244 wvratio = op->contr->mode & PU_RATIO;
1245 if (1000 * query_cost (tmp, op, F_TRUE) / tmp->total_weight () >= wvratio * 100)
1246 {
1247 #if 0
1248 fprintf (stderr, "HIGH WEIGHT/VALUE [");
1249 if (tmp->name != NULL)
1250 {
1251 fprintf (stderr, "%s", tmp->name);
1252 }
1253 else
1254 fprintf (stderr, "%s", tmp->arch->archname);
1255 fprintf (stderr, ",%d] = ", tmp->type);
1256 fprintf (stderr, "%d\n", (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1257 #endif
1258 CHK_PICK_PICKUP;
1259 continue;
1260 }
1261 } /* the new pickup model */
1262 }
1263
1264 return !stop;
1265 }
1266
1267 /*
1268 * Find an arrow in the inventory and after that
1269 * in the right type container (quiver). Pointer to the
1270 * found object is returned.
1271 */
1272 object *
1273 find_arrow (object *op, const char *type)
1274 {
1275 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1276 if (tmp->type == ARROW && !strcmp (&tmp->race, type))
1277 return splay (tmp);
1278
1279 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1280 if (tmp->type == CONTAINER && QUERY_FLAG (tmp, FLAG_APPLIED) && !strcmp (&tmp->race, type))
1281 if (object *arrow = find_arrow (tmp, type))
1282 {
1283 splay (tmp);
1284 return arrow;
1285 }
1286
1287 return 0;
1288 }
1289
1290 /*
1291 * Similar to find_arrow, but looks for (roughly) the best arrow to use
1292 * against the target. A full test is not performed, simply a basic test
1293 * of resistances. The archer is making a quick guess at what he sees down
1294 * the hall. Failing that it does it's best to pick the highest plus arrow.
1295 */
1296 object *
1297 find_better_arrow (object *op, object *target, shstr_cmp type, int *better)
1298 {
1299 object *tmp = NULL, *arrow, *ntmp;
1300 int attacknum, attacktype, betterby = 0, i;
1301
1302 if (!type)
1303 return NULL;
1304
1305 for (arrow = op->inv; arrow; arrow = arrow->below)
1306 {
1307 if (arrow->type == CONTAINER && arrow->race == type && QUERY_FLAG (arrow, FLAG_APPLIED))
1308 {
1309 i = 0;
1310 ntmp = find_better_arrow (arrow, target, type, &i);
1311
1312 if (i > betterby)
1313 {
1314 tmp = ntmp;
1315 betterby = i;
1316 }
1317 }
1318 else if (arrow->type == ARROW && arrow->race == type)
1319 {
1320 /* allways prefer assasination/slaying */
1321 if (target->race && arrow->slaying.contains (target->race))
1322 {
1323 if (arrow->attacktype & AT_DEATH)
1324 {
1325 *better = 100;
1326 return arrow;
1327 }
1328 else
1329 {
1330 tmp = arrow;
1331 betterby = (arrow->magic + arrow->stats.dam) * 2;
1332 }
1333 }
1334 else
1335 {
1336 for (attacknum = 0; attacknum < NROFATTACKS; attacknum++)
1337 {
1338 attacktype = 1 << attacknum;
1339 if ((arrow->attacktype & attacktype) && (target->arch->resist[attacknum]) < 0)
1340 if (((arrow->magic + arrow->stats.dam) * (100 - target->arch->resist[attacknum]) / 100) > betterby)
1341 {
1342 tmp = arrow;
1343 betterby = (arrow->magic + arrow->stats.dam) * (100 - target->arch->resist[attacknum]) / 100;
1344 }
1345 }
1346
1347 if ((2 + arrow->magic + arrow->stats.dam) > betterby)
1348 {
1349 tmp = arrow;
1350 betterby = 2 + arrow->magic + arrow->stats.dam;
1351 }
1352
1353 if (arrow->title && (1 + arrow->magic + arrow->stats.dam) > betterby)
1354 {
1355 tmp = arrow;
1356 betterby = 1 + arrow->magic + arrow->stats.dam;
1357 }
1358 }
1359 }
1360 }
1361
1362 if (tmp == NULL && arrow == NULL)
1363 return find_arrow (op, type);
1364
1365 *better = betterby;
1366 return tmp;
1367 }
1368
1369 /* looks in a given direction, finds the first valid target, and calls
1370 * find_better_arrow to find a decent arrow to use.
1371 * op = the shooter
1372 * type = bow->race
1373 * dir = fire direction
1374 */
1375 object *
1376 pick_arrow_target (object *op, shstr_cmp type, int dir)
1377 {
1378 object *tmp = NULL;
1379 maptile *m;
1380 int i, mflags, found, number;
1381 sint16 x, y;
1382
1383 if (op->map == NULL)
1384 return find_arrow (op, type);
1385
1386 /* do a dex check */
1387 number = (die_roll (2, 40, op, PREFER_LOW) - 2) / 2;
1388 if (number > (op->stats.Dex + (op->chosen_skill ? op->chosen_skill->level : op->level)))
1389 return find_arrow (op, type);
1390
1391 m = op->map;
1392 x = op->x;
1393 y = op->y;
1394
1395 /* find the first target */
1396 for (i = 0, found = 0; i < 20; i++)
1397 {
1398 x += freearr_x[dir];
1399 y += freearr_y[dir];
1400 mflags = get_map_flags (m, &m, x, y, &x, &y);
1401
1402 if (mflags & P_OUT_OF_MAP || mflags & P_BLOCKSVIEW)
1403 {
1404 tmp = 0;
1405 break;
1406 }
1407 else if (GET_MAP_MOVE_BLOCK (m, x, y) == MOVE_FLY_LOW)
1408 {
1409 /* This block presumes arrows and the like are MOVE_FLY_SLOW -
1410 * perhaps a bad assumption.
1411 */
1412 tmp = 0;
1413 break;
1414 }
1415
1416 if (mflags & P_IS_ALIVE)
1417 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
1418 if (QUERY_FLAG (tmp, FLAG_ALIVE))
1419 break;
1420 }
1421
1422 if (!tmp)
1423 return find_arrow (op, type);
1424
1425 if (tmp->head)
1426 tmp = tmp->head;
1427
1428 return find_better_arrow (op, tmp, type, &i);
1429 }
1430
1431 /*
1432 * Creature fires a bow - op can be monster or player. Returns
1433 * 1 if bow was actually fired, 0 otherwise.
1434 * op is the object firing the bow.
1435 * part is for multipart creatures - the part firing the bow.
1436 * dir is the direction of fire.
1437 * wc_mod is any special modifier to give (used in special player fire modes)
1438 * sx, sy are coordinates to fire arrow from - also used in some of the special
1439 * player fire modes.
1440 */
1441 int
1442 fire_bow (object *op, object *part, object *arrow, int dir, int wc_mod, sint16 sx, sint16 sy)
1443 {
1444 object *left, *bow;
1445 int mflags;
1446 maptile *m;
1447
1448 if (!dir)
1449 {
1450 new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");
1451 return 0;
1452 }
1453
1454 if (op->contr)
1455 bow = op->current_weapon;
1456 else
1457 {
1458 for (bow = op->inv; bow; bow = bow->below)
1459 /* Don't check for applied - monsters don't apply bows - in that way, they
1460 * don't need to switch back and forth between bows and weapons.
1461 */
1462 if (bow->type == BOW)
1463 break;
1464
1465 if (!bow)
1466 {
1467 LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);
1468 return 0;
1469 }
1470
1471 // optimisation: move object to top so we will find it quickly again
1472 splay (bow);
1473 }
1474
1475 if (!bow->race || !bow->skill)
1476 {
1477 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name);
1478 return 0;
1479 }
1480
1481 if (arrow == NULL)
1482 {
1483 if ((arrow = find_arrow (op, bow->race)) == NULL)
1484 {
1485 if (op->type == PLAYER)
1486 new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);
1487 /* FLAG_READY_BOW will get reset if the monsters picks up some arrows */
1488 else
1489 CLEAR_FLAG (op, FLAG_READY_BOW);
1490
1491 return 0;
1492 }
1493 }
1494
1495 mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);
1496 if (mflags & P_OUT_OF_MAP)
1497 return 0;
1498
1499 if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)
1500 {
1501 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1502 return 0;
1503 }
1504
1505 /* this should not happen, but sometimes does */
1506 if (arrow->nrof == 0)
1507 {
1508 LOG (llevError | logBacktrace, "arrow (%s) has nrof 0\n", arrow->debug_desc ());
1509 arrow->destroy ();
1510 return 0;
1511 }
1512
1513 left = arrow; /* these are arrows left to the player */
1514 arrow = arrow->split ();
1515 if (!arrow)
1516 {
1517 new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);
1518 return 0;
1519 }
1520
1521 arrow->set_owner (op);
1522 arrow->skill = bow->skill;
1523 arrow->direction = dir;
1524
1525 arrow->stats.sp = arrow->stats.wc; /* save original wc, dam, attacktype and slaying */
1526 arrow->stats.hp = arrow->stats.dam;
1527 arrow->stats.grace = arrow->attacktype;
1528 arrow->custom_name = arrow->slaying;
1529
1530 #if 0
1531 if (player *pl = op->contr)
1532 {
1533 float speed = pl->weapon_sp;
1534
1535 /* penalize ROF for bestarrow */
1536 if (pl->bowtype == bow_bestarrow)
1537 speed *= .9f;
1538 else
1539 speed *= 1.f + dex_bonus[op->stats.Dex] * .2f;
1540
1541 op->speed_left += speed - op->speed;
1542 }
1543 #endif
1544
1545 SET_ANIMATION (arrow, arrow->direction);
1546
1547 /* update the speed */
1548 arrow->speed = ((bow->flag [FLAG_NO_STRENGTH] ? 0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.f
1549 + bow->stats.dam / 7.f;
1550
1551 arrow->set_speed (max (arrow->speed, 2.f));
1552 arrow->speed_left = 0;
1553
1554 int wc = op->stats.wc + wc_mod - arrow->magic - arrow->stats.wc;
1555
1556 if (op->type == PLAYER)
1557 {
1558 arrow->level = op->chosen_skill ? op->chosen_skill->level : op->level;
1559 wc -= dex_bonus[op->stats.Dex];
1560
1561 if (!arrow->slaying)
1562 arrow->slaying = op->slaying;
1563
1564 arrow->attacktype |= op->attacktype;
1565 }
1566 else
1567 {
1568 arrow->level = op->level;
1569 arrow->stats.wc -= bow->magic;
1570
1571 if (!arrow->slaying)
1572 arrow->slaying = bow->slaying;
1573
1574 arrow->attacktype |= bow->attacktype;
1575 }
1576
1577 wc -= arrow->level;
1578 arrow->stats.dam = clamp (arrow->stats.dam + op->stats.dam + arrow->magic, MIN_DAM, MAX_DAM);
1579
1580 arrow->stats.wc = clamp (wc, MIN_WC, MAX_WC);
1581 arrow->move_type = MOVE_FLY_LOW;
1582 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
1583
1584 op->play_sound (sound_find ("fire_arrow"));
1585 m->insert (arrow, sx, sy, op);
1586
1587 if (!arrow->destroyed ())
1588 move_arrow (arrow);
1589
1590 return 1;
1591 }
1592
1593 /* Special fire code for players - this takes into
1594 * account the special fire modes players can have
1595 * but monsters can't. Putting that code here
1596 * makes the fire_bow code much cleaner.
1597 * this function should only be called if 'op' is a player,
1598 * hence the function name.
1599 */
1600 int
1601 player_fire_bow (object *op, int dir)
1602 {
1603 int ret;
1604
1605 if (op->contr->bowtype == bow_bestarrow)
1606 {
1607 ret = fire_bow (op, op, pick_arrow_target (op, op->contr->ranged_ob->race, dir), dir, 0, op->x, op->y);
1608 }
1609 else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw)
1610 {
1611 int wcmod = similar_direction (dir, op->contr->bowtype - bow_n + 1) ? 0 : -1;
1612 ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y);
1613 }
1614 else if (op->contr->bowtype == bow_threewide)
1615 {
1616 ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);
1617 ret |= fire_bow (op, op, NULL, dir, -5, op->x + freearr_x[absdir (dir + 2)], op->y + freearr_y[absdir (dir + 2)]);
1618 ret |= fire_bow (op, op, NULL, dir, -5, op->x + freearr_x[absdir (dir - 2)], op->y + freearr_y[absdir (dir - 2)]);
1619 }
1620 else if (op->contr->bowtype == bow_spreadshot)
1621 {
1622 ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);
1623 ret |= fire_bow (op, op, NULL, absdir (dir - 1), -5, op->x, op->y);
1624 ret |= fire_bow (op, op, NULL, absdir (dir + 1), -5, op->x, op->y);
1625 }
1626 else
1627 {
1628 /* Simple case */
1629 ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);
1630 }
1631
1632 return ret;
1633 }
1634
1635 /* Fires a misc (wand/rod/horn) object in 'dir'.
1636 * Broken apart from 'fire' to keep it more readable.
1637 */
1638 void
1639 fire_misc_object (object *op, int dir)
1640 {
1641 object *item = op->contr->ranged_ob;
1642
1643 if (!item)
1644 {
1645 new_draw_info (NDI_UNIQUE, 0, op, "You have range item readied.");
1646 return;
1647 }
1648
1649 if (!item->inv)
1650 {
1651 LOG (llevError, "Object %s lacks a spell\n", &item->name);
1652 return;
1653 }
1654
1655 if (!op->change_weapon (item))
1656 return;
1657
1658 if (item->type == WAND)
1659 {
1660 if (item->stats.food <= 0)
1661 {
1662 op->contr->play_sound (sound_find ("wand_poof"));
1663 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s goes poof.", query_base_name (item, 0));
1664
1665 return;
1666 }
1667 }
1668 else if (item->type == ROD || item->type == HORN)
1669 {
1670 sint16 spell_sp = MAX (item->inv->stats.sp, item->inv->stats.grace);
1671
1672 // using the maximum of the rods charge allows at least one spell cast
1673 // for a rod or horn, this fixes some broken rods.
1674 if (item->stats.hp < MIN (spell_sp, item->stats.maxhp))
1675 {
1676 op->contr->play_sound (sound_find ("wand_poof"));
1677
1678 if (item->type == ROD)
1679 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s whines for a while, but nothing happens.", query_base_name (item, 0));
1680 else
1681 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s needs more time to charge.", query_base_name (item, 0));
1682
1683 return;
1684 }
1685 }
1686
1687 if (cast_spell (op, item, dir, item->inv, NULL))
1688 {
1689 item->flag [FLAG_BEEN_APPLIED] = true; /* You now know something about it */
1690
1691 if (item->type == WAND)
1692 {
1693 if (!(--item->stats.food))
1694 {
1695 object *tmp;
1696
1697 if (item->arch)
1698 {
1699 CLEAR_FLAG (item, FLAG_ANIMATE);
1700 item->face = item->arch->face;
1701 item->set_speed (0);
1702 }
1703
1704 if (object *pl = item->visible_to ())
1705 esrv_update_item (UPD_ANIM, pl, item);
1706 }
1707 }
1708 else if (item->type == ROD || item->type == HORN)
1709 drain_rod_charge (item);
1710 }
1711 }
1712
1713 /* Received a fire command for the player - go and do it.
1714 */
1715 bool
1716 fire (object *op, int dir)
1717 {
1718 int spellcost = 0;
1719
1720 player *pl = op->contr;
1721
1722 if (pl->golem)
1723 {
1724 control_golem (op->contr->golem, dir);
1725 return false;
1726 }
1727
1728 object *ob = pl->ranged_ob;
1729
1730 if (!ob)
1731 return false;
1732
1733 if (op->speed_left > 0.f)
1734 --op->speed_left;
1735 else
1736 return false;
1737
1738 if (!op->change_weapon (ob))
1739 return false;
1740
1741 /* check for loss of invisiblity/hide */
1742 if (action_makes_visible (op))
1743 make_visible (op);
1744
1745 switch (ob->type)
1746 {
1747 case BOW:
1748 player_fire_bow (op, dir);
1749 break;
1750
1751 case SPELL:
1752 spellcost = cast_spell (op, op, dir, ob, *pl->spellparam ? pl->spellparam : 0);
1753 break;
1754
1755 case BUILDER:
1756 apply_map_builder (op, dir);
1757 break;
1758
1759 case SKILL:
1760 do_skill (op, op, ob, dir, 0);
1761 break;
1762
1763 default:
1764 fire_misc_object (op, dir);
1765 break;
1766 }
1767
1768 return true;
1769 }
1770
1771 /* find_key
1772 * We try to find a key for the door as passed. If we find a key
1773 * and successfully use it, we return the key, otherwise NULL
1774 * This function merges both normal and locked door, since the logic
1775 * for both is the same - just the specific key is different.
1776 * pl is the player,
1777 * inv is the objects inventory to searched
1778 * door is the door we are trying to match against.
1779 * This function can be called recursively to search containers.
1780 */
1781 object *
1782 find_key (object *pl, object *container, object *door)
1783 {
1784 object *tmp, *key;
1785
1786 /* Should not happen, but sanity checking is never bad */
1787 if (!container->inv)
1788 return 0;
1789
1790 /* First, lets try to find a key in the top level inventory */
1791 for (tmp = container->inv; tmp; tmp = tmp->below)
1792 {
1793 if (door->type == DOOR && tmp->type == KEY)
1794 break;
1795
1796 /* For sanity, we should really check door type, but other stuff
1797 * (like containers) can be locked with special keys
1798 */
1799 if (tmp->slaying && tmp->type == SPECIAL_KEY && tmp->slaying == door->slaying)
1800 break;
1801 }
1802
1803 /* No key found - lets search inventories now */
1804 /* If we find and use a key in an inventory, return at that time.
1805 * otherwise, if we search all the inventories and still don't find
1806 * a key, return
1807 */
1808 if (!tmp)
1809 {
1810 for (tmp = container->inv; tmp; tmp = tmp->below)
1811 /* No reason to search empty containers */
1812 if (tmp->type == CONTAINER && tmp->inv)
1813 if ((key = find_key (pl, tmp, door)))
1814 return key;
1815
1816 if (!tmp)
1817 return 0;
1818 }
1819
1820 /* We get down here if we have found a key. Now if its in a container,
1821 * see if we actually want to use it
1822 */
1823 if (pl != container)
1824 {
1825 /* Only let players use keys in containers */
1826 if (!pl->contr)
1827 return 0;
1828
1829 /* cases where this fails:
1830 * If we only search the player inventory, return now since we
1831 * are not in the players inventory.
1832 * If the container is not active, return now since only active
1833 * containers can be used.
1834 * If we only search keyrings and the container does not have
1835 * a race/isn't a keyring.
1836 * No checking for all containers - to fall through past here,
1837 * inv must have been an container and must have been active.
1838 *
1839 * Change the color so that the message doesn't disappear with
1840 * all the others.
1841 */
1842 if (pl->contr->usekeys == key_inventory ||
1843 !QUERY_FLAG (container, FLAG_APPLIED) ||
1844 (pl->contr->usekeys == keyrings && container->race != shstr_keys))
1845 {
1846 new_draw_info_format (NDI_UNIQUE | NDI_BROWN, 0, pl,
1847 "The %s in your %s vibrates as you approach the door", query_name (tmp), query_name (container));
1848 return NULL;
1849 }
1850 }
1851
1852 return tmp;
1853 }
1854
1855 /* moved door processing out of move_player_attack.
1856 * returns 1 if player has opened the door with a key
1857 * such that the caller should not do anything more,
1858 * 0 otherwise
1859 */
1860 static int
1861 player_attack_door (object *op, object *door)
1862 {
1863 /* If its a door, try to find a key. If we do destroy the door,
1864 * might as well return immediately as there is nothing more to do -
1865 * otherwise, we fall through to the rest of the code.
1866 */
1867 object *key = find_key (op, op, door);
1868
1869 /* If we found a key, do some extra work */
1870 if (key)
1871 {
1872 object *container = key->env;
1873
1874 if (action_makes_visible (op))
1875 make_visible (op);
1876
1877 if (door->inv && (door->inv->type == RUNE || door->inv->type == TRAP))
1878 spring_trap (door->inv, op);
1879
1880 if (door->type == DOOR)
1881 hit_player (door, 9998, op, AT_PHYSICAL, 1); /* Break through the door */
1882 else if (door->type == LOCKED_DOOR)
1883 {
1884 op->statusmsg (format ("You open the door with the %s", query_short_name (key)), NDI_BROWN);
1885 remove_door2 (door); /* remove door without violence ;-) */
1886 }
1887
1888 /* Do this after we print the message */
1889 key->decrease (); /* Use up one of the keys */
1890
1891 return 1; /* Nothing more to do below */
1892 }
1893 else if (door->type == LOCKED_DOOR)
1894 {
1895 /* Might as well return now - no other way to open this */
1896 op->failmsg (door->msg ? &door->msg : "Hmm, you miss the certain something to open this door...");
1897 return 1;
1898 }
1899
1900 return 0;
1901 }
1902
1903 /* This function is just part of a breakup from move_player.
1904 * It should keep the code cleaner.
1905 * When this is called, the players direction has been updated
1906 * (taking into account confusion.) The player is also actually
1907 * going to try and move (not fire weapons).
1908 */
1909 bool
1910 move_player_attack (object *op, int dir)
1911 {
1912 if (!op->contr->braced && op->speed_left > 0.f && move_ob (op, dir, op))
1913 {
1914 --op->speed_left;
1915 return true;
1916 }
1917
1918 int on_battleground;
1919
1920 sint16 nx = freearr_x[dir] + op->x;
1921 sint16 ny = freearr_y[dir] + op->y;
1922
1923 on_battleground = op_on_battleground (op, 0, 0);
1924
1925 if (out_of_map (op->map, nx, ny))
1926 return false;
1927
1928 /* If braced, or can't move to the square, and it is not out of the
1929 * map, attack it. Note order of if statement is important - don't
1930 * want to be calling move_ob if braced, because move_ob will move the
1931 * player. This is a pretty nasty hack, because if we could
1932 * move to some space, it then means that if we are braced, we should
1933 * do nothing at all. As it is, if we are braced, we go through
1934 * quite a bit of processing. However, it probably is less than what
1935 * move_ob uses.
1936 */
1937 maptile *m = op->map->xy_find (nx, ny);
1938
1939 /* Go through all the objects, and find ones of interest. Only stop if
1940 * we find a monster - that is something we know we want to attack.
1941 * if its a door or barrel (can roll) see if there may be monsters
1942 * on the space
1943 */
1944 object *mon;
1945 for (mon = m->at (nx, ny).bot; mon; mon = mon->above)
1946 {
1947 if ((mon->flag [FLAG_ALIVE]
1948 || mon->type == LOCKED_DOOR
1949 || mon->flag [FLAG_CAN_ROLL])
1950 && mon != op)
1951 break;
1952 }
1953
1954 if (!mon) /* This happens anytime the player tries to move */
1955 return false; /* into a wall */
1956
1957 mon = mon->head_ ();
1958
1959 if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))
1960 if (op->contr->weapon_sp_left > 0.f)
1961 if (player_attack_door (op, mon))
1962 {
1963 --op->contr->weapon_sp_left;
1964 return true;
1965 }
1966
1967 /* The following deals with possibly attacking peaceful
1968 * or friendly creatures. Basically, all players are considered
1969 * unaggressive. If the moving player has peaceful set, then the
1970 * object should be pushed instead of attacked. It is assumed that
1971 * if you are braced, you will not attack friends accidently,
1972 * and thus will not push them.
1973 */
1974
1975 /* If the creature is a pet, push it even if the player is not
1976 * peaceful. Our assumption is the creature is a pet if the
1977 * player owns it and it is either friendly or unagressive.
1978 */
1979 if (op->type == PLAYER
1980 && ((mon->owner && mon->owner->contr
1981 && same_party (mon->owner->contr->party, op->contr->party))
1982 || mon->owner == op)
1983 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))
1984 {
1985 /* If we're braced, we don't want to switch places with it */
1986 if (op->contr->braced)
1987 return false;
1988
1989 if (op->speed_left > 0.f)
1990 {
1991 --op->speed_left;
1992
1993 op->play_sound (sound_find ("push_player"));
1994 push_ob (mon, dir, op);
1995
1996 if (action_makes_visible (op))
1997 make_visible (op);
1998
1999 return true;
2000 }
2001 else
2002 return false;
2003 }
2004
2005 /* in certain circumstances, you shouldn't attack friendly
2006 * creatures. Note that if you are braced, you can't push
2007 * someone, but put it inside this loop so that you won't
2008 * attack them either.
2009 */
2010 if ((mon->type == PLAYER || mon->enemy != op)
2011 && (mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY))
2012 && ((op->contr->peaceful
2013 || (mon->type == PLAYER && mon->contr->peaceful))
2014 && !on_battleground))
2015 {
2016 if (op->speed_left > 0.f)
2017 {
2018 --op->speed_left;
2019
2020 if (!op->contr->braced)
2021 {
2022 op->play_sound (sound_find ("push_player"));
2023 push_ob (mon, dir, op);
2024 }
2025 else
2026 op->statusmsg ("You withhold your attack");
2027
2028 if (op->contr->tmp_invis || op->flag [FLAG_HIDDEN])
2029 make_visible (op);
2030
2031 return true;
2032 }
2033 }
2034 /* If the object is a boulder or other rollable object, then
2035 * roll it if not braced. You can't roll it if you are braced.
2036 */
2037 else if (QUERY_FLAG (mon, FLAG_CAN_ROLL) && (!op->contr->braced))
2038 {
2039 if (op->speed_left > 0.f)
2040 {
2041 --op->speed_left;
2042
2043 recursive_roll (mon, dir, op);
2044 if (action_makes_visible (op))
2045 make_visible (op);
2046
2047 return true;
2048 }
2049 }
2050 /* Any generic living creature. Including things like doors.
2051 * Way it works is like this: First, it must have some hit points
2052 * and be living. Then, it must be one of the following:
2053 * 1) Not a player, 2) A player, but of a different party. Note
2054 * that party_number -1 is no party, so attacks can still happen.
2055 */
2056 else if ((mon->stats.hp >= 0) && QUERY_FLAG (mon, FLAG_ALIVE) &&
2057 ((mon->type != PLAYER || op->contr->party == NULL || op->contr->party != mon->contr->party)))
2058 {
2059 if (op->contr->weapon_sp_left > 0.f && !op->flag [FLAG_WIZPASS])
2060 {
2061 --op->contr->weapon_sp_left;
2062
2063 skill_attack (mon, op, 0, 0, 0);
2064
2065 if (action_makes_visible (op))
2066 make_visible (op);
2067
2068 return true;
2069 }
2070 }
2071
2072 return false;
2073 }
2074
2075 bool
2076 move_player (object *op, int dir)
2077 {
2078 int pick;
2079
2080 if (!op->map || op->map->in_memory != MAP_ACTIVE)
2081 return 0;
2082
2083 /* Sanity check: make sure dir is valid */
2084 if ((dir < 0) || (dir >= 9))
2085 {
2086 LOG (llevError, "move_player: invalid direction %d\n", dir);
2087 return 0;
2088 }
2089
2090 /* peterm: added following line */
2091 if (QUERY_FLAG (op, FLAG_CONFUSED) && dir)
2092 dir = absdir (dir + rndm (3) + rndm (3) - 2);
2093
2094 op->facing = dir;
2095
2096 if (op->flag [FLAG_HIDDEN])
2097 do_hidden_move (op);
2098
2099 bool retval;
2100
2101 if (INVOKE_PLAYER (MOVE, op->contr, ARG_INT (dir)))
2102 retval = RESULT_INT (0);
2103 else if (op->contr->fire_on)
2104 retval = fire (op, dir);
2105 else
2106 {
2107 retval = move_player_attack (op, dir);
2108 pick = check_pick (op);
2109 }
2110
2111 /* Add special check for newcs players and fire on - this way, the
2112 * server can handle repeat firing.
2113 */
2114 if (op->contr->fire_on || (op->contr->run_on && pick != 0))
2115 op->direction = dir;
2116 else
2117 op->direction = 0;
2118
2119 /* Update how the player looks. Use the facing, so direction may
2120 * get reset to zero. This allows for full animation capabilities
2121 * for players.
2122 */
2123 animate_object (op, op->facing);
2124
2125 return retval;
2126 }
2127
2128 /* This is similar to handle_player, below, but is only used by the
2129 * new client/server stuff.
2130 * This is sort of special, in that the new client/server actually uses
2131 * the new speed values for commands.
2132 *
2133 * Returns true if there are more actions we can do. Should not do
2134 * many actions in a row, as that would be too unfair to other
2135 * players.
2136 */
2137 bool
2138 handle_newcs_player (object *op)
2139 {
2140 if (QUERY_FLAG (op, FLAG_SCARED))
2141 {
2142 if (op->speed_left > 0.f)
2143 {
2144 --op->speed_left;
2145 flee_player (op);
2146
2147 return true;
2148 }
2149 else
2150 return false;
2151 }
2152
2153 /* call this here - we also will call this in do_ericserver, but
2154 * the players time has been increased when doericserver has been
2155 * called, so we recheck it here.
2156 */
2157 if (op->contr->ns->handle_command ())
2158 return true;
2159
2160 if (op->direction && (op->contr->run_on || op->contr->fire_on))
2161 return move_player (op, op->direction);
2162
2163 return false;
2164 }
2165
2166 int
2167 save_life (object *op)
2168 {
2169 if (!QUERY_FLAG (op, FLAG_LIFESAVE))
2170 return 0;
2171
2172 for (object *tmp = op->inv; tmp; tmp = tmp->below)
2173 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE))
2174 {
2175 op->play_sound (sound_find ("ob_evaporate"));
2176 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp));
2177
2178 tmp->destroy ();
2179 CLEAR_FLAG (op, FLAG_LIFESAVE);
2180
2181 if (op->stats.hp < 0)
2182 op->stats.hp = op->stats.maxhp;
2183
2184 if (op->stats.food < 0)
2185 op->stats.food = 999;
2186
2187 op->update_stats ();
2188 return 1;
2189 }
2190
2191 LOG (llevError, "Error: LIFESAVE set without applied object.\n");
2192 CLEAR_FLAG (op, FLAG_LIFESAVE);
2193 enter_player_savebed (op); /* bring him home. */
2194 return 0;
2195 }
2196
2197 /* This goes throws the inventory and removes unpaid objects, and puts them
2198 * back in the map (location and map determined by values of env). This
2199 * function will descend into containers. op is the object to start the search
2200 * from.
2201 */
2202 static void
2203 drop_unpaid_items (object *op, object *env)
2204 {
2205 while (op)
2206 {
2207 object *next = op->below; /* Make sure we have a good value, in case we remove object 'op' */
2208
2209 if (QUERY_FLAG (op, FLAG_UNPAID))
2210 op->insert_at (env);
2211 else if (op->inv)
2212 drop_unpaid_items (op->inv, env);
2213
2214 op = next;
2215 }
2216 }
2217
2218 void
2219 object::drop_unpaid_items ()
2220 {
2221 if (!flag [FLAG_REMOVED])
2222 ::drop_unpaid_items (inv, this);
2223 }
2224
2225 /*
2226 * Returns pointer a static string containing gravestone text
2227 * Moved from apply.c to player.c - player.c is what
2228 * actually uses this function. player.c may not be quite the
2229 * best, a misc file for object actions is probably better,
2230 * but there isn't one in the server directory.
2231 */
2232 const char *
2233 gravestone_text (object *op)
2234 {
2235 static dynbuf_text buf;
2236
2237 buf << "---- R.I.P. ----\n\n"
2238 << op->name;
2239
2240 if (op->type == PLAYER)
2241 buf << " the " << op->contr->title;
2242
2243 buf << "\n\n";
2244
2245 buf << "who was level ";
2246 buf << (sint32)op->level << "\n\n" // OO breakdown
2247 << " when " << (op->contr ? "killed" : "died") << "\n\n";
2248
2249 if (op->type == PLAYER)
2250 buf << "by " << op->contr->killer_name () << ".\n\n";
2251
2252 {
2253 static char buf2[128];
2254 time_t now = time (NULL);
2255 strftime (buf2, 128, "%b %d %Y\n\n", localtime (&now));
2256 buf << buf2;
2257 }
2258
2259 return buf;
2260 }
2261
2262 void
2263 do_some_living (object *op)
2264 {
2265 int last_food = op->stats.food;
2266 int gen_hp, gen_sp, gen_grace;
2267 int over_hp, over_sp, over_grace;
2268 int i;
2269 int rate_hp = 1200;
2270 int rate_sp = 2500;
2271 int rate_grace = 2000;
2272 const int max_hp = 1;
2273 const int max_sp = 1;
2274 const int max_grace = 1;
2275
2276 if (op->contr->hidden)
2277 {
2278 op->invisible = 1000;
2279 /* the socket code flashes the player visible/invisible
2280 * depending on the value of invisible, so we need to
2281 * alternate it here for it to work correctly.
2282 */
2283 if (pticks & 2)
2284 op->invisible--;
2285 }
2286 else if (op->invisible && !(QUERY_FLAG (op, FLAG_MAKE_INVIS)))
2287 {
2288 if (!op->invisible--)
2289 {
2290 make_visible (op);
2291 new_draw_info (NDI_UNIQUE, 0, op, "Your invisibility spell runs out.");
2292 }
2293 }
2294
2295 if (op->contr->ns->state == ST_PLAYING)
2296 {
2297 /* these next three if clauses make it possible to SLOW DOWN
2298 hp/grace/spellpoint regeneration. */
2299 if (op->contr->gen_hp >= 0)
2300 gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;
2301 else
2302 {
2303 gen_hp = op->stats.maxhp;
2304 rate_hp -= rate_hp / 2 * op->contr->gen_hp;
2305 }
2306
2307 if (op->contr->gen_sp >= 0)
2308 gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;
2309 else
2310 {
2311 gen_sp = op->stats.maxsp;
2312 rate_sp -= rate_sp / 2 * op->contr->gen_sp;
2313 }
2314
2315 if (op->contr->gen_grace >= 0)
2316 gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;
2317 else
2318 {
2319 gen_grace = op->stats.maxgrace;
2320 rate_grace -= rate_grace / 2 * op->contr->gen_grace;
2321 }
2322
2323 /* Regenerate Grace */
2324 /* I altered this a little - maximum grace is ony achieved through prayer -b.t. */
2325 if (--op->last_grace < 0)
2326 {
2327 if (op->stats.grace < op->stats.maxgrace / 2)
2328 op->stats.grace++; /* no penalty in food for regaining grace */
2329
2330 if (max_grace > 1)
2331 {
2332 over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;
2333 if (over_grace > 0)
2334 {
2335 op->stats.sp += over_grace
2336 + (random_roll (0, rate_grace - 1, op, PREFER_HIGH) > ((gen_grace < 20 ? 30 : gen_grace + 10) % rate_grace)) ? -1 : 0;
2337 op->last_grace = 0;
2338 }
2339 else
2340 {
2341 op->last_grace = rate_grace / (gen_grace < 20 ? 30 : gen_grace + 10);
2342 }
2343 }
2344 else
2345 {
2346 op->last_grace = rate_grace / (gen_grace < 20 ? 30 : gen_grace + 10);
2347 }
2348 /* wearing stuff doesn't detract from grace generation. */
2349 }
2350
2351 if (op->stats.food > 0)
2352 {
2353 /* Regenerate Spell Points */
2354 if (!op->contr->golem && --op->last_sp < 0)
2355 {
2356 gen_sp = gen_sp * 10 / (op->contr->gen_sp_armour < 10 ? 10 : op->contr->gen_sp_armour);
2357
2358 if (op->stats.sp < op->stats.maxsp)
2359 {
2360 op->stats.sp++;
2361
2362 /* dms do not consume food */
2363 if (!QUERY_FLAG (op, FLAG_WIZ))
2364 {
2365 op->stats.food--;
2366
2367 if (op->contr->digestion < 0)
2368 op->stats.food += op->contr->digestion;
2369 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2370 op->stats.food = last_food;
2371 }
2372 }
2373
2374 if (max_sp > 1)
2375 {
2376 over_sp = (gen_sp + 10) / rate_sp;
2377 if (over_sp > 0)
2378 {
2379 if (op->stats.sp < op->stats.maxsp)
2380 {
2381 op->stats.sp += over_sp > max_sp ? max_sp : over_sp;
2382
2383 if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp))
2384 op->stats.sp--;
2385
2386 if (op->stats.sp > op->stats.maxsp)
2387 op->stats.sp = op->stats.maxsp;
2388 }
2389
2390 op->last_sp = 0;
2391 }
2392 else
2393 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2394 }
2395 else
2396 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2397 }
2398
2399 /* Regenerate Hit Points */
2400 if (--op->last_heal < 0)
2401 {
2402 if (op->stats.hp < op->stats.maxhp)
2403 {
2404 op->stats.hp++;
2405
2406 /* dms do not consume food */
2407 if (!QUERY_FLAG (op, FLAG_WIZ))
2408 {
2409 op->stats.food--;
2410
2411 if (op->contr->digestion < 0)
2412 op->stats.food += op->contr->digestion;
2413 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2414 op->stats.food = last_food;
2415 }
2416 }
2417
2418 if (max_hp > 1)
2419 {
2420 over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;
2421
2422 if (over_hp > 0)
2423 {
2424 op->stats.sp += over_hp + (rndm (rate_hp) > ((gen_hp < 20 ? 30 : gen_hp + 10) % rate_hp)) ? -1 : 0;
2425 op->last_heal = 0;
2426 }
2427 else
2428 op->last_heal = rate_hp / (gen_hp < 20 ? 30 : gen_hp + 10);
2429 }
2430 else
2431 op->last_heal = rate_hp / (gen_hp < 20 ? 30 : gen_hp + 10);
2432 }
2433 }
2434
2435 /* Digestion */
2436 if (--op->last_eat < 0)
2437 {
2438 int bonus = max (0, op->contr->digestion),
2439 penalty = max (0, -op->contr->digestion);
2440
2441 op->last_eat = 25 * (1 + bonus) / (max (0, op->contr->gen_hp) + penalty + 1);
2442
2443 /* dms do not consume food */
2444 if (!QUERY_FLAG (op, FLAG_WIZ))
2445 op->stats.food--;
2446 }
2447
2448 if (op->stats.food < 0 && op->stats.hp >= 0)
2449 {
2450 object *flesh = 0;
2451
2452 for_inv_removable (op, tmp)
2453 {
2454 if (QUERY_FLAG (tmp, FLAG_UNPAID))
2455 continue;
2456
2457 if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
2458 {
2459 op->statusmsg ("You blindly grab for a bite of food. "
2460 "H<To prevent you from starving, you ate some random item from your backpack.>");
2461 manual_apply (op, tmp, 0);
2462
2463 if (op->stats.food >= 0 || op->stats.hp < 0)
2464 break;
2465 }
2466 else if (tmp->type == FLESH)
2467 flesh = tmp;
2468 }
2469
2470 /* If player is still starving, it means they don't have any food, so
2471 * eat flesh instead.
2472 */
2473 if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)
2474 {
2475 op->statusmsg ("You blindly grab for a bite of food. "
2476 "H<To prevent you from starving, you ate some random item from your backpack.>");
2477 manual_apply (op, flesh, 0);
2478 }
2479
2480 // If player is still starving, alert him!
2481 if (op->stats.food < 0)
2482 op->failmsg ("You are starving! "
2483 "H<Eat some food to increase your food and prevent you from an untimely death.>");
2484 }
2485
2486 if (op->stats.food < 0)
2487 {
2488 op->stats.hp += op->stats.food;
2489 op->stats.food = 0;
2490
2491 if (op->stats.hp < 0)
2492 {
2493 op->contr->killer = archetype::get ("killer_starvation");
2494 op->contr->killer->destroy ();
2495 }
2496 }
2497
2498 /* killer should be set here already */
2499 if (op->stats.hp < 0 && !QUERY_FLAG (op, FLAG_WIZ))
2500 kill_player (op);
2501 }
2502 }
2503
2504 /* If the player should die (lack of hp, food, etc), we call this.
2505 * op is the player in jeopardy. If the player can not be saved (not
2506 * permadeath, no lifesave), this will take care of removing the player
2507 * file.
2508 */
2509 void
2510 kill_player (object *op)
2511 {
2512 int x, y;
2513 maptile *map; /* this is for resurrection */
2514 int will_kill_again;
2515 archetype *at;
2516 object *tmp;
2517
2518 if (save_life (op))
2519 return;
2520
2521 dynbuf_text deathtab;
2522
2523 /* restore player */
2524 at = archetype::find ("poisoning");
2525 if (object *tmp = present_arch_in_ob (at, op))
2526 {
2527 tmp->destroy ();
2528 deathtab << "Your body feels cleansed...\r";
2529 }
2530
2531 at = archetype::find ("confusion");
2532 if (object *tmp = present_arch_in_ob (at, op))
2533 {
2534 tmp->destroy ();
2535 deathtab << "Your mind feels clearer...\r";
2536 }
2537
2538 cure_disease (op, 0, 0); /* remove any disease */
2539
2540 max_it (op->stats.hp , op->stats.maxhp);
2541 max_it (op->stats.sp , op->stats.maxsp);
2542 max_it (op->stats.grace, op->stats.maxgrace);
2543
2544 if (op->stats.food <= 0)
2545 op->stats.food = 999;
2546
2547 // remove all spell effects that are active
2548 // to avoid long-term effects such as word-of-recall
2549 for (object *item = op->inv; item; )
2550 {
2551 object *next = item->below;
2552
2553 if (item->type == SPELL_EFFECT && item->active)
2554 item->destroy ();
2555
2556 item = next;
2557 }
2558
2559 /* If player dies on BATTLEGROUND, no stat/exp loss! For Combat-Arenas
2560 * in cities ONLY!!! It is very important that this doesn't get abused.
2561 * Look at op_on_battleground() for more info --AndreasV
2562 */
2563 if (op_on_battleground (op, &x, &y))
2564 {
2565 deathtab << "You almost died in combat, but local medics have saved your life...\r";
2566
2567 /* create a bodypart-trophy to make the winner happy */
2568 if (object *tmp = arch_to_object (archetype::find ("finger")))
2569 {
2570 tmp->name = format ("%s's finger" , &op->name);
2571 tmp->name_pl = format ("%s's fingers", &op->name);
2572 tmp->msg = format (
2573 "This finger has been cut off of %s the %s, when he was defeated at level %d by %s.\n",
2574 &op->name, op->contr->title,
2575 (int)op->level,
2576 op->contr->killer_name ()
2577 );
2578 tmp->value = 0, tmp->type = 0;
2579 tmp->materialname = "organics";
2580 tmp->insert_at (op, tmp);
2581 }
2582
2583 /* teleport defeated player to new destination */
2584 transfer_ob (op, x, y, 0, NULL);
2585 op->contr->braced = 0;
2586
2587 op->contr->infobox (MSG_CHANNEL ("death"), deathtab);
2588 return;
2589 }
2590
2591 deathtab << "You were killed by " << op->contr->killer_name () << ".\n\n";
2592 deathtab << "T<YOU HAVE DIED>\n\n";
2593
2594 INVOKE_PLAYER (DEATH, op->contr);
2595
2596 command_kill_pets (op, 0);
2597
2598 op->contr->play_sound (sound_find ("player_dies"));
2599
2600 /* save the map location for corpse, gravestone */
2601 x = op->x;
2602 y = op->y;
2603 map = op->map;
2604
2605 /* NOT_PERMADEATH code. This basically brings the character back to
2606 * life if they are dead - it takes some exp and a random stat.
2607 * See the config.h file for a little more in depth detail about this.
2608 */
2609
2610 /* Basically two ways to go - remove a stat permanently, or just
2611 * make it depletion. This bunch of code deals with that aspect
2612 * of death.
2613 */
2614 #ifndef COZY_SERVER
2615 if (settings.balanced_stat_loss)
2616 {
2617 /* If stat loss is permanent, lose one stat only. */
2618 /* Lower level chars don't lose as many stats because they suffer
2619 more if they do. */
2620 /* Higher level characters can afford things such as potions of
2621 restoration, or better, stat potions. So we slug them that
2622 little bit harder. */
2623 /* GD */
2624 if (settings.stat_loss_on_death)
2625 num_stats_lose = 1;
2626 else
2627 num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
2628 }
2629 else
2630 num_stats_lose = 1;
2631
2632 lost_a_stat = 0;
2633
2634 for (z = 0; z < num_stats_lose; z++)
2635 {
2636 i = rndm (NUM_STATS);
2637
2638 if (settings.stat_loss_on_death)
2639 {
2640 /* Pick a random stat and take a point off it. Tell the player
2641 * what he lost.
2642 */
2643 change_attr_value (&(op->stats), i, -1);
2644 check_stat_bounds (&(op->stats));
2645 change_attr_value (&(op->contr->orig_stats), i, -1);
2646 check_stat_bounds (&(op->contr->orig_stats));
2647 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
2648 lost_a_stat = 1;
2649 }
2650 else
2651 {
2652 /* deplete a stat */
2653 archetype *deparch = archetype::find ("depletion");
2654 object *dep;
2655
2656 dep = present_arch_in_ob (deparch, op);
2657 if (!dep)
2658 {
2659 dep = arch_to_object (deparch);
2660 insert_ob_in_ob (dep, op);
2661 }
2662 lose_this_stat = 1;
2663 if (settings.balanced_stat_loss)
2664 {
2665 /* GD */
2666 /* Get the stat that we're about to deplete. */
2667 this_stat = get_attr_value (&(dep->stats), i);
2668 if (this_stat < 0)
2669 {
2670 int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
2671 int keep_chance = this_stat * this_stat;
2672
2673 /* Yes, I am paranoid. Sue me. */
2674 if (keep_chance < 1)
2675 keep_chance = 1;
2676
2677 /* There is a maximum depletion total per level. */
2678 if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
2679 {
2680 lose_this_stat = 0;
2681 /* Take loss chance vs keep chance to see if we
2682 retain the stat. */
2683 }
2684 else
2685 {
2686 if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
2687 lose_this_stat = 0;
2688 /* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
2689 this_stat, keep_chance, loss_chance,
2690 lose_this_stat?"LOSE":"KEEP"); */
2691 }
2692 }
2693 }
2694
2695 if (lose_this_stat)
2696 {
2697 this_stat = get_attr_value (&dep->stats, i);
2698 /* We could try to do something clever like find another
2699 * stat to reduce if this fails. But chances are, if
2700 * stats have been depleted to -50, all are pretty low
2701 * and should be roughly the same, so it shouldn't make a
2702 * difference.
2703 */
2704 if (this_stat >= -50)
2705 {
2706 change_attr_value (&(dep->stats), i, -1);
2707 SET_FLAG (dep, FLAG_APPLIED);
2708 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
2709 op->update_stats ();
2710 lost_a_stat = 1;
2711 }
2712 }
2713 }
2714 }
2715
2716 /* If no stat lost, tell the player. */
2717 if (!lost_a_stat)
2718 {
2719 /* determine_god() seems to not work sometimes... why is this?
2720 Should I be using something else? GD */
2721 shstr_tmp god = determine_god (op);
2722
2723 if (god != shstr_none)
2724 deathtab << "For a brief moment you feel the holy presence of " << god << " protecting you.\r";
2725 else
2726 deathtab << "For a brief moment you feel a holy presence protecting you.\r";
2727 }
2728 #else
2729 deathtab << "For a brief moment you feel a holy presence protecting you from losing yourself completely.";
2730 #endif
2731
2732 /* Put a gravestone up where the character 'almost' died. List the
2733 * exp loss on the stone.
2734 */
2735 tmp = arch_to_object (archetype::find ("gravestone"));
2736 tmp->name = format ("%s's gravestone", &op->name);
2737 tmp->name_pl = format ("%s's gravestones", &op->name);
2738 tmp->msg = format ("T<RIP>\n\nHere rests the hero %s the %s,\rwho was killed\rby %s.\n",
2739 &op->name, op->contr->title, op->contr->killer_name ());
2740 tmp->x = op->x, tmp->y = op->y;
2741 insert_ob_in_map (tmp, op->map, NULL, 0);
2742
2743 /**************************************/
2744 /* */
2745 /* Subtract the experience points, */
2746 /* */
2747 /**************************************/
2748
2749 /*add_exp(op, (op->stats.exp * -0.20)); */
2750 apply_death_exp_penalty (op);
2751
2752 /*
2753 * Check to see if the player has any unpaid items. If so, remove them
2754 * and put them back in the map.
2755 */
2756 op->drop_unpaid_items ();
2757
2758 /****************************************/
2759 /* */
2760 /* Move player to his current respawn- */
2761 /* position (usually last savebed) */
2762 /* */
2763 /****************************************/
2764
2765 enter_player_savebed (op);
2766
2767 op->contr->braced = 0;
2768
2769 /* it is possible that the player has blown something up
2770 * at his savebed location, and that can have long lasting
2771 * spell effects. So first see if there is a spell effect
2772 * on the space that might harm the player.
2773 */
2774 will_kill_again = 0;
2775 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
2776 if (tmp->type == SPELL_EFFECT)
2777 will_kill_again |= tmp->attacktype;
2778
2779 if (will_kill_again)
2780 {
2781 object *force;
2782 int at;
2783
2784 force = get_archetype (FORCE_NAME);
2785 /* 50 ticks should be enough time for the spell to abate */
2786 force->speed = 0.1f;
2787 force->speed_left = -5.f;
2788 SET_FLAG (force, FLAG_APPLIED);
2789 for (at = 0; at < NROFATTACKS; at++)
2790 if (will_kill_again & (1 << at))
2791 force->resist[at] = 100;
2792
2793 insert_ob_in_ob (force, op);
2794 op->update_stats ();
2795 }
2796
2797 op->contr->infobox (MSG_CHANNEL ("death"), deathtab);
2798 }
2799
2800 void
2801 loot_object (object *op)
2802 { /* Grab and destroy some treasure */
2803 object *tmp, *tmp2, *next;
2804
2805 op->close_container (); /* close open sack first */
2806
2807 for (tmp = op->inv; tmp; tmp = next)
2808 {
2809 next = tmp->below;
2810
2811 if (tmp->invisible)
2812 continue;
2813
2814 tmp->remove ();
2815 tmp->x = op->x, tmp->y = op->y;
2816
2817 if (tmp->type == CONTAINER)
2818 loot_object (tmp); /* empty container to ground */
2819
2820 if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(rndm (3))))
2821 {
2822 if (tmp->nrof > 1)
2823 {
2824 tmp->decrease (rndm (1, tmp->nrof - 1));
2825 insert_ob_in_map (tmp, op->map, NULL, 0);
2826 }
2827 else
2828 tmp->destroy ();
2829 }
2830 else
2831 insert_ob_in_map (tmp, op->map, NULL, 0);
2832 }
2833 }
2834
2835 /*
2836 * fix_weight(): Check recursively the weight of all players, and fix
2837 * what needs to be fixed. Refresh windows and fix speed if anything
2838 * was changed.
2839 */
2840 void
2841 fix_weight (void)
2842 {
2843 for_all_players (pl)
2844 {
2845 sint32 old = pl->ob->carrying;
2846
2847 pl->ob->update_weight ();
2848
2849 if (old != pl->ob->carrying)
2850 {
2851 pl->ob->update_stats ();
2852 LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, (int)old, (int)pl->ob->carrying);
2853 }
2854 }
2855 }
2856
2857 void
2858 fix_luck (void)
2859 {
2860 for_all_players (pl)
2861 if (!pl->ob->contr->ns->state)
2862 pl->ob->change_luck (0);
2863 }
2864
2865 /* cast_dust() - handles op throwing objects of type 'DUST'.
2866 * This is much simpler in the new spell code - we basically
2867 * just treat this as any other spell casting object.
2868 */
2869 void
2870 cast_dust (object *op, object *throw_ob, int dir)
2871 {
2872 object *skop, *spob;
2873
2874 skop = find_skill_by_name (op, throw_ob->skill);
2875
2876 /* casting POTION 'dusts' is really a use_magic_item skill */
2877 if (op->type == PLAYER && throw_ob->type == POTION && !skop)
2878 {
2879 LOG (llevError, "Player %s lacks critical skill use_magic_item!\n", &op->name);
2880 return;
2881 }
2882
2883 spob = throw_ob->inv;
2884
2885 // elmex Tue Aug 15 17:19:46 CEST 2006: Added this check to
2886 // not pass NULL to cast_spell (which did indeed check itself, but
2887 // errors should be reported as early as possible IMHO)
2888 if (!spob)
2889 {
2890 LOG (llevError, "cast_dust: thrown object %s (by %s) had no spell in it!", &throw_ob->name, &op->name);
2891 return;
2892 }
2893
2894 if (op->type == PLAYER)
2895 new_draw_info_format (NDI_UNIQUE, 0, op, "You cast %s.", &spob->name);
2896
2897 cast_spell (op, throw_ob, dir, spob, NULL);
2898
2899 throw_ob->destroy ();
2900 }
2901
2902 void
2903 make_visible (object *op)
2904 {
2905 op->flag [FLAG_HIDDEN] = 0;
2906 op->invisible = 0;
2907
2908 if (op->type == PLAYER)
2909 {
2910 op->contr->tmp_invis = 0;
2911 op->contr->invis_race = 0;
2912 }
2913
2914 update_object (op, UP_OBJ_CHANGE);
2915 }
2916
2917 int
2918 is_true_undead (object *op)
2919 {
2920 if (QUERY_FLAG (op->arch, FLAG_UNDEAD))
2921 return 1;
2922
2923 return 0;
2924 }
2925
2926 /* look at the surrounding terrain to determine
2927 * the hideability of this object. Positive levels
2928 * indicate greater hideability.
2929 */
2930 int
2931 hideability (object *ob)
2932 {
2933 int i, level = 0, mflag;
2934 sint16 x, y;
2935
2936 if (!ob || !ob->map)
2937 return 0;
2938
2939 /* so, on normal lighted maps, its hard to hide */
2940 level = ob->map->darklevel () - 2;
2941
2942 /* this also picks up whether the object is glowing.
2943 * If you carry a light on a non-dark map, its not
2944 * as bad as carrying a light on a pitch dark map */
2945 if (ob->has_carried_lights ())
2946 level = -(10 + (2 * ob->map->darklevel ()));
2947
2948 /* scan through all nearby squares for terrain to hide in */
2949 for (i = 0, x = ob->x, y = ob->y;
2950 i <= SIZEOFFREE1;
2951 i++, x = ob->x + freearr_x[i], y = ob->y + freearr_y[i])
2952 {
2953 mflag = get_map_flags (ob->map, NULL, x, y, NULL, NULL);
2954 if (mflag & P_OUT_OF_MAP)
2955 continue;
2956
2957 if (mflag & P_BLOCKSVIEW) /* something to hide near! */
2958 level += 2;
2959 else /* open terrain! */
2960 level -= 1;
2961 }
2962
2963 #if 0
2964 LOG (llevDebug, "hideability of %s is %d\n", ob->name, level);
2965 #endif
2966 return level;
2967 }
2968
2969 /* For Hidden creatures - a chance of becoming 'unhidden'
2970 * every time they move - as we subtract off 'invisibility'
2971 * AND, for players, if they move into a ridiculously unhideable
2972 * spot (surrounded by clear terrain in broad daylight). -b.t.
2973 */
2974 void
2975 do_hidden_move (object *op)
2976 {
2977 int hide = 0;
2978
2979 if (!op || !op->map)
2980 return;
2981
2982 object *skop = find_obj_by_type_subtype (op, SKILL, SK_HIDING);
2983 int num = random_roll (0, 19, op, PREFER_LOW);
2984
2985 /* its *extremely* hard to run and sneak/hide at the same time! */
2986 if (op->type == PLAYER && op->contr->run_on)
2987 if (!skop || num >= skop->level)
2988 {
2989 new_draw_info (NDI_UNIQUE, 0, op, "You ran too much! You are no longer hidden!");
2990 make_visible (op);
2991 return;
2992 }
2993 else
2994 num += 20;
2995
2996 num += op->map->difficulty;
2997 hide = hideability (op); /* modify by terrain hidden level */
2998 num -= hide;
2999
3000 if ((op->type == PLAYER && hide < -10) || ((op->invisible -= num) <= 0))
3001 {
3002 make_visible (op);
3003
3004 if (op->type == PLAYER)
3005 new_draw_info (NDI_UNIQUE, 0, op, "You moved out of hiding! You are visible!");
3006 }
3007 else if (op->type == PLAYER && skop)
3008 change_exp (op, calc_skill_exp (op, NULL, skop), skop->skill, 0);
3009 }
3010
3011 /* determine if who is standing near a hostile creature. */
3012
3013 int
3014 stand_near_hostile (object *who)
3015 {
3016 object *tmp = NULL;
3017 int i, friendly = 0, player = 0, mflags;
3018 maptile *m;
3019 sint16 x, y;
3020
3021 if (!who)
3022 return 0;
3023
3024 if (who->type == PLAYER)
3025 player = 1;
3026
3027 else
3028 friendly = QUERY_FLAG (who, FLAG_FRIENDLY);
3029
3030 /* search adjacent squares */
3031 for (i = 1; i < 9; i++)
3032 {
3033 x = who->x + freearr_x[i];
3034 y = who->y + freearr_y[i];
3035 m = who->map;
3036 mflags = get_map_flags (m, &m, x, y, &x, &y);
3037 /* space must be blocked if there is a monster. If not
3038 * blocked, don't need to check this space.
3039 */
3040 if (mflags & P_OUT_OF_MAP)
3041 continue;
3042 if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y)))
3043 continue;
3044
3045 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
3046 {
3047 if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))
3048 return 1;
3049 else if (tmp->type == PLAYER)
3050 {
3051 /*don't let a hidden DM prevent you from hiding */
3052 if (!QUERY_FLAG (tmp, FLAG_WIZ) || tmp->contr->hidden == 0)
3053 return 1;
3054 }
3055 }
3056 }
3057 return 0;
3058 }
3059
3060 /* check the player los field for viewability of the
3061 * object op. This function works fine for monsters,
3062 * but we dont worry if the object isnt the top one in
3063 * a pile (say a coin under a table would return "viewable"
3064 * by this routine). Another question, should we be
3065 * concerned with the direction the player is looking
3066 * in? Realistically, most of us can't see stuff behind
3067 * our backs...on the other hand, does the "facing" direction
3068 * imply the way your head, or body is facing? It's possible
3069 * for them to differ. Sigh, this fctn could get a bit more complex.
3070 * -b.t.
3071 * This function is now map tiling safe.
3072 */
3073 int
3074 player_can_view (object *pl, object *op)
3075 {
3076 rv_vector rv;
3077 int dx, dy;
3078
3079 if (pl->type != PLAYER)
3080 {
3081 LOG (llevError, "player_can_view() called for non-player object\n");
3082 return -1;
3083 }
3084
3085 if (!pl || !op)
3086 return 0;
3087
3088 op = op->head_ ();
3089
3090 get_rangevector (pl, op, &rv, 0x1);
3091
3092 /* starting with the 'head' part, lets loop
3093 * through the object and find if it has any
3094 * part that is in the los array but isn't on
3095 * a blocked los square.
3096 * we use the archetype to figure out offsets.
3097 */
3098 while (op)
3099 {
3100 dx = rv.distance_x + op->arch->x;
3101 dy = rv.distance_y + op->arch->y;
3102
3103 if (pl->contr->blocked_los (dx, dy) != LOS_BLOCKED)
3104 return 1;
3105
3106 op = op->more;
3107 }
3108
3109 return 0;
3110 }
3111
3112 /* routine for both players and monsters. We call this when
3113 * there is a possibility for our action distrubing our hiding
3114 * place or invisiblity spell. Artefact invisiblity causes
3115 * "noise" instead. If we arent invisible to begin with, we
3116 * return 0.
3117 */
3118 int
3119 action_makes_visible (object *op)
3120 {
3121 if (op->invisible && QUERY_FLAG (op, FLAG_ALIVE))
3122 {
3123 if (QUERY_FLAG (op, FLAG_MAKE_INVIS))
3124 {
3125 // artefact invisibility is permanent, but we still make noise
3126 // this is important for game-balance.
3127 if (op->contr)
3128 op->make_noise ();
3129
3130 return 0;
3131 }
3132
3133 if (op->contr && op->contr->tmp_invis == 0)
3134 return 0;
3135
3136 /* If monsters, they should become visible */
3137 if (op->flag [FLAG_HIDDEN] || !op->contr || (op->contr && op->contr->tmp_invis))
3138 {
3139 new_draw_info_format (NDI_UNIQUE, 0, op, "You become %s!", op->flag [FLAG_HIDDEN] ? "unhidden" : "visible");
3140 return 1;
3141 }
3142 }
3143
3144 return 0;
3145 }
3146
3147 /* op_on_battleground - checks if the given object op (usually
3148 * a player) is standing on a valid battleground-tile,
3149 * function returns TRUE/FALSE. If true x, y returns the battleground
3150 * -exit-coord. (and if x, y not NULL)
3151 * 19 March 2005 - josh@woosworld.net modifed to check if the battleground also has slaying, maxhp, and maxsp set
3152 * and if those are all set and the player has a marker that matches the slaying send them to a different x, y
3153 * Default is to do the same as before, so only people wanting to have different points need worry about this
3154 */
3155 int
3156 op_on_battleground (object *op, int *x, int *y)
3157 {
3158 /* A battleground-tile needs the following attributes to be valid:
3159 * is_floor 1 (has to be the FIRST floor beneath the player's feet),
3160 * name="battleground", no_pick 1, type=58 (type BATTLEGROUND)
3161 * and the exit-coordinates sp/hp must both be > 0.
3162 * => The intention here is to prevent abuse of the battleground-
3163 * feature (like pickable or hidden battleground tiles). */
3164 for (object *tmp = op->below; tmp; tmp = tmp->below)
3165 {
3166 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
3167 {
3168 if (QUERY_FLAG (tmp, FLAG_NO_PICK)
3169 && tmp->type == BATTLEGROUND
3170 && tmp->name == shstr_battleground
3171 && EXIT_X (tmp) && EXIT_Y (tmp))
3172 {
3173 /* before we assign the exit, check if this is a teambattle */
3174 if (EXIT_ALT_X (tmp) && EXIT_ALT_Y (tmp) && EXIT_PATH (tmp))
3175 {
3176 for (object *invtmp = op->inv; invtmp; invtmp = invtmp->below)
3177 {
3178 if (invtmp->type == FORCE && invtmp->slaying && tmp->slaying == invtmp->slaying)
3179 {
3180 if (x && y)
3181 *x = EXIT_ALT_X (tmp), *y = EXIT_ALT_Y (tmp);
3182
3183 return 1;
3184 }
3185 }
3186 }
3187
3188 if (x && y)
3189 *x = EXIT_X (tmp), *y = EXIT_Y (tmp);
3190
3191 return 1;
3192 }
3193 }
3194 }
3195
3196 /* If we got here, did not find a battleground */
3197 return 0;
3198 }
3199
3200 /*
3201 * When a dragon-player gains a new stage of evolution,
3202 * he gets some treasure
3203 *
3204 * attributes:
3205 * object *who the dragon player
3206 * int atnr the attack-number of the ability focus
3207 * int level ability level
3208 */
3209 void
3210 dragon_ability_gain (object *who, int atnr, int level)
3211 {
3212 treasurelist *trlist = NULL; /* treasurelist */
3213 treasure *tr; /* treasure */
3214 object *tmp, *skop; /* tmp. object */
3215 object *item; /* treasure object */
3216 char buf[MAX_BUF]; /* tmp. string buffer */
3217 int i = 0, j = 0;
3218
3219 /* get the appropriate treasurelist */
3220 if (atnr == ATNR_FIRE)
3221 trlist = treasurelist::find (shstr_dragon_ability_fire);
3222 else if (atnr == ATNR_COLD)
3223 trlist = treasurelist::find (shstr_dragon_ability_cold);
3224 else if (atnr == ATNR_ELECTRICITY)
3225 trlist = treasurelist::find (shstr_dragon_ability_elec);
3226 else if (atnr == ATNR_POISON)
3227 trlist = treasurelist::find (shstr_dragon_ability_poison);
3228
3229 if (trlist == NULL || who->type != PLAYER)
3230 return;
3231
3232 for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++);
3233
3234 if (!tr || !tr->item)
3235 {
3236 /* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */
3237 return;
3238 }
3239
3240 /* everything seems okay - now bring on the gift: */
3241 item = tr->item;
3242
3243 if (item->type == SPELL)
3244 {
3245 if (check_spell_known (who, item->name))
3246 return;
3247
3248 new_draw_info_format (NDI_UNIQUE | NDI_BLUE, 0, who, "You gained the ability of %s", &item->name);
3249 do_learn_spell (who, item, 0);
3250 return;
3251 }
3252
3253 /* grant direct spell */
3254 if (item->type == SPELLBOOK)
3255 {
3256 if (!item->inv)
3257 {
3258 LOG (llevDebug, "dragon_ability_gain: Broken spellbook %s\n", &item->name);
3259 return;
3260 }
3261 if (check_spell_known (who, item->inv->name))
3262 return;
3263 if (item->invisible)
3264 {
3265 new_draw_info_format (NDI_UNIQUE | NDI_BLUE, 0, who, "You gained the ability of %s", &item->inv->name);
3266 do_learn_spell (who, item->inv, 0);
3267 return;
3268 }
3269 }
3270 else if (item->type == SKILL_TOOL && item->invisible)
3271 {
3272 if (item->subtype == SK_CLAWING && (skop = find_skill_by_name (who, item->skill)) != NULL)
3273 {
3274
3275 /* should this perhaps be (skop->attackyp & item->attacktype)!=item->attacktype ...
3276 * in this way, if the player is missing any of the attacktypes, he gets
3277 * them. As it is now, if the player has any that match the granted skill,
3278 * but not all of them, he gets nothing.
3279 */
3280 if (!(skop->attacktype & item->attacktype))
3281 {
3282 /* Give new attacktype */
3283 skop->attacktype |= item->attacktype;
3284
3285 /* always add physical if there's none */
3286 skop->attacktype |= AT_PHYSICAL;
3287
3288 if (item->msg != NULL)
3289 new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, who, item->msg);
3290
3291 /* Give player new face */
3292 if (item->animation_id)
3293 {
3294 who->face = skop->face;
3295 who->animation_id = item->animation_id;
3296 who->anim_speed = item->anim_speed;
3297 who->last_anim = 0;
3298 who->state = 0;
3299 animate_object (who, who->direction);
3300 }
3301 }
3302 }
3303 }
3304 else if (item->type == FORCE)
3305 {
3306 /* forces in the treasurelist can alter the player's stats */
3307 object *skin;
3308
3309 /* first get the dragon skin force */
3310 for (skin = who->inv; skin && !(skin->arch->archname == shstr_dragon_skin_force); skin = skin->below)
3311 ;
3312
3313 if (!skin)
3314 return;
3315
3316 /* adding new spellpath attunements */
3317 if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned))
3318 {
3319 skin->path_attuned |= item->path_attuned; /* add attunement to skin */
3320
3321 /* print message */
3322 sprintf (buf, "You feel attuned to ");
3323 for (i = 0, j = 0; i < NRSPELLPATHS; i++)
3324 {
3325 if (item->path_attuned & (1 << i))
3326 {
3327 if (j)
3328 strcat (buf, " and ");
3329 else
3330 j = 1;
3331 strcat (buf, spellpathnames[i]);
3332 }
3333 }
3334 strcat (buf, ".");
3335 new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, who, buf);
3336 }
3337
3338 /* evtl. adding flags: */
3339 if (QUERY_FLAG (item, FLAG_XRAYS))
3340 SET_FLAG (skin, FLAG_XRAYS);
3341 if (QUERY_FLAG (item, FLAG_STEALTH))
3342 SET_FLAG (skin, FLAG_STEALTH);
3343 if (QUERY_FLAG (item, FLAG_SEE_IN_DARK))
3344 SET_FLAG (skin, FLAG_SEE_IN_DARK);
3345
3346 /* print message if there is one */
3347 if (item->msg != NULL)
3348 new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, who, item->msg);
3349 }
3350 else
3351 {
3352 /* generate misc. treasure */
3353 tmp = arch_to_object (tr->item);
3354 new_draw_info_format (NDI_UNIQUE | NDI_BLUE, 0, who, "You gained %s", query_short_name (tmp));
3355 who->insert (tmp);
3356 }
3357 }
3358
3359 /**
3360 * Unready an object for a player. This function does nothing if the object was
3361 * not readied.
3362 */
3363 void
3364 player_unready_range_ob (player *pl, object *ob)
3365 {
3366 if (pl->ob->current_weapon == ob)
3367 pl->ob->current_weapon = 0;
3368
3369 if (pl->combat_ob == ob)
3370 pl->combat_ob = 0;
3371
3372 if (pl->ranged_ob == ob)
3373 pl->ranged_ob = 0;
3374 }
3375
3376 sint8
3377 player::darkness_at (maptile *map, int x, int y) const
3378 {
3379 if (!ns)
3380 return LOS_BLOCKED;
3381
3382 int dx, dy;
3383 if (!adjacent_map (map, ns->current_map, &dx, &dy))
3384 return LOS_BLOCKED;
3385
3386 x += dx - ns->current_x;
3387 y += dy - ns->current_y;
3388
3389 return blocked_los (x, y);
3390 }
3391
3392 void
3393 player::infobox (const char *title, const char *msg, int color)
3394 {
3395 send_msg (color | NDI_DEF | NDI_REPLY | NDI_CLEAR, title, msg);
3396 }
3397
3398 void
3399 player::statusmsg (const char *msg, int color)
3400 {
3401 send_msg (color | NDI_REPLY, INFO_CHANNEL, msg);
3402 }
3403
3404 void
3405 player::failmsg (const char *msg, int color)
3406 {
3407 play_sound (sound_find ("generic_failure"));
3408 statusmsg (msg, color);
3409 }
3410