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

Comparing deliantra/server/server/player.C (file contents):
Revision 1.146 by root, Sun Jun 3 17:05:36 2007 UTC vs.
Revision 1.158 by root, Mon Aug 13 15:46:45 2007 UTC

3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team 4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Crossfire TRT is free software; you can redistribute it and/or modify it 8 * Crossfire TRT is free software: you can redistribute it and/or modify
9 * under the terms of the GNU General Public License as published by the Free 9 * it under the terms of the GNU General Public License as published by
10 * Software Foundation; either version 2 of the License, or (at your option) 10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version. 11 * (at your option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, but 13 * This program is distributed in the hope that it will be useful,
14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License along 18 * You should have received a copy of the GNU General Public License
19 * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 * 20 *
22 * The authors can be reached via e-mail to <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <crossfire@schmorp.de>
23 */ 22 */
24 23
25#include <global.h> 24#include <global.h>
207 ob->close_container (); //TODO: client-specific 206 ob->close_container (); //TODO: client-specific
208 207
209 ns->update_look = 0; 208 ns->update_look = 0;
210 ns->look_position = 0; 209 ns->look_position = 0;
211 210
212 clear_los (ob); 211 clear_los (this);
213 212
214 ns->reset_stats (); 213 ns->reset_stats ();
215 214
216 /* make sure he's a player -- needed because of class change. */ 215 /* make sure he's a player -- needed because of class change. */
217 ob->type = PLAYER; // we are paranoid 216 ob->type = PLAYER; // we are paranoid
218 ob->race = ob->arch->clone.race; 217 ob->race = ob->arch->race;
219 218
220 ob->carrying = sum_weight (ob); 219 ob->carrying = sum_weight (ob);
221 link_player_skills (ob); 220 link_player_skills (ob);
222 221
223 CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER); 222 CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER);
224 223
225 assign (title, ob->arch->clone.name); 224 assign (title, ob->arch->object::name);
226 225
227 /* if it's a dragon player, set the correct title here */ 226 /* if it's a dragon player, set the correct title here */
228 if (is_dragon_pl (ob)) 227 if (is_dragon_pl (ob))
229 { 228 {
230 object *tmp, *abil = 0, *skin = 0; 229 object *tmp, *abil = 0, *skin = 0;
231 230
232 shstr_cmp dragon_ability_force ("dragon_ability_force");
233 shstr_cmp dragon_skin_force ("dragon_skin_force");
234
235 for (tmp = ob->inv; tmp; tmp = tmp->below) 231 for (tmp = ob->inv; tmp; tmp = tmp->below)
236 if (tmp->type == FORCE) 232 if (tmp->type == FORCE)
237 if (tmp->arch->name == dragon_ability_force) 233 if (tmp->arch->archname == shstr_dragon_ability_force)
238 abil = tmp; 234 abil = tmp;
239 else if (tmp->arch->name == dragon_skin_force) 235 else if (tmp->arch->archname == shstr_dragon_skin_force)
240 skin = tmp; 236 skin = tmp;
241 237
242 set_dragon_name (ob, abil, skin); 238 set_dragon_name (ob, abil, skin);
243 } 239 }
244 240
301 ns->pl = 0; 297 ns->pl = 0;
302 ns = 0; 298 ns = 0;
303 } 299 }
304 300
305 if (ob) 301 if (ob)
302 {
306 ob->close_container (); //TODO: client-specific 303 ob->close_container (); //TODO: client-specific
304 ob->drop_unpaid_items ();
305 }
306
307 observe = ob;
307 308
308 deactivate (); 309 deactivate ();
309} 310}
310 311
311// the need for this function can be explained 312// the need for this function can be explained
324 325
325void 326void
326player::set_observe (object *op) 327player::set_observe (object *op)
327{ 328{
328 observe = op ? op : ob; 329 observe = op ? op : ob;
330 do_los = 1;
329} 331}
330 332
331player::player () 333player::player ()
332{ 334{
333 /* There are some elements we want initialised to non zero value - 335 /* There are some elements we want initialised to non zero value -
361 if (ob) 363 if (ob)
362 { 364 {
363 ob->destroy_inv (false); 365 ob->destroy_inv (false);
364 ob->destroy (); 366 ob->destroy ();
365 } 367 }
368
369 ob = observe = 0;
366} 370}
367 371
368player::~player () 372player::~player ()
369{ 373{
370 /* Clear item stack */ 374 /* Clear item stack */
397 * Note: there MUST be at least one player archetype! 401 * Note: there MUST be at least one player archetype!
398 */ 402 */
399archetype * 403archetype *
400get_player_archetype (archetype *at) 404get_player_archetype (archetype *at)
401{ 405{
402 archetype *start = at; 406 archvec::iterator i = at ? archetypes.find (at) : archetypes.begin ();
403 407
404 for (;;) 408 for (;;)
405 { 409 {
406 if (at == NULL || at->next == NULL) 410 if (++i == archetypes.end ())
407 at = first_archetype; 411 i = archetypes.begin ();
408 else 412 else if (*i == at)
409 at = at->next; 413 cleanup ("not a single player archetype found");
410 414
411 if (at->clone.type == PLAYER) 415 if ((*i)->type == PLAYER)
412 return at; 416 return *i;
413
414 if (at == start)
415 {
416 LOG (llevError, "No Player archetypes\n");
417 exit (-1);
418 }
419 } 417 }
420} 418}
421 419
422object * 420object *
423get_nearest_player (object *mon) 421get_nearest_player (object *mon)
913 if (*first_map_ext_path) 911 if (*first_map_ext_path)
914 { 912 {
915 object *tmp; 913 object *tmp;
916 char mapname[MAX_BUF]; 914 char mapname[MAX_BUF];
917 915
918 snprintf (mapname, MAX_BUF - 1, "%s/%s", &first_map_ext_path, &ob->arch->name); 916 snprintf (mapname, MAX_BUF - 1, "%s/%s", &first_map_ext_path, &ob->arch->archname);
919 tmp = object::create (); 917 tmp = object::create ();
920 EXIT_PATH (tmp) = mapname; 918 EXIT_PATH (tmp) = mapname;
921 EXIT_X (tmp) = ob->x; 919 EXIT_X (tmp) = ob->x;
922 EXIT_Y (tmp) = ob->y; 920 EXIT_Y (tmp) = ob->y;
923 ob->enter_exit (tmp); /* we don't really care if it succeeded; 921 ob->enter_exit (tmp); /* we don't really care if it succeeded;
942 int x = ob->x, y = ob->y; 940 int x = ob->x, y = ob->y;
943 941
944 ob->remove_statbonus (); 942 ob->remove_statbonus ();
945 ob->remove (); 943 ob->remove ();
946 ob->arch = get_player_archetype (ob->arch); 944 ob->arch = get_player_archetype (ob->arch);
947 ob->arch->clone.copy_to (ob); 945 ob->arch->copy_to (ob);
948 ob->instantiate (); 946 ob->instantiate ();
949 ob->stats = ob->contr->orig_stats; 947 ob->stats = ob->contr->orig_stats;
950 ob->name = ob->name_pl = name; 948 ob->name = ob->name_pl = name;
951 ob->x = x; 949 ob->x = x;
952 ob->y = y; 950 ob->y = y;
953 SET_ANIMATION (ob, 2); /* So player faces south */ 951 SET_ANIMATION (ob, 2); /* So player faces south */
954 insert_ob_in_map (ob, ob->map, ob, 0); 952 insert_ob_in_map (ob, ob->map, ob, 0);
955 assign (ob->contr->title, ob->arch->clone.name); 953 assign (ob->contr->title, ob->arch->object::name);
956 ob->add_statbonus (); 954 ob->add_statbonus ();
957 } 955 }
958 while (!allowed_class (ob)); 956 while (!allowed_class (ob));
959 957
960 update_object (ob, UP_OBJ_FACE); 958 update_object (ob, UP_OBJ_FACE);
1105 if (tmp->name != NULL) 1103 if (tmp->name != NULL)
1106 sprintf (putstring, "item name: %s item type: %d weight/value: %d", 1104 sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1107 &tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1)))); 1105 &tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1108 else 1106 else
1109 sprintf (putstring, "item name: %s item type: %d weight/value: %d", 1107 sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1110 &tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1)))); 1108 &tmp->arch->archname, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1111 1109
1112 new_draw_info (NDI_UNIQUE, 0, op, putstring); 1110 new_draw_info (NDI_UNIQUE, 0, op, putstring);
1113 } 1111 }
1114 1112
1115 /* philosophy: 1113 /* philosophy:
1190 pick_up (op, tmp); 1188 pick_up (op, tmp);
1191 continue; 1189 continue;
1192 } 1190 }
1193 1191
1194 if (op->contr->mode & PU_READABLES) 1192 if (op->contr->mode & PU_READABLES)
1195 if (tmp->type == BOOK || tmp->type == SCROLL) 1193 if (tmp->type == BOOK || tmp->type == SCROLL || tmp->type == INSCRIBABLE)
1196 { 1194 {
1197 pick_up (op, tmp); 1195 pick_up (op, tmp);
1198 continue; 1196 continue;
1199 } 1197 }
1200 1198
1308 /* careful: chairs and tables are weapons! */ 1306 /* careful: chairs and tables are weapons! */
1309 if (op->contr->mode & PU_ALLWEAPON) 1307 if (op->contr->mode & PU_ALLWEAPON)
1310 { 1308 {
1311 if (tmp->type == WEAPON && tmp->name != NULL) 1309 if (tmp->type == WEAPON && tmp->name != NULL)
1312 { 1310 {
1313 if (strstr (tmp->name, "table") == NULL && strstr (tmp->arch->name, "table") == NULL && 1311 if (strstr (tmp->name, "table") == NULL && strstr (tmp->arch->archname, "table") == NULL &&
1314 strstr (tmp->name, "chair") && strstr (tmp->arch->name, "chair") == NULL) 1312 strstr (tmp->name, "chair") && strstr (tmp->arch->archname, "chair") == NULL)
1315 { 1313 {
1316 pick_up (op, tmp); 1314 pick_up (op, tmp);
1317 continue; 1315 continue;
1318 } 1316 }
1319 } 1317 }
1320 1318
1321 if (tmp->type == WEAPON && tmp->name == NULL) 1319 if (tmp->type == WEAPON && tmp->name == NULL)
1322 { 1320 {
1323 if (strstr (tmp->arch->name, "table") == NULL && strstr (tmp->arch->name, "chair") == NULL) 1321 if (strstr (tmp->arch->archname, "table") == NULL && strstr (tmp->arch->archname, "chair") == NULL)
1324 { 1322 {
1325 pick_up (op, tmp); 1323 pick_up (op, tmp);
1326 continue; 1324 continue;
1327 } 1325 }
1328 } 1326 }
1353 if (tmp->name != NULL) 1351 if (tmp->name != NULL)
1354 { 1352 {
1355 fprintf (stderr, "%s", tmp->name); 1353 fprintf (stderr, "%s", tmp->name);
1356 } 1354 }
1357 else 1355 else
1358 fprintf (stderr, "%s", tmp->arch->name); 1356 fprintf (stderr, "%s", tmp->arch->archname);
1359 fprintf (stderr, ",%d] = ", tmp->type); 1357 fprintf (stderr, ",%d] = ", tmp->type);
1360 fprintf (stderr, "%d\n", (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1)))); 1358 fprintf (stderr, "%d\n", (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1361#endif 1359#endif
1362 continue; 1360 continue;
1363 } 1361 }
1433 else 1431 else
1434 { 1432 {
1435 for (attacknum = 0; attacknum < NROFATTACKS; attacknum++) 1433 for (attacknum = 0; attacknum < NROFATTACKS; attacknum++)
1436 { 1434 {
1437 attacktype = 1 << attacknum; 1435 attacktype = 1 << attacknum;
1438 if ((arrow->attacktype & attacktype) && (target->arch->clone.resist[attacknum]) < 0) 1436 if ((arrow->attacktype & attacktype) && (target->arch->resist[attacknum]) < 0)
1439 if (((arrow->magic + arrow->stats.dam) * (100 - target->arch->clone.resist[attacknum]) / 100) > betterby) 1437 if (((arrow->magic + arrow->stats.dam) * (100 - target->arch->resist[attacknum]) / 100) > betterby)
1440 { 1438 {
1441 tmp = arrow; 1439 tmp = arrow;
1442 betterby = (arrow->magic + arrow->stats.dam) * (100 - target->arch->clone.resist[attacknum]) / 100; 1440 betterby = (arrow->magic + arrow->stats.dam) * (100 - target->arch->resist[attacknum]) / 100;
1443 } 1441 }
1444 } 1442 }
1445 if ((2 + arrow->magic + arrow->stats.dam) > betterby) 1443 if ((2 + arrow->magic + arrow->stats.dam) > betterby)
1446 { 1444 {
1447 tmp = arrow; 1445 tmp = arrow;
1685 1683
1686 arrow->stats.wc = clamp (wc, MIN_WC, MAX_WC); 1684 arrow->stats.wc = clamp (wc, MIN_WC, MAX_WC);
1687 arrow->move_type = MOVE_FLY_LOW; 1685 arrow->move_type = MOVE_FLY_LOW;
1688 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK; 1686 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
1689 1687
1690 play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW); 1688 op->play_sound (sound_find ("fire_arrow"));
1691 m->insert (arrow, sx, sy, op); 1689 m->insert (arrow, sx, sy, op);
1692 1690
1693 if (!arrow->destroyed ()) 1691 if (!arrow->destroyed ())
1694 move_arrow (arrow); 1692 move_arrow (arrow);
1695 1693
1773 1771
1774 if (item->type == WAND) 1772 if (item->type == WAND)
1775 { 1773 {
1776 if (item->stats.food <= 0) 1774 if (item->stats.food <= 0)
1777 { 1775 {
1778 play_sound_player_only (op->contr, SOUND_WAND_POOF, 0, 0); 1776 op->contr->play_sound (sound_find ("wand_poof"));
1779 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s goes poof.", query_base_name (item, 0)); 1777 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s goes poof.", query_base_name (item, 0));
1780 1778
1781 return; 1779 return;
1782 } 1780 }
1783 } 1781 }
1784 else if (item->type == ROD || item->type == HORN) 1782 else if (item->type == ROD || item->type == HORN)
1785 { 1783 {
1786 if (item->stats.hp < MAX (item->inv->stats.sp, item->inv->stats.grace)) 1784 if (item->stats.hp < MAX (item->inv->stats.sp, item->inv->stats.grace))
1787 { 1785 {
1788 play_sound_player_only (op->contr, SOUND_WAND_POOF, 0, 0); 1786 op->contr->play_sound (sound_find ("wand_poof"));
1789 1787
1790 if (item->type == ROD) 1788 if (item->type == ROD)
1791 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s whines for a while, but nothing happens.", query_base_name (item, 0)); 1789 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s whines for a while, but nothing happens.", query_base_name (item, 0));
1792 else 1790 else
1793 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s needs more time to charge.", query_base_name (item, 0)); 1791 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s needs more time to charge.", query_base_name (item, 0));
1806 object *tmp; 1804 object *tmp;
1807 1805
1808 if (item->arch) 1806 if (item->arch)
1809 { 1807 {
1810 CLEAR_FLAG (item, FLAG_ANIMATE); 1808 CLEAR_FLAG (item, FLAG_ANIMATE);
1811 item->face = item->arch->clone.face; 1809 item->face = item->arch->face;
1812 item->set_speed (0); 1810 item->set_speed (0);
1813 } 1811 }
1814 1812
1815 if ((tmp = item->in_player ())) 1813 if ((tmp = item->in_player ()))
1816 esrv_update_item (UPD_ANIM, tmp, item); 1814 esrv_update_item (UPD_ANIM, tmp, item);
1982 /* If we found a key, do some extra work */ 1980 /* If we found a key, do some extra work */
1983 if (key) 1981 if (key)
1984 { 1982 {
1985 object *container = key->env; 1983 object *container = key->env;
1986 1984
1987 play_sound_map (op->map, op->x, op->y, SOUND_OPEN_DOOR);
1988
1989 if (action_makes_visible (op)) 1985 if (action_makes_visible (op))
1990 make_visible (op); 1986 make_visible (op);
1991 1987
1992 if (door->inv && (door->inv->type == RUNE || door->inv->type == TRAP)) 1988 if (door->inv && (door->inv->type == RUNE || door->inv->type == TRAP))
1993 spring_trap (door->inv, op); 1989 spring_trap (door->inv, op);
2106 2102
2107 if (op->speed_left > 0.f) 2103 if (op->speed_left > 0.f)
2108 { 2104 {
2109 --op->speed_left; 2105 --op->speed_left;
2110 2106
2111 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2107 op->play_sound (sound_find ("push_player"));
2112 push_ob (mon, dir, op); 2108 push_ob (mon, dir, op);
2113 2109
2114 if (op->contr->tmp_invis || op->hide) 2110 if (op->contr->tmp_invis || op->hide)
2115 make_visible (op); 2111 make_visible (op);
2116 2112
2135 { 2131 {
2136 --op->speed_left; 2132 --op->speed_left;
2137 2133
2138 if (!op->contr->braced) 2134 if (!op->contr->braced)
2139 { 2135 {
2140 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2136 op->play_sound (sound_find ("push_player"));
2141 push_ob (mon, dir, op); 2137 push_ob (mon, dir, op);
2142 } 2138 }
2143 else 2139 else
2144 new_draw_info (0, 0, op, "You withhold your attack"); 2140 new_draw_info (0, 0, op, "You withhold your attack");
2145 2141
2288 return 0; 2284 return 0;
2289 2285
2290 for (object *tmp = op->inv; tmp; tmp = tmp->below) 2286 for (object *tmp = op->inv; tmp; tmp = tmp->below)
2291 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE)) 2287 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE))
2292 { 2288 {
2293 play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE); 2289 op->play_sound (sound_find ("ob_evaporate"));
2294 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp)); 2290 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp));
2295 2291
2296 if (op->contr) 2292 if (op->contr)
2297 esrv_del_item (op->contr, tmp->count); 2293 esrv_del_item (op->contr, tmp->count);
2298 2294
2318/* This goes throws the inventory and removes unpaid objects, and puts them 2314/* This goes throws the inventory and removes unpaid objects, and puts them
2319 * back in the map (location and map determined by values of env). This 2315 * back in the map (location and map determined by values of env). This
2320 * function will descend into containers. op is the object to start the search 2316 * function will descend into containers. op is the object to start the search
2321 * from. 2317 * from.
2322 */ 2318 */
2323void 2319static void
2324remove_unpaid_objects (object *op, object *env) 2320drop_unpaid_items (object *op, object *env)
2325{ 2321{
2326 while (op) 2322 while (op)
2327 { 2323 {
2328 object *next = op->below; /* Make sure we have a good value, in case we remove object 'op' */ 2324 object *next = op->below; /* Make sure we have a good value, in case we remove object 'op' */
2329 2325
2333 esrv_del_item (env->contr, op->count); 2329 esrv_del_item (env->contr, op->count);
2334 2330
2335 op->insert_at (env); 2331 op->insert_at (env);
2336 } 2332 }
2337 else if (op->inv) 2333 else if (op->inv)
2338 remove_unpaid_objects (op->inv, env); 2334 drop_unpaid_items (op->inv, env);
2339 2335
2340 op = next; 2336 op = next;
2341 } 2337 }
2338}
2339
2340void
2341object::drop_unpaid_items ()
2342{
2343 if (!flag [FLAG_REMOVED])
2344 ::drop_unpaid_items (inv, this);
2342} 2345}
2343 2346
2344/* 2347/*
2345 * Returns pointer a static string containing gravestone text 2348 * Returns pointer a static string containing gravestone text
2346 * Moved from apply.c to player.c - player.c is what 2349 * Moved from apply.c to player.c - player.c is what
2552 } 2555 }
2553 2556
2554 /* Digestion */ 2557 /* Digestion */
2555 if (--op->last_eat < 0) 2558 if (--op->last_eat < 0)
2556 { 2559 {
2557 int bonus = op->contr->digestion > 0 ? op->contr->digestion : 0, penalty = op->contr->digestion < 0 ? -op->contr->digestion : 0; 2560 int bonus = max (0, op->contr->digestion),
2561 penalty = max (0, -op->contr->digestion);
2558 2562
2559 if (op->contr->gen_hp > 0)
2560 op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1); 2563 op->last_eat = 25 * (1 + bonus) / (max (0, op->contr->gen_hp) + penalty + 1);
2561 else
2562 op->last_eat = 25 * (1 + bonus) / (penalty + 1);
2563 2564
2564 /* dms do not consume food */ 2565 /* dms do not consume food */
2565 if (!QUERY_FLAG (op, FLAG_WIZ)) 2566 if (!QUERY_FLAG (op, FLAG_WIZ))
2566 op->stats.food--; 2567 op->stats.food--;
2567 } 2568 }
2628 object *tmp; 2629 object *tmp;
2629 2630
2630 if (save_life (op)) 2631 if (save_life (op))
2631 return; 2632 return;
2632 2633
2633
2634 /* If player dies on BATTLEGROUND, no stat/exp loss! For Combat-Arenas 2634 /* If player dies on BATTLEGROUND, no stat/exp loss! For Combat-Arenas
2635 * in cities ONLY!!! It is very important that this doesn't get abused. 2635 * in cities ONLY!!! It is very important that this doesn't get abused.
2636 * Look at op_on_battleground() for more info --AndreasV 2636 * Look at op_on_battleground() for more info --AndreasV
2637 */ 2637 */
2638 if (op_on_battleground (op, &x, &y)) 2638 if (op_on_battleground (op, &x, &y))
2690 strcpy (op->contr->killer, "starvation"); 2690 strcpy (op->contr->killer, "starvation");
2691 } 2691 }
2692 else 2692 else
2693 sprintf (buf, "%s died.", &op->name); 2693 sprintf (buf, "%s died.", &op->name);
2694 2694
2695 play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0); 2695 op->contr->play_sound (sound_find ("player_dies"));
2696 2696
2697 /* save the map location for corpse, gravestone */ 2697 /* save the map location for corpse, gravestone */
2698 x = op->x; 2698 x = op->x;
2699 y = op->y; 2699 y = op->y;
2700 map = op->map; 2700 map = op->map;
2877 2877
2878 /* 2878 /*
2879 * Check to see if the player has any unpaid items. If so, remove them 2879 * Check to see if the player has any unpaid items. If so, remove them
2880 * and put them back in the map. 2880 * and put them back in the map.
2881 */ 2881 */
2882 remove_unpaid_objects (op->inv, op); 2882 op->drop_unpaid_items ();
2883 2883
2884 /****************************************/ 2884 /****************************************/
2885 /* */ 2885 /* */
2886 /* Move player to his current respawn- */ 2886 /* Move player to his current respawn- */
2887 /* position (usually last savebed) */ 2887 /* position (usually last savebed) */
3039} 3039}
3040 3040
3041int 3041int
3042is_true_undead (object *op) 3042is_true_undead (object *op)
3043{ 3043{
3044 if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD)) 3044 if (QUERY_FLAG (op->arch, FLAG_UNDEAD))
3045 return 1; 3045 return 1;
3046 3046
3047 return 0; 3047 return 0;
3048} 3048}
3049 3049
3219 * a blocked los square. 3219 * a blocked los square.
3220 * we use the archetype to figure out offsets. 3220 * we use the archetype to figure out offsets.
3221 */ 3221 */
3222 while (op) 3222 while (op)
3223 { 3223 {
3224 dx = rv.distance_x + op->arch->clone.x; 3224 dx = rv.distance_x + op->arch->x;
3225 dy = rv.distance_y + op->arch->clone.y; 3225 dy = rv.distance_y + op->arch->y;
3226 3226
3227 /* only the viewable area the player sees is updated by LOS 3227 /* only the viewable area the player sees is updated by LOS
3228 * code, so we need to restrict ourselves to that range of values 3228 * code, so we need to restrict ourselves to that range of values
3229 * for any meaningful values. 3229 * for any meaningful values.
3230 */ 3230 */
3355 /* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */ 3355 /* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */
3356 return; 3356 return;
3357 } 3357 }
3358 3358
3359 /* everything seems okay - now bring on the gift: */ 3359 /* everything seems okay - now bring on the gift: */
3360 item = &(tr->item->clone); 3360 item = tr->item;
3361 3361
3362 if (item->type == SPELL) 3362 if (item->type == SPELL)
3363 { 3363 {
3364 if (check_spell_known (who, item->name)) 3364 if (check_spell_known (who, item->name))
3365 return; 3365 return;
3424 { 3424 {
3425 /* forces in the treasurelist can alter the player's stats */ 3425 /* forces in the treasurelist can alter the player's stats */
3426 object *skin; 3426 object *skin;
3427 3427
3428 /* first get the dragon skin force */ 3428 /* first get the dragon skin force */
3429 shstr_cmp dragon_skin_force ("dragon_skin_force");
3430 for (skin = who->inv; skin && !(skin->arch->name == dragon_skin_force); skin = skin->below) 3429 for (skin = who->inv; skin && !(skin->arch->archname == shstr_dragon_skin_force); skin = skin->below)
3431 ; 3430 ;
3432 3431
3433 if (!skin) 3432 if (!skin)
3434 return; 3433 return;
3435 3434

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines