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.23 by root, Thu Sep 14 22:34:04 2006 UTC vs.
Revision 1.45 by root, Sat Dec 16 17:16:52 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
… …
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 if (p->socket.faces_sent == NULL) 319
335 fatal (OUT_OF_MEMORY); 320 p->next = first_player;
336 memcpy (p->socket.faces_sent, ns->faces_sent, p->socket.faces_sent_len * sizeof (*p->socket.faces_sent)); 321 first_player = p;
337 /* Needed because the socket we just copied over needs to be cleared. 322
338 * Note that this can result in a client reset if there is partial data 323 p = get_player (p);
339 * on the uncoming socket. 324
340 */
341 p->socket.inbuf.len = 0;
342 set_first_map (p->ob); 325 set_first_map (p->ob);
343 326
344 CLEAR_FLAG (p->ob, FLAG_FRIENDLY); 327 CLEAR_FLAG (p->ob, FLAG_FRIENDLY);
345 add_friendly_object (p->ob); 328 add_friendly_object (p->ob);
346 send_rules (p->ob); 329 send_rules (p->ob);
347 send_news (p->ob); 330 send_news (p->ob);
348 display_motd (p->ob); 331 display_motd (p->ob);
349 get_name (p->ob); 332 get_name (p->ob);
333
350 return 0; 334 return 0;
351} 335}
352 336
353/* 337/*
354 * get_player_archetype() return next player archetype from archetype 338 * get_player_archetype() return next player archetype from archetype
… …
489path_to_player (object *mon, object *pl, unsigned mindiff) 473path_to_player (object *mon, object *pl, unsigned mindiff)
490{ 474{
491 rv_vector rv; 475 rv_vector rv;
492 sint16 x, y; 476 sint16 x, y;
493 int lastx, lasty, dir, i, diff, firstdir = 0, lastdir, max = MAX_SPACES, mflags, blocked; 477 int lastx, lasty, dir, i, diff, firstdir = 0, lastdir, max = MAX_SPACES, mflags, blocked;
494 mapstruct *m, *lastmap; 478 maptile *m, *lastmap;
495 479
496 get_rangevector (mon, pl, &rv, 0); 480 get_rangevector (mon, pl, &rv, 0);
497 481
498 if (rv.distance < mindiff) 482 if (rv.distance < mindiff)
499 return 0; 483 return 0;
… …
643 (op->type == ARMOUR || op->type == BOOTS || 627 (op->type == ARMOUR || op->type == BOOTS ||
644 op->type == CLOAK || op->type == HELMET || 628 op->type == CLOAK || op->type == HELMET ||
645 op->type == SHIELD || op->type == GLOVES || 629 op->type == SHIELD || op->type == GLOVES ||
646 op->type == BRACERS || op->type == GIRDLE)) || (!QUERY_FLAG (pl, FLAG_USE_WEAPON) && op->type == WEAPON)) 630 op->type == BRACERS || op->type == GIRDLE)) || (!QUERY_FLAG (pl, FLAG_USE_WEAPON) && op->type == WEAPON))
647 { 631 {
648 remove_ob (op); 632 op->destroy ();
649 free_object (op);
650 continue; 633 continue;
651 } 634 }
652 } 635 }
653 636
654 /* This really needs to be better - we should really give 637 /* This really needs to be better - we should really give
… …
665 if (tmp->type == op->type && tmp->name == op->name) 648 if (tmp->type == op->type && tmp->name == op->name)
666 break; 649 break;
667 650
668 if (tmp) 651 if (tmp)
669 { 652 {
670 remove_ob (op); 653 op->destroy ();
671 free_object (op);
672 LOG (llevError, "give_initial_items: Removing duplicate object %s\n", &tmp->name); 654 LOG (llevError, "give_initial_items: Removing duplicate object %s\n", &tmp->name);
673 continue; 655 continue;
674 } 656 }
657
675 if (op->nrof > 1) 658 if (op->nrof > 1)
676 op->nrof = 1; 659 op->nrof = 1;
677 } 660 }
678 661
679 if (op->type == SPELLBOOK && op->inv) 662 if (op->type == SPELLBOOK && op->inv)
… …
691 CLEAR_FLAG (op, FLAG_CURSED); 674 CLEAR_FLAG (op, FLAG_CURSED);
692 CLEAR_FLAG (op, FLAG_DAMNED); 675 CLEAR_FLAG (op, FLAG_DAMNED);
693 } 676 }
694 if (op->type == SPELL) 677 if (op->type == SPELL)
695 { 678 {
696 remove_ob (op); 679 op->destroy ();
697 free_object (op);
698 continue; 680 continue;
699 } 681 }
700 else if (op->type == SKILL) 682 else if (op->type == SKILL)
701 { 683 {
702 SET_FLAG (op, FLAG_CAN_USE_SKILL); 684 SET_FLAG (op, FLAG_CAN_USE_SKILL);
… …
715void 697void
716get_name (object *op) 698get_name (object *op)
717{ 699{
718 op->contr->write_buf[0] = '\0'; 700 op->contr->write_buf[0] = '\0';
719 op->contr->state = ST_GET_NAME; 701 op->contr->state = ST_GET_NAME;
720 send_query (&op->contr->socket, 0, "What is your name?\n:"); 702 send_query (op->contr->socket, 0, "What is your name?\n:");
721} 703}
722 704
723void 705void
724get_password (object *op) 706get_password (object *op)
725{ 707{
726 op->contr->write_buf[0] = '\0'; 708 op->contr->write_buf[0] = '\0';
727 op->contr->state = ST_GET_PASSWORD; 709 op->contr->state = ST_GET_PASSWORD;
728 send_query (&op->contr->socket, CS_QUERY_HIDEINPUT, "What is your password?\n:"); 710 send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "What is your password?\n:");
729} 711}
730 712
731void 713void
732play_again (object *op) 714play_again (object *op)
733{ 715{
734 op->contr->state = ST_PLAY_AGAIN; 716 op->contr->state = ST_PLAY_AGAIN;
735 op->chosen_skill = NULL; 717 op->chosen_skill = NULL;
736 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Do you want to play again (a/q)?"); 718 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Do you want to play again (a/q)?");
737 /* a bit of a hack, but there are various places early in th 719 /* a bit of a hack, but there are various places early in th
738 * player creation process that a user can quit (eg, roll 720 * player creation process that a user can quit (eg, roll
739 * stats) that isn't removing the player. Taking a quick 721 * stats) that isn't removing the player. Taking a quick
740 * look, there are many places that call play_again without 722 * look, there are many places that call play_again without
741 * removing the player - it probably makes more sense 723 * removing the player - it probably makes more sense
742 * to leave it to play_again to remove the object in all 724 * to leave it to play_again to remove the object in all
743 * cases. 725 * cases.
744 */ 726 */
745 if (!QUERY_FLAG (op, FLAG_REMOVED)) 727 if (!QUERY_FLAG (op, FLAG_REMOVED))
746 remove_ob (op); 728 op->remove ();
747 /* Need to set this to null - otherwise, it could point to garbage, 729 /* Need to set this to null - otherwise, it could point to garbage,
748 * and draw() doesn't check to see if the player is removed, only if 730 * and draw() doesn't check to see if the player is removed, only if
749 * the map is null or not swapped out. 731 * the map is null or not swapped out.
750 */ 732 */
751 op->map = NULL; 733 op->map = NULL;
… …
765 player *pl = op->contr; 747 player *pl = op->contr;
766 shstr name = op->name; 748 shstr name = op->name;
767 749
768 op->contr = 0; 750 op->contr = 0;
769 op->type = 0; 751 op->type = 0;
770 op->free (1); 752 op->destroy (1);
771 pl = get_player (pl); 753 pl = get_player (pl);
772 op = pl->ob; 754 op = pl->ob;
773 add_friendly_object (op); 755 add_friendly_object (op);
774 op->contr->password[0] = '~'; 756 op->contr->password[0] = '~';
775 op->name = op->name_pl = 0; 757 op->name = op->name_pl = 0;
… …
790confirm_password (object *op) 772confirm_password (object *op)
791{ 773{
792 774
793 op->contr->write_buf[0] = '\0'; 775 op->contr->write_buf[0] = '\0';
794 op->contr->state = ST_CONFIRM_PASSWORD; 776 op->contr->state = ST_CONFIRM_PASSWORD;
795 send_query (&op->contr->socket, CS_QUERY_HIDEINPUT, "Please type your password again.\n:"); 777 send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "Please type your password again.\n:");
796} 778}
797 779
798void 780void
799get_party_password (object *op, partylist *party) 781get_party_password (object *op, partylist *party)
800{ 782{
… …
804 return; 786 return;
805 } 787 }
806 op->contr->write_buf[0] = '\0'; 788 op->contr->write_buf[0] = '\0';
807 op->contr->state = ST_GET_PARTY_PASSWORD; 789 op->contr->state = ST_GET_PARTY_PASSWORD;
808 op->contr->party_to_join = party; 790 op->contr->party_to_join = party;
809 send_query (&op->contr->socket, CS_QUERY_HIDEINPUT, "What is the password?\n:"); 791 send_query (op->contr->socket, CS_QUERY_HIDEINPUT, "What is the password?\n:");
810} 792}
811 793
812 794
813/* This rolls four 1-6 rolls and sums the best 3 of the 4. */ 795/* This rolls four 1-6 rolls and sums the best 3 of the 4. */
814int 796int
… …
911 893
912void 894void
913Roll_Again (object *op) 895Roll_Again (object *op)
914{ 896{
915 esrv_new_player (op->contr, 0); 897 esrv_new_player (op->contr, 0);
916 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, 898 send_query (op->contr->socket, CS_QUERY_SINGLECHAR,
917 "[y] to roll new stats [n] to use stats\n[1-7] [1-7] to swap stats.\nRoll again (y/n/1-7)? "); 899 "[y] to roll new stats [n] to use stats\n[1-7] [1-7] to swap stats.\nRoll again (y/n/1-7)? ");
918} 900}
919 901
920void 902void
921Swap_Stat (object *op, int Swap_Second) 903Swap_Stat (object *op, int Swap_Second)
… …
988 new_draw_info (NDI_UNIQUE, 0, op, buf); 970 new_draw_info (NDI_UNIQUE, 0, op, buf);
989 } 971 }
990 else 972 else
991 Swap_Stat (op, stat_trans[keynum]); 973 Swap_Stat (op, stat_trans[keynum]);
992 974
993 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, ""); 975 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "");
994 return 1; 976 return 1;
995 } 977 }
996 switch (key) 978 switch (key)
997 { 979 {
998 case 'n': 980 case 'n':
… …
1012 enter_exit (op, NULL); 994 enter_exit (op, NULL);
1013#endif 995#endif
1014 SET_ANIMATION (op, 2); /* So player faces south */ 996 SET_ANIMATION (op, 2); /* So player faces south */
1015 /* Enter exit adds a player otherwise */ 997 /* Enter exit adds a player otherwise */
1016 add_statbonus (op); 998 add_statbonus (op);
1017 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, 999 send_query (op->contr->socket, CS_QUERY_SINGLECHAR,
1018 "Now choose a character.\nPress any key to change outlook.\nPress `d' when you're pleased.\n"); 1000 "Now choose a character.\nPress any key to change outlook.\nPress `d' when you're pleased.\n");
1019 op->contr->state = ST_CHANGE_CLASS; 1001 op->contr->state = ST_CHANGE_CLASS;
1020 if (op->msg) 1002 if (op->msg)
1021 new_draw_info (NDI_BLUE, 0, op, op->msg); 1003 new_draw_info (NDI_BLUE, 0, op, op->msg);
1022 return 0; 1004 return 0;
1023 } 1005 }
1024 case 'y': 1006 case 'y':
1025 case 'Y': 1007 case 'Y':
1026 roll_stats (op); 1008 roll_stats (op);
1027 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, ""); 1009 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "");
1028 return 1; 1010 return 1;
1029 1011
1030 case 'q': 1012 case 'q':
1031 case 'Q': 1013 case 'Q':
1032 play_again (op); 1014 play_again (op);
1033 return 1; 1015 return 1;
1034 1016
1035 default: 1017 default:
1036 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Yes, No, Quit or 1-6. Roll again?"); 1018 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Yes, No, Quit or 1-6. Roll again?");
1037 return 0; 1019 return 0;
1038 } 1020 }
1039 return 0; 1021 return 0;
1040} 1022}
1041 1023
… …
1051{ 1033{
1052 int tmp_loop; 1034 int tmp_loop;
1053 1035
1054 if (key == 'q' || key == 'Q') 1036 if (key == 'q' || key == 'Q')
1055 { 1037 {
1056 remove_ob (op); 1038 op->remove ();
1057 play_again (op); 1039 play_again (op);
1058 return 0; 1040 return 0;
1059 } 1041 }
1060 if (key == 'd' || key == 'D') 1042 if (key == 'd' || key == 'D')
1061 { 1043 {
1062 char buf[MAX_BUF]; 1044 char buf[MAX_BUF];
1063 1045
1064 /* this must before then initial items are given */ 1046 /* this must before then initial items are given */
1065 esrv_new_player (op->contr, op->weight + op->carrying); 1047 esrv_new_player (op->contr, op->weight + op->carrying);
1048
1066 create_treasure (find_treasurelist ("starting_wealth"), op, 0, 0, 0); 1049 treasurelist *tl = find_treasurelist ("starting_wealth");
1050 if (tl)
1051 create_treasure (tl, op, 0, 0, 0);
1067 1052
1068 INVOKE_PLAYER (BIRTH, op->contr); 1053 INVOKE_PLAYER (BIRTH, op->contr);
1069 INVOKE_PLAYER (LOGIN, op->contr); 1054 INVOKE_PLAYER (LOGIN, op->contr);
1070 1055
1071 op->contr->state = ST_PLAYING; 1056 op->contr->state = ST_PLAYING;
… …
1096 { 1081 {
1097 object *tmp; 1082 object *tmp;
1098 char mapname[MAX_BUF]; 1083 char mapname[MAX_BUF];
1099 1084
1100 snprintf (mapname, MAX_BUF - 1, "%s/%s", first_map_ext_path, &op->arch->name); 1085 snprintf (mapname, MAX_BUF - 1, "%s/%s", first_map_ext_path, &op->arch->name);
1101 tmp = get_object (); 1086 tmp = object::create ();
1102 EXIT_PATH (tmp) = mapname; 1087 EXIT_PATH (tmp) = mapname;
1103 EXIT_X (tmp) = op->x; 1088 EXIT_X (tmp) = op->x;
1104 EXIT_Y (tmp) = op->y; 1089 EXIT_Y (tmp) = op->y;
1105 enter_exit (op, tmp); /* we don't really care if it succeeded; 1090 enter_exit (op, tmp); /* we don't really care if it succeeded;
1106 * if the map isn't there, then stay on the 1091 * if the map isn't there, then stay on the
1107 * default initial map */ 1092 * default initial map */
1108 free_object (tmp); 1093 tmp->destroy ();
1109 } 1094 }
1110 else 1095 else
1111 { 1096 {
1112 LOG (llevDebug, "first_map_ext_path not set\n"); 1097 LOG (llevDebug, "first_map_ext_path not set\n");
1113 } 1098 }
… …
1123 { 1108 {
1124 shstr name = op->name; 1109 shstr name = op->name;
1125 int x = op->x, y = op->y; 1110 int x = op->x, y = op->y;
1126 1111
1127 remove_statbonus (op); 1112 remove_statbonus (op);
1128 remove_ob (op); 1113 op->remove ();
1129 op->arch = get_player_archetype (op->arch); 1114 op->arch = get_player_archetype (op->arch);
1130 copy_object (&op->arch->clone, op); 1115 op->arch->clone.copy_to (op);
1131 op->instantiate (); 1116 op->instantiate ();
1132 op->stats = op->contr->orig_stats; 1117 op->stats = op->contr->orig_stats;
1133 op->name = op->name_pl = name; 1118 op->name = op->name_pl = name;
1134 op->x = x; 1119 op->x = x;
1135 op->y = y; 1120 op->y = y;
… …
1148 op->stats.grace = 0; 1133 op->stats.grace = 0;
1149 1134
1150 if (op->msg) 1135 if (op->msg)
1151 new_draw_info (NDI_BLUE, 0, op, op->msg); 1136 new_draw_info (NDI_BLUE, 0, op, op->msg);
1152 1137
1153 send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n"); 1138 send_query (op->contr->socket, CS_QUERY_SINGLECHAR, "Press any key for the next race.\nPress `d' to play this race.\n");
1154 return 0; 1139 return 0;
1155} 1140}
1156 1141
1157int 1142int
1158key_confirm_quit (object *op, char key) 1143key_confirm_quit (object *op, char key)
… …
1180 if (settings.set_title == TRUE) 1165 if (settings.set_title == TRUE)
1181 op->contr->own_title[0] = '\0'; 1166 op->contr->own_title[0] = '\0';
1182 1167
1183 if (!QUERY_FLAG (op, FLAG_WAS_WIZ)) 1168 if (!QUERY_FLAG (op, FLAG_WAS_WIZ))
1184 { 1169 {
1185 mapstruct *mp, *next; 1170 maptile *mp, *next;
1186 1171
1187 /* We need to hunt for any per player unique maps in memory and 1172 /* We need to hunt for any per player unique maps in memory and
1188 * get rid of them. The trailing slash in the path is intentional, 1173 * get rid of them. The trailing slash in the path is intentional,
1189 * so that players named 'Ab' won't match against players 'Abe' pathname 1174 * so that players named 'Ab' won't match against players 'Abe' pathname
1190 */ 1175 */
… …
1264 */ 1249 */
1265int 1250int
1266check_pick (object *op) 1251check_pick (object *op)
1267{ 1252{
1268 object *tmp, *next; 1253 object *tmp, *next;
1269 tag_t next_tag = 0, op_tag;
1270 int stop = 0; 1254 int stop = 0;
1271 int j, k, wvratio; 1255 int j, k, wvratio;
1272 char putstring[128], tmpstr[16]; 1256 char putstring[128], tmpstr[16];
1273 1257
1274
1275 /* if you're flying, you cna't pick up anything */ 1258 /* if you're flying, you cna't pick up anything */
1276 if (op->move_type & MOVE_FLYING) 1259 if (op->move_type & MOVE_FLYING)
1277 return 1; 1260 return 1;
1278 1261
1279 op_tag = op->count;
1280
1281 next = op->below; 1262 next = op->below;
1282 if (next)
1283 next_tag = next->count;
1284 1263
1285 /* loop while there are items on the floor that are not marked as 1264 /* loop while there are items on the floor that are not marked as
1286 * destroyed */ 1265 * destroyed */
1287 while (next && !was_destroyed (next, next_tag)) 1266 while (next && !next->destroyed ())
1288 { 1267 {
1289 tmp = next; 1268 tmp = next;
1290 next = tmp->below; 1269 next = tmp->below;
1291 if (next)
1292 next_tag = next->count;
1293 1270
1294 if (was_destroyed (op, op_tag)) 1271 if (op->destroyed ())
1295 return 0; 1272 return 0;
1296 1273
1297 if (!can_pick (op, tmp)) 1274 if (!can_pick (op, tmp))
1298 continue; 1275 continue;
1299 1276
… …
1431 /* question: don't pick up known-poisonous stuff? */ 1408 /* question: don't pick up known-poisonous stuff? */
1432 if (op->contr->mode & PU_FOOD) 1409 if (op->contr->mode & PU_FOOD)
1433 if (tmp->type == FOOD) 1410 if (tmp->type == FOOD)
1434 { 1411 {
1435 pick_up (op, tmp); 1412 pick_up (op, tmp);
1436 if (0)
1437 fprintf (stderr, "FOOD\n");
1438 continue; 1413 continue;
1439 } 1414 }
1415
1440 if (op->contr->mode & PU_DRINK) 1416 if (op->contr->mode & PU_DRINK)
1441 if (tmp->type == DRINK || (tmp->type == POISON && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED))) 1417 if (tmp->type == DRINK || (tmp->type == POISON && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED)))
1442 { 1418 {
1443 pick_up (op, tmp); 1419 pick_up (op, tmp);
1444 if (0)
1445 fprintf (stderr, "DRINK\n");
1446 continue; 1420 continue;
1447 } 1421 }
1448 1422
1449 if (op->contr->mode & PU_POTION) 1423 if (op->contr->mode & PU_POTION)
1450 if (tmp->type == POTION) 1424 if (tmp->type == POTION)
1451 { 1425 {
1452 pick_up (op, tmp); 1426 pick_up (op, tmp);
1453 if (0)
1454 fprintf (stderr, "POTION\n");
1455 continue; 1427 continue;
1456 } 1428 }
1457 1429
1458 /* spellbooks, skillscrolls and normal books/scrolls */ 1430 /* spellbooks, skillscrolls and normal books/scrolls */
1459 if (op->contr->mode & PU_SPELLBOOK) 1431 if (op->contr->mode & PU_SPELLBOOK)
1460 if (tmp->type == SPELLBOOK) 1432 if (tmp->type == SPELLBOOK)
1461 { 1433 {
1462 pick_up (op, tmp); 1434 pick_up (op, tmp);
1463 if (0)
1464 fprintf (stderr, "SPELLBOOK\n");
1465 continue; 1435 continue;
1466 } 1436 }
1437
1467 if (op->contr->mode & PU_SKILLSCROLL) 1438 if (op->contr->mode & PU_SKILLSCROLL)
1468 if (tmp->type == SKILLSCROLL) 1439 if (tmp->type == SKILLSCROLL)
1469 { 1440 {
1470 pick_up (op, tmp); 1441 pick_up (op, tmp);
1471 if (0)
1472 fprintf (stderr, "SKILLSCROLL\n");
1473 continue; 1442 continue;
1474 } 1443 }
1444
1475 if (op->contr->mode & PU_READABLES) 1445 if (op->contr->mode & PU_READABLES)
1476 if (tmp->type == BOOK || tmp->type == SCROLL) 1446 if (tmp->type == BOOK || tmp->type == SCROLL)
1477 { 1447 {
1478 pick_up (op, tmp); 1448 pick_up (op, tmp);
1479 if (0)
1480 fprintf (stderr, "READABLES\n");
1481 continue; 1449 continue;
1482 } 1450 }
1483 1451
1484 /* wands/staves/rods/horns */ 1452 /* wands/staves/rods/horns */
1485 if (op->contr->mode & PU_MAGIC_DEVICE) 1453 if (op->contr->mode & PU_MAGIC_DEVICE)
1486 if (tmp->type == WAND || tmp->type == ROD || tmp->type == HORN) 1454 if (tmp->type == WAND || tmp->type == ROD || tmp->type == HORN)
1487 { 1455 {
1488 pick_up (op, tmp); 1456 pick_up (op, tmp);
1489 if (0)
1490 fprintf (stderr, "MAGIC_DEVICE\n");
1491 continue; 1457 continue;
1492 } 1458 }
1493 1459
1494 /* pick up all magical items */ 1460 /* pick up all magical items */
1495 if (op->contr->mode & PU_MAGICAL) 1461 if (op->contr->mode & PU_MAGICAL)
1496 if (QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED)) 1462 if (QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED))
1497 { 1463 {
1498 pick_up (op, tmp); 1464 pick_up (op, tmp);
1499 if (0)
1500 fprintf (stderr, "MAGICAL\n");
1501 continue; 1465 continue;
1502 } 1466 }
1503 1467
1504 if (op->contr->mode & PU_VALUABLES) 1468 if (op->contr->mode & PU_VALUABLES)
1505 { 1469 {
1506 if (tmp->type == MONEY || tmp->type == GEM) 1470 if (tmp->type == MONEY || tmp->type == GEM)
1507 { 1471 {
1508 pick_up (op, tmp); 1472 pick_up (op, tmp);
1509 if (0)
1510 fprintf (stderr, "MONEY/GEM\n");
1511 continue; 1473 continue;
1512 } 1474 }
1513 } 1475 }
1514 1476
1515 /* rings & amulets - talismans seems to be typed AMULET */ 1477 /* rings & amulets - talismans seems to be typed AMULET */
1516 if (op->contr->mode & PU_JEWELS) 1478 if (op->contr->mode & PU_JEWELS)
1517 if (tmp->type == RING || tmp->type == AMULET) 1479 if (tmp->type == RING || tmp->type == AMULET)
1518 { 1480 {
1519 pick_up (op, tmp); 1481 pick_up (op, tmp);
1482 continue;
1520 if (0) 1483 }
1521 fprintf (stderr, "JEWELS\n"); 1484
1485 /* we don't forget dragon food */
1486 if (op->contr->mode & PU_FLESH)
1487 if (tmp->type == FLESH)
1488 {
1489 pick_up (op, tmp);
1522 continue; 1490 continue;
1523 } 1491 }
1524 1492
1525 /* bows and arrows. Bows are good for selling! */ 1493 /* bows and arrows. Bows are good for selling! */
1526 if (op->contr->mode & PU_BOW) 1494 if (op->contr->mode & PU_BOW)
1527 if (tmp->type == BOW) 1495 if (tmp->type == BOW)
1528 { 1496 {
1529 pick_up (op, tmp); 1497 pick_up (op, tmp);
1530 if (0)
1531 fprintf (stderr, "BOW\n");
1532 continue; 1498 continue;
1533 } 1499 }
1500
1534 if (op->contr->mode & PU_ARROW) 1501 if (op->contr->mode & PU_ARROW)
1535 if (tmp->type == ARROW) 1502 if (tmp->type == ARROW)
1536 { 1503 {
1537 pick_up (op, tmp); 1504 pick_up (op, tmp);
1538 if (0)
1539 fprintf (stderr, "ARROW\n");
1540 continue; 1505 continue;
1541 } 1506 }
1542 1507
1543 /* all kinds of armor etc. */ 1508 /* all kinds of armor etc. */
1544 if (op->contr->mode & PU_ARMOUR) 1509 if (op->contr->mode & PU_ARMOUR)
1545 if (tmp->type == ARMOUR) 1510 if (tmp->type == ARMOUR)
1546 { 1511 {
1547 pick_up (op, tmp); 1512 pick_up (op, tmp);
1548 if (0)
1549 fprintf (stderr, "ARMOUR\n");
1550 continue; 1513 continue;
1551 } 1514 }
1515
1552 if (op->contr->mode & PU_HELMET) 1516 if (op->contr->mode & PU_HELMET)
1553 if (tmp->type == HELMET) 1517 if (tmp->type == HELMET)
1554 { 1518 {
1555 pick_up (op, tmp); 1519 pick_up (op, tmp);
1556 if (0)
1557 fprintf (stderr, "HELMET\n");
1558 continue; 1520 continue;
1559 } 1521 }
1522
1560 if (op->contr->mode & PU_SHIELD) 1523 if (op->contr->mode & PU_SHIELD)
1561 if (tmp->type == SHIELD) 1524 if (tmp->type == SHIELD)
1562 { 1525 {
1563 pick_up (op, tmp); 1526 pick_up (op, tmp);
1564 if (0)
1565 fprintf (stderr, "SHIELD\n");
1566 continue; 1527 continue;
1567 } 1528 }
1529
1568 if (op->contr->mode & PU_BOOTS) 1530 if (op->contr->mode & PU_BOOTS)
1569 if (tmp->type == BOOTS) 1531 if (tmp->type == BOOTS)
1570 { 1532 {
1571 pick_up (op, tmp); 1533 pick_up (op, tmp);
1572 if (0)
1573 fprintf (stderr, "BOOTS\n");
1574 continue; 1534 continue;
1575 } 1535 }
1536
1576 if (op->contr->mode & PU_GLOVES) 1537 if (op->contr->mode & PU_GLOVES)
1577 if (tmp->type == GLOVES) 1538 if (tmp->type == GLOVES)
1578 { 1539 {
1579 pick_up (op, tmp); 1540 pick_up (op, tmp);
1580 if (0)
1581 fprintf (stderr, "GLOVES\n");
1582 continue; 1541 continue;
1583 } 1542 }
1543
1584 if (op->contr->mode & PU_CLOAK) 1544 if (op->contr->mode & PU_CLOAK)
1585 if (tmp->type == CLOAK) 1545 if (tmp->type == CLOAK)
1586 { 1546 {
1587 pick_up (op, tmp); 1547 pick_up (op, tmp);
1588 if (0)
1589 fprintf (stderr, "GLOVES\n");
1590 continue; 1548 continue;
1591 } 1549 }
1592 1550
1593 /* hoping to catch throwing daggers here */ 1551 /* hoping to catch throwing daggers here */
1594 if (op->contr->mode & PU_MISSILEWEAPON) 1552 if (op->contr->mode & PU_MISSILEWEAPON)
1595 if (tmp->type == WEAPON && QUERY_FLAG (tmp, FLAG_IS_THROWN)) 1553 if (tmp->type == WEAPON && QUERY_FLAG (tmp, FLAG_IS_THROWN))
1596 { 1554 {
1597 pick_up (op, tmp); 1555 pick_up (op, tmp);
1598 if (0)
1599 fprintf (stderr, "MISSILEWEAPON\n");
1600 continue; 1556 continue;
1601 } 1557 }
1602 1558
1603 /* careful: chairs and tables are weapons! */ 1559 /* careful: chairs and tables are weapons! */
1604 if (op->contr->mode & PU_ALLWEAPON) 1560 if (op->contr->mode & PU_ALLWEAPON)
… …
1607 { 1563 {
1608 if (strstr (tmp->name, "table") == NULL && strstr (tmp->arch->name, "table") == NULL && 1564 if (strstr (tmp->name, "table") == NULL && strstr (tmp->arch->name, "table") == NULL &&
1609 strstr (tmp->name, "chair") && strstr (tmp->arch->name, "chair") == NULL) 1565 strstr (tmp->name, "chair") && strstr (tmp->arch->name, "chair") == NULL)
1610 { 1566 {
1611 pick_up (op, tmp); 1567 pick_up (op, tmp);
1612 if (0)
1613 fprintf (stderr, "WEAPON\n");
1614 continue; 1568 continue;
1615 } 1569 }
1616 } 1570 }
1571
1617 if (tmp->type == WEAPON && tmp->name == NULL) 1572 if (tmp->type == WEAPON && tmp->name == NULL)
1618 { 1573 {
1619 if (strstr (tmp->arch->name, "table") == NULL && strstr (tmp->arch->name, "chair") == NULL) 1574 if (strstr (tmp->arch->name, "table") == NULL && strstr (tmp->arch->name, "chair") == NULL)
1620 { 1575 {
1621 pick_up (op, tmp); 1576 pick_up (op, tmp);
1622 if (0)
1623 fprintf (stderr, "WEAPON\n");
1624 continue; 1577 continue;
1625 } 1578 }
1626 } 1579 }
1627 } 1580 }
1628 1581
1629 /* misc stuff that's useful */ 1582 /* misc stuff that's useful */
1630 if (op->contr->mode & PU_KEY) 1583 if (op->contr->mode & PU_KEY)
1631 if (tmp->type == KEY || tmp->type == SPECIAL_KEY) 1584 if (tmp->type == KEY || tmp->type == SPECIAL_KEY)
1632 { 1585 {
1633 pick_up (op, tmp); 1586 pick_up (op, tmp);
1634 if (0)
1635 fprintf (stderr, "KEY\n");
1636 continue; 1587 continue;
1637 } 1588 }
1638 1589
1639 /* any of the last 4 bits set means we use the ratio for value 1590 /* any of the last 4 bits set means we use the ratio for value
1640 * pickups */ 1591 * pickups */
… …
1662 continue; 1613 continue;
1663 } 1614 }
1664 } 1615 }
1665 } /* the new pickup model */ 1616 } /* the new pickup model */
1666 } 1617 }
1618
1667 return !stop; 1619 return !stop;
1668} 1620}
1669 1621
1670/* 1622/*
1671 * Find an arrow in the inventory and after that 1623 * Find an arrow in the inventory and after that
… …
1770 1722
1771object * 1723object *
1772pick_arrow_target (object *op, const char *type, int dir) 1724pick_arrow_target (object *op, const char *type, int dir)
1773{ 1725{
1774 object *tmp = NULL; 1726 object *tmp = NULL;
1775 mapstruct *m; 1727 maptile *m;
1776 int i, mflags, found, number; 1728 int i, mflags, found, number;
1777 sint16 x, y; 1729 sint16 x, y;
1778 1730
1779 if (op->map == NULL) 1731 if (op->map == NULL)
1780 return find_arrow (op, type); 1732 return find_arrow (op, type);
… …
1840 */ 1792 */
1841int 1793int
1842fire_bow (object *op, object *part, object *arrow, int dir, int wc_mod, sint16 sx, sint16 sy) 1794fire_bow (object *op, object *part, object *arrow, int dir, int wc_mod, sint16 sx, sint16 sy)
1843{ 1795{
1844 object *left, *bow; 1796 object *left, *bow;
1845 tag_t left_tag, tag;
1846 int bowspeed, mflags; 1797 int bowspeed, mflags;
1847 mapstruct *m; 1798 maptile *m;
1848 1799
1849 if (!dir) 1800 if (!dir)
1850 { 1801 {
1851 new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!"); 1802 new_draw_info (NDI_UNIQUE, 0, op, "You can't shoot yourself!");
1852 return 0; 1803 return 0;
… …
1906 } 1857 }
1907 1858
1908 /* this should not happen, but sometimes does */ 1859 /* this should not happen, but sometimes does */
1909 if (arrow->nrof == 0) 1860 if (arrow->nrof == 0)
1910 { 1861 {
1911 remove_ob (arrow); 1862 arrow->destroy ();
1912 free_object (arrow);
1913 return 0; 1863 return 0;
1914 } 1864 }
1915 1865
1916 left = arrow; /* these are arrows left to the player */ 1866 left = arrow; /* these are arrows left to the player */
1917 left_tag = left->count;
1918 arrow = get_split_ob (arrow, 1); 1867 arrow = get_split_ob (arrow, 1);
1919 if (arrow == NULL) 1868 if (arrow == NULL)
1920 { 1869 {
1921 new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race); 1870 new_draw_info_format (NDI_UNIQUE, 0, op, "You have no %s left.", &bow->race);
1922 return 0; 1871 return 0;
1923 } 1872 }
1924 set_owner (arrow, op); 1873 arrow->set_owner (op);
1925 arrow->skill = bow->skill; 1874 arrow->skill = bow->skill;
1926 1875
1927 arrow->direction = dir; 1876 arrow->direction = dir;
1928 arrow->x = sx; 1877 arrow->x = sx;
1929 arrow->y = sy; 1878 arrow->y = sy;
… …
1937 SET_ANIMATION (arrow, arrow->direction); 1886 SET_ANIMATION (arrow, arrow->direction);
1938 arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */ 1887 arrow->stats.sp = arrow->stats.wc; /* save original wc and dam */
1939 arrow->stats.hp = arrow->stats.dam; 1888 arrow->stats.hp = arrow->stats.dam;
1940 arrow->stats.grace = arrow->attacktype; 1889 arrow->stats.grace = arrow->attacktype;
1941 if (arrow->slaying != NULL) 1890 if (arrow->slaying != NULL)
1942 arrow->spellarg = strdup_local (arrow->slaying); 1891 arrow->spellarg = strdup (arrow->slaying);
1943 1892
1944 /* Note that this was different for monsters - they got their level 1893 /* Note that this was different for monsters - they got their level
1945 * added to the damage. I think the strength bonus is more proper. 1894 * added to the damage. I think the strength bonus is more proper.
1946 */ 1895 */
1947 1896
… …
1965 arrow->level = op->chosen_skill ? op->chosen_skill->level : op->level; 1914 arrow->level = op->chosen_skill ? op->chosen_skill->level : op->level;
1966 } 1915 }
1967 else 1916 else
1968 { 1917 {
1969 arrow->stats.wc = op->stats.wc - bow->magic - arrow->magic - arrow->stats.wc + wc_mod; 1918 arrow->stats.wc = op->stats.wc - bow->magic - arrow->magic - arrow->stats.wc + wc_mod;
1970
1971 arrow->level = op->level; 1919 arrow->level = op->level;
1972 } 1920 }
1921
1973 if (arrow->attacktype == AT_PHYSICAL) 1922 if (arrow->attacktype == AT_PHYSICAL)
1974 arrow->attacktype |= bow->attacktype; 1923 arrow->attacktype |= bow->attacktype;
1924
1975 if (bow->slaying != NULL) 1925 if (bow->slaying != NULL)
1976 arrow->slaying = bow->slaying; 1926 arrow->slaying = bow->slaying;
1977 1927
1978 arrow->map = m; 1928 arrow->map = m;
1979 arrow->move_type = MOVE_FLY_LOW; 1929 arrow->move_type = MOVE_FLY_LOW;
1980 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK; 1930 arrow->move_on = MOVE_FLY_LOW | MOVE_WALK;
1981 1931
1982 play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW); 1932 play_sound_map (op->map, op->x, op->y, SOUND_FIRE_ARROW);
1983 tag = arrow->count;
1984 insert_ob_in_map (arrow, m, op, 0); 1933 insert_ob_in_map (arrow, m, op, 0);
1985 1934
1986 if (!was_destroyed (arrow, tag)) 1935 if (!arrow->destroyed ())
1987 move_arrow (arrow); 1936 move_arrow (arrow);
1988 1937
1989 if (op->type == PLAYER) 1938 if (op->type == PLAYER)
1990 { 1939 {
1991 if (was_destroyed (left, left_tag)) 1940 if (left->destroyed ())
1992 esrv_del_item (op->contr, left_tag); 1941 esrv_del_item (op->contr, left->count);
1993 else 1942 else
1994 esrv_send_item (op, left); 1943 esrv_send_item (op, left);
1995 } 1944 }
1945
1996 return 1; 1946 return 1;
1997} 1947}
1998 1948
1999/* Special fire code for players - this takes into 1949/* Special fire code for players - this takes into
2000 * account the special fire modes players can have 1950 * account the special fire modes players can have
… …
2136 case range_misc: 2086 case range_misc:
2137 fire_misc_object (op, dir); 2087 fire_misc_object (op, dir);
2138 return; 2088 return;
2139 2089
2140 case range_golem: /* Control summoned monsters from scrolls */ 2090 case range_golem: /* Control summoned monsters from scrolls */
2141 if (op->contr->ranges[range_golem] == NULL || op->contr->golem_count != op->contr->ranges[range_golem]->count) 2091 if (QUERY_FLAG (op->contr->ranges[range_golem], FLAG_REMOVED))
2142 { 2092 {
2143 op->contr->ranges[range_golem] = NULL; 2093 op->contr->ranges[range_golem] = 0;
2144 op->contr->shoottype = range_none; 2094 op->contr->shoottype = range_none;
2145 op->contr->golem_count = 0;
2146 } 2095 }
2147 else 2096 else
2148 control_golem (op->contr->ranges[range_golem], dir); 2097 control_golem (op->contr->ranges[range_golem], dir);
2149 return; 2098 return;
2150 2099
… …
2312move_player_attack (object *op, int dir) 2261move_player_attack (object *op, int dir)
2313{ 2262{
2314 object *tmp, *mon; 2263 object *tmp, *mon;
2315 sint16 nx, ny; 2264 sint16 nx, ny;
2316 int on_battleground; 2265 int on_battleground;
2317 mapstruct *m; 2266 maptile *m;
2318 2267
2319 nx = freearr_x[dir] + op->x; 2268 nx = freearr_x[dir] + op->x;
2320 ny = freearr_y[dir] + op->y; 2269 ny = freearr_y[dir] + op->y;
2321 2270
2322 on_battleground = op_on_battleground (op, NULL, NULL); 2271 on_battleground = op_on_battleground (op, NULL, NULL);
… …
2358 if (tmp == op) 2307 if (tmp == op)
2359 { 2308 {
2360 tmp = tmp->above; 2309 tmp = tmp->above;
2361 continue; 2310 continue;
2362 } 2311 }
2312
2363 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 2313 if (QUERY_FLAG (tmp, FLAG_ALIVE))
2364 { 2314 {
2365 mon = tmp; 2315 mon = tmp;
2366 break; 2316 break;
2367 } 2317 }
2318
2368 if (tmp->type == LOCKED_DOOR || QUERY_FLAG (tmp, FLAG_CAN_ROLL)) 2319 if (tmp->type == LOCKED_DOOR || QUERY_FLAG (tmp, FLAG_CAN_ROLL))
2369 mon = tmp; 2320 mon = tmp;
2321
2370 tmp = tmp->above; 2322 tmp = tmp->above;
2371 } 2323 }
2372 2324
2373 if (mon == NULL) /* This happens anytime the player tries to move */ 2325 if (mon == NULL) /* This happens anytime the player tries to move */
2374 return; /* into a wall */ 2326 return; /* into a wall */
… …
2393 * player owns it and it is either friendly or unagressive. 2345 * player owns it and it is either friendly or unagressive.
2394 */ 2346 */
2395 if ((op->type == PLAYER) 2347 if ((op->type == PLAYER)
2396#if COZY_SERVER 2348#if COZY_SERVER
2397 && 2349 &&
2398 ((get_owner (mon) && get_owner (mon)->contr 2350 ((mon->owner && mon->owner->contr
2399 && same_party (get_owner (mon)->contr->party, op->contr->party)) || get_owner (mon) == op) 2351 && same_party (mon->owner->contr->party, op->contr->party)) || mon->owner == op)
2400#else 2352#else
2401 && get_owner (mon) == op 2353 && mon->owner == op
2402#endif 2354#endif
2403 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY))) 2355 && (QUERY_FLAG (mon, FLAG_UNAGGRESSIVE) || QUERY_FLAG (mon, FLAG_FRIENDLY)))
2404 { 2356 {
2405 /* If we're braced, we don't want to switch places with it */ 2357 /* If we're braced, we don't want to switch places with it */
2406 if (op->contr->braced) 2358 if (op->contr->braced)
… …
2593 /* I've been seeing crashes where the golem has been destroyed, but 2545 /* I've been seeing crashes where the golem has been destroyed, but
2594 * the player object still points to the defunct golem. The code that 2546 * the player object still points to the defunct golem. The code that
2595 * destroys the golem looks correct, and it doesn't always happen, so 2547 * destroys the golem looks correct, and it doesn't always happen, so
2596 * put this in a a workaround to clean up the golem pointer. 2548 * put this in a a workaround to clean up the golem pointer.
2597 */ 2549 */
2598 if (op->contr->ranges[range_golem] &&
2599 ((op->contr->golem_count != op->contr->ranges[range_golem]->count) || QUERY_FLAG (op->contr->ranges[range_golem], FLAG_REMOVED))) 2550 if (op->contr->ranges[range_golem] && QUERY_FLAG (op->contr->ranges[range_golem], FLAG_REMOVED))
2600 {
2601 op->contr->ranges[range_golem] = NULL; 2551 op->contr->ranges[range_golem] = 0;
2602 op->contr->golem_count = 0;
2603 }
2604 2552
2605 /* call this here - we also will call this in do_ericserver, but 2553 /* call this here - we also will call this in do_ericserver, but
2606 * the players time has been increased when doericserver has been 2554 * the players time has been increased when doericserver has been
2607 * called, so we recheck it here. 2555 * called, so we recheck it here.
2608 */ 2556 */
2609 HandleClient (&op->contr->socket, op->contr); 2557 op->contr->socket->handle_command ();
2610 if (op->speed_left < 0) 2558 if (op->speed_left < 0)
2611 return 0; 2559 return 0;
2612 2560
2613 if (op->direction && (op->contr->run_on || op->contr->fire_on)) 2561 if (op->direction && (op->contr->run_on || op->contr->fire_on))
2614 { 2562 {
… …
2623 if (op->speed_left > 0) 2571 if (op->speed_left > 0)
2624 return 1; 2572 return 1;
2625 else 2573 else
2626 return 0; 2574 return 0;
2627 } 2575 }
2576
2628 return 0; 2577 return 0;
2629} 2578}
2630 2579
2631int 2580int
2632save_life (object *op) 2581save_life (object *op)
2633{ 2582{
2634 object *tmp;
2635
2636 if (!QUERY_FLAG (op, FLAG_LIFESAVE)) 2583 if (!QUERY_FLAG (op, FLAG_LIFESAVE))
2637 return 0; 2584 return 0;
2638 2585
2639 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 2586 for (object *tmp = op->inv; tmp; tmp = tmp->below)
2640 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE)) 2587 if (QUERY_FLAG (tmp, FLAG_APPLIED) && QUERY_FLAG (tmp, FLAG_LIFESAVE))
2641 { 2588 {
2642 play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE); 2589 play_sound_map (op->map, op->x, op->y, SOUND_OB_EVAPORATE);
2643 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp)); 2590 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s vibrates violently, then evaporates.", query_name (tmp));
2591
2644 if (op->contr) 2592 if (op->contr)
2645 esrv_del_item (op->contr, tmp->count); 2593 esrv_del_item (op->contr, tmp->count);
2646 remove_ob (tmp); 2594
2647 free_object (tmp); 2595 tmp->destroy ();
2648 CLEAR_FLAG (op, FLAG_LIFESAVE); 2596 CLEAR_FLAG (op, FLAG_LIFESAVE);
2597
2649 if (op->stats.hp < 0) 2598 if (op->stats.hp < 0)
2650 op->stats.hp = op->stats.maxhp; 2599 op->stats.hp = op->stats.maxhp;
2600
2651 if (op->stats.food < 0) 2601 if (op->stats.food < 0)
2652 op->stats.food = 999; 2602 op->stats.food = 999;
2603
2653 fix_player (op); 2604 fix_player (op);
2654 return 1; 2605 return 1;
2655 } 2606 }
2607
2656 LOG (llevError, "Error: LIFESAVE set without applied object.\n"); 2608 LOG (llevError, "Error: LIFESAVE set without applied object.\n");
2657 CLEAR_FLAG (op, FLAG_LIFESAVE); 2609 CLEAR_FLAG (op, FLAG_LIFESAVE);
2658 enter_player_savebed (op); /* bring him home. */ 2610 enter_player_savebed (op); /* bring him home. */
2659 return 0; 2611 return 0;
2660} 2612}
… …
2674 next = op->below; /* Make sure we have a good value, in case 2626 next = op->below; /* Make sure we have a good value, in case
2675 * we remove object 'op' 2627 * we remove object 'op'
2676 */ 2628 */
2677 if (QUERY_FLAG (op, FLAG_UNPAID)) 2629 if (QUERY_FLAG (op, FLAG_UNPAID))
2678 { 2630 {
2679 remove_ob (op); 2631 op->remove ();
2680 op->x = env->x; 2632 op->x = env->x;
2681 op->y = env->y; 2633 op->y = env->y;
2682 if (env->type == PLAYER) 2634 if (env->type == PLAYER)
2683 esrv_del_item (env->contr, op->count); 2635 esrv_del_item (env->contr, op->count);
2684 insert_ob_in_map (op, env->map, NULL, 0); 2636 insert_ob_in_map (op, env->map, NULL, 0);
2685 } 2637 }
2686 else if (op->inv) 2638 else if (op->inv)
2687 remove_unpaid_objects (op->inv, env); 2639 remove_unpaid_objects (op->inv, env);
2640
2688 op = next; 2641 op = next;
2689 } 2642 }
2690} 2643}
2691 2644
2692 2645
… …
2707 strcpy (buf2, " R.I.P.\n\n"); 2660 strcpy (buf2, " R.I.P.\n\n");
2708 if (op->type == PLAYER) 2661 if (op->type == PLAYER)
2709 sprintf (buf, "%s the %s\n", &op->name, op->contr->title); 2662 sprintf (buf, "%s the %s\n", &op->name, op->contr->title);
2710 else 2663 else
2711 sprintf (buf, "%s\n", &op->name); 2664 sprintf (buf, "%s\n", &op->name);
2665
2712 strncat (buf2, " ", 20 - strlen (buf) / 2); 2666 strncat (buf2, " ", 20 - strlen (buf) / 2);
2713 strcat (buf2, buf); 2667 strcat (buf2, buf);
2714 if (op->type == PLAYER) 2668 if (op->type == PLAYER)
2715 sprintf (buf, "who was in level %d when killed\n", op->level); 2669 sprintf (buf, "who was in level %d when killed\n", op->level);
2716 else 2670 else
2717 sprintf (buf, "who was in level %d when died.\n\n", op->level); 2671 sprintf (buf, "who was in level %d when died.\n\n", op->level);
2672
2718 strncat (buf2, " ", 20 - strlen (buf) / 2); 2673 strncat (buf2, " ", 20 - strlen (buf) / 2);
2719 strcat (buf2, buf); 2674 strcat (buf2, buf);
2720 if (op->type == PLAYER) 2675 if (op->type == PLAYER)
2721 { 2676 {
2722 sprintf (buf, "by %s.\n\n", op->contr->killer); 2677 sprintf (buf, "by %s.\n\n", op->contr->killer);
2723 strncat (buf2, " ", 21 - strlen (buf) / 2); 2678 strncat (buf2, " ", 21 - strlen (buf) / 2);
2724 strcat (buf2, buf); 2679 strcat (buf2, buf);
2725 } 2680 }
2681
2726 strftime (buf, MAX_BUF, "%b %d %Y\n", localtime (&now)); 2682 strftime (buf, MAX_BUF, "%b %d %Y\n", localtime (&now));
2727 strncat (buf2, " ", 20 - strlen (buf) / 2); 2683 strncat (buf2, " ", 20 - strlen (buf) / 2);
2728 strcat (buf2, buf); 2684 strcat (buf2, buf);
2685
2729 return buf2; 2686 return buf2;
2730} 2687}
2731 2688
2732 2689
2733 2690
… …
2952{ 2909{
2953 char buf[MAX_BUF]; 2910 char buf[MAX_BUF];
2954 int x, y; 2911 int x, y;
2955 2912
2956 //int i; 2913 //int i;
2957 mapstruct *map; /* this is for resurrection */ 2914 maptile *map; /* this is for resurrection */
2958 2915
2959 /* int z; 2916 /* int z;
2960 int num_stats_lose; 2917 int num_stats_lose;
2961 int lost_a_stat; 2918 int lost_a_stat;
2962 int lose_this_stat; 2919 int lose_this_stat;
… …
2981 /* restore player */ 2938 /* restore player */
2982 at = archetype::find ("poisoning"); 2939 at = archetype::find ("poisoning");
2983 tmp = present_arch_in_ob (at, op); 2940 tmp = present_arch_in_ob (at, op);
2984 if (tmp) 2941 if (tmp)
2985 { 2942 {
2986 remove_ob (tmp); 2943 tmp->destroy ();
2987 free_object (tmp);
2988 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed"); 2944 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
2989 } 2945 }
2990 2946
2991 at = archetype::find ("confusion"); 2947 at = archetype::find ("confusion");
2992 tmp = present_arch_in_ob (at, op); 2948 tmp = present_arch_in_ob (at, op);
2993 if (tmp) 2949 if (tmp)
2994 { 2950 {
2995 remove_ob (tmp); 2951 tmp->destroy ();
2996 free_object (tmp);
2997 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 2952 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
2998 } 2953 }
2999 2954
3000 cure_disease (op, 0); /* remove any disease */ 2955 cure_disease (op, 0); /* remove any disease */
3001 op->stats.hp = op->stats.maxhp; 2956 op->stats.hp = op->stats.maxhp;
… …
3178 /* determine_god() seems to not work sometimes... why is this? 3133 /* determine_god() seems to not work sometimes... why is this?
3179 Should I be using something else? GD */ 3134 Should I be using something else? GD */
3180 const char *god = determine_god (op); 3135 const char *god = determine_god (op);
3181 3136
3182 if (god && (strcmp (god, "none"))) 3137 if (god && (strcmp (god, "none")))
3183 new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief " "moment you feel the holy presence of %s protecting" " you.", god); 3138 new_draw_info_format (NDI_UNIQUE, 0, op, "For a brief moment you feel the holy presence of %s protecting" " you.", god);
3184 else 3139 else
3185 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you."); 3140 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you feel a holy presence protecting you.");
3186 } 3141 }
3142#else
3143 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");
3187#endif 3144#endif
3188 new_draw_info (NDI_UNIQUE, 0, op, "For a brief moment you" " feel a holy presence protecting you from losing yourself completely.");
3189 3145
3190 /* Put a gravestone up where the character 'almost' died. List the 3146 /* Put a gravestone up where the character 'almost' died. List the
3191 * exp loss on the stone. 3147 * exp loss on the stone.
3192 */ 3148 */
3193 tmp = arch_to_object (archetype::find ("gravestone")); 3149 tmp = arch_to_object (archetype::find ("gravestone"));
… …
3198 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); 3154 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);
3199 tmp->msg = buf; 3155 tmp->msg = buf;
3200 tmp->x = op->x, tmp->y = op->y; 3156 tmp->x = op->x, tmp->y = op->y;
3201 insert_ob_in_map (tmp, op->map, NULL, 0); 3157 insert_ob_in_map (tmp, op->map, NULL, 0);
3202 3158
3203 /**************************************/ 3159 /**************************************/
3204 /* */ 3160 /* */
3205 /* Subtract the experience points, */ 3161 /* Subtract the experience points, */
3206 /* if we died cause of food, give us */ 3162 /* if we died cause of food, give us */
3207 /* food, and reset HP's... */ 3163 /* food, and reset HP's... */
3208 /* */ 3164 /* */
3209
3210 /**************************************/ 3165 /**************************************/
3211 3166
3212 /* remove any poisoning and confusion the character may be suffering. */ 3167 /* remove any poisoning and confusion the character may be suffering. */
3213 /* restore player */ 3168 /* restore player */
3214 at = archetype::find ("poisoning"); 3169 at = archetype::find ("poisoning");
3215 tmp = present_arch_in_ob (at, op); 3170 tmp = present_arch_in_ob (at, op);
3171
3216 if (tmp) 3172 if (tmp)
3217 { 3173 {
3218 remove_ob (tmp); 3174 tmp->destroy ();
3219 free_object (tmp);
3220 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed"); 3175 new_draw_info (NDI_UNIQUE, 0, op, "Your body feels cleansed");
3221 } 3176 }
3222 3177
3223 at = archetype::find ("confusion"); 3178 at = archetype::find ("confusion");
3224 tmp = present_arch_in_ob (at, op); 3179 tmp = present_arch_in_ob (at, op);
3225 if (tmp) 3180 if (tmp)
3226 { 3181 {
3227 remove_ob (tmp); 3182 tmp->destroy ();
3228 free_object (tmp);
3229 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 3183 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
3230 } 3184 }
3185
3231 cure_disease (op, 0); /* remove any disease */ 3186 cure_disease (op, 0); /* remove any disease */
3232 3187
3233 /*add_exp(op, (op->stats.exp * -0.20)); */ 3188 /*add_exp(op, (op->stats.exp * -0.20)); */
3234 apply_death_exp_penalty (op); 3189 apply_death_exp_penalty (op);
3235 if (op->stats.food < 100) 3190 if (op->stats.food < 100)
… …
3245 */ 3200 */
3246 3201
3247 if (is_in_shop (op)) 3202 if (is_in_shop (op))
3248 remove_unpaid_objects (op->inv, op); 3203 remove_unpaid_objects (op->inv, op);
3249 3204
3250 /****************************************/ 3205 /****************************************/
3251 /* */ 3206 /* */
3252 /* Move player to his current respawn- */ 3207 /* Move player to his current respawn- */
3253 /* position (usually last savebed) */ 3208 /* position (usually last savebed) */
3254 /* */ 3209 /* */
3255
3256 /****************************************/ 3210 /****************************************/
3257 3211
3258 enter_player_savebed (op); 3212 enter_player_savebed (op);
3259 3213
3260 /* Save the player before inserting the force to reduce 3214 /* Save the player before inserting the force to reduce
3261 * chance of abuse. 3215 * chance of abuse.
… …
3268 * spell effects. So first see if there is a spell effect 3222 * spell effects. So first see if there is a spell effect
3269 * on the space that might harm the player. 3223 * on the space that might harm the player.
3270 */ 3224 */
3271 will_kill_again = 0; 3225 will_kill_again = 0;
3272 for (tmp = get_map_ob (op->map, op->x, op->y); tmp; tmp = tmp->above) 3226 for (tmp = get_map_ob (op->map, op->x, op->y); tmp; tmp = tmp->above)
3273 {
3274 if (tmp->type == SPELL_EFFECT) 3227 if (tmp->type == SPELL_EFFECT)
3275 will_kill_again |= tmp->attacktype; 3228 will_kill_again |= tmp->attacktype;
3276 } 3229
3277 if (will_kill_again) 3230 if (will_kill_again)
3278 { 3231 {
3279 object *force; 3232 object *force;
3280 int at; 3233 int at;
3281 3234
… …
3283 /* 50 ticks should be enough time for the spell to abate */ 3236 /* 50 ticks should be enough time for the spell to abate */
3284 force->speed = 0.1; 3237 force->speed = 0.1;
3285 force->speed_left = -5.0; 3238 force->speed_left = -5.0;
3286 SET_FLAG (force, FLAG_APPLIED); 3239 SET_FLAG (force, FLAG_APPLIED);
3287 for (at = 0; at < NROFATTACKS; at++) 3240 for (at = 0; at < NROFATTACKS; at++)
3288 {
3289 if (will_kill_again & (1 << at)) 3241 if (will_kill_again & (1 << at))
3290 force->resist[at] = 100; 3242 force->resist[at] = 100;
3291 } 3243
3292 insert_ob_in_ob (force, op); 3244 insert_ob_in_ob (force, op);
3293 fix_player (op); 3245 fix_player (op);
3294 3246
3295 } 3247 }
3296 3248
… …
3306 op->contr->party = NULL; 3258 op->contr->party = NULL;
3307 if (settings.set_title == TRUE) 3259 if (settings.set_title == TRUE)
3308 op->contr->own_title[0] = '\0'; 3260 op->contr->own_title[0] = '\0';
3309 new_draw_info (NDI_UNIQUE | NDI_ALL, 0, NULL, buf); 3261 new_draw_info (NDI_UNIQUE | NDI_ALL, 0, NULL, buf);
3310 check_score (op); 3262 check_score (op);
3263
3311 if (op->contr->ranges[range_golem] != NULL) 3264 if (op->contr->ranges[range_golem])
3312 { 3265 {
3313 remove_friendly_object (op->contr->ranges[range_golem]); 3266 remove_friendly_object (op->contr->ranges[range_golem]);
3314 remove_ob (op->contr->ranges[range_golem]); 3267 op->contr->ranges[range_golem]->destroy ();
3315 free_object (op->contr->ranges[range_golem]);
3316 op->contr->ranges[range_golem] = NULL; 3268 op->contr->ranges[range_golem] = 0;
3317 op->contr->golem_count = 0;
3318 } 3269 }
3270
3319 loot_object (op); /* Remove some of the items for good */ 3271 loot_object (op); /* Remove some of the items for good */
3320 remove_ob (op); 3272 op->remove ();
3321 op->direction = 0; 3273 op->direction = 0;
3322 3274
3323 if (!QUERY_FLAG (op, FLAG_WAS_WIZ) && op->stats.exp) 3275 if (!QUERY_FLAG (op, FLAG_WAS_WIZ) && op->stats.exp)
3324 { 3276 {
3325 delete_character (op->name, 0); 3277 delete_character (op->name, 0);
… …
3378 for (tmp = op->inv; tmp != NULL; tmp = next) 3330 for (tmp = op->inv; tmp != NULL; tmp = next)
3379 { 3331 {
3380 next = tmp->below; 3332 next = tmp->below;
3381 if (tmp->type == EXPERIENCE || tmp->invisible) 3333 if (tmp->type == EXPERIENCE || tmp->invisible)
3382 continue; 3334 continue;
3383 remove_ob (tmp); 3335 tmp->remove ();
3384 tmp->x = op->x, tmp->y = op->y; 3336 tmp->x = op->x, tmp->y = op->y;
3385 if (tmp->type == CONTAINER) 3337 if (tmp->type == CONTAINER)
3386 { /* empty container to ground */ 3338 { /* empty container to ground */
3387 loot_object (tmp); 3339 loot_object (tmp);
3388 } 3340 }
3389 if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(RANDOM () % 3))) 3341 if (!QUERY_FLAG (tmp, FLAG_UNIQUE) && (QUERY_FLAG (tmp, FLAG_STARTEQUIP) || QUERY_FLAG (tmp, FLAG_NO_DROP) || !(RANDOM () % 3)))
3390 { 3342 {
3391 if (tmp->nrof > 1) 3343 if (tmp->nrof > 1)
3392 { 3344 {
3393 tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1)); 3345 tmp2 = get_split_ob (tmp, 1 + RANDOM () % (tmp->nrof - 1));
3394 free_object (tmp2); 3346 tmp2->destroy ();
3395 insert_ob_in_map (tmp, op->map, NULL, 0); 3347 insert_ob_in_map (tmp, op->map, NULL, 0);
3396 } 3348 }
3397 else 3349 else
3398 free_object (tmp); 3350 tmp->destroy ();
3399 } 3351 }
3400 else 3352 else
3401 insert_ob_in_map (tmp, op->map, NULL, 0); 3353 insert_ob_in_map (tmp, op->map, NULL, 0);
3402 } 3354 }
3403} 3355}
… …
3468 if (op->type == PLAYER) 3420 if (op->type == PLAYER)
3469 new_draw_info_format (NDI_UNIQUE, 0, op, "You cast %s.", &spob->name); 3421 new_draw_info_format (NDI_UNIQUE, 0, op, "You cast %s.", &spob->name);
3470 3422
3471 cast_spell (op, throw_ob, dir, spob, NULL); 3423 cast_spell (op, throw_ob, dir, spob, NULL);
3472 3424
3473 if (!QUERY_FLAG (throw_ob, FLAG_REMOVED)) 3425 throw_ob->destroy ();
3474 remove_ob (throw_ob);
3475 free_object (throw_ob);
3476} 3426}
3477 3427
3478void 3428void
3479make_visible (object *op) 3429make_visible (object *op)
3480{ 3430{
… …
3596int 3546int
3597stand_near_hostile (object *who) 3547stand_near_hostile (object *who)
3598{ 3548{
3599 object *tmp = NULL; 3549 object *tmp = NULL;
3600 int i, friendly = 0, player = 0, mflags; 3550 int i, friendly = 0, player = 0, mflags;
3601 mapstruct *m; 3551 maptile *m;
3602 sint16 x, y; 3552 sint16 x, y;
3603 3553
3604 if (!who) 3554 if (!who)
3605 return 0; 3555 return 0;
3606 3556
… …
3687 3637
3688 /* only the viewable area the player sees is updated by LOS 3638 /* only the viewable area the player sees is updated by LOS
3689 * code, so we need to restrict ourselves to that range of values 3639 * code, so we need to restrict ourselves to that range of values
3690 * for any meaningful values. 3640 * for any meaningful values.
3691 */ 3641 */
3692 if (FABS (dx) <= (pl->contr->socket.mapx / 2) && 3642 if (FABS (dx) <= (pl->contr->socket->mapx / 2) &&
3693 FABS (dy) <= (pl->contr->socket.mapy / 2) && 3643 FABS (dy) <= (pl->contr->socket->mapy / 2) &&
3694 !pl->contr->blocked_los[dx + (pl->contr->socket.mapx / 2)][dy + (pl->contr->socket.mapy / 2)]) 3644 !pl->contr->blocked_los[dx + (pl->contr->socket->mapx / 2)][dy + (pl->contr->socket->mapy / 2)])
3695 return 1; 3645 return 1;
3696 op = op->more; 3646 op = op->more;
3697 } 3647 }
3698 return 0; 3648 return 0;
3699} 3649}

Diff Legend

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