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.39 by root, Thu Dec 14 14:23:09 2006 UTC vs.
Revision 1.82 by elmex, Wed Jan 3 02:30:52 2007 UTC

… …
27#include <sounds.h> 27#include <sounds.h>
28#include <living.h> 28#include <living.h>
29#include <object.h> 29#include <object.h>
30#include <spells.h> 30#include <spells.h>
31#include <skills.h> 31#include <skills.h>
32#include <newclient.h>
33 32
34#ifdef COZY_SERVER 33#include <algorithm>
35extern int same_party (partylist *a, partylist *b); 34#include <functional>
36#endif
37 35
38player * 36player *
39find_player (const char *plname) 37find_player (const char *plname)
40{ 38{
41 player *pl; 39 for_all_players (pl)
42
43 for (pl = first_player; pl != NULL; pl = pl->next)
44 {
45 if (pl->ob != NULL && !strcmp (query_name (pl->ob), plname)) 40 if (pl->ob && !strcmp (query_name (pl->ob), plname))
46 return pl; 41 return pl;
47 }; 42
48 return NULL; 43 return 0;
49}
50
51player *
52find_player_partial_name (const char *plname)
53{
54 player *pl;
55 player *found = NULL;
56 size_t namelen = strlen (plname);
57
58 for (pl = first_player; pl != NULL; pl = pl->next)
59 {
60 if ((size_t) strlen (pl->ob->name) < namelen)
61 continue;
62
63 if (!strcmp (pl->ob->name, plname))
64 return pl;
65
66 if (!strncasecmp (pl->ob->name, plname, namelen))
67 {
68 if (found)
69 return NULL;
70
71 found = pl;
72 }
73 }
74 return found;
75} 44}
76 45
77void 46void
78display_motd (const object *op) 47display_motd (const object *op)
79{ 48{
… …
83 int comp; 52 int comp;
84 int size; 53 int size;
85 54
86 sprintf (buf, "%s/%s", settings.confdir, settings.motd); 55 sprintf (buf, "%s/%s", settings.confdir, settings.motd);
87 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL) 56 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
88 {
89 return; 57 return;
90 } 58
91 motd[0] = '\0'; 59 motd[0] = '\0';
92 size = 0; 60 size = 0;
61
93 while (fgets (buf, MAX_BUF, fp) != NULL) 62 while (fgets (buf, MAX_BUF, fp))
94 { 63 {
95 if (*buf == '#') 64 if (*buf == '#')
96 continue; 65 continue;
66
97 strncat (motd + size, buf, HUGE_BUF - size); 67 strncat (motd + size, buf, HUGE_BUF - size);
98 size += strlen (buf); 68 size += strlen (buf);
99 } 69 }
70
100 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_MOTD, MSG_SUBTYPE_NONE, motd, NULL); 71 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_MOTD, MSG_SUBTYPE_NONE, motd, NULL);
101 close_and_delete (fp, comp); 72 close_and_delete (fp, comp);
102} 73}
103 74
104void 75void
… …
110 int comp; 81 int comp;
111 int size; 82 int size;
112 83
113 sprintf (buf, "%s/%s", settings.confdir, settings.rules); 84 sprintf (buf, "%s/%s", settings.confdir, settings.rules);
114 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL) 85 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
115 {
116 return; 86 return;
117 } 87
118 rules[0] = '\0'; 88 rules[0] = '\0';
119 size = 0; 89 size = 0;
90
120 while (fgets (buf, MAX_BUF, fp) != NULL) 91 while (fgets (buf, MAX_BUF, fp))
121 { 92 {
122 if (*buf == '#') 93 if (*buf == '#')
123 continue; 94 continue;
95
124 if (size + strlen (buf) >= HUGE_BUF) 96 if (size + strlen (buf) >= HUGE_BUF)
125 { 97 {
126 LOG (llevDebug, "Warning, rules size is > %d bytes.\n", HUGE_BUF); 98 LOG (llevDebug, "Warning, rules size is > %d bytes.\n", HUGE_BUF);
127 break; 99 break;
128 } 100 }
101
129 strncat (rules + size, buf, HUGE_BUF - size); 102 strncat (rules + size, buf, HUGE_BUF - size);
130 size += strlen (buf); 103 size += strlen (buf);
131 } 104 }
105
132 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_RULES, rules, NULL); 106 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_RULES, rules, NULL);
133 close_and_delete (fp, comp); 107 close_and_delete (fp, comp);
134} 108}
135 109
136void 110void
… …
144 int size; 118 int size;
145 119
146 sprintf (buf, "%s/%s", settings.confdir, settings.news); 120 sprintf (buf, "%s/%s", settings.confdir, settings.news);
147 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL) 121 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
148 return; 122 return;
123
149 news[0] = '\0'; 124 news[0] = '\0';
150 subject[0] = '\0'; 125 subject[0] = '\0';
151 size = 0; 126 size = 0;
127
152 while (fgets (buf, MAX_BUF, fp) != NULL) 128 while (fgets (buf, MAX_BUF, fp) != NULL)
153 { 129 {
154 if (*buf == '#') 130 if (*buf == '#')
155 continue; 131 continue;
132
156 if (*buf == '%') 133 if (*buf == '%')
157 { /* send one news */ 134 { /* send one news */
158 if (size > 0) 135 if (size > 0)
159 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s", "%s\n%s", subject, news); /*send previously read news */ 136 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s", "%s\n%s", subject, news); /*send previously read news */
160 strcpy (subject, buf + 1); 137 strcpy (subject, buf + 1);
… …
177 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op, 154 draw_ext_info_format (NDI_UNIQUE | NDI_GREEN, 0, op,
178 MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s\n", "%s\n%s", subject, news); 155 MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_NEWS, "INFORMATION: %s\n%s\n", "%s\n%s", subject, news);
179 close_and_delete (fp, comp); 156 close_and_delete (fp, comp);
180} 157}
181 158
182int 159/* This loads the first map an puts the player on it. */
183playername_ok (const char *cp) 160static void
161set_first_map (object *op)
184{ 162{
185 /* Don't allow - or _ as first character in the name */ 163 op->contr->maplevel = first_map_path;
186 if (*cp == '-' || *cp == '_') 164 op->x = -1;
187 return 0; 165 op->y = -1;
188
189 for (; *cp != '\0'; cp++)
190 if (!((*cp >= 'a' && *cp <= 'z') || (*cp >= 'A' && *cp <= 'Z')) && *cp != '-' && *cp != '_')
191 return 0;
192 return 1;
193} 166}
194 167
195/* This no longer sets the player map. Also, it now updates 168void
196 * all the pointers so the caller doesn't need to do that. 169player::enter_map ()
197 * Caller is responsible for setting the correct map.
198 */
199
200/* Redo this to do both get_player_ob and get_player.
201 * Hopefully this will be less bugfree and simpler.
202 * Returns the player structure. If 'p' is null,
203 * we create a new one. Otherwise, we recycle
204 * the one that is passed.
205 */
206static player *
207get_player (player *p)
208{ 170{
209 object *op = arch_to_object (get_player_archetype (0)); 171 object *tmp = object::create ();
210 int i;
211 172
212 /* Clears basically the entire player structure except 173 EXIT_PATH (tmp) = maplevel;
213 * for next and socket. 174 EXIT_X (tmp) = ob->x;
175 EXIT_Y (tmp) = ob->y;
176 ob->enter_exit (tmp);
177
178 tmp->destroy ();
179}
180
181// connect the player with a specific client
182// also changed, rationalises, and fixes some incorrect settings
183void
184player::connect (client *ns)
185{
186 this->ns = ns;
187 ns->pl = this;
188
189 next = first_player;
190 first_player = this;
191
192 ns->update_look = 0;
193 ns->look_position = 0;
194
195 clear_los (ob);
196
197 /* make sure he's a player -- needed because of class change. */
198 ob->type = PLAYER; // we are paranoid
199 ob->race = ob->arch->clone.race;
200
201 if (!legal_range (ob, shoottype))
202 shoottype = range_none;
203
204 ob->carrying = sum_weight (ob);
205 link_player_skills (ob);
206
207 CLEAR_FLAG (ob, FLAG_NO_FIX_PLAYER);
208
209 assign (title, ob->arch->clone.name);
210
211 /* can_use_shield is a new flag. However, the can_use.. seems to largely come
212 * from the class, and not race. I don't see any way to get the class information
213 * to then update this. I don't think this will actually break anything - anyone
214 * that can use armour should be able to use a shield. What this may 'break'
215 * are features new characters get, eg, if someone starts up with a Q, they
216 * should be able to use a shield. However, old Q's won't get that advantage.
214 */ 217 */
215 p->clear (); 218 if (QUERY_FLAG (ob, FLAG_USE_ARMOUR))
219 SET_FLAG (ob, FLAG_USE_SHIELD);
216 220
221 /* if it's a dragon player, set the correct title here */
222 if (is_dragon_pl (ob))
223 {
224 object *tmp, *abil = 0, *skin = 0;
225
226 shstr_cmp dragon_ability_force ("dragon_ability_force");
227 shstr_cmp dragon_skin_force ("dragon_skin_force");
228
229 for (tmp = ob->inv; tmp; tmp = tmp->below)
230 if (tmp->type == FORCE)
231 if (tmp->arch->name == dragon_ability_force)
232 abil = tmp;
233 else if (tmp->arch->name == dragon_skin_force)
234 skin = tmp;
235
236 set_dragon_name (ob, abil, skin);
237 }
238
239 CLEAR_FLAG (ob, FLAG_FRIENDLY);
240 add_friendly_object (ob);
241
242 LOG (llevInfo, "LOGIN: Player named %s from ip %s\n", &ob->name, ns->host);
243
244 new_draw_info (NDI_UNIQUE, 0, ob, "Welcome Back!");
245
246 esrv_new_player (this, ob->weight + ob->carrying);
247
248 ob->update_stats ();
249 ns->floorbox_update ();
250
251 esrv_send_inventory (ob, ob);
252 esrv_add_spells (this, 0);
253
254 ob->activate_recursive ();
255 enter_map ();
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
265void
266player::disconnect ()
267{
268 if (ob)
269 ob->deactivate_recursive ();
270
271 //TODO: don't be so harsh and destroy :)
272 if (ns)
273 {
274 if (enable_save)
275 {
276 INVOKE_PLAYER (LOGOUT, this, ARG_INT (0));
277 save (true);
278 }
279
280 INVOKE_PLAYER (DISCONNECT, this);
281
282 client *ns = this->ns;
283 ns->send_packet ("goodbye");
284 ns->flush ();
285 ns->pl = 0;
286 this->ns = 0;
287
288 ns->destroy ();
289 destroy ();
290 }
291}
292
293// the need for this function can be explained
294// by load_object not returning the object
295void
296player::set_object (object *op)
297{
298 ob = op;
299 ob->contr = this; /* this aren't yet in archetype */
300
301 ob->speed_left = 0.5;
302 ob->speed = 1.0;
303 ob->direction = 5; /* So player faces south */
304 ob->stats.wc = 2;
305 ob->run_away = 25; /* Then we panick... */
306
307 ob->roll_stats ();
308}
309
310player::player ()
311{
217 /* There are some elements we want initialized to non zero value - 312 /* There are some elements we want initialised to non zero value -
218 * we deal with that below this point. 313 * we deal with that below this point.
219 */ 314 */
220 p->party = NULL;
221 p->outputs_sync = 16; /* Every 2 seconds */ 315 outputs_sync = 16; /* Every 2 seconds */
222 p->outputs_count = 8; /* Keeps present behaviour */ 316 outputs_count = 8; /* Keeps present behaviour */
223 p->unapply = unapply_nochoice; 317 unapply = unapply_nochoice;
224 p->Swap_First = -1;
225 318
226#ifdef AUTOSAVE
227 p->last_save_tick = 9999999;
228#endif
229
230 strcpy (p->savebed_map, first_map_path); /* Init. respawn position */ 319 savebed_map = first_map_path; /* Init. respawn position */
231 320
232 op->contr = p; /* this aren't yet in archetype */
233 p->ob = op;
234 op->speed_left = 0.5;
235 op->speed = 1.0;
236 op->direction = 5; /* So player faces south */
237 op->stats.wc = 2;
238 op->run_away = 25; /* Then we panick... */
239
240 {
241 int oldmon = p->socket->monitor_spells; // what a hack
242 p->socket->monitor_spells = 0; /* Needed because esrv_update_spells( ) gets called by roll_stats */
243 roll_stats (op);
244 p->socket->monitor_spells = oldmon;
245 }
246 p->state = ST_ROLL_STAT;
247 clear_los (op);
248
249 p->gen_sp_armour = 10; 321 gen_sp_armour = 10;
250 p->last_speed = -1; 322 last_speed = -1;
251 p->shoottype = range_none; 323 shoottype = range_none;
252 p->bowtype = bow_normal; 324 bowtype = bow_normal;
253 p->petmode = pet_normal; 325 petmode = pet_normal;
254 p->listening = 10; 326 listening = 10;
255 p->usekeys = containers; 327 usekeys = containers;
256 p->last_weapon_sp = -1; 328 last_weapon_sp = -1;
257 p->peaceful = 1; /* default peaceful */ 329 peaceful = 1; /* default peaceful */
258 p->do_los = 1; 330 do_los = 1;
259 p->explore = 0;
260 p->no_shout = 0; /* default can shout */
261
262 assign (p->title, op->arch->clone.name);
263 op->race = op->arch->clone.race;
264
265 CLEAR_FLAG (op, FLAG_READY_SKILL);
266 331
267 /* we need to clear these to -1 and not zero - otherwise, 332 /* we need to clear these to -1 and not zero - otherwise,
268 * if a player quits and starts a new character, we wont 333 * if a player quits and starts a new character, we wont
269 * send new values to the client, as things like exp start 334 * send new values to the client, as things like exp start
270 * at zero. 335 * at zero.
271 */ 336 */
272 for (i = 0; i < NUM_SKILLS; i++) 337 for (int i = 0; i < NUM_SKILLS; i++)
273 {
274 p->last_skill_exp[i] = -1; 338 last_skill_exp[i] = -1;
275 p->last_skill_ob[i] = NULL;
276 }
277 339
278 for (i = 0; i < NROFATTACKS; i++) 340 for (int i = 0; i < NROFATTACKS; i++)
279 p->last_resist[i] = -1; 341 last_resist[i] = -1;
280 342
281 p->last_stats.exp = -1; 343 last_stats.exp = -1;
282 p->last_weight = (uint32) - 1; 344 last_weight = (uint32) - 1;
283
284 p->socket->update_look = 0;
285 p->socket->look_position = 0;
286
287 return p;
288} 345}
289 346
290/* This loads the first map an puts the player on it. */ 347void
291static void 348player::do_destroy ()
292set_first_map (object *op)
293{ 349{
294 strcpy (op->contr->maplevel, first_map_path); 350 disconnect ();
295 op->x = -1;
296 op->y = -1;
297 enter_exit (op, NULL);
298}
299 351
352 save (false);
353 enable_save = false;
354
355 attachable::do_destroy ();
356
357 terminate_all_pets (ob);
358
359 if (first_player != this)
360 {
361 player *prev = first_player;
362
363 while (prev && prev->next && prev->next != this)
364 prev = prev->next;
365
366 if (prev->next != this)
367 {
368 LOG (llevError, "Free_player: Can't find previous player.\n");
369 abort ();
370 }
371
372 prev->next = next;
373 }
374 else
375 first_player = next;
376
377 if (ob)
378 {
379 ob->destroy_inv (false);
380 ob->destroy ();
381 }
382}
383
384player::~player ()
385{
386 /* Clear item stack */
387 free (stack_items);
388}
389
300/* Tries to add player on the connection passwd in ns. 390/* Tries to add player on the connection passed in ns.
301 * All we can really get in this is some settings like host and display 391 * All we can really get in this is some settings like host and display
302 * mode. 392 * mode.
303 */ 393 */
304 394player *
305int 395player::create ()
306add_player (client_socket *ns)
307{ 396{
308 player *p = new player; 397 player *pl = new player;
309 398
310 p->socket = ns; 399 pl->set_object (arch_to_object (get_player_archetype (0)));
311 ns->pl = p;
312
313 p->next = first_player;
314 first_player = p;
315
316 p = get_player (p);
317
318 set_first_map (p->ob); 400 set_first_map (pl->ob);
319 401
320 CLEAR_FLAG (p->ob, FLAG_FRIENDLY);
321 add_friendly_object (p->ob);
322 send_rules (p->ob);
323 send_news (p->ob);
324 display_motd (p->ob);
325 get_name (p->ob);
326
327 return 0; 402 return pl;
328} 403}
329 404
330/* 405/*
331 * get_player_archetype() return next player archetype from archetype 406 * get_player_archetype() return next player archetype from archetype
332 * list. Not very efficient routine, but used only creating new players. 407 * list. Not very efficient routine, but used only creating new players.
… …
341 { 416 {
342 if (at == NULL || at->next == NULL) 417 if (at == NULL || at->next == NULL)
343 at = first_archetype; 418 at = first_archetype;
344 else 419 else
345 at = at->next; 420 at = at->next;
421
346 if (at->clone.type == PLAYER) 422 if (at->clone.type == PLAYER)
347 return at; 423 return at;
424
348 if (at == start) 425 if (at == start)
349 { 426 {
350 LOG (llevError, "No Player archetypes\n"); 427 LOG (llevError, "No Player archetypes\n");
351 exit (-1); 428 exit (-1);
352 } 429 }
353 } 430 }
354} 431}
355 432
356
357object * 433object *
358get_nearest_player (object *mon) 434get_nearest_player (object *mon)
359{ 435{
360 object *op = NULL; 436 object *op = NULL;
361 player *pl = NULL;
362 objectlink *ol; 437 objectlink *ol;
363 unsigned lastdist; 438 unsigned lastdist;
364 rv_vector rv; 439 rv_vector rv;
365 440
366 for (ol = first_friendly_object, lastdist = 1000; ol != NULL; ol = ol->next) 441 for (ol = first_friendly_object, lastdist = 1000; ol != NULL; ol = ol->next)
… …
398 { 473 {
399 op = ol->ob; 474 op = ol->ob;
400 lastdist = rv.distance; 475 lastdist = rv.distance;
401 } 476 }
402 } 477 }
403 for (pl = first_player; pl != NULL; pl = pl->next) 478
404 { 479 for_all_players (pl)
405 if (can_detect_enemy (mon, pl->ob, &rv)) 480 if (can_detect_enemy (mon, pl->ob, &rv))
406 {
407
408 if (lastdist > rv.distance) 481 if (lastdist > rv.distance)
409 { 482 {
410 op = pl->ob; 483 op = pl->ob;
411 lastdist = rv.distance; 484 lastdist = rv.distance;
412 } 485 }
413 } 486
414 }
415#if 0 487#if 0
416 LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)"); 488 LOG (llevDebug, "get_nearest_player() finds player: %s\n", op ? &op->name : "(null)");
417#endif 489#endif
418 return op; 490 return op;
419} 491}
… …
437 * circling behaviour. Unfortunately, this function is also used to determined 509 * circling behaviour. Unfortunately, this function is also used to determined
438 * if the creature should cast a spell, so returning a direction in that case 510 * if the creature should cast a spell, so returning a direction in that case
439 * is probably not a good thing. 511 * is probably not a good thing.
440 */ 512 */
441#define MAX_SPACES 50 513#define MAX_SPACES 50
442
443 514
444/* 515/*
445 * Returns the direction to the player, if valid. Returns 0 otherwise. 516 * Returns the direction to the player, if valid. Returns 0 otherwise.
446 * modified to verify there is a path to the player. Does this by stepping towards 517 * modified to verify there is a path to the player. Does this by stepping towards
447 * player and if path is blocked then see if blockage is close enough to player that 518 * player and if path is blocked then see if blockage is close enough to player that
… …
686 /* Need to set up the skill pointers */ 757 /* Need to set up the skill pointers */
687 link_player_skills (pl); 758 link_player_skills (pl);
688} 759}
689 760
690void 761void
691get_name (object *op)
692{
693 op->contr->write_buf[0] = '\0';
694 op->contr->state = ST_GET_NAME;
695 send_query (op->contr->socket, 0, "What is your name?\n:");
696}
697
698void
699get_password (object *op)
700{
701 op->contr->write_buf[0] = '\0';
702 op->contr->state = ST_GET_PASSWORD;
703 send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "What is your password?\n:");
704}
705
706void
707play_again (object *op)
708{
709 op->contr->state = ST_PLAY_AGAIN;
710 op->chosen_skill = NULL;
711 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Do you want to play again (a/q)?");
712 /* a bit of a hack, but there are various places early in th
713 * player creation process that a user can quit (eg, roll
714 * stats) that isn't removing the player. Taking a quick
715 * look, there are many places that call play_again without
716 * removing the player - it probably makes more sense
717 * to leave it to play_again to remove the object in all
718 * cases.
719 */
720 if (!QUERY_FLAG (op, FLAG_REMOVED))
721 op->remove ();
722 /* Need to set this to null - otherwise, it could point to garbage,
723 * and draw() doesn't check to see if the player is removed, only if
724 * the map is null or not swapped out.
725 */
726 op->map = NULL;
727}
728
729int
730receive_play_again (object *op, char key)
731{
732 if (key == 'q' || key == 'Q')
733 {
734 remove_friendly_object (op);
735 leave (op->contr, 0); /* ericserver will draw the message */
736 return 2;
737 }
738 else if (key == 'a' || key == 'A')
739 {
740 player *pl = op->contr;
741 shstr name = op->name;
742
743 op->contr = 0;
744 op->type = 0;
745 op->destroy (1);
746 pl = get_player (pl);
747 op = pl->ob;
748 add_friendly_object (op);
749 op->contr->password[0] = '~';
750 op->name = op->name_pl = 0;
751 /* Lets put a space in here */
752 new_draw_info (NDI_UNIQUE, 0, op, "\n");
753 get_name (op);
754 op->name = op->name_pl = name;
755 set_first_map (op);
756 }
757 else
758 /* user pressed something else so just ask again... */
759 play_again (op);
760
761 return 0;
762}
763
764void
765confirm_password (object *op)
766{
767
768 op->contr->write_buf[0] = '\0';
769 op->contr->state = ST_CONFIRM_PASSWORD;
770 send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "Please type your password again.\n:");
771}
772
773void
774get_party_password (object *op, partylist *party) 762get_party_password (object *op, partylist *party)
775{ 763{
776 if (party == NULL) 764 if (party == NULL)
777 { 765 {
778 LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name); 766 LOG (llevError, "get_party_password(): tried to make player %s join a NULL party", &op->name);
779 return; 767 return;
780 } 768 }
769
781 op->contr->write_buf[0] = '\0'; 770 op->contr->write_buf[0] = '\0';
782 op->contr->state = ST_GET_PARTY_PASSWORD; 771 op->contr->ns->state = ST_GET_PARTY_PASSWORD;
783 op->contr->party_to_join = party; 772 op->contr->party_to_join = party;
784 send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "What is the password?\n:"); 773 send_query (op->contr->ns, CS_QUERY_HIDEINPUT, "What is the password?\n:");
785} 774}
786
787 775
788/* This rolls four 1-6 rolls and sums the best 3 of the 4. */ 776/* This rolls four 1-6 rolls and sums the best 3 of the 4. */
789int 777static int
790roll_stat (void) 778roll_stat (void)
791{ 779{
792 int a[4], i, j, k; 780 int a[4], i, j, k;
793 781
794 for (i = 0; i < 4; i++) 782 for (i = 0; i < 4; i++)
… …
797 for (i = 0, j = 0, k = 7; i < 4; i++) 785 for (i = 0, j = 0, k = 7; i < 4; i++)
798 if (a[i] < k) 786 if (a[i] < k)
799 k = a[i], j = i; 787 k = a[i], j = i;
800 788
801 for (i = 0, k = 0; i < 4; i++) 789 for (i = 0, k = 0; i < 4; i++)
802 {
803 if (i != j) 790 if (i != j)
804 k += a[i]; 791 k += a[i];
805 } 792
806 return k; 793 return k;
807} 794}
808 795
809void 796void
810roll_stats (object *op) 797object::roll_stats ()
811{ 798{
812 int sum = 0;
813 int i = 0, j = 0;
814 int statsort[7]; 799 int statsort [7];
815 800
816 do 801 for (;;)
817 {
818 op->stats.Str = roll_stat ();
819 op->stats.Dex = roll_stat ();
820 op->stats.Int = roll_stat ();
821 op->stats.Con = roll_stat ();
822 op->stats.Wis = roll_stat ();
823 op->stats.Pow = roll_stat ();
824 op->stats.Cha = roll_stat ();
825 sum = op->stats.Str + op->stats.Dex + op->stats.Int + op->stats.Con + op->stats.Wis + op->stats.Pow + op->stats.Cha;
826 } 802 {
827 while (sum < 82 || sum > 116); 803 int sum = 0;
804 for (int i = 7; i--; )
805 sum += statsort [i] = roll_stat ();
828 806
807 if (sum >= 82 && sum <= 116)
808 break;
809 }
810
829 /* Sort the stats so that rerolling is easier... */ 811 // Sort the stats so that rerolling is easier...
830 statsort[0] = op->stats.Str; 812 std::sort (statsort, statsort + 7, std::greater<int>());
831 statsort[1] = op->stats.Dex;
832 statsort[2] = op->stats.Int;
833 statsort[3] = op->stats.Con;
834 statsort[4] = op->stats.Wis;
835 statsort[5] = op->stats.Pow;
836 statsort[6] = op->stats.Cha;
837 813
838 /* a quick and dirty bubblesort? */
839 do
840 {
841 if (statsort[i] < statsort[i + 1])
842 {
843 j = statsort[i];
844 statsort[i] = statsort[i + 1];
845 statsort[i + 1] = j;
846 i = 0;
847 }
848 else
849 {
850 i++;
851 }
852 }
853 while (i < 6);
854
855 op->stats.Str = statsort[0]; 814 stats.Str = statsort[0];
856 op->stats.Dex = statsort[1]; 815 stats.Dex = statsort[1];
857 op->stats.Con = statsort[2]; 816 stats.Con = statsort[2];
858 op->stats.Int = statsort[3]; 817 stats.Int = statsort[3];
859 op->stats.Wis = statsort[4]; 818 stats.Wis = statsort[4];
860 op->stats.Pow = statsort[5]; 819 stats.Pow = statsort[5];
861 op->stats.Cha = statsort[6]; 820 stats.Cha = statsort[6];
862 821
863
864 op->contr->orig_stats.Str = op->stats.Str;
865 op->contr->orig_stats.Dex = op->stats.Dex;
866 op->contr->orig_stats.Int = op->stats.Int;
867 op->contr->orig_stats.Con = op->stats.Con;
868 op->contr->orig_stats.Wis = op->stats.Wis;
869 op->contr->orig_stats.Pow = op->stats.Pow;
870 op->contr->orig_stats.Cha = op->stats.Cha;
871
872 op->level = 1;
873 op->stats.exp = 0; 822 stats.exp = 0;
874 op->stats.ac = 0; 823 stats.ac = 0;
875 824
876 op->contr->levhp[1] = 9;
877 op->contr->levsp[1] = 6;
878 op->contr->levgrace[1] = 3;
879
880 fix_player (op);
881 op->stats.hp = op->stats.maxhp; 825 stats.hp = stats.maxhp;
882 op->stats.sp = op->stats.maxsp; 826 stats.sp = stats.maxsp;
883 op->stats.grace = op->stats.maxgrace; 827 stats.grace = stats.maxgrace;
828
829 if (contr)
830 {
831 contr->levhp[1] = 9;
832 contr->levsp[1] = 6;
833 contr->levgrace[1] = 3;
834
884 op->contr->orig_stats = op->stats; 835 contr->orig_stats = stats;
836 }
885} 837}
886 838
887void 839void
888Roll_Again (object *op) 840object::swap_stats (int a, int b)
889{ 841{
890 esrv_new_player (op->contr, 0); 842 int tmp = get_attr_value (&contr->orig_stats, a);
891 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, 843 set_attr_value (&contr->orig_stats, a, get_attr_value (&contr->orig_stats, b));
892 "[y] to roll new stats [n] to use stats\n[1-7] [1-7] to swap stats.\nRoll again (y/n/1-7)? "); 844 set_attr_value (&contr->orig_stats, b, tmp);
893}
894 845
895void 846 stats.Str = contr->orig_stats.Str;
896Swap_Stat (object *op, int Swap_Second) 847 stats.Dex = contr->orig_stats.Dex;
848 stats.Con = contr->orig_stats.Con;
849 stats.Int = contr->orig_stats.Int;
850 stats.Wis = contr->orig_stats.Wis;
851 stats.Pow = contr->orig_stats.Pow;
852 stats.Cha = contr->orig_stats.Cha;
853
854 //TODO: the following code looks so borked and should, at the very least,
855 // be merged with the similar code in roll_stats
856 stats.ac = 0;
857
858 level = 1;
859 stats.exp = 0;
860 stats.ac = 0;
861
862 stats.hp = stats.maxhp;
863 stats.sp = stats.maxsp;
864 stats.grace = stats.maxgrace;
865
866 if (contr)
867 {
868 contr->levhp[1] = 9;
869 contr->levsp[1] = 6;
870 contr->levgrace[1] = 3;
871
872 contr->orig_stats = stats;
873 }
874}
875
876static void
877start_info (object *op)
897{ 878{
898 signed char tmp;
899 char buf[MAX_BUF]; 879 char buf[MAX_BUF];
900 880
901 if (op->contr->Swap_First == -1) 881 sprintf (buf, "Welcome to Crossfire v%s!", VERSION);
902 {
903 new_draw_info (NDI_UNIQUE, 0, op, "How the hell did you get here?!?!!!");
904 new_draw_info (NDI_UNIQUE, 0, op, "Error in Swap_Stat code,");
905 new_draw_info (NDI_UNIQUE, 0, op, "mail korg@rdt.monash.edu.au");
906 return;
907 }
908
909 tmp = get_attr_value (&op->contr->orig_stats, op->contr->Swap_First);
910
911 set_attr_value (&op->contr->orig_stats, op->contr->Swap_First, get_attr_value (&op->contr->orig_stats, Swap_Second));
912
913 set_attr_value (&op->contr->orig_stats, Swap_Second, tmp);
914
915 sprintf (buf, "%s done\n", short_stat_name[Swap_Second]);
916 new_draw_info (NDI_UNIQUE, 0, op, buf); 882 new_draw_info (NDI_UNIQUE, 0, op, buf);
917 op->stats.Str = op->contr->orig_stats.Str; 883 //new_draw_info (NDI_UNIQUE, 0, op, "Press `?' for help");
918 op->stats.Dex = op->contr->orig_stats.Dex;
919 op->stats.Con = op->contr->orig_stats.Con;
920 op->stats.Int = op->contr->orig_stats.Int;
921 op->stats.Wis = op->contr->orig_stats.Wis;
922 op->stats.Pow = op->contr->orig_stats.Pow;
923 op->stats.Cha = op->contr->orig_stats.Cha;
924 op->stats.ac = 0;
925
926 op->level = 1;
927 op->stats.exp = 0;
928 op->stats.ac = 0;
929
930 op->contr->levhp[1] = 9;
931 op->contr->levsp[1] = 6;
932 op->contr->levgrace[1] = 3;
933
934 fix_player (op);
935 op->stats.hp = op->stats.maxhp;
936 op->stats.sp = op->stats.maxsp;
937 op->stats.grace = op->stats.maxgrace;
938 op->contr->orig_stats = op->stats;
939 op->contr->Swap_First = -1;
940}
941
942
943/* This code has been greatly reduced, because with set_attr_value
944 * and get_attr_value, the stats can be accessed just numeric
945 * ids. stat_trans is a table that translate the number entered
946 * into the actual stat. It is needed because the order the stats
947 * are displayed in the stat window is not the same as how
948 * the number's access that stat. The table does that translation.
949 */
950int
951key_roll_stat (object *op, char key)
952{
953 int keynum = key - '0';
954 char buf[MAX_BUF];
955 static sint8 stat_trans[] = { -1, STR, DEX, CON, INT, WIS, POW, CHA };
956
957 if (keynum > 0 && keynum <= 7)
958 {
959 if (op->contr->Swap_First == -1)
960 {
961 op->contr->Swap_First = stat_trans[keynum];
962 sprintf (buf, "%s ->", short_stat_name[stat_trans[keynum]]);
963 new_draw_info (NDI_UNIQUE, 0, op, buf); 884 //new_draw_info (NDI_UNIQUE, 0, op, " ");
964 }
965 else
966 Swap_Stat (op, stat_trans[keynum]);
967
968 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "");
969 return 1;
970 }
971 switch (key)
972 {
973 case 'n':
974 case 'N':
975 {
976 SET_FLAG (op, FLAG_WIZ);
977 if (op->map == NULL)
978 {
979 LOG (llevError, "Map == NULL in state 2\n");
980 break;
981 }
982
983#if 0
984 /* So that enter_exit will put us at startx/starty */
985 op->x = -1;
986
987 enter_exit (op, NULL);
988#endif
989 SET_ANIMATION (op, 2); /* So player faces south */
990 /* Enter exit adds a player otherwise */
991 add_statbonus (op);
992 send_query (op->contr->socket, CS_QUERY_SINGLECHAR,
993 "Now choose a character.\nPress any key to change outlook.\nPress `d' when you're pleased.\n");
994 op->contr->state = ST_CHANGE_CLASS;
995 if (op->msg)
996 new_draw_info (NDI_BLUE, 0, op, op->msg);
997 return 0;
998 }
999 case 'y':
1000 case 'Y':
1001 roll_stats (op);
1002 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "");
1003 return 1;
1004
1005 case 'q':
1006 case 'Q':
1007 play_again (op);
1008 return 1;
1009
1010 default:
1011 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Yes, No, Quit or 1-6. Roll again?");
1012 return 0;
1013 }
1014 return 0;
1015} 885}
1016 886
1017/* This function takes the key that is passed, and does the 887/* This function takes the key that is passed, and does the
1018 * appropriate action with it (change race, or other things). 888 * appropriate action with it (change race, or other things).
1019 * The function name is for historical reasons - now we have 889 * The function name is for historical reasons - now we have
1020 * separate race and class; this actually changes the RACE, 890 * separate race and class; this actually changes the RACE,
1021 * not the class. 891 * not the class.
1022 */ 892 */
1023
1024int 893int
1025key_change_class (object *op, char key) 894key_change_class (object *op, char key)
1026{ 895{
1027 int tmp_loop; 896 int tmp_loop;
1028 897
1029 if (key == 'q' || key == 'Q')
1030 {
1031 op->remove ();
1032 play_again (op);
1033 return 0;
1034 }
1035 if (key == 'd' || key == 'D') 898 if (key == 'd' || key == 'D')
1036 { 899 {
1037 char buf[MAX_BUF]; 900 char buf[MAX_BUF];
1038 901
1039 /* this must before then initial items are given */ 902 /* this must before then initial items are given */
… …
1044 create_treasure (tl, op, 0, 0, 0); 907 create_treasure (tl, op, 0, 0, 0);
1045 908
1046 INVOKE_PLAYER (BIRTH, op->contr); 909 INVOKE_PLAYER (BIRTH, op->contr);
1047 INVOKE_PLAYER (LOGIN, op->contr); 910 INVOKE_PLAYER (LOGIN, op->contr);
1048 911
1049 op->contr->state = ST_PLAYING; 912 op->contr->ns->state = ST_PLAYING;
1050 913
1051 if (op->msg) 914 if (op->msg)
1052 op->msg = NULL; 915 op->msg = NULL;
1053 916
1054 /* We create this now because some of the unique maps will need it 917 /* We create this now because some of the unique maps will need it
… …
1063 start_info (op); 926 start_info (op);
1064 CLEAR_FLAG (op, FLAG_WIZ); 927 CLEAR_FLAG (op, FLAG_WIZ);
1065 give_initial_items (op, op->randomitems); 928 give_initial_items (op, op->randomitems);
1066 link_player_skills (op); 929 link_player_skills (op);
1067 esrv_send_inventory (op, op); 930 esrv_send_inventory (op, op);
1068 fix_player (op); 931 op->update_stats ();
1069 932
1070 /* This moves the player to a different start map, if there 933 /* This moves the player to a different start map, if there
1071 * is one for this race 934 * is one for this race
1072 */ 935 */
1073 if (*first_map_ext_path) 936 if (*first_map_ext_path)
1074 { 937 {
1075 object *tmp; 938 object *tmp;
1076 char mapname[MAX_BUF]; 939 char mapname[MAX_BUF];
1077 940
1078 snprintf (mapname, MAX_BUF - 1, "%s/%s", first_map_ext_path, &op->arch->name); 941 snprintf (mapname, MAX_BUF - 1, "%s/%s", &first_map_ext_path, &op->arch->name);
1079 tmp = object::create (); 942 tmp = object::create ();
1080 EXIT_PATH (tmp) = mapname; 943 EXIT_PATH (tmp) = mapname;
1081 EXIT_X (tmp) = op->x; 944 EXIT_X (tmp) = op->x;
1082 EXIT_Y (tmp) = op->y; 945 EXIT_Y (tmp) = op->y;
1083 enter_exit (op, tmp); /* we don't really care if it succeeded; 946 op->enter_exit (tmp); /* we don't really care if it succeeded;
1084 * if the map isn't there, then stay on the 947 * if the map isn't there, then stay on the
1085 * default initial map */ 948 * default initial map */
1086 tmp->destroy (); 949 tmp->destroy ();
1087 } 950 }
1088 else 951 else
1089 {
1090 LOG (llevDebug, "first_map_ext_path not set\n"); 952 LOG (llevDebug, "first_map_ext_path not set\n");
1091 } 953
1092 return 0; 954 return 0;
1093 } 955 }
1094 956
1095 /* Following actually changes the race - this is the default command 957 /* Following actually changes the race - this is the default command
1096 * if we don't match with one of the options above. 958 * if we don't match with one of the options above.
… …
1100 while (!tmp_loop) 962 while (!tmp_loop)
1101 { 963 {
1102 shstr name = op->name; 964 shstr name = op->name;
1103 int x = op->x, y = op->y; 965 int x = op->x, y = op->y;
1104 966
1105 remove_statbonus (op); 967 op->remove_statbonus ();
1106 op->remove (); 968 op->remove ();
1107 op->arch = get_player_archetype (op->arch); 969 op->arch = get_player_archetype (op->arch);
1108 op->arch->clone.copy_to (op); 970 op->arch->clone.copy_to (op);
1109 op->instantiate (); 971 op->instantiate ();
1110 op->stats = op->contr->orig_stats; 972 op->stats = op->contr->orig_stats;
… …
1112 op->x = x; 974 op->x = x;
1113 op->y = y; 975 op->y = y;
1114 SET_ANIMATION (op, 2); /* So player faces south */ 976 SET_ANIMATION (op, 2); /* So player faces south */
1115 insert_ob_in_map (op, op->map, op, 0); 977 insert_ob_in_map (op, op->map, op, 0);
1116 assign (op->contr->title, op->arch->clone.name); 978 assign (op->contr->title, op->arch->clone.name);
1117 add_statbonus (op); 979 op->add_statbonus ();
1118 tmp_loop = allowed_class (op); 980 tmp_loop = allowed_class (op);
1119 } 981 }
1120 982
1121 update_object (op, UP_OBJ_FACE); 983 update_object (op, UP_OBJ_FACE);
1122 esrv_update_item (UPD_FACE, op, op); 984 esrv_update_item (UPD_FACE, op, op);
1123 fix_player (op); 985 op->update_stats ();
1124 op->stats.hp = op->stats.maxhp; 986 op->stats.hp = op->stats.maxhp;
1125 op->stats.sp = op->stats.maxsp; 987 op->stats.sp = op->stats.maxsp;
1126 op->stats.grace = 0; 988 op->stats.grace = 0;
1127 989
1128 if (op->msg) 990 if (op->msg)
1129 new_draw_info (NDI_BLUE, 0, op, op->msg); 991 new_draw_info (NDI_BLUE, 0, op, op->msg);
1130 992
1131 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n"); 993 send_query (op->contr->ns, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n");
1132 return 0; 994 return 0;
1133} 995}
1134 996
1135int 997int
1136key_confirm_quit (object *op, char key) 998key_confirm_quit (object *op, char key)
1137{ 999{
1138 char buf[MAX_BUF];
1139
1140 if (key != 'y' && key != 'Y' && key != 'q' && key != 'Q') 1000 if (key != 'y' && key != 'Y' && key != 'q' && key != 'Q')
1141 { 1001 {
1142 op->contr->state = ST_PLAYING; 1002 op->contr->ns->state = ST_PLAYING;
1143 new_draw_info (NDI_UNIQUE, 0, op, "OK, continuing to play."); 1003 new_draw_info (NDI_UNIQUE, 0, op, "OK, continuing to play.");
1144 return 1; 1004 return 1;
1145 } 1005 }
1146 1006
1147 INVOKE_PLAYER (LOGOUT, op->contr); 1007 INVOKE_PLAYER (LOGOUT, op->contr);
1148 INVOKE_PLAYER (QUIT, op->contr); 1008 INVOKE_PLAYER (QUIT, op->contr);
1149 1009
1010 op->contr->enable_save = false;
1011
1150 terminate_all_pets (op); 1012 terminate_all_pets (op);
1151 leave_map (op); 1013 op->remove ();
1152 op->direction = 0; 1014 op->direction = 0;
1153 new_draw_info_format (NDI_UNIQUE | NDI_ALL, 5, NULL, "%s quits the game.", &op->name); 1015 new_draw_info_format (NDI_UNIQUE | NDI_ALL, 5, NULL, "%s quits the game.", &op->name);
1154 1016
1155 strcpy (op->contr->killer, "quit"); 1017 strcpy (op->contr->killer, "quit");
1156 check_score (op); 1018 check_score (op);
1157 op->contr->party = NULL; 1019 op->contr->party = 0;
1158 if (settings.set_title == TRUE)
1159 op->contr->own_title[0] = '\0'; 1020 op->contr->own_title[0] = '\0';
1021 op->contr->destroy ();
1160 1022
1161 if (!QUERY_FLAG (op, FLAG_WAS_WIZ))
1162 {
1163 maptile *mp, *next;
1164
1165 /* We need to hunt for any per player unique maps in memory and
1166 * get rid of them. The trailing slash in the path is intentional,
1167 * so that players named 'Ab' won't match against players 'Abe' pathname
1168 */
1169 sprintf (buf, "%s/%s/%s/", settings.localdir, settings.playerdir, &op->name);
1170 for (mp = first_map; mp != NULL; mp = next)
1171 {
1172 next = mp->next;
1173 if (!strncmp (mp->path, buf, strlen (buf)))
1174 delete_map (mp);
1175 }
1176
1177 delete_character (op->name, 1);
1178 }
1179
1180 play_again (op);
1181 return 1; 1023 return 1;
1182} 1024}
1183 1025
1184void 1026void
1185flee_player (object *op) 1027flee_player (object *op)
… …
1216 { 1058 {
1217 op->enemy = NULL; 1059 op->enemy = NULL;
1218 CLEAR_FLAG (op, FLAG_SCARED); 1060 CLEAR_FLAG (op, FLAG_SCARED);
1219 return; 1061 return;
1220 } 1062 }
1063
1221 get_rangevector (op, op->enemy, &rv, 0); 1064 get_rangevector (op, op->enemy, &rv, 0);
1222 1065
1223 dir = absdir (4 + rv.direction); 1066 dir = absdir (4 + rv.direction);
1224 for (diff = 0; diff < 3; diff++) 1067 for (diff = 0; diff < 3; diff++)
1225 { 1068 {
1226 int m = 1 - (RANDOM () & 2); 1069 int m = 1 - (RANDOM () & 2);
1227 1070
1228 if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op))) 1071 if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op)))
1229 {
1230 return; 1072 return;
1231 }
1232 } 1073 }
1074
1233 /* Cornered, get rid of scared */ 1075 /* Cornered, get rid of scared */
1234 CLEAR_FLAG (op, FLAG_SCARED); 1076 CLEAR_FLAG (op, FLAG_SCARED);
1235 op->enemy = NULL; 1077 op->enemy = NULL;
1236} 1078}
1237 1079
… …
1323 sprintf (putstring, "item name: %s item type: %d weight/value: %d", 1165 sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1324 &tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1)))); 1166 &tmp->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1325 else 1167 else
1326 sprintf (putstring, "item name: %s item type: %d weight/value: %d", 1168 sprintf (putstring, "item name: %s item type: %d weight/value: %d",
1327 &tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1)))); 1169 &tmp->arch->name, tmp->type, (int) (query_cost (tmp, op, F_TRUE) * 100 / (tmp->weight * MAX (tmp->nrof, 1))));
1170
1328 new_draw_info (NDI_UNIQUE, 0, op, putstring); 1171 new_draw_info (NDI_UNIQUE, 0, op, putstring);
1329
1330 sprintf (putstring, "...flags: ");
1331 for (k = 0; k < 4; k++)
1332 {
1333 for (j = 0; j < 32; j++)
1334 {
1335 if ((tmp->flags[k] >> j) & 0x01)
1336 {
1337 sprintf (tmpstr, "%d ", k * 32 + j);
1338 strcat (putstring, tmpstr);
1339 }
1340 }
1341 }
1342 new_draw_info (NDI_UNIQUE, 0, op, putstring);
1343
1344#if 0
1345 /* print the flags too */
1346 for (k = 0; k < 4; k++)
1347 {
1348 fprintf (stderr, "%d [%d] ", k, k * 32 + 31);
1349 for (j = 0; j < 32; j++)
1350 {
1351 fprintf (stderr, "%d", tmp->flags[k] >> (31 - j) & 0x01);
1352 if (!((j + 1) % 4))
1353 fprintf (stderr, " ");
1354 }
1355 fprintf (stderr, " [%d]\n", k * 32);
1356 }
1357#endif
1358 } 1172 }
1173
1359 /* philosophy: 1174 /* philosophy:
1360 * It's easy to grab an item type from a pile, as long as it's 1175 * It's easy to grab an item type from a pile, as long as it's
1361 * generic. This takes no game-time. For more detailed pickups 1176 * generic. This takes no game-time. For more detailed pickups
1362 * and selections, select-items shoul dbe used. This is a 1177 * and selections, select-items should be used. This is a
1363 * grab-as-you-run type mode that's really useful for arrows for 1178 * grab-as-you-run type mode that's really useful for arrows for
1364 * example. 1179 * example.
1365 * The drawback: right now it has no frontend, so you need to 1180 * The drawback: right now it has no frontend, so you need to
1366 * stick the bits you want into a calculator in hex mode and then 1181 * stick the bits you want into a calculator in hex mode and then
1367 * convert to decimal and then 'pickup <#> 1182 * convert to decimal and then 'pickup <#>
… …
1793 if (!dir) 1608 if (!dir)
1794 { 1609 {
1795 new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!"); 1610 new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");
1796 return 0; 1611 return 0;
1797 } 1612 }
1613
1798 if (op->type == PLAYER) 1614 if (op->type == PLAYER)
1799 bow = op->contr->ranges[range_bow]; 1615 bow = op->contr->ranges[range_bow];
1800 else 1616 else
1801 { 1617 {
1802 for (bow = op->inv; bow; bow = bow->below) 1618 for (bow = op->inv; bow; bow = bow->below)
… …
1810 { 1626 {
1811 LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name); 1627 LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);
1812 return 0; 1628 return 0;
1813 } 1629 }
1814 } 1630 }
1631
1815 if (!bow->race || !bow->skill) 1632 if (!bow->race || !bow->skill)
1816 { 1633 {
1817 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name); 1634 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name);
1818 return 0; 1635 return 0;
1819 } 1636 }
… …
1821 bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex]; 1638 bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex];
1822 1639
1823 /* penalize ROF for bestarrow */ 1640 /* penalize ROF for bestarrow */
1824 if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow) 1641 if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow)
1825 bowspeed -= dex_bonus[op->stats.Dex] + 5; 1642 bowspeed -= dex_bonus[op->stats.Dex] + 5;
1643
1826 if (bowspeed < 1) 1644 if (bowspeed < 1)
1827 bowspeed = 1; 1645 bowspeed = 1;
1828 1646
1829 if (arrow == NULL) 1647 if (arrow == NULL)
1830 { 1648 {
… …
1836 else 1654 else
1837 CLEAR_FLAG (op, FLAG_READY_BOW); 1655 CLEAR_FLAG (op, FLAG_READY_BOW);
1838 return 0; 1656 return 0;
1839 } 1657 }
1840 } 1658 }
1659
1841 mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy); 1660 mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);
1842 if (mflags & P_OUT_OF_MAP) 1661 if (mflags & P_OUT_OF_MAP)
1843 {
1844 return 0; 1662 return 0;
1845 } 1663
1846 if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW) 1664 if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)
1847 { 1665 {
1848 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 1666 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1849 return 0; 1667 return 0;
1850 } 1668 }
… …
1856 return 0; 1674 return 0;
1857 } 1675 }
1858 1676
1859 left = arrow; /* these are arrows left to the player */ 1677 left = arrow; /* these are arrows left to the player */
1860 arrow = get_split_ob (arrow, 1); 1678 arrow = get_split_ob (arrow, 1);
1861 if (arrow == NULL) 1679 if (!arrow)
1862 { 1680 {
1863 new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race); 1681 new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);
1864 return 0; 1682 return 0;
1865 } 1683 }
1684
1866 arrow->set_owner (op); 1685 arrow->set_owner (op);
1867 arrow->skill = bow->skill; 1686 arrow->skill = bow->skill;
1868
1869 arrow->direction = dir; 1687 arrow->direction = dir;
1870 arrow->x = sx;
1871 arrow->y = sy;
1872 1688
1873 if (op->type == PLAYER) 1689 if (op->type == PLAYER)
1874 { 1690 {
1875 op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed; 1691 op->speed_left = 0.01 - (float) FABS (op->speed) * 100 / bowspeed;
1876 fix_player (op); 1692 op->update_stats ();
1877 } 1693 }
1878 1694
1879 SET_ANIMATION (arrow, arrow->direction); 1695 SET_ANIMATION (arrow, arrow->direction);
1880 arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */ 1696 arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */
1881 arrow->stats.hp = arrow->stats.dam; 1697 arrow->stats.hp = arrow->stats.dam;
1882 arrow->stats.grace = arrow->attacktype; 1698 arrow->stats.grace = arrow->attacktype;
1883 if (arrow->slaying != NULL) 1699 if (arrow->slaying != NULL)
1884 arrow->spellarg = strdup_local (arrow->slaying); 1700 arrow->spellarg = strdup (arrow->slaying);
1885 1701
1886 /* Note that this was different for monsters - they got their level 1702 /* Note that this was different for monsters - they got their level
1887 * added to the damage. I think the strength bonus is more proper. 1703 * added to the damage. I think the strength bonus is more proper.
1888 */ 1704 */
1889 1705
… …
1891 1707
1892 /* update the speed */ 1708 /* update the speed */
1893 arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ? 1709 arrow->speed = (float) ((QUERY_FLAG (bow, FLAG_NO_STRENGTH) ?
1894 0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 + (float) bow->stats.dam / 7.0; 1710 0 : dam_bonus[op->stats.Str]) + bow->magic + arrow->magic) / 5.0 + (float) bow->stats.dam / 7.0;
1895 1711
1896 if (arrow->speed < 1.0) 1712 arrow->set_speed (max (arrow->speed, 1.0));
1897 arrow->speed = 1.0;
1898 update_ob_speed (arrow);
1899 arrow->speed_left = 0; 1713 arrow->speed_left = 0;
1900 1714
1901 if (op->type == PLAYER) 1715 if (op->type == PLAYER)
1902 { 1716 {
1903 arrow->stats.wc = 20 - bow->magic - arrow->magic - 1717 arrow->stats.wc = 20 - bow->magic - arrow->magic -
… …
1913 } 1727 }
1914 1728
1915 if (arrow->attacktype == AT_PHYSICAL) 1729 if (arrow->attacktype == AT_PHYSICAL)
1916 arrow->attacktype |= bow->attacktype; 1730 arrow->attacktype |= bow->attacktype;
1917 1731
1918 if (bow->slaying != NULL) 1732 if (bow->slaying)
1919 arrow->slaying = bow->slaying; 1733 arrow->slaying = bow->slaying;
1920 1734
1921 arrow->map = m;
1922 arrow->move_type = MOVE_FLY_LOW; 1735 arrow->move_type = MOVE_FLY_LOW;
1923 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK; 1736 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
1924 1737
1925 play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW); 1738 play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW);
1926 insert_ob_in_map (arrow, m, op, 0); 1739 m->insert (arrow, sx, sy, op);
1927 1740
1928 if (!arrow->destroyed ()) 1741 if (!arrow->destroyed ())
1929 move_arrow (arrow); 1742 move_arrow (arrow);
1930 1743
1931 if (op->type == PLAYER) 1744 if (op->type == PLAYER)
… …
1957 } 1770 }
1958 else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw) 1771 else if (op->contr->bowtype >= bow_n && op->contr->bowtype <= bow_nw)
1959 { 1772 {
1960 if (!similar_direction (dir, op->contr->bowtype - bow_n + 1)) 1773 if (!similar_direction (dir, op->contr->bowtype - bow_n + 1))
1961 wcmod = -1; 1774 wcmod = -1;
1775
1962 ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y); 1776 ret = fire_bow (op, op, NULL, op->contr->bowtype - bow_n + 1, wcmod, op->x, op->y);
1963 } 1777 }
1964 else if (op->contr->bowtype == bow_threewide) 1778 else if (op->contr->bowtype == bow_threewide)
1965 { 1779 {
1966 ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y); 1780 ret = fire_bow (op, op, NULL, dir, 0, op->x, op->y);
… …
2036 1850
2037 if (item->arch) 1851 if (item->arch)
2038 { 1852 {
2039 CLEAR_FLAG (item, FLAG_ANIMATE); 1853 CLEAR_FLAG (item, FLAG_ANIMATE);
2040 item->face = item->arch->clone.face; 1854 item->face = item->arch->clone.face;
2041 item->speed = 0; 1855 item->set_speed (0);
2042 update_ob_speed (item);
2043 } 1856 }
1857
2044 if ((tmp = is_player_inv (item))) 1858 if ((tmp = item->in_player ()))
2045 esrv_update_item (UPD_ANIM, tmp, item); 1859 esrv_update_item (UPD_ANIM, tmp, item);
2046 } 1860 }
2047 } 1861 }
2048 else if (item->type == ROD || item->type == HORN) 1862 else if (item->type == ROD || item->type == HORN)
2049 {
2050 drain_rod_charge (item); 1863 drain_rod_charge (item);
2051 }
2052 } 1864 }
2053} 1865}
2054 1866
2055/* Received a fire command for the player - go and do it. 1867/* Received a fire command for the player - go and do it.
2056 */ 1868 */
… …
2199 * 0 otherwise 2011 * 0 otherwise
2200 */ 2012 */
2201static int 2013static int
2202player_attack_door (object *op, object *door) 2014player_attack_door (object *op, object *door)
2203{ 2015{
2204
2205 /* If its a door, try to find a use a key. If we do destroy the door, 2016 /* If its a door, try to find a use a key. If we do destroy the door,
2206 * might as well return immediately as there is nothing more to do - 2017 * might as well return immediately as there is nothing more to do -
2207 * otherwise, we fall through to the rest of the code. 2018 * otherwise, we fall through to the rest of the code.
2208 */ 2019 */
2209 object *key = find_key (op, op, door); 2020 object *key = find_key (op, op, door);
… …
2247 * It should keep the code cleaner. 2058 * It should keep the code cleaner.
2248 * When this is called, the players direction has been updated 2059 * When this is called, the players direction has been updated
2249 * (taking into account confusion.) The player is also actually 2060 * (taking into account confusion.) The player is also actually
2250 * going to try and move (not fire weapons). 2061 * going to try and move (not fire weapons).
2251 */ 2062 */
2252
2253void 2063void
2254move_player_attack (object *op, int dir) 2064move_player_attack (object *op, int dir)
2255{ 2065{
2256 object *tmp, *mon; 2066 object *tmp, *mon;
2257 sint16 nx, ny; 2067 sint16 nx, ny;
… …
2259 maptile *m; 2069 maptile *m;
2260 2070
2261 nx = freearr_x[dir] + op->x; 2071 nx = freearr_x[dir] + op->x;
2262 ny = freearr_y[dir] + op->y; 2072 ny = freearr_y[dir] + op->y;
2263 2073
2264 on_battleground = op_on_battleground (op, NULL, NULL); 2074 on_battleground = op_on_battleground (op, 0, 0);
2265 2075
2266 /* If braced, or can't move to the square, and it is not out of the 2076 /* If braced, or can't move to the square, and it is not out of the
2267 * map, attack it. Note order of if statement is important - don't 2077 * map, attack it. Note order of if statement is important - don't
2268 * want to be calling move_ob if braced, because move_ob will move the 2078 * want to be calling move_ob if braced, because move_ob will move the
2269 * player. This is a pretty nasty hack, because if we could 2079 * player. This is a pretty nasty hack, because if we could
… …
2281 return; /* Don't think this should happen */ 2091 return; /* Don't think this should happen */
2282 } 2092 }
2283 else 2093 else
2284 m = op->map; 2094 m = op->map;
2285 2095
2286 if ((tmp = get_map_ob (m, nx, ny)) == NULL) 2096 if ((tmp = GET_MAP_OB (m, nx, ny)) == NULL)
2287 { 2097 {
2288 /* LOG(llevError,"player_move_attack: get_map_ob returns NULL, but player can not more there.\n"); */ 2098 /* LOG(llevError,"player_move_attack: GET_MAP_OB returns NULL, but player can not move there.\n"); */
2289 return; 2099 return;
2290 } 2100 }
2291 2101
2292 mon = NULL; 2102 mon = 0;
2293 /* Go through all the objects, and find ones of interest. Only stop if 2103 /* Go through all the objects, and find ones of interest. Only stop if
2294 * we find a monster - that is something we know we want to attack. 2104 * we find a monster - that is something we know we want to attack.
2295 * if its a door or barrel (can roll) see if there may be monsters 2105 * if its a door or barrel (can roll) see if there may be monsters
2296 * on the space 2106 * on the space
2297 */ 2107 */
2298 while (tmp != NULL) 2108 while (tmp)
2299 { 2109 {
2300 if (tmp == op) 2110 if (tmp == op)
2301 { 2111 {
2302 tmp = tmp->above; 2112 tmp = tmp->above;
2303 continue; 2113 continue;
… …
2313 mon = tmp; 2123 mon = tmp;
2314 2124
2315 tmp = tmp->above; 2125 tmp = tmp->above;
2316 } 2126 }
2317 2127
2318 if (mon == NULL) /* This happens anytime the player tries to move */ 2128 if (!mon) /* This happens anytime the player tries to move */
2319 return; /* into a wall */ 2129 return; /* into a wall */
2320 2130
2321 if (mon->head != NULL) 2131 if (mon->head)
2322 mon = mon->head; 2132 mon = mon->head;
2323 2133
2324 if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR)) 2134 if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))
2325 if (player_attack_door (op, mon)) 2135 if (player_attack_door (op, mon))
2326 return; 2136 return;
… …
2363 * attack them either. 2173 * attack them either.
2364 */ 2174 */
2365 if ((mon->type == PLAYER || mon->enemy != op) && 2175 if ((mon->type == PLAYER || mon->enemy != op) &&
2366 (mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && ( 2176 (mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && (
2367#ifdef PROHIBIT_PLAYERKILL 2177#ifdef PROHIBIT_PLAYERKILL
2368 (op->contr->peaceful 2178 (op->contr->peaceful
2369 || (mon->type == PLAYER 2179 || (mon->type == PLAYER
2370 && mon->contr-> 2180 && mon->contr->
2371 peaceful)) && 2181 peaceful)) &&
2372#else 2182#else
2373 op->contr->peaceful && 2183 op->contr->peaceful &&
2374#endif 2184#endif
2375 !on_battleground)) 2185 !on_battleground))
2376 { 2186 {
2377 if (!op->contr->braced) 2187 if (!op->contr->braced)
2378 { 2188 {
2379 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2189 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2380 (void) push_ob (mon, dir, op); 2190 (void) push_ob (mon, dir, op);
2381 } 2191 }
2382 else 2192 else
2383 {
2384 new_draw_info (0, 0, op, "You withhold your attack"); 2193 new_draw_info (0, 0, op, "You withhold your attack");
2385 } 2194
2386 if (op->contr->tmp_invis || op->hide) 2195 if (op->contr->tmp_invis || op->hide)
2387 make_visible (op); 2196 make_visible (op);
2388 } 2197 }
2389 2198
2390 /* If the object is a boulder or other rollable object, then 2199 /* If the object is a boulder or other rollable object, then
… …
2418 op->speed_left += op->speed / op->contr->weapon_sp; 2227 op->speed_left += op->speed / op->contr->weapon_sp;
2419 2228
2420 op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */ 2229 op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */
2421 } 2230 }
2422 2231
2423 skill_attack (mon, op, 0, NULL, NULL); 2232 skill_attack (mon, op, 0, 0, 0);
2424 2233
2425 /* If attacking another player, that player gets automatic 2234 /* If attacking another player, that player gets automatic
2426 * hitback, and doesn't loose luck either. 2235 * hitback, and doesn't loose luck either.
2427 * Disable hitback on the battleground or if the target is 2236 * Disable hitback on the battleground or if the target is
2428 * the wiz. 2237 * the wiz.
… …
2430 if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ)) 2239 if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ))
2431 { 2240 {
2432 short luck = mon->stats.luck; 2241 short luck = mon->stats.luck;
2433 2242
2434 mon->contr->has_hit = 1; 2243 mon->contr->has_hit = 1;
2435 skill_attack (op, mon, 0, NULL, NULL); 2244 skill_attack (op, mon, 0, 0, 0);
2436 mon->stats.luck = luck; 2245 mon->stats.luck = luck;
2437 } 2246 }
2247
2438 if (action_makes_visible (op)) 2248 if (action_makes_visible (op))
2439 make_visible (op); 2249 make_visible (op);
2440 } 2250 }
2441 } /* if player should attack something */ 2251 } /* if player should attack something */
2442} 2252}
… …
2477 2287
2478 /* Add special check for newcs players and fire on - this way, the 2288 /* Add special check for newcs players and fire on - this way, the
2479 * server can handle repeat firing. 2289 * server can handle repeat firing.
2480 */ 2290 */
2481 if (op->contr->fire_on || (op->contr->run_on && pick != 0)) 2291 if (op->contr->fire_on || (op->contr->run_on && pick != 0))
2482 {
2483 op->direction = dir; 2292 op->direction = dir;
2484 }
2485 else 2293 else
2486 {
2487 op->direction = 0; 2294 op->direction = 0;
2488 } 2295
2489 /* Update how the player looks. Use the facing, so direction may 2296 /* Update how the player looks. Use the facing, so direction may
2490 * get reset to zero. This allows for full animation capabilities 2297 * get reset to zero. This allows for full animation capabilities
2491 * for players. 2298 * for players.
2492 */ 2299 */
2493 animate_object (op, op->facing); 2300 animate_object (op, op->facing);
… …
2545 2352
2546 /* call this here - we also will call this in do_ericserver, but 2353 /* call this here - we also will call this in do_ericserver, but
2547 * the players time has been increased when doericserver has been 2354 * the players time has been increased when doericserver has been
2548 * called, so we recheck it here. 2355 * called, so we recheck it here.
2549 */ 2356 */
2550 HandleClient (op->contr->socket, op->contr); 2357 op->contr->ns->handle_command ();
2358
2551 if (op->speed_left < 0) 2359 if (op->speed_left < 0)
2552 return 0; 2360 return 0;
2553 2361
2554 if (op->direction && (op->contr->run_on || op->contr->fire_on)) 2362 if (op->direction && (op->contr->run_on || op->contr->fire_on))
2555 { 2363 {
… …
2564 if (op->speed_left > 0) 2372 if (op->speed_left > 0)
2565 return 1; 2373 return 1;
2566 else 2374 else
2567 return 0; 2375 return 0;
2568 } 2376 }
2377
2569 return 0; 2378 return 0;
2570} 2379}
2571 2380
2572int 2381int
2573save_life (object *op) 2382save_life (object *op)
2574{ 2383{
2575 object *tmp;
2576
2577 if (!QUERY_FLAG (op, FLAG_LIFESAVE)) 2384 if (!QUERY_FLAG (op, FLAG_LIFESAVE))
2578 return 0; 2385 return 0;
2579 2386
2580 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 2387 for (object *tmp = op->inv; tmp; tmp = tmp->below)
2581 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE)) 2388 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE))
2582 { 2389 {
2583 play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE); 2390 play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE);
2584 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp)); 2391 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp));
2585 2392
… …
2593 op->stats.hp = op->stats.maxhp; 2400 op->stats.hp = op->stats.maxhp;
2594 2401
2595 if (op->stats.food < 0) 2402 if (op->stats.food < 0)
2596 op->stats.food = 999; 2403 op->stats.food = 999;
2597 2404
2598 fix_player (op); 2405 op->update_stats ();
2599 return 1; 2406 return 1;
2600 } 2407 }
2408
2601 LOG (llevError, "Error: LIFESAVE set without applied object.\n"); 2409 LOG (llevError, "Error: LIFESAVE set without applied object.\n");
2602 CLEAR_FLAG (op, FLAG_LIFESAVE); 2410 CLEAR_FLAG (op, FLAG_LIFESAVE);
2603 enter_player_savebed (op); /* bring him home. */ 2411 enter_player_savebed (op); /* bring him home. */
2604 return 0; 2412 return 0;
2605} 2413}
… …
2614{ 2422{
2615 object *next; 2423 object *next;
2616 2424
2617 while (op) 2425 while (op)
2618 { 2426 {
2619 next = op->below; /* Make sure we have a good value, in case 2427 object *next = op->below; /* Make sure we have a good value, in case we remove object 'op' */
2620 * we remove object 'op' 2428
2621 */
2622 if (QUERY_FLAG (op, FLAG_UNPAID)) 2429 if (QUERY_FLAG (op, FLAG_UNPAID))
2623 { 2430 {
2624 op->remove ();
2625 op->x = env->x;
2626 op->y = env->y;
2627 if (env->type == PLAYER) 2431 if (env->type == PLAYER)
2628 esrv_del_item (env->contr, op->count); 2432 esrv_del_item (env->contr, op->count);
2629 insert_ob_in_map (op, env->map, NULL, 0); 2433
2434 op->insert_at (env);
2630 } 2435 }
2631 else if (op->inv) 2436 else if (op->inv)
2632 remove_unpaid_objects (op->inv, env); 2437 remove_unpaid_objects (op->inv, env);
2438
2633 op = next; 2439 op = next;
2634 } 2440 }
2635} 2441}
2636
2637 2442
2638/* 2443/*
2639 * Returns pointer a static string containing gravestone text 2444 * Returns pointer a static string containing gravestone text
2640 * Moved from apply.c to player.c - player.c is what 2445 * Moved from apply.c to player.c - player.c is what
2641 * actually uses this function. player.c may not be quite the 2446 * actually uses this function. player.c may not be quite the
… …
2652 strcpy (buf2, " R.I.P.\n\n"); 2457 strcpy (buf2, " R.I.P.\n\n");
2653 if (op->type == PLAYER) 2458 if (op->type == PLAYER)
2654 sprintf (buf, "%s the %s\n", &op->name, op->contr->title); 2459 sprintf (buf, "%s the %s\n", &op->name, op->contr->title);
2655 else 2460 else
2656 sprintf (buf, "%s\n", &op->name); 2461 sprintf (buf, "%s\n", &op->name);
2462
2657 strncat (buf2, " ", 20 - strlen (buf) / 2); 2463 strncat (buf2, " ", 20 - strlen (buf) / 2);
2658 strcat (buf2, buf); 2464 strcat (buf2, buf);
2659 if (op->type == PLAYER) 2465 if (op->type == PLAYER)
2660 sprintf (buf, "who was in level %d when killed\n", op->level); 2466 sprintf (buf, "who was in level %d when killed\n", op->level);
2661 else 2467 else
2662 sprintf (buf, "who was in level %d when died.\n\n", op->level); 2468 sprintf (buf, "who was in level %d when died.\n\n", op->level);
2469
2663 strncat (buf2, " ", 20 - strlen (buf) / 2); 2470 strncat (buf2, " ", 20 - strlen (buf) / 2);
2664 strcat (buf2, buf); 2471 strcat (buf2, buf);
2665 if (op->type == PLAYER) 2472 if (op->type == PLAYER)
2666 { 2473 {
2667 sprintf (buf, "by %s.\n\n", op->contr->killer); 2474 sprintf (buf, "by %s.\n\n", op->contr->killer);
2668 strncat (buf2, " ", 21 - strlen (buf) / 2); 2475 strncat (buf2, " ", 21 - strlen (buf) / 2);
2669 strcat (buf2, buf); 2476 strcat (buf2, buf);
2670 } 2477 }
2478
2671 strftime (buf, MAX_BUF, "%b %d %Y\n", localtime (&now)); 2479 strftime (buf, MAX_BUF, "%b %d %Y\n", localtime (&now));
2672 strncat (buf2, " ", 20 - strlen (buf) / 2); 2480 strncat (buf2, " ", 20 - strlen (buf) / 2);
2673 strcat (buf2, buf); 2481 strcat (buf2, buf);
2482
2674 return buf2; 2483 return buf2;
2675} 2484}
2676
2677
2678 2485
2679void 2486void
2680do_some_living (object *op) 2487do_some_living (object *op)
2681{ 2488{
2682 int last_food = op->stats.food; 2489 int last_food = op->stats.food;
… …
2691 const int max_grace = 1; 2498 const int max_grace = 1;
2692 2499
2693 if (op->contr->outputs_sync) 2500 if (op->contr->outputs_sync)
2694 { 2501 {
2695 for (i = 0; i < NUM_OUTPUT_BUFS; i++) 2502 for (i = 0; i < NUM_OUTPUT_BUFS; i++)
2696 if (op->contr->outputs[i].buf != NULL && (op->contr->outputs[i].first_update + op->contr->outputs_sync) < (uint16) pticks) 2503 if (op->contr->outputs[i].buf && (op->contr->outputs[i].first_update + op->contr->outputs_sync) < (uint16) pticks)
2697 flush_output_element (op, &op->contr->outputs[i]); 2504 flush_output_element (op, &op->contr->outputs[i]);
2698 } 2505 }
2699 2506
2700 if (op->contr->state == ST_PLAYING) 2507 if (op->contr->ns->state == ST_PLAYING)
2701 { 2508 {
2702
2703 /* these next three if clauses make it possible to SLOW DOWN 2509 /* these next three if clauses make it possible to SLOW DOWN
2704 hp/grace/spellpoint regeneration. */ 2510 hp/grace/spellpoint regeneration. */
2705 if (op->contr->gen_hp >= 0) 2511 if (op->contr->gen_hp >= 0)
2706 gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp; 2512 gen_hp = (op->contr->gen_hp + 1) * op->stats.maxhp;
2707 else 2513 else
2708 { 2514 {
2709 gen_hp = op->stats.maxhp; 2515 gen_hp = op->stats.maxhp;
2710 rate_hp -= rate_hp / 2 * op->contr->gen_hp; 2516 rate_hp -= rate_hp / 2 * op->contr->gen_hp;
2711 } 2517 }
2518
2712 if (op->contr->gen_sp >= 0) 2519 if (op->contr->gen_sp >= 0)
2713 gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp; 2520 gen_sp = (op->contr->gen_sp + 1) * op->stats.maxsp;
2714 else 2521 else
2715 { 2522 {
2716 gen_sp = op->stats.maxsp; 2523 gen_sp = op->stats.maxsp;
2717 rate_sp -= rate_sp / 2 * op->contr->gen_sp; 2524 rate_sp -= rate_sp / 2 * op->contr->gen_sp;
2718 } 2525 }
2526
2719 if (op->contr->gen_grace >= 0) 2527 if (op->contr->gen_grace >= 0)
2720 gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace; 2528 gen_grace = (op->contr->gen_grace + 1) * op->stats.maxgrace;
2721 else 2529 else
2722 { 2530 {
2723 gen_grace = op->stats.maxgrace; 2531 gen_grace = op->stats.maxgrace;
… …
2739 op->stats.food += op->contr->digestion; 2547 op->stats.food += op->contr->digestion;
2740 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH)) 2548 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2741 op->stats.food = last_food; 2549 op->stats.food = last_food;
2742 } 2550 }
2743 } 2551 }
2552
2744 if (max_sp > 1) 2553 if (max_sp > 1)
2745 { 2554 {
2746 over_sp = (gen_sp + 10) / rate_sp; 2555 over_sp = (gen_sp + 10) / rate_sp;
2747 if (over_sp > 0) 2556 if (over_sp > 0)
2748 { 2557 {
2749 if (op->stats.sp < op->stats.maxsp) 2558 if (op->stats.sp < op->stats.maxsp)
2750 { 2559 {
2751 op->stats.sp += over_sp > max_sp ? max_sp : over_sp; 2560 op->stats.sp += over_sp > max_sp ? max_sp : over_sp;
2561
2752 if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp)) 2562 if (random_roll (0, rate_sp - 1, op, PREFER_LOW) > ((gen_sp + 10) % rate_sp))
2753 op->stats.sp--; 2563 op->stats.sp--;
2564
2754 if (op->stats.sp > op->stats.maxsp) 2565 if (op->stats.sp > op->stats.maxsp)
2755 op->stats.sp = op->stats.maxsp; 2566 op->stats.sp = op->stats.maxsp;
2756 } 2567 }
2757 op->last_sp = 0; 2568 op->last_sp = 0;
2758 } 2569 }
2759 else 2570 else
2760 {
2761 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10); 2571 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2762 }
2763 } 2572 }
2764 else 2573 else
2765 {
2766 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10); 2574 op->last_sp = rate_sp / (gen_sp < 20 ? 30 : gen_sp + 10);
2767 }
2768 } 2575 }
2769 2576
2770 /* Regenerate Grace */ 2577 /* Regenerate Grace */
2771 /* I altered this a little - maximum grace is ony achieved through prayer -b.t. */ 2578 /* I altered this a little - maximum grace is ony achieved through prayer -b.t. */
2772 if (--op->last_grace < 0) 2579 if (--op->last_grace < 0)
2773 { 2580 {
2774 if (op->stats.grace < op->stats.maxgrace / 2) 2581 if (op->stats.grace < op->stats.maxgrace / 2)
2775 op->stats.grace++; /* no penalty in food for regaining grace */ 2582 op->stats.grace++; /* no penalty in food for regaining grace */
2583
2776 if (max_grace > 1) 2584 if (max_grace > 1)
2777 { 2585 {
2778 over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace; 2586 over_grace = (gen_grace < 20 ? 30 : gen_grace + 10) / rate_grace;
2779 if (over_grace > 0) 2587 if (over_grace > 0)
2780 { 2588 {
… …
2808 op->stats.food += op->contr->digestion; 2616 op->stats.food += op->contr->digestion;
2809 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH)) 2617 else if (op->contr->digestion > 0 && random_roll (0, op->contr->digestion, op, PREFER_HIGH))
2810 op->stats.food = last_food; 2618 op->stats.food = last_food;
2811 } 2619 }
2812 } 2620 }
2621
2813 if (max_hp > 1) 2622 if (max_hp > 1)
2814 { 2623 {
2815 over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp; 2624 over_hp = (gen_hp < 20 ? 30 : gen_hp + 10) / rate_hp;
2816 if (over_hp > 0) 2625 if (over_hp > 0)
2817 { 2626 {
… …
2841 2650
2842 if (op->contr->gen_hp > 0) 2651 if (op->contr->gen_hp > 0)
2843 op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1); 2652 op->last_eat = 25 * (1 + bonus) / (op->contr->gen_hp + penalty + 1);
2844 else 2653 else
2845 op->last_eat = 25 * (1 + bonus) / (penalty + 1); 2654 op->last_eat = 25 * (1 + bonus) / (penalty + 1);
2655
2846 /* dms do not consume food */ 2656 /* dms do not consume food */
2847 if (!QUERY_FLAG (op, FLAG_WIZ)) 2657 if (!QUERY_FLAG (op, FLAG_WIZ))
2848 op->stats.food--; 2658 op->stats.food--;
2849 } 2659 }
2850 }
2851 2660
2852 if (op->contr->state == ST_PLAYING && op->stats.food < 0 && op->stats.hp >= 0) 2661 if (op->stats.food < 0 && op->stats.hp >= 0)
2853 { 2662 {
2854 object *tmp, *flesh = NULL; 2663 object *tmp, *flesh = 0;
2855 2664
2856 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 2665 for (tmp = op->inv; tmp; tmp = tmp->below)
2857 { 2666 {
2858 if (!QUERY_FLAG (tmp, FLAG_UNPAID)) 2667 if (!QUERY_FLAG (tmp, FLAG_UNPAID))
2859 {
2860 if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
2861 { 2668 {
2669 if (tmp->type == FOOD || tmp->type == DRINK || tmp->type == POISON)
2670 {
2862 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food."); 2671 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2863 manual_apply (op, tmp, 0); 2672 manual_apply (op, tmp, 0);
2864 if (op->stats.food >= 0 || op->stats.hp < 0) 2673 if (op->stats.food >= 0 || op->stats.hp < 0)
2865 break; 2674 break;
2866 } 2675 }
2867 else if (tmp->type == FLESH) 2676 else if (tmp->type == FLESH)
2868 flesh = tmp; 2677 flesh = tmp;
2869 } /* End if paid for object */ 2678 } /* End if paid for object */
2870 } /* end of for loop */ 2679 } /* end of for loop */
2680
2871 /* If player is still starving, it means they don't have any food, so 2681 /* If player is still starving, it means they don't have any food, so
2872 * eat flesh instead. 2682 * eat flesh instead.
2873 */ 2683 */
2874 if (op->stats.food < 0 && op->stats.hp >= 0 && flesh) 2684 if (op->stats.food < 0 && op->stats.hp >= 0 && flesh)
2875 { 2685 {
2876 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food."); 2686 new_draw_info (NDI_UNIQUE, 0, op, "You blindly grab for a bite of food.");
2877 manual_apply (op, flesh, 0); 2687 manual_apply (op, flesh, 0);
2878 } 2688 }
2879 } /* end if player is starving */ 2689 }
2880 2690
2881 while (op->stats.food < 0 && op->stats.hp > 0) 2691 while (op->stats.food < 0 && op->stats.hp >= 0)
2882 op->stats.food++, op->stats.hp--; 2692 op->stats.food++, op->stats.hp--;
2883 2693
2884 if (!op->contr->state && !QUERY_FLAG (op, FLAG_WIZ) && (op->stats.hp < 0 || op->stats.food < 0)) 2694 if (op->stats.hp < 0 && !QUERY_FLAG (op, FLAG_WIZ))
2885 kill_player (op); 2695 kill_player (op);
2696 }
2886} 2697}
2887
2888
2889 2698
2890/* If the player should die (lack of hp, food, etc), we call this. 2699/* If the player should die (lack of hp, food, etc), we call this.
2891 * op is the player in jeopardy. If the player can not be saved (not 2700 * op is the player in jeopardy. If the player can not be saved (not
2892 * permadeath, no lifesave), this will take care of removing the player 2701 * permadeath, no lifesave), this will take care of removing the player
2893 * file. 2702 * file.
… …
2923 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!"); 2732 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You have been defeated in combat!");
2924 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life..."); 2733 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Local medics have saved your life...");
2925 2734
2926 /* restore player */ 2735 /* restore player */
2927 at = archetype::find ("poisoning"); 2736 at = archetype::find ("poisoning");
2928 tmp = present_arch_in_ob (at, op); 2737 if (object *tmp = present_arch_in_ob (at, op))
2929 if (tmp)
2930 { 2738 {
2931 tmp->destroy (); 2739 tmp->destroy ();
2932 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed"); 2740 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
2933 } 2741 }
2934 2742
2935 at = archetype::find ("confusion"); 2743 at = archetype::find ("confusion");
2936 tmp = present_arch_in_ob (at, op); 2744 if (object *tmp = present_arch_in_ob (at, op))
2937 if (tmp)
2938 { 2745 {
2939 tmp->destroy (); 2746 tmp->destroy ();
2940 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 2747 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
2941 } 2748 }
2942 2749
… …
2944 op->stats.hp = op->stats.maxhp; 2751 op->stats.hp = op->stats.maxhp;
2945 if (op->stats.food <= 0) 2752 if (op->stats.food <= 0)
2946 op->stats.food = 999; 2753 op->stats.food = 999;
2947 2754
2948 /* create a bodypart-trophy to make the winner happy */ 2755 /* create a bodypart-trophy to make the winner happy */
2949 tmp = arch_to_object (archetype::find ("finger")); 2756 if (object *tmp = arch_to_object (archetype::find ("finger")))
2950 if (tmp != NULL)
2951 { 2757 {
2952 sprintf (buf, "%s's finger", &op->name); 2758 sprintf (buf, "%s's finger", &op->name);
2953 tmp->name = buf; 2759 tmp->name = buf;
2954 sprintf (buf, " This finger has been cut off %s\n" 2760 sprintf (buf, " This finger has been cut off %s\n"
2955 " the %s, when he was defeated at\n level %d by %s.\n", 2761 " the %s, when he was defeated at\n level %d by %s.\n",
2956 &op->name, op->contr->title, (int) (op->level), op->contr->killer); 2762 &op->name, op->contr->title, (int) (op->level), op->contr->killer);
2957 tmp->msg = buf; 2763 tmp->msg = buf;
2958 tmp->value = 0, tmp->material = 0, tmp->type = 0; 2764 tmp->value = 0, tmp->material = 0, tmp->type = 0;
2959 tmp->materialname = NULL; 2765 tmp->materialname = NULL;
2960 tmp->x = op->x, tmp->y = op->y; 2766 op->insert_at (tmp, op);
2961 insert_ob_in_map (tmp, op->map, op, 0);
2962 } 2767 }
2963 2768
2964 /* teleport defeated player to new destination */ 2769 /* teleport defeated player to new destination */
2965 transfer_ob (op, x, y, 0, NULL); 2770 transfer_ob (op, x, y, 0, NULL);
2966 op->contr->braced = 0; 2771 op->contr->braced = 0;
… …
2992 op->stats.hp = op->stats.maxhp; 2797 op->stats.hp = op->stats.maxhp;
2993 return; 2798 return;
2994 } 2799 }
2995 sprintf (buf, "%s died.", &op->name); 2800 sprintf (buf, "%s died.", &op->name);
2996 } 2801 }
2802
2997 play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0); 2803 play_sound_player_only (op->contr, SOUND_PLAYER_DIES, 0, 0);
2998 2804
2999 /* save the map location for corpse, gravestone */ 2805 /* save the map location for corpse, gravestone */
3000 x = op->x; 2806 x = op->x;
3001 y = op->y; 2807 y = op->y;
3002 map = op->map; 2808 map = op->map;
3003 2809
3004
3005 if (settings.not_permadeth == TRUE)
3006 {
3007 /* NOT_PERMADEATH code. This basically brings the character back to 2810 /* NOT_PERMADEATH code. This basically brings the character back to
3008 * life if they are dead - it takes some exp and a random stat. 2811 * life if they are dead - it takes some exp and a random stat.
3009 * See the config.h file for a little more in depth detail about this. 2812 * See the config.h file for a little more in depth detail about this.
3010 */ 2813 */
3011 2814
3012 /* Basically two ways to go - remove a stat permanently, or just 2815 /* Basically two ways to go - remove a stat permanently, or just
3013 * make it depletion. This bunch of code deals with that aspect 2816 * make it depletion. This bunch of code deals with that aspect
3014 * of death. 2817 * of death.
3015 */ 2818 */
3016#ifndef COZY_SERVER 2819#ifndef COZY_SERVER
3017 if (settings.balanced_stat_loss) 2820 if (settings.balanced_stat_loss)
3018 { 2821 {
3019 /* If stat loss is permanent, lose one stat only. */ 2822 /* If stat loss is permanent, lose one stat only. */
3020 /* Lower level chars don't lose as many stats because they suffer 2823 /* Lower level chars don't lose as many stats because they suffer
3021 more if they do. */ 2824 more if they do. */
3022 /* Higher level characters can afford things such as potions of 2825 /* Higher level characters can afford things such as potions of
3023 restoration, or better, stat potions. So we slug them that 2826 restoration, or better, stat potions. So we slug them that
3024 little bit harder. */ 2827 little bit harder. */
3025 /* GD */ 2828 /* GD */
3026 if (settings.stat_loss_on_death) 2829 if (settings.stat_loss_on_death)
3027 num_stats_lose = 1; 2830 num_stats_lose = 1;
3028 else
3029 num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
3030 }
3031 else 2831 else
3032 { 2832 num_stats_lose = 1 + op->level / BALSL_NUMBER_LOSSES_RATIO;
2833 }
2834 else
3033 num_stats_lose = 1; 2835 num_stats_lose = 1;
3034 } 2836
3035 lost_a_stat = 0; 2837 lost_a_stat = 0;
3036 2838
3037 for (z = 0; z < num_stats_lose; z++) 2839 for (z = 0; z < num_stats_lose; z++)
3038 { 2840 {
3039 i = RANDOM () % NUM_STATS; 2841 i = RANDOM () % NUM_STATS;
3040 2842
3041 if (settings.stat_loss_on_death) 2843 if (settings.stat_loss_on_death)
3042 { 2844 {
3043 /* Pick a random stat and take a point off it. Tell the player 2845 /* Pick a random stat and take a point off it. Tell the player
3044 * what he lost. 2846 * what he lost.
3045 */ 2847 */
3046 change_attr_value (&(op->stats), i, -1); 2848 change_attr_value (&(op->stats), i, -1);
3047 check_stat_bounds (&(op->stats)); 2849 check_stat_bounds (&(op->stats));
3048 change_attr_value (&(op->contr->orig_stats), i, -1); 2850 change_attr_value (&(op->contr->orig_stats), i, -1);
3049 check_stat_bounds (&(op->contr->orig_stats)); 2851 check_stat_bounds (&(op->contr->orig_stats));
3050 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]); 2852 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3051 lost_a_stat = 1; 2853 lost_a_stat = 1;
2854 }
2855 else
2856 {
2857 /* deplete a stat */
2858 archetype *deparch = archetype::find ("depletion");
2859 object *dep;
2860
2861 dep = present_arch_in_ob (deparch, op);
2862 if (!dep)
2863 {
2864 dep = arch_to_object (deparch);
2865 insert_ob_in_ob (dep, op);
3052 } 2866 }
3053 else 2867 lose_this_stat = 1;
2868 if (settings.balanced_stat_loss)
3054 { 2869 {
3055 /* deplete a stat */ 2870 /* GD */
3056 archetype *deparch = archetype::find ("depletion"); 2871 /* Get the stat that we're about to deplete. */
3057 object *dep; 2872 this_stat = get_attr_value (&(dep->stats), i);
3058 2873 if (this_stat < 0)
3059 dep = present_arch_in_ob (deparch, op);
3060 if (!dep)
3061 { 2874 {
3062 dep = arch_to_object (deparch); 2875 int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3063 insert_ob_in_ob (dep, op); 2876 int keep_chance = this_stat * this_stat;
3064 } 2877
3065 lose_this_stat = 1; 2878 /* Yes, I am paranoid. Sue me. */
3066 if (settings.balanced_stat_loss)
3067 {
3068 /* GD */
3069 /* Get the stat that we're about to deplete. */
3070 this_stat = get_attr_value (&(dep->stats), i);
3071 if (this_stat < 0) 2879 if (keep_chance < 1)
2880 keep_chance = 1;
2881
2882 /* There is a maximum depletion total per level. */
2883 if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3072 { 2884 {
3073 int loss_chance = 1 + op->level / BALSL_LOSS_CHANCE_RATIO;
3074 int keep_chance = this_stat * this_stat;
3075
3076 /* Yes, I am paranoid. Sue me. */
3077 if (keep_chance < 1)
3078 keep_chance = 1;
3079
3080 /* There is a maximum depletion total per level. */
3081 if (this_stat < -1 - op->level / BALSL_MAX_LOSS_RATIO)
3082 {
3083 lose_this_stat = 0; 2885 lose_this_stat = 0;
3084 /* Take loss chance vs keep chance to see if we 2886 /* Take loss chance vs keep chance to see if we
3085 retain the stat. */ 2887 retain the stat. */
3086 }
3087 else
3088 {
3089 if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3090 lose_this_stat = 0;
3091 /* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
3092 this_stat, keep_chance, loss_chance,
3093 lose_this_stat?"LOSE":"KEEP"); */
3094 }
3095 } 2888 }
3096 }
3097
3098 if (lose_this_stat)
3099 {
3100 this_stat = get_attr_value (&(dep->stats), i);
3101 /* We could try to do something clever like find another
3102 * stat to reduce if this fails. But chances are, if
3103 * stats have been depleted to -50, all are pretty low
3104 * and should be roughly the same, so it shouldn't make a
3105 * difference.
3106 */ 2889 else
3107 if (this_stat >= -50)
3108 { 2890 {
3109 change_attr_value (&(dep->stats), i, -1); 2891 if (random_roll (0, loss_chance + keep_chance - 1, op, PREFER_LOW) < keep_chance)
3110 SET_FLAG (dep, FLAG_APPLIED);
3111 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
3112 fix_player (op);
3113 lost_a_stat = 1; 2892 lose_this_stat = 0;
2893 /* LOG(llevDebug, "Determining stat loss. Stat: %d Keep: %d Lose: %d Result: %s.\n",
2894 this_stat, keep_chance, loss_chance,
2895 lose_this_stat?"LOSE":"KEEP"); */
3114 } 2896 }
3115 } 2897 }
3116 } 2898 }
2899
2900 if (lose_this_stat)
2901 {
2902 this_stat = get_attr_value (&(dep->stats), i);
2903 /* We could try to do something clever like find another
2904 * stat to reduce if this fails. But chances are, if
2905 * stats have been depleted to -50, all are pretty low
2906 * and should be roughly the same, so it shouldn't make a
2907 * difference.
2908 */
2909 if (this_stat >= -50)
2910 {
2911 change_attr_value (&(dep->stats), i, -1);
2912 SET_FLAG (dep, FLAG_APPLIED);
2913 new_draw_info (NDI_UNIQUE, 0, op, lose_msg[i]);
2914 op->update_stats ();
2915 lost_a_stat = 1;
2916 }
3117 } 2917 }
2918 }
2919 }
3118 /* If no stat lost, tell the player. */ 2920 /* If no stat lost, tell the player. */
3119 if (!lost_a_stat) 2921 if (!lost_a_stat)
3120 { 2922 {
3121 /* determine_god() seems to not work sometimes... why is this? 2923 /* determine_god() seems to not work sometimes... why is this?
3122 Should I be using something else? GD */ 2924 Should I be using something else? GD */
3123 const char *god = determine_god (op); 2925 const char *god = determine_god (op);
3124 2926
3125 if (god && (strcmp (god, "none"))) 2927 if (god && (strcmp (god, "none")))
3126 new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god); 2928 new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god);
3127 else 2929 else
3128 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you."); 2930 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you.");
3129 } 2931 }
3130#else 2932#else
3131 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely."); 2933 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");
3132#endif 2934#endif
3133 2935
3134 /* Put a gravestone up where the character 'almost' died. List the 2936 /* Put a gravestone up where the character 'almost' died. List the
3135 * exp loss on the stone. 2937 * exp loss on the stone.
3136 */ 2938 */
3137 tmp = arch_to_object (archetype::find ("gravestone")); 2939 tmp = arch_to_object (archetype::find ("gravestone"));
3138 sprintf (buf, "%s's gravestone", &op->name); 2940 sprintf (buf, "%s's gravestone", &op->name);
3139 tmp->name = buf; 2941 tmp->name = buf;
3140 sprintf (buf, "%s's gravestones", &op->name); 2942 sprintf (buf, "%s's gravestones", &op->name);
3141 tmp->name_pl = buf; 2943 tmp->name_pl = buf;
3142 sprintf (buf, "RIP\nHere rests the hero %s the %s,\n" "who was killed\n" "by %s.\n", &op->name, op->contr->title, op->contr->killer); 2944 sprintf (buf, "RIP\nHere rests the hero %s the %s,\n" "who was killed\n" "by %s.\n", &op->name, op->contr->title, op->contr->killer);
3143 tmp->msg = buf; 2945 tmp->msg = buf;
3144 tmp->x = op->x, tmp->y = op->y; 2946 tmp->x = op->x, tmp->y = op->y;
3145 insert_ob_in_map (tmp, op->map, NULL, 0); 2947 insert_ob_in_map (tmp, op->map, NULL, 0);
3146 2948
3147 /**************************************/ 2949 /**************************************/
3148 /* */ 2950 /* */
3149 /* Subtract the experience points, */ 2951 /* Subtract the experience points, */
3150 /* if we died cause of food, give us */ 2952 /* if we died cause of food, give us */
3151 /* food, and reset HP's... */ 2953 /* food, and reset HP's... */
3152 /* */ 2954 /* */
3153 /**************************************/ 2955 /**************************************/
3154 2956
3155 /* remove any poisoning and confusion the character may be suffering. */ 2957 /* remove any poisoning and confusion the character may be suffering. */
3156 /* restore player */ 2958 /* restore player */
3157 at = archetype::find ("poisoning"); 2959 at = archetype::find ("poisoning");
3158 tmp = present_arch_in_ob (at, op); 2960 tmp = present_arch_in_ob (at, op);
3159 2961
3160 if (tmp) 2962 if (tmp)
3161 { 2963 {
3162 tmp->destroy (); 2964 tmp->destroy ();
3163 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed"); 2965 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
3164 } 2966 }
3165 2967
3166 at = archetype::find ("confusion"); 2968 at = archetype::find ("confusion");
3167 tmp = present_arch_in_ob (at, op); 2969 tmp = present_arch_in_ob (at, op);
3168 if (tmp) 2970 if (tmp)
3169 { 2971 {
3170 tmp->destroy (); 2972 tmp->destroy ();
3171 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 2973 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
3172 } 2974 }
3173 2975
3174 cure_disease (op, 0); /* remove any disease */ 2976 cure_disease (op, 0); /* remove any disease */
3175 2977
3176 /*add_exp(op, (op->stats.exp * -0.20)); */ 2978 /*add_exp(op, (op->stats.exp * -0.20)); */
3177 apply_death_exp_penalty (op); 2979 apply_death_exp_penalty (op);
3178 if (op->stats.food < 100) 2980 if (op->stats.food < 100)
3179 op->stats.food = 900; 2981 op->stats.food = 900;
3180 op->stats.hp = op->stats.maxhp; 2982 op->stats.hp = op->stats.maxhp;
3181 op->stats.sp = MAX (op->stats.sp, op->stats.maxsp); 2983 op->stats.sp = MAX (op->stats.sp, op->stats.maxsp);
3182 op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace); 2984 op->stats.grace = MAX (op->stats.grace, op->stats.maxgrace);
3183 2985
3184 /* 2986 /*
3185 * Check to see if the player is in a shop. IF so, then check to see if 2987 * Check to see if the player is in a shop. IF so, then check to see if
3186 * the player has any unpaid items. If so, remove them and put them back 2988 * the player has any unpaid items. If so, remove them and put them back
3187 * in the map. 2989 * in the map.
3188 */ 2990 */
3189 2991
3190 if (is_in_shop (op)) 2992 if (is_in_shop (op))
3191 remove_unpaid_objects (op->inv, op); 2993 remove_unpaid_objects (op->inv, op);
3192 2994
3193 /****************************************/ 2995 /****************************************/
3194 /* */ 2996 /* */
3195 /* Move player to his current respawn- */ 2997 /* Move player to his current respawn- */
3196 /* position (usually last savebed) */ 2998 /* position (usually last savebed) */
3197 /* */ 2999 /* */
3198 /****************************************/ 3000 /****************************************/
3199 3001
3200 enter_player_savebed (op); 3002 enter_player_savebed (op);
3201 3003
3202 /* Save the player before inserting the force to reduce 3004 /* Save the player before inserting the force to reduce
3203 * chance of abuse. 3005 * chance of abuse.
3204 */ 3006 */
3205 op->contr->braced = 0; 3007 op->contr->braced = 0;
3206 save_player (op, 1); 3008 op->contr->save ();
3207 3009
3208 /* it is possible that the player has blown something up 3010 /* it is possible that the player has blown something up
3209 * at his savebed location, and that can have long lasting 3011 * at his savebed location, and that can have long lasting
3210 * spell effects. So first see if there is a spell effect 3012 * spell effects. So first see if there is a spell effect
3211 * on the space that might harm the player. 3013 * on the space that might harm the player.
3212 */ 3014 */
3213 will_kill_again = 0; 3015 will_kill_again = 0;
3214 for (tmp = get_map_ob (op->map, op->x, op->y); tmp; tmp = tmp->above) 3016 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
3215 if (tmp->type == SPELL_EFFECT) 3017 if (tmp->type == SPELL_EFFECT)
3216 will_kill_again |= tmp->attacktype; 3018 will_kill_again |= tmp->attacktype;
3217 3019
3218 if (will_kill_again) 3020 if (will_kill_again)
3219 { 3021 {
3220 object *force; 3022 object *force;
3221 int at; 3023 int at;
3222 3024
3223 force = get_archetype (FORCE_NAME); 3025 force = get_archetype (FORCE_NAME);
3224 /* 50 ticks should be enough time for the spell to abate */ 3026 /* 50 ticks should be enough time for the spell to abate */
3225 force->speed = 0.1; 3027 force->speed = 0.1;
3226 force->speed_left = -5.0; 3028 force->speed_left = -5.0;
3227 SET_FLAG (force, FLAG_APPLIED); 3029 SET_FLAG (force, FLAG_APPLIED);
3228 for (at = 0; at < NROFATTACKS; at++) 3030 for (at = 0; at < NROFATTACKS; at++)
3229 if (will_kill_again & (1 << at)) 3031 if (will_kill_again & (1 << at))
3230 force->resist[at] = 100; 3032 force->resist[at] = 100;
3231 3033
3232 insert_ob_in_ob (force, op); 3034 insert_ob_in_ob (force, op);
3233 fix_player (op); 3035 op->update_stats ();
3234 3036
3235 } 3037 }
3236 3038
3237 new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED."); 3039 new_draw_info (NDI_UNIQUE, 0, op, "YOU HAVE DIED.");
3238 return;
3239 } /* NOT_PERMADETH */
3240 else
3241 {
3242 /* If NOT_PERMADETH is set, then the rest of this is not reachable. This
3243 * should probably be embedded in an else statement.
3244 */
3245
3246 op->contr->party = NULL;
3247 if (settings.set_title == TRUE)
3248 op->contr->own_title[0] = '\0';
3249 new_draw_info (NDI_UNIQUE | NDI_ALL, 0, NULL, buf);
3250 check_score (op);
3251
3252 if (op->contr->ranges[range_golem])
3253 {
3254 remove_friendly_object (op->contr->ranges[range_golem]);
3255 op->contr->ranges[range_golem]->destroy ();
3256 op->contr->ranges[range_golem] = 0;
3257 }
3258
3259 loot_object (op); /* Remove some of the items for good */
3260 op->remove ();
3261 op->direction = 0;
3262
3263 if (!QUERY_FLAG (op, FLAG_WAS_WIZ) && op->stats.exp)
3264 {
3265 delete_character (op->name, 0);
3266 if (settings.resurrection == TRUE)
3267 {
3268 /* save playerfile sans equipment when player dies
3269 ** then save it as player.pl.dead so that future resurrection
3270 ** type spells will work on them nicely
3271 */
3272 delete_character (op->name, 0);
3273 op->stats.hp = op->stats.maxhp;
3274 op->stats.food = 999;
3275
3276 /* set the location of where the person will reappear when */
3277 /* maybe resurrection code should fix map also */
3278 strcpy (op->contr->maplevel, settings.emergency_mapname);
3279 if (op->map != NULL)
3280 op->map = NULL;
3281 op->x = settings.emergency_x;
3282 op->y = settings.emergency_y;
3283 save_player (op, 0);
3284 op->map = map;
3285 /* please see resurrection.c: peterm */
3286 dead_player (op);
3287 }
3288 else
3289 delete_character (op->name, 1);
3290 }
3291
3292 play_again (op);
3293
3294 /* peterm: added to create a corpse at deathsite. */
3295 tmp = arch_to_object (archetype::find ("corpse_pl"));
3296 sprintf (buf, "%s", &op->name);
3297 tmp->name = tmp->name_pl = buf;
3298 tmp->level = op->level;
3299 tmp->x = x;
3300 tmp->y = y;
3301 tmp->msg = gravestone_text (op);
3302 SET_FLAG (tmp, FLAG_UNIQUE);
3303 insert_ob_in_map (tmp, map, NULL, 0);
3304 }
3305} 3040}
3306
3307 3041
3308void 3042void
3309loot_object (object *op) 3043loot_object (object *op)
3310{ /* Grab and destroy some treasure */ 3044{ /* Grab and destroy some treasure */
3311 object *tmp, *tmp2, *next; 3045 object *tmp, *tmp2, *next;
3312 3046
3313 if (op->container) 3047 if (op->container)
3314 { /* close open sack first */
3315 esrv_apply_container (op, op->container); 3048 esrv_apply_container (op, op->container); /* close open sack first */
3316 }
3317 3049
3318 for (tmp = op->inv; tmp != NULL; tmp = next) 3050 for (tmp = op->inv; tmp; tmp = next)
3319 { 3051 {
3320 next = tmp->below; 3052 next = tmp->below;
3321 if (tmp->type == EXPERIENCE || tmp->invisible) 3053
3054 if (tmp->invisible)
3322 continue; 3055 continue;
3056
3323 tmp->remove (); 3057 tmp->remove ();
3324 tmp->x = op->x, tmp->y = op->y; 3058 tmp->x = op->x, tmp->y = op->y;
3325 if (tmp->type == CONTAINER) 3059 if (tmp->type == CONTAINER)
3326 { /* empty container to ground */ 3060 { /* empty container to ground */
3327 loot_object (tmp); 3061 loot_object (tmp);
… …
3349 */ 3083 */
3350 3084
3351void 3085void
3352fix_weight (void) 3086fix_weight (void)
3353{ 3087{
3354 player *pl; 3088 for_all_players (pl)
3355
3356 for (pl = first_player; pl != NULL; pl = pl->next)
3357 { 3089 {
3358 int old = pl->ob->carrying, sum = sum_weight (pl->ob); 3090 int old = pl->ob->carrying, sum = sum_weight (pl->ob);
3359 3091
3360 if (old == sum) 3092 if (old == sum)
3361 continue; 3093 continue;
3362 fix_player (pl->ob); 3094 pl->ob->update_stats ();
3363 LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum); 3095 LOG (llevDebug, "Fixed inventory in %s (%d -> %d)\n", &pl->ob->name, old, sum);
3364 } 3096 }
3365} 3097}
3366 3098
3367void 3099void
3368fix_luck (void) 3100fix_luck (void)
3369{ 3101{
3370 player *pl; 3102 for_all_players (pl)
3371
3372 for (pl = first_player; pl != NULL; pl = pl->next)
3373 if (!pl->ob->contr->state) 3103 if (!pl->ob->contr->ns->state)
3374 change_luck (pl->ob, 0); 3104 pl->ob->change_luck (0);
3375} 3105}
3376
3377 3106
3378/* cast_dust() - handles op throwing objects of type 'DUST'. 3107/* cast_dust() - handles op throwing objects of type 'DUST'.
3379 * This is much simpler in the new spell code - we basically 3108 * This is much simpler in the new spell code - we basically
3380 * just treat this as any other spell casting object. 3109 * just treat this as any other spell casting object.
3381 */ 3110 */
3382
3383void 3111void
3384cast_dust (object *op, object *throw_ob, int dir) 3112cast_dust (object *op, object *throw_ob, int dir)
3385{ 3113{
3386 object *skop, *spob; 3114 object *skop, *spob;
3387 3115
… …
3432 object *tmp = NULL; 3160 object *tmp = NULL;
3433 3161
3434 if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD)) 3162 if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))
3435 return 1; 3163 return 1;
3436 3164
3437 if (op->type == PLAYER)
3438 for (tmp = op->inv; tmp; tmp = tmp->below)
3439 if (tmp->type == EXPERIENCE && tmp->stats.Wis)
3440 if (QUERY_FLAG (tmp, FLAG_UNDEAD))
3441 return 1;
3442 return 0; 3165 return 0;
3443} 3166}
3444 3167
3445/* look at the surrounding terrain to determine 3168/* look at the surrounding terrain to determine
3446 * the hideability of this object. Positive levels 3169 * the hideability of this object. Positive levels
… …
3561 if (mflags & P_OUT_OF_MAP) 3284 if (mflags & P_OUT_OF_MAP)
3562 continue; 3285 continue;
3563 if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y))) 3286 if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y)))
3564 continue; 3287 continue;
3565 3288
3566 for (tmp = get_map_ob (m, x, y); tmp; tmp = tmp->above) 3289 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
3567 { 3290 {
3568 if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE)) 3291 if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))
3569 return 1; 3292 return 1;
3570 else if (tmp->type == PLAYER) 3293 else if (tmp->type == PLAYER)
3571 { 3294 {
… …
3601 if (pl->type != PLAYER) 3324 if (pl->type != PLAYER)
3602 { 3325 {
3603 LOG (llevError, "player_can_view() called for non-player object\n"); 3326 LOG (llevError, "player_can_view() called for non-player object\n");
3604 return -1; 3327 return -1;
3605 } 3328 }
3329
3606 if (!pl || !op) 3330 if (!pl || !op)
3607 return 0; 3331 return 0;
3608 3332
3609 if (op->head)
3610 {
3611 op = op->head; 3333 op = op->head_ ();
3612 } 3334
3613 get_rangevector (pl, op, &rv, 0x1); 3335 get_rangevector (pl, op, &rv, 0x1);
3614 3336
3615 /* starting with the 'head' part, lets loop 3337 /* starting with the 'head' part, lets loop
3616 * through the object and find if it has any 3338 * through the object and find if it has any
3617 * part that is in the los array but isnt on 3339 * part that is in the los array but isnt on
… …
3625 3347
3626 /* only the viewable area the player sees is updated by LOS 3348 /* only the viewable area the player sees is updated by LOS
3627 * code, so we need to restrict ourselves to that range of values 3349 * code, so we need to restrict ourselves to that range of values
3628 * for any meaningful values. 3350 * for any meaningful values.
3629 */ 3351 */
3630 if (FABS (dx) <= (pl->contr->socket->mapx / 2) && 3352 if (FABS (dx) <= (pl->contr->ns->mapx / 2) &&
3631 FABS (dy) <= (pl->contr->socket->mapy / 2) && 3353 FABS (dy) <= (pl->contr->ns->mapy / 2) &&
3632 !pl->contr->blocked_los[dx + (pl->contr->socket->mapx / 2)][dy + (pl->contr->socket->mapy / 2)]) 3354 !pl->contr->blocked_los[dx + (pl->contr->ns->mapx / 2)][dy + (pl->contr->ns->mapy / 2)])
3633 return 1; 3355 return 1;
3634 op = op->more; 3356 op = op->more;
3635 } 3357 }
3636 return 0; 3358 return 0;
3637} 3359}
… …
3747 if (trlist == NULL || who->type != PLAYER) 3469 if (trlist == NULL || who->type != PLAYER)
3748 return; 3470 return;
3749 3471
3750 for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++); 3472 for (i = 0, tr = trlist->items; tr != NULL && i < level - 1; tr = tr->next, i++);
3751 3473
3752 if (tr == NULL || tr->item == NULL) 3474 if (!tr || !tr->item)
3753 { 3475 {
3754 /* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */ 3476 /* LOG(llevDebug, "-> no more treasure for %s\n", change_resist_msg[atnr]); */
3755 return; 3477 return;
3756 } 3478 }
3757 3479
… …
3823 { 3545 {
3824 /* forces in the treasurelist can alter the player's stats */ 3546 /* forces in the treasurelist can alter the player's stats */
3825 object *skin; 3547 object *skin;
3826 3548
3827 /* first get the dragon skin force */ 3549 /* first get the dragon skin force */
3550 shstr_cmp dragon_skin_force ("dragon_skin_force");
3828 for (skin = who->inv; skin != NULL && strcmp (skin->arch->name, "dragon_skin_force") != 0; skin = skin->below); 3551 for (skin = who->inv; skin && !(skin->arch->name == dragon_skin_force); skin = skin->below)
3552 ;
3553
3829 if (skin == NULL) 3554 if (!skin)
3830 return; 3555 return;
3831 3556
3832 /* adding new spellpath attunements */ 3557 /* adding new spellpath attunements */
3833 if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned)) 3558 if (item->path_attuned > 0 && !(skin->path_attuned & item->path_attuned))
3834 { 3559 {

Diff Legend

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