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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.303 by root, Tue Nov 10 04:38:45 2009 UTC vs.
Revision 1.331 by root, Sun Apr 18 14:04:50 2010 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * the terms of the Affero GNU General Public License as published by the 9 * the terms of the Affero GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version. 11 * option) any later version.
… …
26#include <stdio.h> 26#include <stdio.h>
27#include <sys/types.h> 27#include <sys/types.h>
28#include <sys/uio.h> 28#include <sys/uio.h>
29#include <object.h> 29#include <object.h>
30#include <sproto.h> 30#include <sproto.h>
31#include <loader.h>
32 31
33#include <bitset> 32#include <bitset>
34 33
35UUID UUID::cur; 34UUID UUID::cur;
36static uint64_t seq_next_save; 35static uint64_t seq_next_save;
37static const uint64 UUID_GAP = 1<<19; 36static const uint64 UUID_GAP = 1<<19;
38uint32_t mapspace::smellcount = 10000; 37uint32_t mapspace::smellcount = 10000;
39 38
40objectvec objects; 39objectvec objects;
41activevec actives; 40activevec actives;
41
42freelist_item *object::freelist;
43uint32_t object::object_count;
44uint32_t object::free_count;
45uint32_t object::create_count;
46uint32_t object::destroy_count;
42 47
43//+GPL 48//+GPL
44 49
45short freearr_x[SIZEOFFREE] = { 50short freearr_x[SIZEOFFREE] = {
46 0, 51 0,
… …
77 CALL_CALL ("cf::write_uuid", G_DISCARD); 82 CALL_CALL ("cf::write_uuid", G_DISCARD);
78 CALL_END; 83 CALL_END;
79} 84}
80 85
81static void 86static void
82read_uuid (void) 87read_uuid ()
83{ 88{
84 char filename[MAX_BUF]; 89 char filename[MAX_BUF];
85 90
86 sprintf (filename, "%s/uuid", settings.localdir); 91 sprintf (filename, "%s/uuid", settings.localdir);
87 92
… …
248 * Improvements made with merge: Better checking on potion, and also 253 * Improvements made with merge: Better checking on potion, and also
249 * check weight 254 * check weight
250 */ 255 */
251bool object::can_merge_slow (object *ob1, object *ob2) 256bool object::can_merge_slow (object *ob1, object *ob2)
252{ 257{
253 /* A couple quicksanity checks */ 258 /* A couple quick sanity checks */
254 if (ob1 == ob2 259 if (ob1 == ob2
255 || ob1->type != ob2->type 260 || ob1->type != ob2->type
256 || fabs (ob1->speed - ob2->speed) >= MIN_ACTIVE_SPEED
257 || ob1->value != ob2->value 261 || ob1->value != ob2->value
258 || ob1->name != ob2->name) 262 || ob1->name != ob2->name
263 || fabs (ob1->speed - ob2->speed) >= MIN_ACTIVE_SPEED)
259 return 0; 264 return 0;
260 265
261 /* Do not merge objects if nrof would overflow, assume nrof 266 /* Do not merge objects if nrof would overflow, assume nrof
262 * is always 0 .. 2**31-1 */ 267 * is always 0 .. 2**31-1 */
263 if (ob1->nrof > 0x7fffffff - ob2->nrof) 268 if (ob1->nrof > 0x7fffffff - ob2->nrof)
… …
267 * This is to the comparison of the flags below will be OK. We 272 * This is to the comparison of the flags below will be OK. We
268 * just can't ignore the been applied or identified flags, as they 273 * just can't ignore the been applied or identified flags, as they
269 * are not equal - just if it has been identified, the been_applied 274 * are not equal - just if it has been identified, the been_applied
270 * flags lose any meaning. 275 * flags lose any meaning.
271 */ 276 */
272 if (QUERY_FLAG (ob1, FLAG_IDENTIFIED)) 277 if (ob1->flag [FLAG_IDENTIFIED])
273 SET_FLAG (ob1, FLAG_BEEN_APPLIED); 278 ob1->set_flag (FLAG_BEEN_APPLIED);
274 279
275 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED)) 280 if (ob2->flag [FLAG_IDENTIFIED])
276 SET_FLAG (ob2, FLAG_BEEN_APPLIED); 281 ob2->set_flag (FLAG_BEEN_APPLIED);
277 282
278 if (ob1->arch->archname != ob2->arch->archname 283 if (ob1->arch->archname != ob2->arch->archname
279 || ob1->name != ob2->name 284 || ob1->name != ob2->name
280 || ob1->title != ob2->title 285 || ob1->title != ob2->title
281 || ob1->msg != ob2->msg 286 || ob1->msg != ob2->msg
… …
284 || ob1->magic != ob2->magic 289 || ob1->magic != ob2->magic
285 || ob1->slaying != ob2->slaying 290 || ob1->slaying != ob2->slaying
286 || ob1->skill != ob2->skill 291 || ob1->skill != ob2->skill
287 || ob1->value != ob2->value 292 || ob1->value != ob2->value
288 || ob1->animation_id != ob2->animation_id 293 || ob1->animation_id != ob2->animation_id
289 || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependent on each other 294 || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependend on each other
290 || ob1->client_type != ob2->client_type 295 || ob1->client_type != ob2->client_type
291 || ob1->material != ob2->material 296 || ob1->material != ob2->material
292 || ob1->lore != ob2->lore 297 || ob1->lore != ob2->lore
293 || ob1->subtype != ob2->subtype 298 || ob1->subtype != ob2->subtype
294 || ob1->move_type != ob2->move_type 299 || ob1->move_type != ob2->move_type
… …
330 335
331 /* Don't merge objects that are applied. With the new 'body' code, 336 /* Don't merge objects that are applied. With the new 'body' code,
332 * it is possible for most any character to have more than one of 337 * it is possible for most any character to have more than one of
333 * some items equipped, and we don't want those to merge. 338 * some items equipped, and we don't want those to merge.
334 */ 339 */
335 if (QUERY_FLAG (ob1, FLAG_APPLIED) || QUERY_FLAG (ob2, FLAG_APPLIED)) 340 if (ob1->flag [FLAG_APPLIED] || ob2->flag [FLAG_APPLIED])
336 return 0; 341 return 0;
337 342
338 /* Note sure why the following is the case - either the object has to 343 /* Note sure why the following is the case - either the object has to
339 * be animated or have a very low speed. Is this an attempted monster 344 * be animated or have a very low speed. Is this an attempted monster
340 * check? 345 * check?
341 */ 346 */
342 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && ob1->has_active_speed ()) 347 if (!ob1->flag [FLAG_ANIMATE] && ob1->has_active_speed ())
343 return 0; 348 return 0;
344 349
345 switch (ob1->type) 350 switch (ob1->type)
346 { 351 {
347 case SCROLL: 352 case SCROLL:
… …
478 483
479 sum = weight_adjust_for (this, sum); 484 sum = weight_adjust_for (this, sum);
480 485
481 if (sum != carrying) 486 if (sum != carrying)
482 { 487 {
488 if (carrying != sum)//D
489 LOG (llevDebug, "updating weight got %ld, expected %ld (%s)\n",
490 (long long)sum, (long long)carrying, debug_desc ());
491
483 carrying = sum; 492 carrying = sum;
484 493
485 if (object *pl = visible_to ()) 494 if (object *pl = visible_to ())
486 if (pl != this) // player is handled lazily 495 if (pl != this) // player is handled lazily
487 esrv_update_item (UPD_WEIGHT, pl, this); 496 esrv_update_item (UPD_WEIGHT, pl, this);
… …
515object * 524object *
516find_object (tag_t i) 525find_object (tag_t i)
517{ 526{
518 for_all_objects (op) 527 for_all_objects (op)
519 if (op->count == i) 528 if (op->count == i)
529 return op;
530
531 return 0;
532}
533
534/*
535 * Returns the object which has the uuid equal to the argument.
536 * MOAR VERRRY slow.
537 */
538
539object *
540find_object_uuid (UUID i)
541{
542 for_all_objects (op)
543 if (op->uuid == i)
520 return op; 544 return op;
521 545
522 return 0; 546 return 0;
523} 547}
524 548
… …
558 LOG (llevError | logBacktrace, "tried to set owner of %s to %s\n", debug_desc (), owner->debug_desc ()); 582 LOG (llevError | logBacktrace, "tried to set owner of %s to %s\n", debug_desc (), owner->debug_desc ());
559 return; 583 return;
560 } 584 }
561 585
562 this->owner = owner; 586 this->owner = owner;
563}
564
565int
566object::slottype () const
567{
568 if (type == SKILL)
569 {
570 if (IS_COMBAT_SKILL (subtype)) return slot_combat;
571 if (IS_RANGED_SKILL (subtype)) return slot_ranged;
572 }
573 else
574 {
575 if (slot [body_combat].info) return slot_combat;
576 if (slot [body_range ].info) return slot_ranged;
577 }
578
579 return slot_none;
580}
581
582bool
583object::change_weapon (object *ob)
584{
585 if (current_weapon == ob)
586 return true;
587
588 if (chosen_skill)
589 chosen_skill->flag [FLAG_APPLIED] = false;
590
591 current_weapon = ob;
592 chosen_skill = !ob || ob->type == SKILL ? ob : find_skill_by_name (this, ob->skill);
593
594 if (chosen_skill)
595 chosen_skill->flag [FLAG_APPLIED] = true;
596
597 update_stats ();
598
599 if (ob)
600 {
601 // now check wether any body locations became invalid, in which case
602 // we cannot apply the weapon at the moment.
603 for (int i = 0; i < NUM_BODY_LOCATIONS; ++i)
604 if (slot[i].used < 0)
605 {
606 current_weapon = chosen_skill = 0;
607 update_stats ();
608
609 new_draw_info_format (NDI_UNIQUE, 0, this,
610 "You try to balance all your items at once, "
611 "but the %s is just too much for your body. "
612 "[You need to unapply some items first - use the 'body' command to see "
613 "how many items you cna wera on a specific body part.]", &ob->name);
614 return false;
615 }
616
617 //new_draw_info_format (NDI_UNIQUE, 0, this, "You switch to your %s.", &ob->name);
618 }
619 else
620 ;//new_draw_info_format (NDI_UNIQUE, 0, this, "You unwield your weapons.");
621
622 if (ob && !ob->flag [FLAG_APPLIED] && ob->type != SPELL)
623 {
624 LOG (llevError | logBacktrace, "%s changed to unapplied weapon %s",
625 &name, ob->debug_desc ());
626 return false;
627 }
628
629 return true;
630} 587}
631 588
632/* Zero the key_values on op, decrementing the shared-string 589/* Zero the key_values on op, decrementing the shared-string
633 * refcounts and freeing the links. 590 * refcounts and freeing the links.
634 */ 591 */
… …
687 tail = new_link; 644 tail = new_link;
688 } 645 }
689 } 646 }
690 } 647 }
691 648
692 if (speed < 0)
693 dst->speed_left -= rndm ();
694
695 dst->activate (); 649 dst->activate ();
696} 650}
697 651
698void 652void
699object::instantiate () 653object::instantiate ()
700{ 654{
701 if (!uuid.seq) // HACK 655 if (!uuid.seq) // HACK
702 uuid = UUID::gen (); 656 uuid = UUID::gen ();
703 657
658 // TODO: unclean state changes, should nt be done in copy_to AND instantiate
659 if (flag [FLAG_RANDOM_SPEED] && speed)
660 speed_left = - speed - rndm (); // TODO animation
661 else
704 speed_left = -0.1f; 662 speed_left = -1.;
663
705 /* copy the body_info to the body_used - this is only really 664 /* copy the body_info to the body_used - this is only really
706 * need for monsters, but doesn't hurt to do it for everything. 665 * need for monsters, but doesn't hurt to do it for everything.
707 * by doing so, when a monster is created, it has good starting 666 * by doing so, when a monster is created, it has good starting
708 * values for the body_used info, so when items are created 667 * values for the body_used info, so when items are created
709 * for it, they can be properly equipped. 668 * for it, they can be properly equipped.
… …
717object * 676object *
718object::clone () 677object::clone ()
719{ 678{
720 object *neu = create (); 679 object *neu = create ();
721 copy_to (neu); 680 copy_to (neu);
681
682 // TODO: unclean state changes, should not be done in clone AND instantiate
683 if (neu->flag [FLAG_RANDOM_SPEED] && neu->speed)
684 neu->speed_left = - neu->speed - rndm (); // TODO animation
685
722 neu->map = map; // not copied by copy_to 686 neu->map = map; // not copied by copy_to
723 return neu; 687 return neu;
724} 688}
725 689
726/* 690/*
… …
729 * be called to update the face variable, _and_ how it looks on the map. 693 * be called to update the face variable, _and_ how it looks on the map.
730 */ 694 */
731void 695void
732update_turn_face (object *op) 696update_turn_face (object *op)
733{ 697{
734 if (!QUERY_FLAG (op, FLAG_IS_TURNABLE) || !op->arch) 698 if (!op->flag [FLAG_IS_TURNABLE] || !op->arch)
735 return; 699 return;
736 700
737 SET_ANIMATION (op, op->direction); 701 SET_ANIMATION (op, op->direction);
738 update_object (op, UP_OBJ_FACE); 702 update_object (op, UP_OBJ_FACE);
739} 703}
… …
805 /* nop */; 769 /* nop */;
806 else if (action == UP_OBJ_INSERT) 770 else if (action == UP_OBJ_INSERT)
807 { 771 {
808#if 0 772#if 0
809 // this is likely overkill, TODO: revisit (schmorp) 773 // this is likely overkill, TODO: revisit (schmorp)
810 if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(m.flags_ & P_BLOCKSVIEW)) 774 if ((op->flag [FLAG_BLOCKSVIEW] && !(m.flags_ & P_BLOCKSVIEW))
811 || (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(m.flags_ & P_NO_MAGIC)) 775 || (op->flag [FLAG_NO_MAGIC] && !(m.flags_ & P_NO_MAGIC))
812 || (op->is_player () && !(m.flags_ & P_PLAYER)) 776 || (op->is_player () && !(m.flags_ & P_PLAYER))
813 || (op->type == SAFE_GROUND && !(m.flags_ & P_SAFE)) 777 || (op->type == SAFE_GROUND && !(m.flags_ & P_SAFE))
814 || (QUERY_FLAG (op, FLAG_ALIVE) && !(m.flags_ & P_IS_ALIVE)) 778 || (op->flag [FLAG_ALIVE] && !(m.flags_ & P_IS_ALIVE))
815 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC)) 779 || (op->flag [FLAG_DAMNED] && !(m.flags_ & P_NO_CLERIC))
816 || (m.move_on | op->move_on ) != m.move_on 780 || (m.move_on | op->move_on ) != m.move_on
817 || (m.move_off | op->move_off ) != m.move_off 781 || (m.move_off | op->move_off ) != m.move_off
818 || (m.move_slow | op->move_slow) != m.move_slow 782 || (m.move_slow | op->move_slow) != m.move_slow
819 /* This isn't perfect, but I don't expect a lot of objects to 783 /* This isn't perfect, but I don't expect a lot of objects to
820 * have move_allow right now. 784 * have move_allow right now.
… …
841 update_object (op->more, action); 805 update_object (op->more, action);
842} 806}
843 807
844object::object () 808object::object ()
845{ 809{
846 SET_FLAG (this, FLAG_REMOVED); 810 this->set_flag (FLAG_REMOVED);
847 811
848 //expmul = 1.0; declared const for the time being 812 //expmul = 1.0; declared const for the time being
849 face = blank_face; 813 face = blank_face;
850 material = &material_null; 814 material = MATERIAL_NULL;
851} 815}
852 816
853object::~object () 817object::~object ()
854{ 818{
855 unlink (); 819 unlink ();
856 820
857 free_key_values (this); 821 free_key_values (this);
858} 822}
859
860static int object_count;
861 823
862void object::link () 824void object::link ()
863{ 825{
864 assert (!index);//D 826 assert (!index);//D
865 uuid = UUID::gen (); 827 uuid = UUID::gen ();
866 count = ++object_count;
867 828
868 refcnt_inc (); 829 refcnt_inc ();
869 objects.insert (this); 830 objects.insert (this);
831
832 ++create_count;
833
870} 834}
871 835
872void object::unlink () 836void object::unlink ()
873{ 837{
874 if (!index) 838 if (!index)
875 return; 839 return;
840
841 ++destroy_count;
876 842
877 objects.erase (this); 843 objects.erase (this);
878 refcnt_dec (); 844 refcnt_dec ();
879} 845}
880 846
… …
985 map->insert (op, x, y); 951 map->insert (op, x, y);
986 } 952 }
987 } 953 }
988} 954}
989 955
956/*
957 * Remove and free all objects in the inventory of the given object.
958 * Unlike destroy_inv, this assumes the *this is destroyed as well
959 * well, so we can (and have to!) take shortcuts.
960 */
961void
962object::destroy_inv_fast ()
963{
964 while (object *op = inv)
965 {
966 // remove from object the fast way
967 op->flag [FLAG_REMOVED] = true;
968 op->env = 0;
969 if ((inv = inv->below))
970 inv->above = 0;
971
972 // then destroy
973 op->destroy ();
974 }
975}
976
977void
978object::freelist_free (int count)
979{
980 while (count-- && freelist)
981 {
982 freelist_item *next = freelist->next;
983 // count is being "destroyed"
984
985 sfree ((char *)freelist, sizeof (object));
986
987 freelist = next;
988 --free_count;
989 }
990}
991
992object *
990object *object::create () 993object::create ()
991{ 994{
992 object *op = new object; 995 object *op;
996
997 if (freelist)
998 {
999 freelist_item li = *freelist;
1000 memset (freelist, 0, sizeof (object));
1001
1002 op = new (freelist) object;
1003 op->count = li.count;
1004
1005 freelist = li.next;
1006 --free_count;
1007 }
1008 else
1009 {
1010 void *ni = salloc0<char> (sizeof (object));
1011
1012 op = new(ni) object;
1013
1014 op->count = ++object_count;
1015 }
1016
993 op->link (); 1017 op->link ();
1018
994 return op; 1019 return op;
995} 1020}
996 1021
1022void
1023object::do_delete ()
1024{
1025 uint32_t count = this->count;
1026
1027 this->~object ();
1028
1029 freelist_item *li = (freelist_item *)this;
1030 li->next = freelist;
1031 li->count = count;
1032
1033 freelist = li;
1034 ++free_count;
1035}
1036
997static struct freed_map : maptile 1037static struct freed_map : maptile
998{ 1038{
999 freed_map () 1039 freed_map ()
1040 : maptile (3, 3)
1000 { 1041 {
1001 path = "<freed objects map>"; 1042 path = "<freed objects map>";
1002 name = "/internal/freed_objects_map"; 1043 name = "/internal/freed_objects_map";
1003 width = 3;
1004 height = 3;
1005 no_drop = 1; 1044 no_drop = 1;
1006 no_reset = 1; 1045 no_reset = 1;
1007 1046
1008 alloc ();
1009 in_memory = MAP_ACTIVE; 1047 in_memory = MAP_ACTIVE;
1010 } 1048 }
1011 1049
1012 ~freed_map () 1050 ~freed_map ()
1013 { 1051 {
… …
1064 LOG (llevError | logBacktrace, "tried to destroy the tail of an object"); 1102 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1065 head->destroy (); 1103 head->destroy ();
1066 return; 1104 return;
1067 } 1105 }
1068 1106
1069 destroy_inv (false); 1107 destroy_inv_fast ();
1070 1108
1071 if (is_head ()) 1109 if (is_head ())
1072 if (sound_destroy) 1110 if (sound_destroy)
1073 play_sound (sound_destroy); 1111 play_sound (sound_destroy);
1074 else if (flag [FLAG_MONSTER]) 1112 else if (flag [FLAG_MONSTER])
… …
1126 1164
1127 above = 0; 1165 above = 0;
1128 below = 0; 1166 below = 0;
1129 env = 0; 1167 env = 0;
1130 1168
1131 /* NO_FIX_PLAYER is set when a great many changes are being 1169 if (pl && pl->is_player ())
1132 * made to players inventory. If set, avoiding the call
1133 * to save cpu time.
1134 */ 1170 {
1135 if (pl) 1171 if (expect_false (pl->contr->combat_ob == this))
1136 if (pl->is_player () && (glow_radius || !QUERY_FLAG (pl, FLAG_NO_FIX_PLAYER)))
1137 { 1172 {
1138 pl->update_stats (); 1173 pl->apply (pl->contr->combat_ob, AP_UNAPPLY);
1174 pl->contr->combat_ob = 0;
1175 if (pl->contr->ranged_ob) pl->apply (pl->contr->ranged_ob);
1176 }
1139 1177
1178 if (expect_false (pl->contr->ranged_ob == this))
1179 {
1180 pl->apply (pl->contr->ranged_ob, AP_UNAPPLY);
1181 pl->contr->ranged_ob = 0;
1182 if (pl->contr->combat_ob) pl->apply (pl->contr->combat_ob);
1183 }
1184
1185 pl->contr->queue_stats_update ();
1186
1140 if (glow_radius && pl->is_on_map ()) 1187 if (expect_false (glow_radius) && pl->is_on_map ())
1141 update_all_los (pl->map, pl->x, pl->y); 1188 update_all_los (pl->map, pl->x, pl->y);
1142 } 1189 }
1143 } 1190 }
1144 else if (map) 1191 else if (map)
1145 { 1192 {
1146 map->dirty = true; 1193 map->dirty = true;
1147 mapspace &ms = this->ms (); 1194 mapspace &ms = this->ms ();
… …
1165 else if (pl->container_ () == this) 1212 else if (pl->container_ () == this)
1166 { 1213 {
1167 // removing a container should close it 1214 // removing a container should close it
1168 close_container (); 1215 close_container ();
1169 } 1216 }
1170 1217 else
1171 esrv_del_item (pl->contr, count); 1218 esrv_del_item (pl->contr, count);
1172 } 1219 }
1173 1220
1174 /* link the object above us */ 1221 /* link the object above us */
1175 // re-link, make sure compiler can easily use cmove 1222 // re-link, make sure compiler can easily use cmove
1176 *(above ? &above->below : &ms.top) = below; 1223 *(above ? &above->below : &ms.top) = below;
… …
1267 1314
1268 object *prev = this; 1315 object *prev = this;
1269 1316
1270 for (archetype *at = (archetype *)arch->more; at; at = (archetype *)at->more) 1317 for (archetype *at = (archetype *)arch->more; at; at = (archetype *)at->more)
1271 { 1318 {
1272 object *op = arch_to_object (at); 1319 object *op = at->instance ();
1273 1320
1274 op->name = name; 1321 op->name = name;
1275 op->name_pl = name_pl; 1322 op->name_pl = name_pl;
1276 op->title = title; 1323 op->title = title;
1277 1324
… …
1315 * Passing 0 for flag gives proper default values, so flag really only needs 1362 * Passing 0 for flag gives proper default values, so flag really only needs
1316 * to be set if special handling is needed. 1363 * to be set if special handling is needed.
1317 * 1364 *
1318 * Return value: 1365 * Return value:
1319 * new object if 'op' was merged with other object 1366 * new object if 'op' was merged with other object
1320 * NULL if 'op' was destroyed 1367 * NULL if there was an error (destroyed, blocked etc.)
1321 * just 'op' otherwise 1368 * just 'op' otherwise
1322 */ 1369 */
1323object * 1370object *
1324insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1371insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1325{ 1372{
… …
1362 // from here :/ 1409 // from here :/
1363 op->nrof += tmp->nrof; 1410 op->nrof += tmp->nrof;
1364 tmp->destroy (); 1411 tmp->destroy ();
1365 } 1412 }
1366 1413
1367 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ 1414 op->clr_flag (FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1368 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1415 op->clr_flag (FLAG_INV_LOCKED);
1369 1416
1370 if (!QUERY_FLAG (op, FLAG_ALIVE)) 1417 if (!op->flag [FLAG_ALIVE])
1371 CLEAR_FLAG (op, FLAG_NO_STEAL); 1418 op->clr_flag (FLAG_NO_STEAL);
1372 1419
1373 if (flag & INS_BELOW_ORIGINATOR) 1420 if (flag & INS_BELOW_ORIGINATOR)
1374 { 1421 {
1375 if (originator->map != op->map || originator->x != op->x || originator->y != op->y) 1422 if (originator->map != op->map || originator->x != op->x || originator->y != op->y)
1376 { 1423 {
… …
1411 * when lots of spells are cast in one area. Currently, it is presumed 1458 * when lots of spells are cast in one area. Currently, it is presumed
1412 * that flying non pickable objects are spell objects. 1459 * that flying non pickable objects are spell objects.
1413 */ 1460 */
1414 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1461 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1415 { 1462 {
1416 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || QUERY_FLAG (tmp, FLAG_OVERLAY_FLOOR)) 1463 if (tmp->flag [FLAG_IS_FLOOR] || tmp->flag [FLAG_OVERLAY_FLOOR])
1417 floor = tmp; 1464 floor = tmp;
1418 1465
1419 if (QUERY_FLAG (tmp, FLAG_NO_PICK) && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1466 if (tmp->flag [FLAG_NO_PICK] && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !tmp->flag [FLAG_IS_FLOOR])
1420 { 1467 {
1421 /* We insert above top, so we want this object below this */ 1468 /* We insert above top, so we want this object below this */
1422 top = tmp->below; 1469 top = tmp->below;
1423 break; 1470 break;
1424 } 1471 }
… …
1442 && (op->face && !faces [op->face].visibility)) 1489 && (op->face && !faces [op->face].visibility))
1443 { 1490 {
1444 object *last; 1491 object *last;
1445 1492
1446 for (last = top; last != floor; last = last->below) 1493 for (last = top; last != floor; last = last->below)
1447 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT)) 1494 if (last->flag [FLAG_BLOCKSVIEW] && (last->type != EXIT))
1448 break; 1495 break;
1449 1496
1450 /* Check to see if we found the object that blocks view, 1497 /* Check to see if we found the object that blocks view,
1451 * and make sure we have a below pointer for it so that 1498 * and make sure we have a below pointer for it so that
1452 * we can get inserted below this one, which requires we 1499 * we can get inserted below this one, which requires we
… …
1552 1599
1553 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above) 1600 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1554 if (tmp->arch->archname == archname) /* same archetype */ 1601 if (tmp->arch->archname == archname) /* same archetype */
1555 tmp->destroy (); 1602 tmp->destroy ();
1556 1603
1557 object *tmp = arch_to_object (archetype::find (archname)); 1604 object *tmp = archetype::find (archname)->instance ();
1558 1605
1559 tmp->x = op->x; 1606 tmp->x = op->x;
1560 tmp->y = op->y; 1607 tmp->y = op->y;
1561 1608
1562 insert_ob_in_map (tmp, op->map, op, 0); 1609 insert_ob_in_map (tmp, op->map, op, 0);
… …
1583 || (items < m->max_items 1630 || (items < m->max_items
1584 && ms.volume () < m->max_volume)) 1631 && ms.volume () < m->max_volume))
1585 return true; 1632 return true;
1586 1633
1587 if (originator && originator->is_player ()) 1634 if (originator && originator->is_player ())
1588 originator->contr->failmsg (format ( 1635 originator->contr->failmsgf (
1589 "No matter how hard you try, you just cannot put the %s here H<Try to remove some items from the floor first.>", 1636 "No matter how hard you try, you just cannot put the %s here H<Try to remove some items from the floor first.>",
1590 query_name () 1637 query_name ()
1591 )); 1638 );
1592 1639
1593 return false; 1640 return false;
1594} 1641}
1595 1642
1596/* 1643/*
… …
1738 if (op->glow_radius && is_on_map ()) 1785 if (op->glow_radius && is_on_map ())
1739 { 1786 {
1740 update_stats (); 1787 update_stats ();
1741 update_all_los (map, x, y); 1788 update_all_los (map, x, y);
1742 } 1789 }
1743 else if (is_player () && !flag [FLAG_NO_FIX_PLAYER]) 1790 else if (is_player ())
1744 // if this is a player's inventory, update stats 1791 // if this is a player's inventory, update stats
1745 update_stats (); 1792 contr->queue_stats_update ();
1746 1793
1747 INVOKE_OBJECT (INSERT, this); 1794 INVOKE_OBJECT (INSERT, this);
1748 1795
1749 return op; 1796 return op;
1750} 1797}
… …
1770 * on top. 1817 * on top.
1771 */ 1818 */
1772int 1819int
1773check_move_on (object *op, object *originator) 1820check_move_on (object *op, object *originator)
1774{ 1821{
1775 if (QUERY_FLAG (op, FLAG_NO_APPLY)) 1822 if (op->flag [FLAG_NO_APPLY])
1776 return 0; 1823 return 0;
1777 1824
1778 object *tmp; 1825 object *tmp;
1779 maptile *m = op->map; 1826 maptile *m = op->map;
1780 int x = op->x, y = op->y; 1827 int x = op->x, y = op->y;
… …
1817 * Second check makes sure that the movement types not being slowed 1864 * Second check makes sure that the movement types not being slowed
1818 * (~slow_move) is not blocked on this space - just because the 1865 * (~slow_move) is not blocked on this space - just because the
1819 * space doesn't slow down swimming (for example), if you can't actually 1866 * space doesn't slow down swimming (for example), if you can't actually
1820 * swim on that space, can't use it to avoid the penalty. 1867 * swim on that space, can't use it to avoid the penalty.
1821 */ 1868 */
1822 if (!QUERY_FLAG (op, FLAG_WIZPASS)) 1869 if (!op->flag [FLAG_WIZPASS])
1823 { 1870 {
1824 if ((!op->move_type && tmp->move_slow & MOVE_WALK) || 1871 if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
1825 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0)) 1872 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
1826 { 1873 {
1827 float diff = tmp->move_slow_penalty * fabs (op->speed); 1874 float diff = tmp->move_slow_penalty * fabs (op->speed);
… …
1958void 2005void
1959flag_inv (object *op, int flag) 2006flag_inv (object *op, int flag)
1960{ 2007{
1961 for (object *tmp = op->inv; tmp; tmp = tmp->below) 2008 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1962 { 2009 {
1963 SET_FLAG (tmp, flag); 2010 tmp->set_flag (flag);
1964 flag_inv (tmp, flag); 2011 flag_inv (tmp, flag);
1965 } 2012 }
1966} 2013}
1967 2014
1968/* 2015/*
… …
1971void 2018void
1972unflag_inv (object *op, int flag) 2019unflag_inv (object *op, int flag)
1973{ 2020{
1974 for (object *tmp = op->inv; tmp; tmp = tmp->below) 2021 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1975 { 2022 {
1976 CLEAR_FLAG (tmp, flag); 2023 tmp->clr_flag (flag);
1977 unflag_inv (tmp, flag); 2024 unflag_inv (tmp, flag);
1978 } 2025 }
1979} 2026}
1980 2027
1981/* 2028/*
… …
2171{ 2218{
2172 return (ob1->x - ob2->x) * (ob1->x - ob2->x) + (ob1->y - ob2->y) * (ob1->y - ob2->y); 2219 return (ob1->x - ob2->x) * (ob1->x - ob2->x) + (ob1->y - ob2->y) * (ob1->y - ob2->y);
2173} 2220}
2174 2221
2175/* 2222/*
2176 * find_dir_2(delta-x,delta-y) will return a direction in which 2223 * find_dir_2(delta-x,delta-y) will return a direction value
2177 * an object which has subtracted the x and y coordinates of another 2224 * for running into direct [dx, dy].
2178 * object, needs to travel toward it. 2225 * (the opposite of crossfire's find_dir_2!)
2179 */ 2226 */
2180int 2227int
2181find_dir_2 (int x, int y) 2228find_dir_2 (int x, int y)
2182{ 2229{
2230#if 1 // new algorithm
2231 // this works by putting x, y into 16 sectors, which
2232 // are not equal sized, but are a better approximation
2233 // then the old algorithm, and then using a mapping
2234 // table to map it into a direction value.
2235 // basically, it maps these comparisons to each bit
2236 // bit #3: x < 0
2237 // bit #2: y < 0
2238 // bit #1: x > y
2239 // bit #0: x > 2y
2240
2241 static const uint8 dir[16] = {
2242 4, 5, 4, 3,
2243 2, 1, 2, 3,
2244 6, 5, 6, 7,
2245 8, 1, 8, 7,
2246 };
2247 int sector = 0;
2248
2249 // this is a bit ugly, but more likely to result in branchless code
2250 sector |= x < 0 ? 8 : 0;
2251 x = x < 0 ? -x : x; // abs
2252
2253 sector |= y < 0 ? 4 : 0;
2254 y = y < 0 ? -y : y; // abs
2255
2256 if (x > y)
2257 {
2258 sector |= 2;
2259
2260 if (x > y * 2)
2261 sector |= 1;
2262 }
2263 else
2264 {
2265 if (y > x * 2)
2266 sector |= 1;
2267 else if (!y)
2268 return 0; // x == 0 here
2269 }
2270
2271 return dir [sector];
2272#else // old algorithm
2183 int q; 2273 int q;
2184 2274
2185 if (y) 2275 if (y)
2186 q = x * 100 / y; 2276 q = 128 * x / y;
2187 else if (x) 2277 else if (x)
2188 q = -300 * x; 2278 q = -512 * x; // to make it > 309
2189 else 2279 else
2190 return 0; 2280 return 0;
2191 2281
2192 if (y > 0) 2282 if (y > 0)
2193 { 2283 {
2194 if (q < -242) 2284 if (q < -309) return 7;
2285 if (q < -52) return 6;
2286 if (q < 52) return 5;
2287 if (q < 309) return 4;
2288
2195 return 3; 2289 return 3;
2196 if (q < -41) 2290 }
2197 return 2; 2291 else
2198 if (q < 41) 2292 {
2199 return 1; 2293 if (q < -309) return 3;
2200 if (q < 242) 2294 if (q < -52) return 2;
2201 return 8; 2295 if (q < 52) return 1;
2296 if (q < 309) return 8;
2297
2202 return 7; 2298 return 7;
2203 } 2299 }
2204 2300#endif
2205 if (q < -242)
2206 return 7;
2207 if (q < -41)
2208 return 6;
2209 if (q < 41)
2210 return 5;
2211 if (q < 242)
2212 return 4;
2213
2214 return 3;
2215} 2301}
2216 2302
2217/* 2303/*
2218 * dirdiff(dir1, dir2) returns how many 45-degrees differences there is 2304 * dirdiff(dir1, dir2) returns how many 45-degrees differences there is
2219 * between two directions (which are expected to be absolute (see absdir()) 2305 * between two directions (which are expected to be absolute (see absdir())
2220 */ 2306 */
2221int 2307int
2222dirdiff (int dir1, int dir2) 2308dirdiff (int dir1, int dir2)
2223{ 2309{
2224 int d;
2225
2226 d = abs (dir1 - dir2); 2310 int d = abs (dir1 - dir2);
2227 if (d > 4)
2228 d = 8 - d;
2229 2311
2230 return d; 2312 return d > 4 ? 8 - d : d;
2231} 2313}
2232 2314
2233/* peterm: 2315/* peterm:
2234 * do LOS stuff for ball lightning. Go after the closest VISIBLE monster. 2316 * do LOS stuff for ball lightning. Go after the closest VISIBLE monster.
2235 * Basically, this is a table of directions, and what directions 2317 * Basically, this is a table of directions, and what directions
… …
2341 * Add a check so we can't pick up invisible objects (0.93.8) 2423 * Add a check so we can't pick up invisible objects (0.93.8)
2342 */ 2424 */
2343int 2425int
2344can_pick (const object *who, const object *item) 2426can_pick (const object *who, const object *item)
2345{ 2427{
2346 return /*QUERY_FLAG(who,FLAG_WIZ)|| */ 2428 return /*who->flag [FLAG_WIZ]|| */
2347 (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) && 2429 (item->weight > 0 && !item->flag [FLAG_NO_PICK] &&
2348 !QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->is_player () || item->weight < who->weight / 3)); 2430 !item->flag [FLAG_ALIVE] && !item->invisible && (who->is_player () || item->weight < who->weight / 3));
2349} 2431}
2350 2432
2351/* 2433/*
2352 * create clone from object to another 2434 * create clone from object to another
2353 */ 2435 */
… …
2561 // TODO: this does not seem to serve any purpose anymore? 2643 // TODO: this does not seem to serve any purpose anymore?
2562#if 0 2644#if 0
2563 // insert the "Close Container" object. 2645 // insert the "Close Container" object.
2564 if (archetype *closer = new_container->other_arch) 2646 if (archetype *closer = new_container->other_arch)
2565 { 2647 {
2566 object *closer = arch_to_object (new_container->other_arch); 2648 object *closer = new_container->other_arch->instance ();
2567 closer->flag [FLAG_NO_MAP_SAVE] = 1; 2649 closer->flag [FLAG_NO_MAP_SAVE] = 1;
2568 new_container->insert (closer); 2650 new_container->insert (closer);
2569 } 2651 }
2570#endif 2652#endif
2571 2653
… …
2677 2759
2678 insert (force); 2760 insert (force);
2679 } 2761 }
2680} 2762}
2681 2763
2764void object::change_move_type (MoveType mt)
2765{
2766 if (move_type == mt)
2767 return;
2768
2769 if (is_on_map ())
2770 {
2771 // we are on the map, so handle move_on/off effects
2772 remove ();
2773 move_type = mt;
2774 map->insert (this, x, y, this);
2775 }
2776 else
2777 move_type = mt;
2778}
2779
2780/* object should be a player.
2781 * we return the object the player has marked with the 'mark' command
2782 * below. If no match is found (or object has changed), we return
2783 * NULL. We leave it up to the calling function to print messages if
2784 * nothing is found.
2785 */
2786object *
2787object::mark () const
2788{
2789 if (contr && contr->mark && contr->mark->env == this)
2790 return contr->mark;
2791 else
2792 return 0;
2793}
2794

Diff Legend

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