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.27 by root, Wed Sep 27 00:36:09 2006 UTC vs.
Revision 1.51 by root, Thu Dec 21 06:12:37 2006 UTC

… …
20 20
21 The author can be reached via e-mail to <crossfire@schmorp.de> 21 The author can be reached via e-mail to <crossfire@schmorp.de>
22*/ 22*/
23 23
24#include <global.h> 24#include <global.h>
25#ifndef WIN32 /* ---win32 remove headers */
26# include <pwd.h> 25#include <pwd.h>
27#endif
28#ifndef __CEXTRACT__
29# include <sproto.h> 26#include <sproto.h>
30#endif
31#include <sounds.h> 27#include <sounds.h>
32#include <living.h> 28#include <living.h>
33#include <object.h> 29#include <object.h>
34#include <spells.h> 30#include <spells.h>
35#include <skills.h> 31#include <skills.h>
36#include <newclient.h>
37 32
38#ifdef COZY_SERVER 33#ifdef COZY_SERVER
39extern int same_party (partylist *a, partylist *b); 34extern int same_party (partylist *a, partylist *b);
40#endif 35#endif
41 36
… …
87 int comp; 82 int comp;
88 int size; 83 int size;
89 84
90 sprintf (buf, "%s/%s", settings.confdir, settings.motd); 85 sprintf (buf, "%s/%s", settings.confdir, settings.motd);
91 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL) 86 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
92 {
93 return; 87 return;
94 } 88
95 motd[0] = '\0'; 89 motd[0] = '\0';
96 size = 0; 90 size = 0;
91
97 while (fgets (buf, MAX_BUF, fp) != NULL) 92 while (fgets (buf, MAX_BUF, fp) != NULL)
98 { 93 {
99 if (*buf == '#') 94 if (*buf == '#')
100 continue; 95 continue;
96
101 strncat (motd + size, buf, HUGE_BUF - size); 97 strncat (motd + size, buf, HUGE_BUF - size);
102 size += strlen (buf); 98 size += strlen (buf);
103 } 99 }
100
104 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_MOTD, MSG_SUBTYPE_NONE, motd, NULL); 101 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_MOTD, MSG_SUBTYPE_NONE, motd, NULL);
105 close_and_delete (fp, comp); 102 close_and_delete (fp, comp);
106} 103}
107 104
108void 105void
… …
114 int comp; 111 int comp;
115 int size; 112 int size;
116 113
117 sprintf (buf, "%s/%s", settings.confdir, settings.rules); 114 sprintf (buf, "%s/%s", settings.confdir, settings.rules);
118 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL) 115 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
119 {
120 return; 116 return;
121 } 117
122 rules[0] = '\0'; 118 rules[0] = '\0';
123 size = 0; 119 size = 0;
120
124 while (fgets (buf, MAX_BUF, fp) != NULL) 121 while (fgets (buf, MAX_BUF, fp) != NULL)
125 { 122 {
126 if (*buf == '#') 123 if (*buf == '#')
127 continue; 124 continue;
125
128 if (size + strlen (buf) >= HUGE_BUF) 126 if (size + strlen (buf) >= HUGE_BUF)
129 { 127 {
130 LOG (llevDebug, "Warning, rules size is > %d bytes.\n", HUGE_BUF); 128 LOG (llevDebug, "Warning, rules size is > %d bytes.\n", HUGE_BUF);
131 break; 129 break;
132 } 130 }
131
133 strncat (rules + size, buf, HUGE_BUF - size); 132 strncat (rules + size, buf, HUGE_BUF - size);
134 size += strlen (buf); 133 size += strlen (buf);
135 } 134 }
135
136 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_RULES, rules, NULL); 136 draw_ext_info (NDI_UNIQUE | NDI_GREEN, 0, op, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_RULES, rules, NULL);
137 close_and_delete (fp, comp); 137 close_and_delete (fp, comp);
138} 138}
139 139
140void 140void
… …
148 int size; 148 int size;
149 149
150 sprintf (buf, "%s/%s", settings.confdir, settings.news); 150 sprintf (buf, "%s/%s", settings.confdir, settings.news);
151 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL) 151 if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
152 return; 152 return;
153
153 news[0] = '\0'; 154 news[0] = '\0';
154 subject[0] = '\0'; 155 subject[0] = '\0';
155 size = 0; 156 size = 0;
157
156 while (fgets (buf, MAX_BUF, fp) != NULL) 158 while (fgets (buf, MAX_BUF, fp) != NULL)
157 { 159 {
158 if (*buf == '#') 160 if (*buf == '#')
159 continue; 161 continue;
162
160 if (*buf == '%') 163 if (*buf == '%')
161 { /* send one news */ 164 { /* send one news */
162 if (size > 0) 165 if (size > 0)
163 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 */ 166 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 */
164 strcpy (subject, buf + 1); 167 strcpy (subject, buf + 1);
… …
191 return 0; 194 return 0;
192 195
193 for (; *cp != '\0'; cp++) 196 for (; *cp != '\0'; cp++)
194 if (!((*cp >= 'a' && *cp <= 'z') || (*cp >= 'A' && *cp <= 'Z')) && *cp != '-' && *cp != '_') 197 if (!((*cp >= 'a' && *cp <= 'z') || (*cp >= 'A' && *cp <= 'Z')) && *cp != '-' && *cp != '_')
195 return 0; 198 return 0;
199
196 return 1; 200 return 1;
197} 201}
198 202
199/* This no longer sets the player map. Also, it now updates 203/* This no longer sets the player map. Also, it now updates
200 * all the pointers so the caller doesn't need to do that. 204 * all the pointers so the caller doesn't need to do that.
… …
208 * the one that is passed. 212 * the one that is passed.
209 */ 213 */
210static player * 214static player *
211get_player (player *p) 215get_player (player *p)
212{ 216{
213 object *op = arch_to_object (get_player_archetype (NULL)); 217 object *op = arch_to_object (get_player_archetype (0));
214 int i; 218 int i;
215
216 if (!p)
217 {
218 p = new player;
219
220 /* This adds the player in the linked list. There is extra
221 * complexity here because we want to add the new player at the
222 * end of the list - there is in fact no compelling reason that
223 * that needs to be done except for things like output of
224 * 'who'.
225 */
226 player *tmp = first_player;
227
228 while (tmp != NULL && tmp->next != NULL)
229 tmp = tmp->next;
230 if (tmp != NULL)
231 tmp->next = p;
232 else
233 first_player = p;
234
235 p->next = NULL;
236 }
237 219
238 /* Clears basically the entire player structure except 220 /* Clears basically the entire player structure except
239 * for next and socket. 221 * for next and socket.
240 */ 222 */
241 p->clear (); 223 p->clear ();
… …
260 op->speed_left = 0.5; 242 op->speed_left = 0.5;
261 op->speed = 1.0; 243 op->speed = 1.0;
262 op->direction = 5; /* So player faces south */ 244 op->direction = 5; /* So player faces south */
263 op->stats.wc = 2; 245 op->stats.wc = 2;
264 op->run_away = 25; /* Then we panick... */ 246 op->run_away = 25; /* Then we panick... */
247
248 {
249 int oldmon = p->socket->monitor_spells; // what a hack
265 p->socket.monitor_spells = 0; /* Needed because esrv_update_spells( ) gets called by roll_stats */ 250 p->socket->monitor_spells = 0; /* Needed because esrv_update_spells( ) gets called by roll_stats */
266
267 roll_stats (op); 251 roll_stats (op);
252 p->socket->monitor_spells = oldmon;
253 }
268 p->state = ST_ROLL_STAT; 254 p->state = ST_ROLL_STAT;
269 clear_los (op); 255 clear_los (op);
270 256
271 p->gen_sp_armour = 10; 257 p->gen_sp_armour = 10;
272 p->last_speed = -1; 258 p->last_speed = -1;
… …
277 p->usekeys = containers; 263 p->usekeys = containers;
278 p->last_weapon_sp = -1; 264 p->last_weapon_sp = -1;
279 p->peaceful = 1; /* default peaceful */ 265 p->peaceful = 1; /* default peaceful */
280 p->do_los = 1; 266 p->do_los = 1;
281 p->explore = 0; 267 p->explore = 0;
282 p->no_shout = 0; /* default can shout */
283 268
284 assign (p->title, op->arch->clone.name); 269 assign (p->title, op->arch->clone.name);
285 op->race = op->arch->clone.race; 270 op->race = op->arch->clone.race;
286 271
287 CLEAR_FLAG (op, FLAG_READY_SKILL); 272 CLEAR_FLAG (op, FLAG_READY_SKILL);
… …
294 for (i = 0; i < NUM_SKILLS; i++) 279 for (i = 0; i < NUM_SKILLS; i++)
295 { 280 {
296 p->last_skill_exp[i] = -1; 281 p->last_skill_exp[i] = -1;
297 p->last_skill_ob[i] = NULL; 282 p->last_skill_ob[i] = NULL;
298 } 283 }
284
299 for (i = 0; i < NROFATTACKS; i++) 285 for (i = 0; i < NROFATTACKS; i++)
300 {
301 p->last_resist[i] = -1; 286 p->last_resist[i] = -1;
302 } 287
303 p->last_stats.exp = -1; 288 p->last_stats.exp = -1;
304 p->last_weight = (uint32) - 1; 289 p->last_weight = (uint32) - 1;
305 290
306 p->socket.update_look = 0; 291 p->socket->update_look = 0;
307 p->socket.look_position = 0; 292 p->socket->look_position = 0;
293
308 return p; 294 return p;
309} 295}
310 296
311/* This loads the first map an puts the player on it. */ 297/* This loads the first map an puts the player on it. */
312static void 298static void
313set_first_map (object *op) 299set_first_map (object *op)
314{ 300{
315 strcpy (op->contr->maplevel, first_map_path); 301 strcpy (op->contr->maplevel, first_map_path);
316 op->x = -1; 302 op->x = -1;
317 op->y = -1; 303 op->y = -1;
318 enter_exit (op, NULL); 304 enter_exit (op, 0);
319} 305}
320 306
321/* Tries to add player on the connection passwd in ns. 307/* Tries to add player on the connection passwd in ns.
322 * All we can really get in this is some settings like host and display 308 * All we can really get in this is some settings like host and display
323 * mode. 309 * mode.
324 */ 310 */
325 311
326int 312int
327add_player (NewSocket * ns) 313add_player (client *ns)
328{ 314{
329 player *p; 315 player *p = new player;
330 316
331 p = get_player (NULL);
332 p->socket = *ns; 317 p->socket = ns;
333 p->socket.faces_sent = (uint8 *) malloc (p->socket.faces_sent_len * sizeof (*p->socket.faces_sent)); 318 ns->pl = p;
334 319
335 if (p->socket.faces_sent == NULL) 320 p->next = first_player;
336 fatal (OUT_OF_MEMORY); 321 first_player = p;
337 322
338 memcpy (p->socket.faces_sent, ns->faces_sent, p->socket.faces_sent_len * sizeof (*p->socket.faces_sent)); 323 p = get_player (p);
339 /* Needed because the socket we just copied over needs to be cleared. 324
340 * Note that this can result in a client reset if there is partial data
341 * on the uncoming socket.
342 */
343 p->socket.inbuf.len = 0;
344 set_first_map (p->ob); 325 set_first_map (p->ob);
345 326
346 CLEAR_FLAG (p->ob, FLAG_FRIENDLY); 327 CLEAR_FLAG (p->ob, FLAG_FRIENDLY);
347 add_friendly_object (p->ob); 328 add_friendly_object (p->ob);
348 send_rules (p->ob); 329 send_rules (p->ob);
349 send_news (p->ob); 330 send_news (p->ob);
350 display_motd (p->ob); 331 display_motd (p->ob);
332
351 get_name (p->ob); 333 get_name (p->ob);
352 334
353 return 0; 335 return 0;
354} 336}
355 337
… …
367 { 349 {
368 if (at == NULL || at->next == NULL) 350 if (at == NULL || at->next == NULL)
369 at = first_archetype; 351 at = first_archetype;
370 else 352 else
371 at = at->next; 353 at = at->next;
354
372 if (at->clone.type == PLAYER) 355 if (at->clone.type == PLAYER)
373 return at; 356 return at;
357
374 if (at == start) 358 if (at == start)
375 { 359 {
376 LOG (llevError, "No Player archetypes\n"); 360 LOG (llevError, "No Player archetypes\n");
377 exit (-1); 361 exit (-1);
378 } 362 }
379 } 363 }
380} 364}
381
382 365
383object * 366object *
384get_nearest_player (object *mon) 367get_nearest_player (object *mon)
385{ 368{
386 object *op = NULL; 369 object *op = NULL;
… …
646 (op->type == ARMOUR || op->type == BOOTS || 629 (op->type == ARMOUR || op->type == BOOTS ||
647 op->type == CLOAK || op->type == HELMET || 630 op->type == CLOAK || op->type == HELMET ||
648 op->type == SHIELD || op->type == GLOVES || 631 op->type == SHIELD || op->type == GLOVES ||
649 op->type == BRACERS || op->type == GIRDLE)) || (!QUERY_FLAG (pl, FLAG_USE_WEAPON) && op->type == WEAPON)) 632 op->type == BRACERS || op->type == GIRDLE)) || (!QUERY_FLAG (pl, FLAG_USE_WEAPON) && op->type == WEAPON))
650 { 633 {
651 remove_ob (op); 634 op->destroy ();
652 free_object (op);
653 continue; 635 continue;
654 } 636 }
655 } 637 }
656 638
657 /* This really needs to be better - we should really give 639 /* This really needs to be better - we should really give
… …
668 if (tmp->type == op->type && tmp->name == op->name) 650 if (tmp->type == op->type && tmp->name == op->name)
669 break; 651 break;
670 652
671 if (tmp) 653 if (tmp)
672 { 654 {
673 remove_ob (op); 655 op->destroy ();
674 free_object (op);
675 LOG (llevError, "give_initial_items: Removing duplicate object %s\n", &tmp->name); 656 LOG (llevError, "give_initial_items: Removing duplicate object %s\n", &tmp->name);
676 continue; 657 continue;
677 } 658 }
659
678 if (op->nrof > 1) 660 if (op->nrof > 1)
679 op->nrof = 1; 661 op->nrof = 1;
680 } 662 }
681 663
682 if (op->type == SPELLBOOK && op->inv) 664 if (op->type == SPELLBOOK && op->inv)
… …
694 CLEAR_FLAG (op, FLAG_CURSED); 676 CLEAR_FLAG (op, FLAG_CURSED);
695 CLEAR_FLAG (op, FLAG_DAMNED); 677 CLEAR_FLAG (op, FLAG_DAMNED);
696 } 678 }
697 if (op->type == SPELL) 679 if (op->type == SPELL)
698 { 680 {
699 remove_ob (op); 681 op->destroy ();
700 free_object (op);
701 continue; 682 continue;
702 } 683 }
703 else if (op->type == SKILL) 684 else if (op->type == SKILL)
704 { 685 {
705 SET_FLAG (op, FLAG_CAN_USE_SKILL); 686 SET_FLAG (op, FLAG_CAN_USE_SKILL);
… …
718void 699void
719get_name (object *op) 700get_name (object *op)
720{ 701{
721 op->contr->write_buf[0] = '\0'; 702 op->contr->write_buf[0] = '\0';
722 op->contr->state = ST_GET_NAME; 703 op->contr->state = ST_GET_NAME;
723 send_query (&op->contr->socket, 0, "What is your name?\n:"); 704 send_query (op->contr->socket, 0, "What is your name?\n:");
724} 705}
725 706
726void 707void
727get_password (object *op) 708get_password (object *op)
728{ 709{
729 op->contr->write_buf[0] = '\0'; 710 op->contr->write_buf[0] = '\0';
730 op->contr->state = ST_GET_PASSWORD; 711 op->contr->state = ST_GET_PASSWORD;
731 send_query (&op->contr->socket, CS_QUERY_HIDEINPUT, "What is your password?\n:"); 712 send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "What is your password?\n:");
732} 713}
733 714
734void 715void
735play_again (object *op) 716play_again (object *op)
736{ 717{
737 op->contr->state = ST_PLAY_AGAIN; 718 op->contr->state = ST_PLAY_AGAIN;
738 op->chosen_skill = NULL; 719 op->chosen_skill = NULL;
739 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Do you want to play again (a/q)?"); 720 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Do you want to play again (a/q)?");
740 /* a bit of a hack, but there are various places early in th 721 /* a bit of a hack, but there are various places early in th
741 * player creation process that a user can quit (eg, roll 722 * player creation process that a user can quit (eg, roll
742 * stats) that isn't removing the player. Taking a quick 723 * stats) that isn't removing the player. Taking a quick
743 * look, there are many places that call play_again without 724 * look, there are many places that call play_again without
744 * removing the player - it probably makes more sense 725 * removing the player - it probably makes more sense
745 * to leave it to play_again to remove the object in all 726 * to leave it to play_again to remove the object in all
746 * cases. 727 * cases.
747 */ 728 */
748 if (!QUERY_FLAG (op, FLAG_REMOVED)) 729 if (!QUERY_FLAG (op, FLAG_REMOVED))
749 remove_ob (op); 730 op->remove ();
731
750 /* Need to set this to null - otherwise, it could point to garbage, 732 /* Need to set this to null - otherwise, it could point to garbage,
751 * and draw() doesn't check to see if the player is removed, only if 733 * and draw() doesn't check to see if the player is removed, only if
752 * the map is null or not swapped out. 734 * the map is null or not swapped out.
753 */ 735 */
754 op->map = NULL; 736 op->map = NULL;
… …
793confirm_password (object *op) 775confirm_password (object *op)
794{ 776{
795 777
796 op->contr->write_buf[0] = '\0'; 778 op->contr->write_buf[0] = '\0';
797 op->contr->state = ST_CONFIRM_PASSWORD; 779 op->contr->state = ST_CONFIRM_PASSWORD;
798 send_query (&op->contr->socket, CS_QUERY_HIDEINPUT, "Please type your password again.\n:"); 780 send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "Please type your password again.\n:");
799} 781}
800 782
801void 783void
802get_party_password (object *op, partylist *party) 784get_party_password (object *op, partylist *party)
803{ 785{
… …
807 return; 789 return;
808 } 790 }
809 op->contr->write_buf[0] = '\0'; 791 op->contr->write_buf[0] = '\0';
810 op->contr->state = ST_GET_PARTY_PASSWORD; 792 op->contr->state = ST_GET_PARTY_PASSWORD;
811 op->contr->party_to_join = party; 793 op->contr->party_to_join = party;
812 send_query (&op->contr->socket, CS_QUERY_HIDEINPUT, "What is the password?\n:"); 794 send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "What is the password?\n:");
813} 795}
814 796
815 797
816/* This rolls four 1-6 rolls and sums the best 3 of the 4. */ 798/* This rolls four 1-6 rolls and sums the best 3 of the 4. */
817int 799int
… …
914 896
915void 897void
916Roll_Again (object *op) 898Roll_Again (object *op)
917{ 899{
918 esrv_new_player (op->contr, 0); 900 esrv_new_player (op->contr, 0);
919 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, 901 send_query (op->contr->socket, CS_QUERY_SINGLECHAR,
920 "[y] to roll new stats [n] to use stats\n[1-7] [1-7] to swap stats.\nRoll again (y/n/1-7)? "); 902 "[y] to roll new stats [n] to use stats\n[1-7] [1-7] to swap stats.\nRoll again (y/n/1-7)? ");
921} 903}
922 904
923void 905void
924Swap_Stat (object *op, int Swap_Second) 906Swap_Stat (object *op, int Swap_Second)
… …
991 new_draw_info (NDI_UNIQUE, 0, op, buf); 973 new_draw_info (NDI_UNIQUE, 0, op, buf);
992 } 974 }
993 else 975 else
994 Swap_Stat (op, stat_trans[keynum]); 976 Swap_Stat (op, stat_trans[keynum]);
995 977
996 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, ""); 978 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "");
997 return 1; 979 return 1;
998 } 980 }
999 switch (key) 981 switch (key)
1000 { 982 {
1001 case 'n': 983 case 'n':
… …
1015 enter_exit (op, NULL); 997 enter_exit (op, NULL);
1016#endif 998#endif
1017 SET_ANIMATION (op, 2); /* So player faces south */ 999 SET_ANIMATION (op, 2); /* So player faces south */
1018 /* Enter exit adds a player otherwise */ 1000 /* Enter exit adds a player otherwise */
1019 add_statbonus (op); 1001 add_statbonus (op);
1020 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, 1002 send_query (op->contr->socket, CS_QUERY_SINGLECHAR,
1021 "Now choose a character.\nPress any key to change outlook.\nPress `d' when you're pleased.\n"); 1003 "Now choose a character.\nPress any key to change outlook.\nPress `d' when you're pleased.\n");
1022 op->contr->state = ST_CHANGE_CLASS; 1004 op->contr->state = ST_CHANGE_CLASS;
1023 if (op->msg) 1005 if (op->msg)
1024 new_draw_info (NDI_BLUE, 0, op, op->msg); 1006 new_draw_info (NDI_BLUE, 0, op, op->msg);
1025 return 0; 1007 return 0;
1026 } 1008 }
1027 case 'y': 1009 case 'y':
1028 case 'Y': 1010 case 'Y':
1029 roll_stats (op); 1011 roll_stats (op);
1030 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, ""); 1012 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "");
1031 return 1; 1013 return 1;
1032 1014
1033 case 'q': 1015 case 'q':
1034 case 'Q': 1016 case 'Q':
1035 play_again (op); 1017 play_again (op);
1036 return 1; 1018 return 1;
1037 1019
1038 default: 1020 default:
1039 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Yes, No, Quit or 1-6. Roll again?"); 1021 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Yes, No, Quit or 1-6. Roll again?");
1040 return 0; 1022 return 0;
1041 } 1023 }
1042 return 0; 1024 return 0;
1043} 1025}
1044 1026
… …
1054{ 1036{
1055 int tmp_loop; 1037 int tmp_loop;
1056 1038
1057 if (key == 'q' || key == 'Q') 1039 if (key == 'q' || key == 'Q')
1058 { 1040 {
1059 remove_ob (op); 1041 op->remove ();
1060 play_again (op); 1042 play_again (op);
1061 return 0; 1043 return 0;
1062 } 1044 }
1063 if (key == 'd' || key == 'D') 1045 if (key == 'd' || key == 'D')
1064 { 1046 {
1065 char buf[MAX_BUF]; 1047 char buf[MAX_BUF];
1066 1048
1067 /* this must before then initial items are given */ 1049 /* this must before then initial items are given */
1068 esrv_new_player (op->contr, op->weight + op->carrying); 1050 esrv_new_player (op->contr, op->weight + op->carrying);
1051
1069 create_treasure (find_treasurelist ("starting_wealth"), op, 0, 0, 0); 1052 treasurelist *tl = find_treasurelist ("starting_wealth");
1053 if (tl)
1054 create_treasure (tl, op, 0, 0, 0);
1070 1055
1071 INVOKE_PLAYER (BIRTH, op->contr); 1056 INVOKE_PLAYER (BIRTH, op->contr);
1072 INVOKE_PLAYER (LOGIN, op->contr); 1057 INVOKE_PLAYER (LOGIN, op->contr);
1073 1058
1074 op->contr->state = ST_PLAYING; 1059 op->contr->state = ST_PLAYING;
… …
1099 { 1084 {
1100 object *tmp; 1085 object *tmp;
1101 char mapname[MAX_BUF]; 1086 char mapname[MAX_BUF];
1102 1087
1103 snprintf (mapname, MAX_BUF - 1, "%s/%s", first_map_ext_path, &op->arch->name); 1088 snprintf (mapname, MAX_BUF - 1, "%s/%s", first_map_ext_path, &op->arch->name);
1104 tmp = get_object (); 1089 tmp = object::create ();
1105 EXIT_PATH (tmp) = mapname; 1090 EXIT_PATH (tmp) = mapname;
1106 EXIT_X (tmp) = op->x; 1091 EXIT_X (tmp) = op->x;
1107 EXIT_Y (tmp) = op->y; 1092 EXIT_Y (tmp) = op->y;
1108 enter_exit (op, tmp); /* we don't really care if it succeeded; 1093 enter_exit (op, tmp); /* we don't really care if it succeeded;
1109 * if the map isn't there, then stay on the 1094 * if the map isn't there, then stay on the
1110 * default initial map */ 1095 * default initial map */
1111 free_object (tmp); 1096 tmp->destroy ();
1112 } 1097 }
1113 else 1098 else
1114 {
1115 LOG (llevDebug, "first_map_ext_path not set\n"); 1099 LOG (llevDebug, "first_map_ext_path not set\n");
1116 } 1100
1117 return 0; 1101 return 0;
1118 } 1102 }
1119 1103
1120 /* Following actually changes the race - this is the default command 1104 /* Following actually changes the race - this is the default command
1121 * if we don't match with one of the options above. 1105 * if we don't match with one of the options above.
… …
1126 { 1110 {
1127 shstr name = op->name; 1111 shstr name = op->name;
1128 int x = op->x, y = op->y; 1112 int x = op->x, y = op->y;
1129 1113
1130 remove_statbonus (op); 1114 remove_statbonus (op);
1131 remove_ob (op); 1115 op->remove ();
1132 op->arch = get_player_archetype (op->arch); 1116 op->arch = get_player_archetype (op->arch);
1133 copy_object (&op->arch->clone, op); 1117 op->arch->clone.copy_to (op);
1134 op->instantiate (); 1118 op->instantiate ();
1135 op->stats = op->contr->orig_stats; 1119 op->stats = op->contr->orig_stats;
1136 op->name = op->name_pl = name; 1120 op->name = op->name_pl = name;
1137 op->x = x; 1121 op->x = x;
1138 op->y = y; 1122 op->y = y;
… …
1151 op->stats.grace = 0; 1135 op->stats.grace = 0;
1152 1136
1153 if (op->msg) 1137 if (op->msg)
1154 new_draw_info (NDI_BLUE, 0, op, op->msg); 1138 new_draw_info (NDI_BLUE, 0, op, op->msg);
1155 1139
1156 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n"); 1140 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n");
1157 return 0; 1141 return 0;
1158} 1142}
1159 1143
1160int 1144int
1161key_confirm_quit (object *op, char key) 1145key_confirm_quit (object *op, char key)
… …
1241 { 1225 {
1242 op->enemy = NULL; 1226 op->enemy = NULL;
1243 CLEAR_FLAG (op, FLAG_SCARED); 1227 CLEAR_FLAG (op, FLAG_SCARED);
1244 return; 1228 return;
1245 } 1229 }
1230
1246 get_rangevector (op, op->enemy, &rv, 0); 1231 get_rangevector (op, op->enemy, &rv, 0);
1247 1232
1248 dir = absdir (4 + rv.direction); 1233 dir = absdir (4 + rv.direction);
1249 for (diff = 0; diff < 3; diff++) 1234 for (diff = 0; diff < 3; diff++)
1250 { 1235 {
1251 int m = 1 - (RANDOM () & 2); 1236 int m = 1 - (RANDOM () & 2);
1252 1237
1253 if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op))) 1238 if (move_ob (op, absdir (dir + diff * m), op) || (diff == 0 && move_ob (op, absdir (dir - diff * m), op)))
1254 {
1255 return; 1239 return;
1256 }
1257 } 1240 }
1241
1258 /* Cornered, get rid of scared */ 1242 /* Cornered, get rid of scared */
1259 CLEAR_FLAG (op, FLAG_SCARED); 1243 CLEAR_FLAG (op, FLAG_SCARED);
1260 op->enemy = NULL; 1244 op->enemy = NULL;
1261} 1245}
1262 1246
… …
1426 /* question: don't pick up known-poisonous stuff? */ 1410 /* question: don't pick up known-poisonous stuff? */
1427 if (op->contr->mode & PU_FOOD) 1411 if (op->contr->mode & PU_FOOD)
1428 if (tmp->type == FOOD) 1412 if (tmp->type == FOOD)
1429 { 1413 {
1430 pick_up (op, tmp); 1414 pick_up (op, tmp);
1431 if (0)
1432 fprintf (stderr, "FOOD\n");
1433 continue; 1415 continue;
1434 } 1416 }
1417
1435 if (op->contr->mode & PU_DRINK) 1418 if (op->contr->mode & PU_DRINK)
1436 if (tmp->type == DRINK || (tmp->type == POISON && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED))) 1419 if (tmp->type == DRINK || (tmp->type == POISON && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED)))
1437 { 1420 {
1438 pick_up (op, tmp); 1421 pick_up (op, tmp);
1439 if (0)
1440 fprintf (stderr, "DRINK\n");
1441 continue; 1422 continue;
1442 } 1423 }
1443 1424
1444 if (op->contr->mode & PU_POTION) 1425 if (op->contr->mode & PU_POTION)
1445 if (tmp->type == POTION) 1426 if (tmp->type == POTION)
1446 { 1427 {
1447 pick_up (op, tmp); 1428 pick_up (op, tmp);
1448 if (0)
1449 fprintf (stderr, "POTION\n");
1450 continue; 1429 continue;
1451 } 1430 }
1452 1431
1453 /* spellbooks, skillscrolls and normal books/scrolls */ 1432 /* spellbooks, skillscrolls and normal books/scrolls */
1454 if (op->contr->mode & PU_SPELLBOOK) 1433 if (op->contr->mode & PU_SPELLBOOK)
1455 if (tmp->type == SPELLBOOK) 1434 if (tmp->type == SPELLBOOK)
1456 { 1435 {
1457 pick_up (op, tmp); 1436 pick_up (op, tmp);
1458 if (0)
1459 fprintf (stderr, "SPELLBOOK\n");
1460 continue; 1437 continue;
1461 } 1438 }
1439
1462 if (op->contr->mode & PU_SKILLSCROLL) 1440 if (op->contr->mode & PU_SKILLSCROLL)
1463 if (tmp->type == SKILLSCROLL) 1441 if (tmp->type == SKILLSCROLL)
1464 { 1442 {
1465 pick_up (op, tmp); 1443 pick_up (op, tmp);
1466 if (0)
1467 fprintf (stderr, "SKILLSCROLL\n");
1468 continue; 1444 continue;
1469 } 1445 }
1446
1470 if (op->contr->mode & PU_READABLES) 1447 if (op->contr->mode & PU_READABLES)
1471 if (tmp->type == BOOK || tmp->type == SCROLL) 1448 if (tmp->type == BOOK || tmp->type == SCROLL)
1472 { 1449 {
1473 pick_up (op, tmp); 1450 pick_up (op, tmp);
1474 if (0)
1475 fprintf (stderr, "READABLES\n");
1476 continue; 1451 continue;
1477 } 1452 }
1478 1453
1479 /* wands/staves/rods/horns */ 1454 /* wands/staves/rods/horns */
1480 if (op->contr->mode & PU_MAGIC_DEVICE) 1455 if (op->contr->mode & PU_MAGIC_DEVICE)
1481 if (tmp->type == WAND || tmp->type == ROD || tmp->type == HORN) 1456 if (tmp->type == WAND || tmp->type == ROD || tmp->type == HORN)
1482 { 1457 {
1483 pick_up (op, tmp); 1458 pick_up (op, tmp);
1484 if (0)
1485 fprintf (stderr, "MAGIC_DEVICE\n");
1486 continue; 1459 continue;
1487 } 1460 }
1488 1461
1489 /* pick up all magical items */ 1462 /* pick up all magical items */
1490 if (op->contr->mode & PU_MAGICAL) 1463 if (op->contr->mode & PU_MAGICAL)
1491 if (QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED)) 1464 if (QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED))
1492 { 1465 {
1493 pick_up (op, tmp); 1466 pick_up (op, tmp);
1494 if (0)
1495 fprintf (stderr, "MAGICAL\n");
1496 continue; 1467 continue;
1497 } 1468 }
1498 1469
1499 if (op->contr->mode & PU_VALUABLES) 1470 if (op->contr->mode & PU_VALUABLES)
1500 { 1471 {
1501 if (tmp->type == MONEY || tmp->type == GEM) 1472 if (tmp->type == MONEY || tmp->type == GEM)
1502 { 1473 {
1503 pick_up (op, tmp); 1474 pick_up (op, tmp);
1504 if (0)
1505 fprintf (stderr, "MONEY/GEM\n");
1506 continue; 1475 continue;
1507 } 1476 }
1508 } 1477 }
1509 1478
1510 /* rings & amulets - talismans seems to be typed AMULET */ 1479 /* rings & amulets - talismans seems to be typed AMULET */
1511 if (op->contr->mode & PU_JEWELS) 1480 if (op->contr->mode & PU_JEWELS)
1512 if (tmp->type == RING || tmp->type == AMULET) 1481 if (tmp->type == RING || tmp->type == AMULET)
1513 { 1482 {
1514 pick_up (op, tmp); 1483 pick_up (op, tmp);
1484 continue;
1515 if (0) 1485 }
1516 fprintf (stderr, "JEWELS\n"); 1486
1487 /* we don't forget dragon food */
1488 if (op->contr->mode & PU_FLESH)
1489 if (tmp->type == FLESH)
1490 {
1491 pick_up (op, tmp);
1517 continue; 1492 continue;
1518 } 1493 }
1519 1494
1520 /* bows and arrows. Bows are good for selling! */ 1495 /* bows and arrows. Bows are good for selling! */
1521 if (op->contr->mode & PU_BOW) 1496 if (op->contr->mode & PU_BOW)
1522 if (tmp->type == BOW) 1497 if (tmp->type == BOW)
1523 { 1498 {
1524 pick_up (op, tmp); 1499 pick_up (op, tmp);
1525 if (0)
1526 fprintf (stderr, "BOW\n");
1527 continue; 1500 continue;
1528 } 1501 }
1502
1529 if (op->contr->mode & PU_ARROW) 1503 if (op->contr->mode & PU_ARROW)
1530 if (tmp->type == ARROW) 1504 if (tmp->type == ARROW)
1531 { 1505 {
1532 pick_up (op, tmp); 1506 pick_up (op, tmp);
1533 if (0)
1534 fprintf (stderr, "ARROW\n");
1535 continue; 1507 continue;
1536 } 1508 }
1537 1509
1538 /* all kinds of armor etc. */ 1510 /* all kinds of armor etc. */
1539 if (op->contr->mode & PU_ARMOUR) 1511 if (op->contr->mode & PU_ARMOUR)
1540 if (tmp->type == ARMOUR) 1512 if (tmp->type == ARMOUR)
1541 { 1513 {
1542 pick_up (op, tmp); 1514 pick_up (op, tmp);
1543 if (0)
1544 fprintf (stderr, "ARMOUR\n");
1545 continue; 1515 continue;
1546 } 1516 }
1517
1547 if (op->contr->mode & PU_HELMET) 1518 if (op->contr->mode & PU_HELMET)
1548 if (tmp->type == HELMET) 1519 if (tmp->type == HELMET)
1549 { 1520 {
1550 pick_up (op, tmp); 1521 pick_up (op, tmp);
1551 if (0)
1552 fprintf (stderr, "HELMET\n");
1553 continue; 1522 continue;
1554 } 1523 }
1524
1555 if (op->contr->mode & PU_SHIELD) 1525 if (op->contr->mode & PU_SHIELD)
1556 if (tmp->type == SHIELD) 1526 if (tmp->type == SHIELD)
1557 { 1527 {
1558 pick_up (op, tmp); 1528 pick_up (op, tmp);
1559 if (0)
1560 fprintf (stderr, "SHIELD\n");
1561 continue; 1529 continue;
1562 } 1530 }
1531
1563 if (op->contr->mode & PU_BOOTS) 1532 if (op->contr->mode & PU_BOOTS)
1564 if (tmp->type == BOOTS) 1533 if (tmp->type == BOOTS)
1565 { 1534 {
1566 pick_up (op, tmp); 1535 pick_up (op, tmp);
1567 if (0)
1568 fprintf (stderr, "BOOTS\n");
1569 continue; 1536 continue;
1570 } 1537 }
1538
1571 if (op->contr->mode & PU_GLOVES) 1539 if (op->contr->mode & PU_GLOVES)
1572 if (tmp->type == GLOVES) 1540 if (tmp->type == GLOVES)
1573 { 1541 {
1574 pick_up (op, tmp); 1542 pick_up (op, tmp);
1575 if (0)
1576 fprintf (stderr, "GLOVES\n");
1577 continue; 1543 continue;
1578 } 1544 }
1545
1579 if (op->contr->mode & PU_CLOAK) 1546 if (op->contr->mode & PU_CLOAK)
1580 if (tmp->type == CLOAK) 1547 if (tmp->type == CLOAK)
1581 { 1548 {
1582 pick_up (op, tmp); 1549 pick_up (op, tmp);
1583 if (0)
1584 fprintf (stderr, "GLOVES\n");
1585 continue; 1550 continue;
1586 } 1551 }
1587 1552
1588 /* hoping to catch throwing daggers here */ 1553 /* hoping to catch throwing daggers here */
1589 if (op->contr->mode & PU_MISSILEWEAPON) 1554 if (op->contr->mode & PU_MISSILEWEAPON)
1590 if (tmp->type == WEAPON && QUERY_FLAG (tmp, FLAG_IS_THROWN)) 1555 if (tmp->type == WEAPON && QUERY_FLAG (tmp, FLAG_IS_THROWN))
1591 { 1556 {
1592 pick_up (op, tmp); 1557 pick_up (op, tmp);
1593 if (0)
1594 fprintf (stderr, "MISSILEWEAPON\n");
1595 continue; 1558 continue;
1596 } 1559 }
1597 1560
1598 /* careful: chairs and tables are weapons! */ 1561 /* careful: chairs and tables are weapons! */
1599 if (op->contr->mode & PU_ALLWEAPON) 1562 if (op->contr->mode & PU_ALLWEAPON)
… …
1602 { 1565 {
1603 if (strstr (tmp->name, "table") == NULL && strstr (tmp->arch->name, "table") == NULL && 1566 if (strstr (tmp->name, "table") == NULL && strstr (tmp->arch->name, "table") == NULL &&
1604 strstr (tmp->name, "chair") && strstr (tmp->arch->name, "chair") == NULL) 1567 strstr (tmp->name, "chair") && strstr (tmp->arch->name, "chair") == NULL)
1605 { 1568 {
1606 pick_up (op, tmp); 1569 pick_up (op, tmp);
1607 if (0)
1608 fprintf (stderr, "WEAPON\n");
1609 continue; 1570 continue;
1610 } 1571 }
1611 } 1572 }
1573
1612 if (tmp->type == WEAPON && tmp->name == NULL) 1574 if (tmp->type == WEAPON && tmp->name == NULL)
1613 { 1575 {
1614 if (strstr (tmp->arch->name, "table") == NULL && strstr (tmp->arch->name, "chair") == NULL) 1576 if (strstr (tmp->arch->name, "table") == NULL && strstr (tmp->arch->name, "chair") == NULL)
1615 { 1577 {
1616 pick_up (op, tmp); 1578 pick_up (op, tmp);
1617 if (0)
1618 fprintf (stderr, "WEAPON\n");
1619 continue; 1579 continue;
1620 } 1580 }
1621 } 1581 }
1622 } 1582 }
1623 1583
1624 /* misc stuff that's useful */ 1584 /* misc stuff that's useful */
1625 if (op->contr->mode & PU_KEY) 1585 if (op->contr->mode & PU_KEY)
1626 if (tmp->type == KEY || tmp->type == SPECIAL_KEY) 1586 if (tmp->type == KEY || tmp->type == SPECIAL_KEY)
1627 { 1587 {
1628 pick_up (op, tmp); 1588 pick_up (op, tmp);
1629 if (0)
1630 fprintf (stderr, "KEY\n");
1631 continue; 1589 continue;
1632 } 1590 }
1633 1591
1634 /* any of the last 4 bits set means we use the ratio for value 1592 /* any of the last 4 bits set means we use the ratio for value
1635 * pickups */ 1593 * pickups */
… …
1657 continue; 1615 continue;
1658 } 1616 }
1659 } 1617 }
1660 } /* the new pickup model */ 1618 } /* the new pickup model */
1661 } 1619 }
1620
1662 return !stop; 1621 return !stop;
1663} 1622}
1664 1623
1665/* 1624/*
1666 * Find an arrow in the inventory and after that 1625 * Find an arrow in the inventory and after that
… …
1843 if (!dir) 1802 if (!dir)
1844 { 1803 {
1845 new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!"); 1804 new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");
1846 return 0; 1805 return 0;
1847 } 1806 }
1807
1848 if (op->type == PLAYER) 1808 if (op->type == PLAYER)
1849 bow = op->contr->ranges[range_bow]; 1809 bow = op->contr->ranges[range_bow];
1850 else 1810 else
1851 { 1811 {
1852 for (bow = op->inv; bow; bow = bow->below) 1812 for (bow = op->inv; bow; bow = bow->below)
… …
1860 { 1820 {
1861 LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name); 1821 LOG (llevError, "Range: bow without activated bow (%s).\n", &op->name);
1862 return 0; 1822 return 0;
1863 } 1823 }
1864 } 1824 }
1825
1865 if (!bow->race || !bow->skill) 1826 if (!bow->race || !bow->skill)
1866 { 1827 {
1867 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name); 1828 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", &bow->name);
1868 return 0; 1829 return 0;
1869 } 1830 }
… …
1871 bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex]; 1832 bowspeed = bow->stats.sp + dex_bonus[op->stats.Dex];
1872 1833
1873 /* penalize ROF for bestarrow */ 1834 /* penalize ROF for bestarrow */
1874 if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow) 1835 if (op->type == PLAYER && op->contr->bowtype == bow_bestarrow)
1875 bowspeed -= dex_bonus[op->stats.Dex] + 5; 1836 bowspeed -= dex_bonus[op->stats.Dex] + 5;
1837
1876 if (bowspeed < 1) 1838 if (bowspeed < 1)
1877 bowspeed = 1; 1839 bowspeed = 1;
1878 1840
1879 if (arrow == NULL) 1841 if (arrow == NULL)
1880 { 1842 {
… …
1886 else 1848 else
1887 CLEAR_FLAG (op, FLAG_READY_BOW); 1849 CLEAR_FLAG (op, FLAG_READY_BOW);
1888 return 0; 1850 return 0;
1889 } 1851 }
1890 } 1852 }
1853
1891 mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy); 1854 mflags = get_map_flags (op->map, &m, sx, sy, &sx, &sy);
1892 if (mflags & P_OUT_OF_MAP) 1855 if (mflags & P_OUT_OF_MAP)
1893 {
1894 return 0; 1856 return 0;
1895 } 1857
1896 if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW) 1858 if (GET_MAP_MOVE_BLOCK (m, sx, sy) == MOVE_FLY_LOW)
1897 { 1859 {
1898 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 1860 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
1899 return 0; 1861 return 0;
1900 } 1862 }
1901 1863
1902 /* this should not happen, but sometimes does */ 1864 /* this should not happen, but sometimes does */
1903 if (arrow->nrof == 0) 1865 if (arrow->nrof == 0)
1904 { 1866 {
1905 remove_ob (arrow); 1867 arrow->destroy ();
1906 free_object (arrow);
1907 return 0; 1868 return 0;
1908 } 1869 }
1909 1870
1910 left = arrow; /* these are arrows left to the player */ 1871 left = arrow; /* these are arrows left to the player */
1911 arrow = get_split_ob (arrow, 1); 1872 arrow = get_split_ob (arrow, 1);
1912 if (arrow == NULL) 1873 if (!arrow)
1913 { 1874 {
1914 new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race); 1875 new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);
1915 return 0; 1876 return 0;
1916 } 1877 }
1917 set_owner (arrow, op); 1878
1879 arrow->set_owner (op);
1918 arrow->skill = bow->skill; 1880 arrow->skill = bow->skill;
1919 1881
1920 arrow->direction = dir; 1882 arrow->direction = dir;
1921 arrow->x = sx; 1883 arrow->x = sx;
1922 arrow->y = sy; 1884 arrow->y = sy;
… …
1930 SET_ANIMATION (arrow, arrow->direction); 1892 SET_ANIMATION (arrow, arrow->direction);
1931 arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */ 1893 arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */
1932 arrow->stats.hp = arrow->stats.dam; 1894 arrow->stats.hp = arrow->stats.dam;
1933 arrow->stats.grace = arrow->attacktype; 1895 arrow->stats.grace = arrow->attacktype;
1934 if (arrow->slaying != NULL) 1896 if (arrow->slaying != NULL)
1935 arrow->spellarg = strdup_local (arrow->slaying); 1897 arrow->spellarg = strdup (arrow->slaying);
1936 1898
1937 /* Note that this was different for monsters - they got their level 1899 /* Note that this was different for monsters - they got their level
1938 * added to the damage. I think the strength bonus is more proper. 1900 * added to the damage. I think the strength bonus is more proper.
1939 */ 1901 */
1940 1902
… …
1964 } 1926 }
1965 1927
1966 if (arrow->attacktype == AT_PHYSICAL) 1928 if (arrow->attacktype == AT_PHYSICAL)
1967 arrow->attacktype |= bow->attacktype; 1929 arrow->attacktype |= bow->attacktype;
1968 1930
1969 if (bow->slaying != NULL) 1931 if (bow->slaying)
1970 arrow->slaying = bow->slaying; 1932 arrow->slaying = bow->slaying;
1971 1933
1972 arrow->map = m; 1934 arrow->map = m;
1973 arrow->move_type = MOVE_FLY_LOW; 1935 arrow->move_type = MOVE_FLY_LOW;
1974 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK; 1936 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
… …
2090 CLEAR_FLAG (item, FLAG_ANIMATE); 2052 CLEAR_FLAG (item, FLAG_ANIMATE);
2091 item->face = item->arch->clone.face; 2053 item->face = item->arch->clone.face;
2092 item->speed = 0; 2054 item->speed = 0;
2093 update_ob_speed (item); 2055 update_ob_speed (item);
2094 } 2056 }
2095 if ((tmp = is_player_inv (item))) 2057 if ((tmp = item->in_player ()))
2096 esrv_update_item (UPD_ANIM, tmp, item); 2058 esrv_update_item (UPD_ANIM, tmp, item);
2097 } 2059 }
2098 } 2060 }
2099 else if (item->type == ROD || item->type == HORN) 2061 else if (item->type == ROD || item->type == HORN)
2100 { 2062 {
… …
2130 case range_misc: 2092 case range_misc:
2131 fire_misc_object (op, dir); 2093 fire_misc_object (op, dir);
2132 return; 2094 return;
2133 2095
2134 case range_golem: /* Control summoned monsters from scrolls */ 2096 case range_golem: /* Control summoned monsters from scrolls */
2135 if (op->contr->ranges[range_golem] == NULL || op->contr->golem_count != op->contr->ranges[range_golem]->count) 2097 if (QUERY_FLAG (op->contr->ranges[range_golem], FLAG_REMOVED))
2136 { 2098 {
2137 op->contr->ranges[range_golem] = NULL; 2099 op->contr->ranges[range_golem] = 0;
2138 op->contr->shoottype = range_none; 2100 op->contr->shoottype = range_none;
2139 op->contr->golem_count = 0;
2140 } 2101 }
2141 else 2102 else
2142 control_golem (op->contr->ranges[range_golem], dir); 2103 control_golem (op->contr->ranges[range_golem], dir);
2143 return; 2104 return;
2144 2105
… …
2251 * 0 otherwise 2212 * 0 otherwise
2252 */ 2213 */
2253static int 2214static int
2254player_attack_door (object *op, object *door) 2215player_attack_door (object *op, object *door)
2255{ 2216{
2256
2257 /* If its a door, try to find a use a key. If we do destroy the door, 2217 /* If its a door, try to find a use a key. If we do destroy the door,
2258 * might as well return immediately as there is nothing more to do - 2218 * might as well return immediately as there is nothing more to do -
2259 * otherwise, we fall through to the rest of the code. 2219 * otherwise, we fall through to the rest of the code.
2260 */ 2220 */
2261 object *key = find_key (op, op, door); 2221 object *key = find_key (op, op, door);
… …
2299 * It should keep the code cleaner. 2259 * It should keep the code cleaner.
2300 * When this is called, the players direction has been updated 2260 * When this is called, the players direction has been updated
2301 * (taking into account confusion.) The player is also actually 2261 * (taking into account confusion.) The player is also actually
2302 * going to try and move (not fire weapons). 2262 * going to try and move (not fire weapons).
2303 */ 2263 */
2304
2305void 2264void
2306move_player_attack (object *op, int dir) 2265move_player_attack (object *op, int dir)
2307{ 2266{
2308 object *tmp, *mon; 2267 object *tmp, *mon;
2309 sint16 nx, ny; 2268 sint16 nx, ny;
… …
2311 maptile *m; 2270 maptile *m;
2312 2271
2313 nx = freearr_x[dir] + op->x; 2272 nx = freearr_x[dir] + op->x;
2314 ny = freearr_y[dir] + op->y; 2273 ny = freearr_y[dir] + op->y;
2315 2274
2316 on_battleground = op_on_battleground (op, NULL, NULL); 2275 on_battleground = op_on_battleground (op, 0, 0);
2317 2276
2318 /* If braced, or can't move to the square, and it is not out of the 2277 /* If braced, or can't move to the square, and it is not out of the
2319 * map, attack it. Note order of if statement is important - don't 2278 * map, attack it. Note order of if statement is important - don't
2320 * want to be calling move_ob if braced, because move_ob will move the 2279 * want to be calling move_ob if braced, because move_ob will move the
2321 * player. This is a pretty nasty hack, because if we could 2280 * player. This is a pretty nasty hack, because if we could
… …
2333 return; /* Don't think this should happen */ 2292 return; /* Don't think this should happen */
2334 } 2293 }
2335 else 2294 else
2336 m = op->map; 2295 m = op->map;
2337 2296
2338 if ((tmp = get_map_ob (m, nx, ny)) == NULL) 2297 if ((tmp = GET_MAP_OB (m, nx, ny)) == NULL)
2339 { 2298 {
2340 /* LOG(llevError,"player_move_attack: get_map_ob returns NULL, but player can not more there.\n"); */ 2299 /* LOG(llevError,"player_move_attack: GET_MAP_OB returns NULL, but player can not move there.\n"); */
2341 return; 2300 return;
2342 } 2301 }
2343 2302
2344 mon = NULL; 2303 mon = 0;
2345 /* Go through all the objects, and find ones of interest. Only stop if 2304 /* Go through all the objects, and find ones of interest. Only stop if
2346 * we find a monster - that is something we know we want to attack. 2305 * we find a monster - that is something we know we want to attack.
2347 * if its a door or barrel (can roll) see if there may be monsters 2306 * if its a door or barrel (can roll) see if there may be monsters
2348 * on the space 2307 * on the space
2349 */ 2308 */
2350 while (tmp != NULL) 2309 while (tmp)
2351 { 2310 {
2352 if (tmp == op) 2311 if (tmp == op)
2353 { 2312 {
2354 tmp = tmp->above; 2313 tmp = tmp->above;
2355 continue; 2314 continue;
… …
2365 mon = tmp; 2324 mon = tmp;
2366 2325
2367 tmp = tmp->above; 2326 tmp = tmp->above;
2368 } 2327 }
2369 2328
2370 if (mon == NULL) /* This happens anytime the player tries to move */ 2329 if (!mon) /* This happens anytime the player tries to move */
2371 return; /* into a wall */ 2330 return; /* into a wall */
2372 2331
2373 if (mon->head != NULL) 2332 if (mon->head)
2374 mon = mon->head; 2333 mon = mon->head;
2375 2334
2376 if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR)) 2335 if ((mon->type == DOOR && mon->stats.hp >= 0) || (mon->type == LOCKED_DOOR))
2377 if (player_attack_door (op, mon)) 2336 if (player_attack_door (op, mon))
2378 return; 2337 return;
… …
2390 * player owns it and it is either friendly or unagressive. 2349 * player owns it and it is either friendly or unagressive.
2391 */ 2350 */
2392 if ((op->type == PLAYER) 2351 if ((op->type == PLAYER)
2393#if COZY_SERVER 2352#if COZY_SERVER
2394 && 2353 &&
2395 ((get_owner (mon) && get_owner (mon)->contr 2354 ((mon->owner && mon->owner->contr
2396 && same_party (get_owner (mon)->contr->party, op->contr->party)) || get_owner (mon) == op) 2355 && same_party (mon->owner->contr->party, op->contr->party)) || mon->owner == op)
2397#else 2356#else
2398 && get_owner (mon) == op 2357 && mon->owner == op
2399#endif 2358#endif
2400 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY))) 2359 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))
2401 { 2360 {
2402 /* If we're braced, we don't want to switch places with it */ 2361 /* If we're braced, we don't want to switch places with it */
2403 if (op->contr->braced) 2362 if (op->contr->braced)
… …
2415 * attack them either. 2374 * attack them either.
2416 */ 2375 */
2417 if ((mon->type == PLAYER || mon->enemy != op) && 2376 if ((mon->type == PLAYER || mon->enemy != op) &&
2418 (mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && ( 2377 (mon->type == PLAYER || QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)) && (
2419#ifdef PROHIBIT_PLAYERKILL 2378#ifdef PROHIBIT_PLAYERKILL
2420 (op->contr->peaceful 2379 (op->contr->peaceful
2421 || (mon->type == PLAYER 2380 || (mon->type == PLAYER
2422 && mon->contr-> 2381 && mon->contr->
2423 peaceful)) && 2382 peaceful)) &&
2424#else 2383#else
2425 op->contr->peaceful && 2384 op->contr->peaceful &&
2426#endif 2385#endif
2427 !on_battleground)) 2386 !on_battleground))
2428 { 2387 {
2429 if (!op->contr->braced) 2388 if (!op->contr->braced)
2430 { 2389 {
2431 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER); 2390 play_sound_map (op->map, op->x, op->y, SOUND_PUSH_PLAYER);
2432 (void) push_ob (mon, dir, op); 2391 (void) push_ob (mon, dir, op);
2433 } 2392 }
2434 else 2393 else
2435 {
2436 new_draw_info (0, 0, op, "You withhold your attack"); 2394 new_draw_info (0, 0, op, "You withhold your attack");
2437 } 2395
2438 if (op->contr->tmp_invis || op->hide) 2396 if (op->contr->tmp_invis || op->hide)
2439 make_visible (op); 2397 make_visible (op);
2440 } 2398 }
2441 2399
2442 /* If the object is a boulder or other rollable object, then 2400 /* If the object is a boulder or other rollable object, then
… …
2470 op->speed_left += op->speed / op->contr->weapon_sp; 2428 op->speed_left += op->speed / op->contr->weapon_sp;
2471 2429
2472 op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */ 2430 op->contr->has_hit = 1; /* The last action was to hit, so use weapon_sp */
2473 } 2431 }
2474 2432
2475 skill_attack (mon, op, 0, NULL, NULL); 2433 skill_attack (mon, op, 0, 0, 0);
2476 2434
2477 /* If attacking another player, that player gets automatic 2435 /* If attacking another player, that player gets automatic
2478 * hitback, and doesn't loose luck either. 2436 * hitback, and doesn't loose luck either.
2479 * Disable hitback on the battleground or if the target is 2437 * Disable hitback on the battleground or if the target is
2480 * the wiz. 2438 * the wiz.
… …
2482 if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ)) 2440 if (mon->type == PLAYER && mon->stats.hp >= 0 && !mon->contr->has_hit && !on_battleground && !QUERY_FLAG (mon, FLAG_WIZ))
2483 { 2441 {
2484 short luck = mon->stats.luck; 2442 short luck = mon->stats.luck;
2485 2443
2486 mon->contr->has_hit = 1; 2444 mon->contr->has_hit = 1;
2487 skill_attack (op, mon, 0, NULL, NULL); 2445 skill_attack (op, mon, 0, 0, 0);
2488 mon->stats.luck = luck; 2446 mon->stats.luck = luck;
2489 } 2447 }
2448
2490 if (action_makes_visible (op)) 2449 if (action_makes_visible (op))
2491 make_visible (op); 2450 make_visible (op);
2492 } 2451 }
2493 } /* if player should attack something */ 2452 } /* if player should attack something */
2494} 2453}
… …
2529 2488
2530 /* Add special check for newcs players and fire on - this way, the 2489 /* Add special check for newcs players and fire on - this way, the
2531 * server can handle repeat firing. 2490 * server can handle repeat firing.
2532 */ 2491 */
2533 if (op->contr->fire_on || (op->contr->run_on && pick != 0)) 2492 if (op->contr->fire_on || (op->contr->run_on && pick != 0))
2534 {
2535 op->direction = dir; 2493 op->direction = dir;
2536 }
2537 else 2494 else
2538 {
2539 op->direction = 0; 2495 op->direction = 0;
2540 } 2496
2541 /* Update how the player looks. Use the facing, so direction may 2497 /* Update how the player looks. Use the facing, so direction may
2542 * get reset to zero. This allows for full animation capabilities 2498 * get reset to zero. This allows for full animation capabilities
2543 * for players. 2499 * for players.
2544 */ 2500 */
2545 animate_object (op, op->facing); 2501 animate_object (op, op->facing);
… …
2590 /* I've been seeing crashes where the golem has been destroyed, but 2546 /* I've been seeing crashes where the golem has been destroyed, but
2591 * the player object still points to the defunct golem. The code that 2547 * the player object still points to the defunct golem. The code that
2592 * destroys the golem looks correct, and it doesn't always happen, so 2548 * destroys the golem looks correct, and it doesn't always happen, so
2593 * put this in a a workaround to clean up the golem pointer. 2549 * put this in a a workaround to clean up the golem pointer.
2594 */ 2550 */
2595 if (op->contr->ranges[range_golem] &&
2596 ((op->contr->golem_count != op->contr->ranges[range_golem]->count) || QUERY_FLAG (op->contr->ranges[range_golem], FLAG_REMOVED))) 2551 if (op->contr->ranges[range_golem] && QUERY_FLAG (op->contr->ranges[range_golem], FLAG_REMOVED))
2597 {
2598 op->contr->ranges[range_golem] = NULL; 2552 op->contr->ranges[range_golem] = 0;
2599 op->contr->golem_count = 0;
2600 }
2601 2553
2602 /* call this here - we also will call this in do_ericserver, but 2554 /* call this here - we also will call this in do_ericserver, but
2603 * the players time has been increased when doericserver has been 2555 * the players time has been increased when doericserver has been
2604 * called, so we recheck it here. 2556 * called, so we recheck it here.
2605 */ 2557 */
2606 HandleClient (&op->contr->socket, op->contr); 2558 //TODO: better than handling 8 commands, use some more intelligent rate-limiting
2559 for (int rep = 8; --rep && op->contr->socket->handle_command (); )
2560 ;
2561
2607 if (op->speed_left < 0) 2562 if (op->speed_left < 0)
2608 return 0; 2563 return 0;
2609 2564
2610 if (op->direction && (op->contr->run_on || op->contr->fire_on)) 2565 if (op->direction && (op->contr->run_on || op->contr->fire_on))
2611 { 2566 {
… …
2620 if (op->speed_left > 0) 2575 if (op->speed_left > 0)
2621 return 1; 2576 return 1;
2622 else 2577 else
2623 return 0; 2578 return 0;
2624 } 2579 }
2580
2625 return 0; 2581 return 0;
2626} 2582}
2627 2583
2628int 2584int
2629save_life (object *op) 2585save_life (object *op)
2630{ 2586{
2631 object *tmp;
2632
2633 if (!QUERY_FLAG (op, FLAG_LIFESAVE)) 2587 if (!QUERY_FLAG (op, FLAG_LIFESAVE))
2634 return 0; 2588 return 0;
2635 2589
2636 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 2590 for (object *tmp = op->inv; tmp; tmp = tmp->below)
2637 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE)) 2591 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE))
2638 { 2592 {
2639 play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE); 2593 play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE);
2640 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp)); 2594 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp));
2595
2641 if (op->contr) 2596 if (op->contr)
2642 esrv_del_item (op->contr, tmp->count); 2597 esrv_del_item (op->contr, tmp->count);
2643 remove_ob (tmp); 2598
2644 free_object (tmp); 2599 tmp->destroy ();
2645 CLEAR_FLAG (op, FLAG_LIFESAVE); 2600 CLEAR_FLAG (op, FLAG_LIFESAVE);
2601
2646 if (op->stats.hp < 0) 2602 if (op->stats.hp < 0)
2647 op->stats.hp = op->stats.maxhp; 2603 op->stats.hp = op->stats.maxhp;
2604
2648 if (op->stats.food < 0) 2605 if (op->stats.food < 0)
2649 op->stats.food = 999; 2606 op->stats.food = 999;
2607
2650 fix_player (op); 2608 fix_player (op);
2651 return 1; 2609 return 1;
2652 } 2610 }
2611
2653 LOG (llevError, "Error: LIFESAVE set without applied object.\n"); 2612 LOG (llevError, "Error: LIFESAVE set without applied object.\n");
2654 CLEAR_FLAG (op, FLAG_LIFESAVE); 2613 CLEAR_FLAG (op, FLAG_LIFESAVE);
2655 enter_player_savebed (op); /* bring him home. */ 2614 enter_player_savebed (op); /* bring him home. */
2656 return 0; 2615 return 0;
2657} 2616}
… …
2671 next = op->below; /* Make sure we have a good value, in case 2630 next = op->below; /* Make sure we have a good value, in case
2672 * we remove object 'op' 2631 * we remove object 'op'
2673 */ 2632 */
2674 if (QUERY_FLAG (op, FLAG_UNPAID)) 2633 if (QUERY_FLAG (op, FLAG_UNPAID))
2675 { 2634 {
2676 remove_ob (op); 2635 op->remove ();
2677 op->x = env->x; 2636 op->x = env->x;
2678 op->y = env->y; 2637 op->y = env->y;
2679 if (env->type == PLAYER) 2638 if (env->type == PLAYER)
2680 esrv_del_item (env->contr, op->count); 2639 esrv_del_item (env->contr, op->count);
2681 insert_ob_in_map (op, env->map, NULL, 0); 2640 insert_ob_in_map (op, env->map, NULL, 0);
2682 } 2641 }
2683 else if (op->inv) 2642 else if (op->inv)
2684 remove_unpaid_objects (op->inv, env); 2643 remove_unpaid_objects (op->inv, env);
2644
2685 op = next; 2645 op = next;
2686 } 2646 }
2687} 2647}
2688 2648
2689 2649
… …
2704 strcpy (buf2, " R.I.P.\n\n"); 2664 strcpy (buf2, " R.I.P.\n\n");
2705 if (op->type == PLAYER) 2665 if (op->type == PLAYER)
2706 sprintf (buf, "%s the %s\n", &op->name, op->contr->title); 2666 sprintf (buf, "%s the %s\n", &op->name, op->contr->title);
2707 else 2667 else
2708 sprintf (buf, "%s\n", &op->name); 2668 sprintf (buf, "%s\n", &op->name);
2669
2709 strncat (buf2, " ", 20 - strlen (buf) / 2); 2670 strncat (buf2, " ", 20 - strlen (buf) / 2);
2710 strcat (buf2, buf); 2671 strcat (buf2, buf);
2711 if (op->type == PLAYER) 2672 if (op->type == PLAYER)
2712 sprintf (buf, "who was in level %d when killed\n", op->level); 2673 sprintf (buf, "who was in level %d when killed\n", op->level);
2713 else 2674 else
2714 sprintf (buf, "who was in level %d when died.\n\n", op->level); 2675 sprintf (buf, "who was in level %d when died.\n\n", op->level);
2676
2715 strncat (buf2, " ", 20 - strlen (buf) / 2); 2677 strncat (buf2, " ", 20 - strlen (buf) / 2);
2716 strcat (buf2, buf); 2678 strcat (buf2, buf);
2717 if (op->type == PLAYER) 2679 if (op->type == PLAYER)
2718 { 2680 {
2719 sprintf (buf, "by %s.\n\n", op->contr->killer); 2681 sprintf (buf, "by %s.\n\n", op->contr->killer);
2720 strncat (buf2, " ", 21 - strlen (buf) / 2); 2682 strncat (buf2, " ", 21 - strlen (buf) / 2);
2721 strcat (buf2, buf); 2683 strcat (buf2, buf);
2722 } 2684 }
2685
2723 strftime (buf, MAX_BUF, "%b %d %Y\n", localtime (&now)); 2686 strftime (buf, MAX_BUF, "%b %d %Y\n", localtime (&now));
2724 strncat (buf2, " ", 20 - strlen (buf) / 2); 2687 strncat (buf2, " ", 20 - strlen (buf) / 2);
2725 strcat (buf2, buf); 2688 strcat (buf2, buf);
2689
2726 return buf2; 2690 return buf2;
2727} 2691}
2728 2692
2729 2693
2730 2694
… …
2978 /* restore player */ 2942 /* restore player */
2979 at = archetype::find ("poisoning"); 2943 at = archetype::find ("poisoning");
2980 tmp = present_arch_in_ob (at, op); 2944 tmp = present_arch_in_ob (at, op);
2981 if (tmp) 2945 if (tmp)
2982 { 2946 {
2983 remove_ob (tmp); 2947 tmp->destroy ();
2984 free_object (tmp);
2985 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed"); 2948 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
2986 } 2949 }
2987 2950
2988 at = archetype::find ("confusion"); 2951 at = archetype::find ("confusion");
2989 tmp = present_arch_in_ob (at, op); 2952 tmp = present_arch_in_ob (at, op);
2990 if (tmp) 2953 if (tmp)
2991 { 2954 {
2992 remove_ob (tmp); 2955 tmp->destroy ();
2993 free_object (tmp);
2994 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 2956 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
2995 } 2957 }
2996 2958
2997 cure_disease (op, 0); /* remove any disease */ 2959 cure_disease (op, 0); /* remove any disease */
2998 op->stats.hp = op->stats.maxhp; 2960 op->stats.hp = op->stats.maxhp;
… …
3175 /* determine_god() seems to not work sometimes... why is this? 3137 /* determine_god() seems to not work sometimes... why is this?
3176 Should I be using something else? GD */ 3138 Should I be using something else? GD */
3177 const char *god = determine_god (op); 3139 const char *god = determine_god (op);
3178 3140
3179 if (god && (strcmp (god, "none"))) 3141 if (god && (strcmp (god, "none")))
3180 new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief " "moment you feel the holy presence of %s protecting" " you.", god); 3142 new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god);
3181 else 3143 else
3182 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you."); 3144 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you.");
3183 } 3145 }
3146#else
3147 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");
3184#endif 3148#endif
3185 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");
3186 3149
3187 /* Put a gravestone up where the character 'almost' died. List the 3150 /* Put a gravestone up where the character 'almost' died. List the
3188 * exp loss on the stone. 3151 * exp loss on the stone.
3189 */ 3152 */
3190 tmp = arch_to_object (archetype::find ("gravestone")); 3153 tmp = arch_to_object (archetype::find ("gravestone"));
… …
3195 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); 3158 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);
3196 tmp->msg = buf; 3159 tmp->msg = buf;
3197 tmp->x = op->x, tmp->y = op->y; 3160 tmp->x = op->x, tmp->y = op->y;
3198 insert_ob_in_map (tmp, op->map, NULL, 0); 3161 insert_ob_in_map (tmp, op->map, NULL, 0);
3199 3162
3200 /**************************************/ 3163 /**************************************/
3201 /* */ 3164 /* */
3202 /* Subtract the experience points, */ 3165 /* Subtract the experience points, */
3203 /* if we died cause of food, give us */ 3166 /* if we died cause of food, give us */
3204 /* food, and reset HP's... */ 3167 /* food, and reset HP's... */
3205 /* */ 3168 /* */
3206
3207 /**************************************/ 3169 /**************************************/
3208 3170
3209 /* remove any poisoning and confusion the character may be suffering. */ 3171 /* remove any poisoning and confusion the character may be suffering. */
3210 /* restore player */ 3172 /* restore player */
3211 at = archetype::find ("poisoning"); 3173 at = archetype::find ("poisoning");
3212 tmp = present_arch_in_ob (at, op); 3174 tmp = present_arch_in_ob (at, op);
3175
3213 if (tmp) 3176 if (tmp)
3214 { 3177 {
3215 remove_ob (tmp); 3178 tmp->destroy ();
3216 free_object (tmp);
3217 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed"); 3179 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
3218 } 3180 }
3219 3181
3220 at = archetype::find ("confusion"); 3182 at = archetype::find ("confusion");
3221 tmp = present_arch_in_ob (at, op); 3183 tmp = present_arch_in_ob (at, op);
3222 if (tmp) 3184 if (tmp)
3223 { 3185 {
3224 remove_ob (tmp); 3186 tmp->destroy ();
3225 free_object (tmp);
3226 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 3187 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
3227 } 3188 }
3189
3228 cure_disease (op, 0); /* remove any disease */ 3190 cure_disease (op, 0); /* remove any disease */
3229 3191
3230 /*add_exp(op, (op->stats.exp * -0.20)); */ 3192 /*add_exp(op, (op->stats.exp * -0.20)); */
3231 apply_death_exp_penalty (op); 3193 apply_death_exp_penalty (op);
3232 if (op->stats.food < 100) 3194 if (op->stats.food < 100)
… …
3242 */ 3204 */
3243 3205
3244 if (is_in_shop (op)) 3206 if (is_in_shop (op))
3245 remove_unpaid_objects (op->inv, op); 3207 remove_unpaid_objects (op->inv, op);
3246 3208
3247 /****************************************/ 3209 /****************************************/
3248 /* */ 3210 /* */
3249 /* Move player to his current respawn- */ 3211 /* Move player to his current respawn- */
3250 /* position (usually last savebed) */ 3212 /* position (usually last savebed) */
3251 /* */ 3213 /* */
3252
3253 /****************************************/ 3214 /****************************************/
3254 3215
3255 enter_player_savebed (op); 3216 enter_player_savebed (op);
3256 3217
3257 /* Save the player before inserting the force to reduce 3218 /* Save the player before inserting the force to reduce
3258 * chance of abuse. 3219 * chance of abuse.
… …
3264 * at his savebed location, and that can have long lasting 3225 * at his savebed location, and that can have long lasting
3265 * spell effects. So first see if there is a spell effect 3226 * spell effects. So first see if there is a spell effect
3266 * on the space that might harm the player. 3227 * on the space that might harm the player.
3267 */ 3228 */
3268 will_kill_again = 0; 3229 will_kill_again = 0;
3269 for (tmp = get_map_ob (op->map, op->x, op->y); tmp; tmp = tmp->above) 3230 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
3270 {
3271 if (tmp->type == SPELL_EFFECT) 3231 if (tmp->type == SPELL_EFFECT)
3272 will_kill_again |= tmp->attacktype; 3232 will_kill_again |= tmp->attacktype;
3273 } 3233
3274 if (will_kill_again) 3234 if (will_kill_again)
3275 { 3235 {
3276 object *force; 3236 object *force;
3277 int at; 3237 int at;
3278 3238
… …
3280 /* 50 ticks should be enough time for the spell to abate */ 3240 /* 50 ticks should be enough time for the spell to abate */
3281 force->speed = 0.1; 3241 force->speed = 0.1;
3282 force->speed_left = -5.0; 3242 force->speed_left = -5.0;
3283 SET_FLAG (force, FLAG_APPLIED); 3243 SET_FLAG (force, FLAG_APPLIED);
3284 for (at = 0; at < NROFATTACKS; at++) 3244 for (at = 0; at < NROFATTACKS; at++)
3285 {
3286 if (will_kill_again & (1 << at)) 3245 if (will_kill_again & (1 << at))
3287 force->resist[at] = 100; 3246 force->resist[at] = 100;
3288 } 3247
3289 insert_ob_in_ob (force, op); 3248 insert_ob_in_ob (force, op);
3290 fix_player (op); 3249 fix_player (op);
3291 3250
3292 } 3251 }
3293 3252
… …
3303 op->contr->party = NULL; 3262 op->contr->party = NULL;
3304 if (settings.set_title == TRUE) 3263 if (settings.set_title == TRUE)
3305 op->contr->own_title[0] = '\0'; 3264 op->contr->own_title[0] = '\0';
3306 new_draw_info (NDI_UNIQUE | NDI_ALL, 0, NULL, buf); 3265 new_draw_info (NDI_UNIQUE | NDI_ALL, 0, NULL, buf);
3307 check_score (op); 3266 check_score (op);
3267
3308 if (op->contr->ranges[range_golem] != NULL) 3268 if (op->contr->ranges[range_golem])
3309 { 3269 {
3310 remove_friendly_object (op->contr->ranges[range_golem]); 3270 remove_friendly_object (op->contr->ranges[range_golem]);
3311 remove_ob (op->contr->ranges[range_golem]); 3271 op->contr->ranges[range_golem]->destroy ();
3312 free_object (op->contr->ranges[range_golem]);
3313 op->contr->ranges[range_golem] = NULL; 3272 op->contr->ranges[range_golem] = 0;
3314 op->contr->golem_count = 0;
3315 } 3273 }
3274
3316 loot_object (op); /* Remove some of the items for good */ 3275 loot_object (op); /* Remove some of the items for good */
3317 remove_ob (op); 3276 op->remove ();
3318 op->direction = 0; 3277 op->direction = 0;
3319 3278
3320 if (!QUERY_FLAG (op, FLAG_WAS_WIZ) && op->stats.exp) 3279 if (!QUERY_FLAG (op, FLAG_WAS_WIZ) && op->stats.exp)
3321 { 3280 {
3322 delete_character (op->name, 0); 3281 delete_character (op->name, 0);
… …
3373 } 3332 }
3374 3333
3375 for (tmp = op->inv; tmp != NULL; tmp = next) 3334 for (tmp = op->inv; tmp != NULL; tmp = next)
3376 { 3335 {
3377 next = tmp->below; 3336 next = tmp->below;
3378 if (tmp->type == EXPERIENCE || tmp->invisible) 3337 if (tmp->invisible)
3379 continue; 3338 continue;
3380 remove_ob (tmp); 3339 tmp->remove ();
3381 tmp->x = op->x, tmp->y = op->y; 3340 tmp->x = op->x, tmp->y = op->y;
3382 if (tmp->type == CONTAINER) 3341 if (tmp->type == CONTAINER)
3383 { /* empty container to ground */ 3342 { /* empty container to ground */
3384 loot_object (tmp); 3343 loot_object (tmp);
3385 } 3344 }
3386 if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(RANDOM () % 3))) 3345 if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(RANDOM () % 3)))
3387 { 3346 {
3388 if (tmp->nrof > 1) 3347 if (tmp->nrof > 1)
3389 { 3348 {
3390 tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1)); 3349 tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1));
3391 free_object (tmp2); 3350 tmp2->destroy ();
3392 insert_ob_in_map (tmp, op->map, NULL, 0); 3351 insert_ob_in_map (tmp, op->map, NULL, 0);
3393 } 3352 }
3394 else 3353 else
3395 free_object (tmp); 3354 tmp->destroy ();
3396 } 3355 }
3397 else 3356 else
3398 insert_ob_in_map (tmp, op->map, NULL, 0); 3357 insert_ob_in_map (tmp, op->map, NULL, 0);
3399 } 3358 }
3400} 3359}
… …
3465 if (op->type == PLAYER) 3424 if (op->type == PLAYER)
3466 new_draw_info_format (NDI_UNIQUE, 0, op, "You cast %s.", &spob->name); 3425 new_draw_info_format (NDI_UNIQUE, 0, op, "You cast %s.", &spob->name);
3467 3426
3468 cast_spell (op, throw_ob, dir, spob, NULL); 3427 cast_spell (op, throw_ob, dir, spob, NULL);
3469 3428
3470 if (!QUERY_FLAG (throw_ob, FLAG_REMOVED)) 3429 throw_ob->destroy ();
3471 remove_ob (throw_ob);
3472 free_object (throw_ob);
3473} 3430}
3474 3431
3475void 3432void
3476make_visible (object *op) 3433make_visible (object *op)
3477{ 3434{
… …
3491 object *tmp = NULL; 3448 object *tmp = NULL;
3492 3449
3493 if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD)) 3450 if (QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD))
3494 return 1; 3451 return 1;
3495 3452
3496 if (op->type == PLAYER)
3497 for (tmp = op->inv; tmp; tmp = tmp->below)
3498 if (tmp->type == EXPERIENCE && tmp->stats.Wis)
3499 if (QUERY_FLAG (tmp, FLAG_UNDEAD))
3500 return 1;
3501 return 0; 3453 return 0;
3502} 3454}
3503 3455
3504/* look at the surrounding terrain to determine 3456/* look at the surrounding terrain to determine
3505 * the hideability of this object. Positive levels 3457 * the hideability of this object. Positive levels
… …
3620 if (mflags & P_OUT_OF_MAP) 3572 if (mflags & P_OUT_OF_MAP)
3621 continue; 3573 continue;
3622 if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y))) 3574 if (OB_TYPE_MOVE_BLOCK (who, GET_MAP_MOVE_BLOCK (m, x, y)))
3623 continue; 3575 continue;
3624 3576
3625 for (tmp = get_map_ob (m, x, y); tmp; tmp = tmp->above) 3577 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
3626 { 3578 {
3627 if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE)) 3579 if ((player ||friendly) &&QUERY_FLAG (tmp, FLAG_MONSTER) && !QUERY_FLAG (tmp, FLAG_UNAGGRESSIVE))
3628 return 1; 3580 return 1;
3629 else if (tmp->type == PLAYER) 3581 else if (tmp->type == PLAYER)
3630 { 3582 {
… …
3684 3636
3685 /* only the viewable area the player sees is updated by LOS 3637 /* only the viewable area the player sees is updated by LOS
3686 * code, so we need to restrict ourselves to that range of values 3638 * code, so we need to restrict ourselves to that range of values
3687 * for any meaningful values. 3639 * for any meaningful values.
3688 */ 3640 */
3689 if (FABS (dx) <= (pl->contr->socket.mapx / 2) && 3641 if (FABS (dx) <= (pl->contr->socket->mapx / 2) &&
3690 FABS (dy) <= (pl->contr->socket.mapy / 2) && 3642 FABS (dy) <= (pl->contr->socket->mapy / 2) &&
3691 !pl->contr->blocked_los[dx + (pl->contr->socket.mapx / 2)][dy + (pl->contr->socket.mapy / 2)]) 3643 !pl->contr->blocked_los[dx + (pl->contr->socket->mapx / 2)][dy + (pl->contr->socket->mapy / 2)])
3692 return 1; 3644 return 1;
3693 op = op->more; 3645 op = op->more;
3694 } 3646 }
3695 return 0; 3647 return 0;
3696} 3648}

Diff Legend

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