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.144 by root, Sat May 26 15:44:08 2007 UTC vs.
Revision 1.158 by root, Mon Aug 13 15:46:45 2007 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game 2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 8 * Crossfire TRT is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) 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, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License 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 18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * 20 *
22 * The author 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>
26#include <sproto.h> 25#include <sproto.h>
27#include <sounds.h> 26#include <sounds.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
312// by load_object not returning the object 313// by load_object not returning the object
313void 314void
314player::set_object (object *op) 315player::set_object (object *op)
315{ 316{
316 ob = op; 317 ob = observe = op;
317 ob->contr = this; /* this aren't yet in archetype */ 318 ob->contr = this; /* this aren't yet in archetype */
318 319
319 ob->speed = 1.0f; 320 ob->speed = 1.0f;
320 ob->speed_left = 0.5f; 321 ob->speed_left = 0.5f;
321 322
322 ob->direction = 5; /* So player faces south */ 323 ob->direction = 5; /* So player faces south */
324}
325
326void
327player::set_observe (object *op)
328{
329 observe = op ? op : ob;
330 do_los = 1;
323} 331}
324 332
325player::player () 333player::player ()
326{ 334{
327 /* There are some elements we want initialised to non zero value - 335 /* There are some elements we want initialised to non zero value -
… …
355 if (ob) 363 if (ob)
356 { 364 {
357 ob->destroy_inv (false); 365 ob->destroy_inv (false);
358 ob->destroy (); 366 ob->destroy ();
359 } 367 }
368
369 ob = observe = 0;
360} 370}
361 371
362player::~player () 372player::~player ()
363{ 373{
364 /* Clear item stack */ 374 /* Clear item stack */
… …
391 * Note: there MUST be at least one player archetype! 401 * Note: there MUST be at least one player archetype!
392 */ 402 */
393archetype * 403archetype *
394get_player_archetype (archetype *at) 404get_player_archetype (archetype *at)
395{ 405{
396 archetype *start = at; 406 archvec::iterator i = at ? archetypes.find (at) : archetypes.begin ();
397 407
398 for (;;) 408 for (;;)
399 { 409 {
400 if (at == NULL || at->next == NULL) 410 if (++i == archetypes.end ())
401 at = first_archetype; 411 i = archetypes.begin ();
402 else 412 else if (*i == at)
403 at = at->next; 413 cleanup ("not a single player archetype found");
404 414
405 if (at->clone.type == PLAYER) 415 if ((*i)->type == PLAYER)
406 return at; 416 return *i;
407
408 if (at == start)
409 {
410 LOG (llevError, "No Player archetypes\n");
411 exit (-1);
412 }
413 } 417 }
414} 418}
415 419
416object * 420object *
417get_nearest_player (object *mon) 421get_nearest_player (object *mon)
… …
907 if (*first_map_ext_path) 911 if (*first_map_ext_path)
908 { 912 {
909 object *tmp; 913 object *tmp;
910 char mapname[MAX_BUF]; 914 char mapname[MAX_BUF];
911 915
912 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);
913 tmp = object::create (); 917 tmp = object::create ();
914 EXIT_PATH (tmp) = mapname; 918 EXIT_PATH (tmp) = mapname;
915 EXIT_X (tmp) = ob->x; 919 EXIT_X (tmp) = ob->x;
916 EXIT_Y (tmp) = ob->y; 920 EXIT_Y (tmp) = ob->y;
917 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;
… …
936 int x = ob->x, y = ob->y; 940 int x = ob->x, y = ob->y;
937 941
938 ob->remove_statbonus (); 942 ob->remove_statbonus ();
939 ob->remove (); 943 ob->remove ();
940 ob->arch = get_player_archetype (ob->arch); 944 ob->arch = get_player_archetype (ob->arch);
941 ob->arch->clone.copy_to (ob); 945 ob->arch->copy_to (ob);
942 ob->instantiate (); 946 ob->instantiate ();
943 ob->stats = ob->contr->orig_stats; 947 ob->stats = ob->contr->orig_stats;
944 ob->name = ob->name_pl = name; 948 ob->name = ob->name_pl = name;
945 ob->x = x; 949 ob->x = x;
946 ob->y = y; 950 ob->y = y;
947 SET_ANIMATION (ob, 2); /* So player faces south */ 951 SET_ANIMATION (ob, 2); /* So player faces south */
948 insert_ob_in_map (ob, ob->map, ob, 0); 952 insert_ob_in_map (ob, ob->map, ob, 0);
949 assign (ob->contr->title, ob->arch->clone.name); 953 assign (ob->contr->title, ob->arch->object::name);
950 ob->add_statbonus (); 954 ob->add_statbonus ();
951 } 955 }
952 while (!allowed_class (ob)); 956 while (!allowed_class (ob));
953 957
954 update_object (ob, UP_OBJ_FACE); 958 update_object (ob, UP_OBJ_FACE);
… …
1099 if (tmp->name != NULL) 1103 if (tmp->name != NULL)
1100 sprintf (putstring, "item name: %s item type: %d weight/value: %d", 1104 sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1101 &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))));
1102 else 1106 else
1103 sprintf (putstring, "item name: %s item type: %d weight/value: %d", 1107 sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1104 &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))));
1105 1109
1106 new_draw_info (NDI_UNIQUE, 0, op, putstring); 1110 new_draw_info (NDI_UNIQUE, 0, op, putstring);
1107 } 1111 }
1108 1112
1109 /* philosophy: 1113 /* philosophy:
… …
1184 pick_up (op, tmp); 1188 pick_up (op, tmp);
1185 continue; 1189 continue;
1186 } 1190 }
1187 1191
1188 if (op->contr->mode & PU_READABLES) 1192 if (op->contr->mode & PU_READABLES)
1189 if (tmp->type == BOOK || tmp->type == SCROLL) 1193 if (tmp->type == BOOK || tmp->type == SCROLL || tmp->type == INSCRIBABLE)
1190 { 1194 {
1191 pick_up (op, tmp); 1195 pick_up (op, tmp);
1192 continue; 1196 continue;
1193 } 1197 }
1194 1198
… …
1302 /* careful: chairs and tables are weapons! */ 1306 /* careful: chairs and tables are weapons! */
1303 if (op->contr->mode & PU_ALLWEAPON) 1307 if (op->contr->mode & PU_ALLWEAPON)
1304 { 1308 {
1305 if (tmp->type == WEAPON && tmp->name != NULL) 1309 if (tmp->type == WEAPON && tmp->name != NULL)
1306 { 1310 {
1307 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 &&
1308 strstr (tmp->name, "chair") && strstr (tmp->arch->name, "chair") == NULL) 1312 strstr (tmp->name, "chair") && strstr (tmp->arch->archname, "chair") == NULL)
1309 { 1313 {
1310 pick_up (op, tmp); 1314 pick_up (op, tmp);
1311 continue; 1315 continue;
1312 } 1316 }
1313 } 1317 }
1314 1318
1315 if (tmp->type == WEAPON && tmp->name == NULL) 1319 if (tmp->type == WEAPON && tmp->name == NULL)
1316 { 1320 {
1317 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)
1318 { 1322 {
1319 pick_up (op, tmp); 1323 pick_up (op, tmp);
1320 continue; 1324 continue;
1321 } 1325 }
1322 } 1326 }
… …
1347 if (tmp->name != NULL) 1351 if (tmp->name != NULL)
1348 { 1352 {
1349 fprintf (stderr, "%s", tmp->name); 1353 fprintf (stderr, "%s", tmp->name);
1350 } 1354 }
1351 else 1355 else
1352 fprintf (stderr, "%s", tmp->arch->name); 1356 fprintf (stderr, "%s", tmp->arch->archname);
1353 fprintf (stderr, ",%d] = ", tmp->type); 1357 fprintf (stderr, ",%d] = ", tmp->type);
1354 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))));
1355#endif 1359#endif
1356 continue; 1360 continue;
1357 } 1361 }
… …
1427 else 1431 else
1428 { 1432 {
1429 for (attacknum = 0; attacknum < NROFATTACKS; attacknum++) 1433 for (attacknum = 0; attacknum < NROFATTACKS; attacknum++)
1430 { 1434 {
1431 attacktype = 1 << attacknum; 1435 attacktype = 1 << attacknum;
1432 if ((arrow->attacktype & attacktype) && (target->arch->clone.resist[attacknum]) < 0) 1436 if ((arrow->attacktype & attacktype) && (target->arch->resist[attacknum]) < 0)
1433 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)
1434 { 1438 {
1435 tmp = arrow; 1439 tmp = arrow;
1436 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;
1437 } 1441 }
1438 } 1442 }
1439 if ((2 + arrow->magic + arrow->stats.dam) > betterby) 1443 if ((2 + arrow->magic + arrow->stats.dam) > betterby)
1440 { 1444 {
1441 tmp = arrow; 1445 tmp = arrow;
… …
1679 1683
1680 arrow->stats.wc = clamp (wc, MIN_WC, MAX_WC); 1684 arrow->stats.wc = clamp (wc, MIN_WC, MAX_WC);
1681 arrow->move_type = MOVE_FLY_LOW; 1685 arrow->move_type = MOVE_FLY_LOW;
1682 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK; 1686 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
1683 1687
1684 play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW); 1688 op->play_sound (sound_find ("fire_arrow"));
1685 m->insert (arrow, sx, sy, op); 1689 m->insert (arrow, sx, sy, op);
1686 1690
1687 if (!arrow->destroyed ()) 1691 if (!arrow->destroyed ())
1688 move_arrow (arrow); 1692 move_arrow (arrow);
1689 1693
… …
1767 1771
1768 if (item->type == WAND) 1772 if (item->type == WAND)
1769 { 1773 {
1770 if (item->stats.food <= 0) 1774 if (item->stats.food <= 0)
1771 { 1775 {
1772 play_sound_player_only (op->contr, SOUND_WAND_POOF, 0, 0); 1776 op->contr->play_sound (sound_find ("wand_poof"));
1773 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));
1774 1778
1775 return; 1779 return;
1776 } 1780 }
1777 } 1781 }
1778 else if (item->type == ROD || item->type == HORN) 1782 else if (item->type == ROD || item->type == HORN)
1779 { 1783 {
1780 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))
1781 { 1785 {
1782 play_sound_player_only (op->contr, SOUND_WAND_POOF, 0, 0); 1786 op->contr->play_sound (sound_find ("wand_poof"));
1783 1787
1784 if (item->type == ROD) 1788 if (item->type == ROD)
1785 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));
1786 else 1790 else
1787 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));
… …
1800 object *tmp; 1804 object *tmp;
1801 1805
1802 if (item->arch) 1806 if (item->arch)
1803 { 1807 {
1804 CLEAR_FLAG (item, FLAG_ANIMATE); 1808 CLEAR_FLAG (item, FLAG_ANIMATE);
1805 item->face = item->arch->clone.face; 1809 item->face = item->arch->face;
1806 item->set_speed (0); 1810 item->set_speed (0);
1807 } 1811 }
1808 1812
1809 if ((tmp = item->in_player ())) 1813 if ((tmp = item->in_player ()))
1810 esrv_update_item (UPD_ANIM, tmp, item); 1814 esrv_update_item (UPD_ANIM, tmp, item);
… …
1976 /* If we found a key, do some extra work */ 1980 /* If we found a key, do some extra work */
1977 if (key) 1981 if (key)
1978 { 1982 {
1979 object *container = key->env; 1983 object *container = key->env;
1980 1984
1981 play_sound_map (op->map, op->x, op->y, SOUND_OPEN_DOOR);
1982
1983 if (action_makes_visible (op)) 1985 if (action_makes_visible (op))
1984 make_visible (op); 1986 make_visible (op);
1985 1987
1986 if (door->inv && (door->inv->type == RUNE || door->inv->type == TRAP)) 1988 if (door->inv && (door->inv->type == RUNE || door->inv->type == TRAP))
1987 spring_trap (door->inv, op); 1989 spring_trap (door->inv, op);
… …
2100 2102
2101 if (op->speed_left > 0.f) 2103 if (op->speed_left > 0.f)
2102 { 2104 {
2103 --op->speed_left; 2105 --op->speed_left;
2104 2106
2105 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2107 op->play_sound (sound_find ("push_player"));
2106 push_ob (mon, dir, op); 2108 push_ob (mon, dir, op);
2107 2109
2108 if (op->contr->tmp_invis || op->hide) 2110 if (op->contr->tmp_invis || op->hide)
2109 make_visible (op); 2111 make_visible (op);
2110 2112
… …
2129 { 2131 {
2130 --op->speed_left; 2132 --op->speed_left;
2131 2133
2132 if (!op->contr->braced) 2134 if (!op->contr->braced)
2133 { 2135 {
2134 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2136 op->play_sound (sound_find ("push_player"));
2135 push_ob (mon, dir, op); 2137 push_ob (mon, dir, op);
2136 } 2138 }
2137 else 2139 else
2138 new_draw_info (0, 0, op, "You withhold your attack"); 2140 new_draw_info (0, 0, op, "You withhold your attack");
2139 2141
… …
2282 return 0; 2284 return 0;
2283 2285
2284 for (object *tmp = op->inv; tmp; tmp = tmp->below) 2286 for (object *tmp = op->inv; tmp; tmp = tmp->below)
2285 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE)) 2287 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE))
2286 { 2288 {
2287 play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE); 2289 op->play_sound (sound_find ("ob_evaporate"));
2288 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));
2289 2291
2290 if (op->contr) 2292 if (op->contr)
2291 esrv_del_item (op->contr, tmp->count); 2293 esrv_del_item (op->contr, tmp->count);
2292 2294
… …
2312/* 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
2313 * 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
2314 * 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
2315 * from. 2317 * from.
2316 */ 2318 */
2317void 2319static void
2318remove_unpaid_objects (object *op, object *env) 2320drop_unpaid_items (object *op, object *env)
2319{ 2321{
2320 while (op) 2322 while (op)
2321 { 2323 {
2322 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' */
2323 2325
… …
2327 esrv_del_item (env->contr, op->count); 2329 esrv_del_item (env->contr, op->count);
2328 2330
2329 op->insert_at (env); 2331 op->insert_at (env);
2330 } 2332 }
2331 else if (op->inv) 2333 else if (op->inv)
2332 remove_unpaid_objects (op->inv, env); 2334 drop_unpaid_items (op->inv, env);
2333 2335
2334 op = next; 2336 op = next;
2335 } 2337 }
2338}
2339
2340void
2341object::drop_unpaid_items ()
2342{
2343 if (!flag [FLAG_REMOVED])
2344 ::drop_unpaid_items (inv, this);
2336} 2345}
2337 2346
2338/* 2347/*
2339 * Returns pointer a static string containing gravestone text 2348 * Returns pointer a static string containing gravestone text
2340 * Moved from apply.c to player.c - player.c is what 2349 * Moved from apply.c to player.c - player.c is what
… …
2546 } 2555 }
2547 2556
2548 /* Digestion */ 2557 /* Digestion */
2549 if (--op->last_eat < 0) 2558 if (--op->last_eat < 0)
2550 { 2559 {
2551 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);
2552 2562
2553 if (op->contr->gen_hp > 0)
2554 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);
2555 else
2556 op->last_eat = 25 * (1 + bonus) / (penalty + 1);
2557 2564
2558 /* dms do not consume food */ 2565 /* dms do not consume food */
2559 if (!QUERY_FLAG (op, FLAG_WIZ)) 2566 if (!QUERY_FLAG (op, FLAG_WIZ))
2560 op->stats.food--; 2567 op->stats.food--;
2561 } 2568 }
… …
2622 object *tmp; 2629 object *tmp;
2623 2630
2624 if (save_life (op)) 2631 if (save_life (op))
2625 return; 2632 return;
2626 2633
2627
2628 /* 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
2629 * 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.
2630 * Look at op_on_battleground() for more info --AndreasV 2636 * Look at op_on_battleground() for more info --AndreasV
2631 */ 2637 */
2632 if (op_on_battleground (op, &x, &y)) 2638 if (op_on_battleground (op, &x, &y))
… …
2684 strcpy (op->contr->killer, "starvation"); 2690 strcpy (op->contr->killer, "starvation");
2685 } 2691 }
2686 else 2692 else
2687 sprintf (buf, "%s died.", &op->name); 2693 sprintf (buf, "%s died.", &op->name);
2688 2694
2689 play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0); 2695 op->contr->play_sound (sound_find ("player_dies"));
2690 2696
2691 /* save the map location for corpse, gravestone */ 2697 /* save the map location for corpse, gravestone */
2692 x = op->x; 2698 x = op->x;
2693 y = op->y; 2699 y = op->y;
2694 map = op->map; 2700 map = op->map;
… …
2871 2877
2872 /* 2878 /*
2873 * 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
2874 * and put them back in the map. 2880 * and put them back in the map.
2875 */ 2881 */
2876 remove_unpaid_objects (op->inv, op); 2882 op->drop_unpaid_items ();
2877 2883
2878 /****************************************/ 2884 /****************************************/
2879 /* */ 2885 /* */
2880 /* Move player to his current respawn- */ 2886 /* Move player to his current respawn- */
2881 /* position (usually last savebed) */ 2887 /* position (usually last savebed) */
… …
3033} 3039}
3034 3040
3035int 3041int
3036is_true_undead (object *op) 3042is_true_undead (object *op)
3037{ 3043{
3038 if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD)) 3044 if (QUERY_FLAG (op->arch, FLAG_UNDEAD))
3039 return 1; 3045 return 1;
3040 3046
3041 return 0; 3047 return 0;
3042} 3048}
3043 3049
… …
3213 * a blocked los square. 3219 * a blocked los square.
3214 * we use the archetype to figure out offsets. 3220 * we use the archetype to figure out offsets.
3215 */ 3221 */
3216 while (op) 3222 while (op)
3217 { 3223 {
3218 dx = rv.distance_x + op->arch->clone.x; 3224 dx = rv.distance_x + op->arch->x;
3219 dy = rv.distance_y + op->arch->clone.y; 3225 dy = rv.distance_y + op->arch->y;
3220 3226
3221 /* only the viewable area the player sees is updated by LOS 3227 /* only the viewable area the player sees is updated by LOS
3222 * 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
3223 * for any meaningful values. 3229 * for any meaningful values.
3224 */ 3230 */
… …
3349 /* 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]); */
3350 return; 3356 return;
3351 } 3357 }
3352 3358
3353 /* everything seems okay - now bring on the gift: */ 3359 /* everything seems okay - now bring on the gift: */
3354 item = &(tr->item->clone); 3360 item = tr->item;
3355 3361
3356 if (item->type == SPELL) 3362 if (item->type == SPELL)
3357 { 3363 {
3358 if (check_spell_known (who, item->name)) 3364 if (check_spell_known (who, item->name))
3359 return; 3365 return;
… …
3418 { 3424 {
3419 /* forces in the treasurelist can alter the player's stats */ 3425 /* forces in the treasurelist can alter the player's stats */
3420 object *skin; 3426 object *skin;
3421 3427
3422 /* first get the dragon skin force */ 3428 /* first get the dragon skin force */
3423 shstr_cmp dragon_skin_force ("dragon_skin_force");
3424 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)
3425 ; 3430 ;
3426 3431
3427 if (!skin) 3432 if (!skin)
3428 return; 3433 return;
3429 3434

Diff Legend

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