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.295 by root, Fri Nov 6 13:03:34 2009 UTC vs.
Revision 1.322 by root, Sun Apr 11 00:34:05 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;
… …
77 CALL_CALL ("cf::write_uuid", G_DISCARD); 76 CALL_CALL ("cf::write_uuid", G_DISCARD);
78 CALL_END; 77 CALL_END;
79} 78}
80 79
81static void 80static void
82read_uuid (void) 81read_uuid ()
83{ 82{
84 char filename[MAX_BUF]; 83 char filename[MAX_BUF];
85 84
86 sprintf (filename, "%s/uuid", settings.localdir); 85 sprintf (filename, "%s/uuid", settings.localdir);
87 86
… …
101 100
102 LOG (llevError, "FATAL: cannot open %s for reading!\n", filename); 101 LOG (llevError, "FATAL: cannot open %s for reading!\n", filename);
103 _exit (1); 102 _exit (1);
104 } 103 }
105 104
106 UUID::BUF buf; 105 char buf [UUID::MAX_LEN];
107 buf[0] = 0; 106 buf[0] = 0;
108 fgets (buf, sizeof (buf), fp); 107 fgets (buf, sizeof (buf), fp);
109 108
110 if (!UUID::cur.parse (buf)) 109 if (!UUID::cur.parse (buf))
111 { 110 {
… …
138 137
139void 138void
140UUID::init () 139UUID::init ()
141{ 140{
142 read_uuid (); 141 read_uuid ();
142}
143
144bool
145UUID::parse (const char *s)
146{
147 if (*s++ != '<' || *s++ != '1' || *s++ != '.')
148 return false;
149
150 seq = 0;
151
152 while (*s != '>')
153 {
154 if (*s < '0')
155 return false;
156
157 // this gives nice branchless code with gcc
158 assert ('0' < 'a' && '0' == 48 && 'a' == 97);
159 int digit = (*s + (*s & 0x40 ? 9 : 0)) & 15;
160
161 seq = (seq << 4) | digit;
162
163 ++s;
164 }
165
166 return true;
167}
168
169char *
170UUID::append (char *buf) const
171{
172 *buf++ = '<';
173 *buf++ = '1';
174 *buf++ = '.';
175
176 uint64_t seq = this->seq;
177 const int bits = 64;
178 char nz = 0;
179 static const char tohex [] = "0123456789abcdef";
180
181 // assert (len >= 3 + bits / 4 + 1 + 1);
182 for (int i = bits / 4; --i; )
183 {
184 uint8_t digit = seq >> (bits - 4);
185
186 *buf = tohex [digit];
187 nz |= digit;
188 buf += nz ? 1 : 0;
189 seq <<= 4;
190 }
191
192 // last digit is special - always emit
193 uint8_t digit = seq >> (bits - 4);
194 *buf++ = tohex [digit];
195
196 *buf++ = '>';
197
198 return buf;
199}
200
201char *
202UUID::c_str () const
203{
204 static char buf [MAX_LEN];
205 *append (buf) = 0;
206 return buf;
143} 207}
144 208
145/* Returns TRUE if every key_values in wants has a partner with the same value in has. */ 209/* Returns TRUE if every key_values in wants has a partner with the same value in has. */
146static bool 210static bool
147compare_ob_value_lists_one (const object *wants, const object *has) 211compare_ob_value_lists_one (const object *wants, const object *has)
… …
183 * Improvements made with merge: Better checking on potion, and also 247 * Improvements made with merge: Better checking on potion, and also
184 * check weight 248 * check weight
185 */ 249 */
186bool object::can_merge_slow (object *ob1, object *ob2) 250bool object::can_merge_slow (object *ob1, object *ob2)
187{ 251{
188 /* A couple quicksanity checks */ 252 /* A couple quick sanity checks */
189 if (ob1 == ob2 253 if (ob1 == ob2
190 || ob1->type != ob2->type 254 || ob1->type != ob2->type
191 || ob1->speed != ob2->speed
192 || ob1->value != ob2->value 255 || ob1->value != ob2->value
193 || ob1->name != ob2->name) 256 || ob1->name != ob2->name
257 || fabs (ob1->speed - ob2->speed) >= MIN_ACTIVE_SPEED)
194 return 0; 258 return 0;
195 259
196 /* Do not merge objects if nrof would overflow, assume nrof 260 /* Do not merge objects if nrof would overflow, assume nrof
197 * is always 0 .. 2**31-1 */ 261 * is always 0 .. 2**31-1 */
198 if (ob1->nrof > 0x7fffffff - ob2->nrof) 262 if (ob1->nrof > 0x7fffffff - ob2->nrof)
… …
202 * This is to the comparison of the flags below will be OK. We 266 * This is to the comparison of the flags below will be OK. We
203 * just can't ignore the been applied or identified flags, as they 267 * just can't ignore the been applied or identified flags, as they
204 * are not equal - just if it has been identified, the been_applied 268 * are not equal - just if it has been identified, the been_applied
205 * flags lose any meaning. 269 * flags lose any meaning.
206 */ 270 */
207 if (QUERY_FLAG (ob1, FLAG_IDENTIFIED)) 271 if (ob1->flag [FLAG_IDENTIFIED])
208 SET_FLAG (ob1, FLAG_BEEN_APPLIED); 272 ob1->set_flag (FLAG_BEEN_APPLIED);
209 273
210 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED)) 274 if (ob2->flag [FLAG_IDENTIFIED])
211 SET_FLAG (ob2, FLAG_BEEN_APPLIED); 275 ob2->set_flag (FLAG_BEEN_APPLIED);
212 276
213 if (ob1->arch->archname != ob2->arch->archname 277 if (ob1->arch->archname != ob2->arch->archname
214 || ob1->name != ob2->name 278 || ob1->name != ob2->name
215 || ob1->title != ob2->title 279 || ob1->title != ob2->title
216 || ob1->msg != ob2->msg 280 || ob1->msg != ob2->msg
… …
219 || ob1->magic != ob2->magic 283 || ob1->magic != ob2->magic
220 || ob1->slaying != ob2->slaying 284 || ob1->slaying != ob2->slaying
221 || ob1->skill != ob2->skill 285 || ob1->skill != ob2->skill
222 || ob1->value != ob2->value 286 || ob1->value != ob2->value
223 || ob1->animation_id != ob2->animation_id 287 || ob1->animation_id != ob2->animation_id
224 || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependent on each other 288 || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependend on each other
225 || ob1->client_type != ob2->client_type 289 || ob1->client_type != ob2->client_type
226 || ob1->materialname != ob2->materialname 290 || ob1->material != ob2->material
227 || ob1->lore != ob2->lore 291 || ob1->lore != ob2->lore
228 || ob1->subtype != ob2->subtype 292 || ob1->subtype != ob2->subtype
229 || ob1->move_type != ob2->move_type 293 || ob1->move_type != ob2->move_type
230 || ob1->move_block != ob2->move_block 294 || ob1->move_block != ob2->move_block
231 || ob1->move_allow != ob2->move_allow 295 || ob1->move_allow != ob2->move_allow
232 || ob1->move_on != ob2->move_on 296 || ob1->move_on != ob2->move_on
233 || ob1->move_off != ob2->move_off 297 || ob1->move_off != ob2->move_off
234 || ob1->move_slow != ob2->move_slow 298 || ob1->move_slow != ob2->move_slow
235 || ob1->move_slow_penalty != ob2->move_slow_penalty 299 || fabs (ob1->move_slow_penalty - ob2->move_slow_penalty) >= (1.f / 1024.f)
236 || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist)) 300 || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist))
237 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats))) 301 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats)))
238 return 0; 302 return 0;
239 303
240 if ((ob1->flag ^ ob2->flag) 304 if ((ob1->flag ^ ob2->flag)
… …
265 329
266 /* Don't merge objects that are applied. With the new 'body' code, 330 /* Don't merge objects that are applied. With the new 'body' code,
267 * it is possible for most any character to have more than one of 331 * it is possible for most any character to have more than one of
268 * some items equipped, and we don't want those to merge. 332 * some items equipped, and we don't want those to merge.
269 */ 333 */
270 if (QUERY_FLAG (ob1, FLAG_APPLIED) || QUERY_FLAG (ob2, FLAG_APPLIED)) 334 if (ob1->flag [FLAG_APPLIED] || ob2->flag [FLAG_APPLIED])
271 return 0; 335 return 0;
272 336
273 /* Note sure why the following is the case - either the object has to 337 /* Note sure why the following is the case - either the object has to
274 * be animated or have a very low speed. Is this an attempted monster 338 * be animated or have a very low speed. Is this an attempted monster
275 * check? 339 * check?
276 */ 340 */
277 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && ob1->has_active_speed ()) 341 if (!ob1->flag [FLAG_ANIMATE] && ob1->has_active_speed ())
278 return 0; 342 return 0;
279 343
280 switch (ob1->type) 344 switch (ob1->type)
281 { 345 {
282 case SCROLL: 346 case SCROLL:
… …
442{ 506{
443 return dump_object (this); 507 return dump_object (this);
444} 508}
445 509
446/* 510/*
447 * get_nearest_part(multi-object, object 2) returns the part of the
448 * multi-object 1 which is closest to the second object.
449 * If it's not a multi-object, it is returned.
450 */
451static object *
452get_nearest_part (object *op, const object *pl)
453{
454 object *tmp, *closest;
455 int last_dist, i;
456
457 if (!op->more)
458 return op;
459
460 for (last_dist = distance (op, pl), closest = op, tmp = op->more;
461 tmp;
462 tmp = tmp->more)
463 if ((i = distance (tmp, pl)) < last_dist)
464 closest = tmp, last_dist = i;
465
466 return closest;
467}
468
469/*
470 * Returns the object which has the count-variable equal to the argument. 511 * Returns the object which has the count-variable equal to the argument.
471 * VERRRY slow. 512 * VERRRY slow.
472 */ 513 */
473object * 514object *
474find_object (tag_t i) 515find_object (tag_t i)
475{ 516{
476 for_all_objects (op) 517 for_all_objects (op)
477 if (op->count == i) 518 if (op->count == i)
519 return op;
520
521 return 0;
522}
523
524/*
525 * Returns the object which has the uuid equal to the argument.
526 * MOAR VERRRY slow.
527 */
528
529object *
530find_object_uuid (UUID i)
531{
532 for_all_objects (op)
533 if (op->uuid == i)
478 return op; 534 return op;
479 535
480 return 0; 536 return 0;
481} 537}
482 538
… …
516 LOG (llevError | logBacktrace, "tried to set owner of %s to %s\n", debug_desc (), owner->debug_desc ()); 572 LOG (llevError | logBacktrace, "tried to set owner of %s to %s\n", debug_desc (), owner->debug_desc ());
517 return; 573 return;
518 } 574 }
519 575
520 this->owner = owner; 576 this->owner = owner;
521}
522
523int
524object::slottype () const
525{
526 if (type == SKILL)
527 {
528 if (IS_COMBAT_SKILL (subtype)) return slot_combat;
529 if (IS_RANGED_SKILL (subtype)) return slot_ranged;
530 }
531 else
532 {
533 if (slot [body_combat].info) return slot_combat;
534 if (slot [body_range ].info) return slot_ranged;
535 }
536
537 return slot_none;
538}
539
540bool
541object::change_weapon (object *ob)
542{
543 if (current_weapon == ob)
544 return true;
545
546 if (chosen_skill)
547 chosen_skill->flag [FLAG_APPLIED] = false;
548
549 current_weapon = ob;
550 chosen_skill = !ob || ob->type == SKILL ? ob : find_skill_by_name (this, ob->skill);
551
552 if (chosen_skill)
553 chosen_skill->flag [FLAG_APPLIED] = true;
554
555 update_stats ();
556
557 if (ob)
558 {
559 // now check wether any body locations became invalid, in which case
560 // we cannot apply the weapon at the moment.
561 for (int i = 0; i < NUM_BODY_LOCATIONS; ++i)
562 if (slot[i].used < 0)
563 {
564 current_weapon = chosen_skill = 0;
565 update_stats ();
566
567 new_draw_info_format (NDI_UNIQUE, 0, this,
568 "You try to balance all your items at once, "
569 "but the %s is just too much for your body. "
570 "[You need to unapply some items first - use the 'body' command to see "
571 "how many items you cna wera on a specific body part.]", &ob->name);
572 return false;
573 }
574
575 //new_draw_info_format (NDI_UNIQUE, 0, this, "You switch to your %s.", &ob->name);
576 }
577 else
578 ;//new_draw_info_format (NDI_UNIQUE, 0, this, "You unwield your weapons.");
579
580 if (ob && !ob->flag [FLAG_APPLIED] && ob->type != SPELL)
581 {
582 LOG (llevError | logBacktrace, "%s changed to unapplied weapon %s",
583 &name, ob->debug_desc ());
584 return false;
585 }
586
587 return true;
588} 577}
589 578
590/* Zero the key_values on op, decrementing the shared-string 579/* Zero the key_values on op, decrementing the shared-string
591 * refcounts and freeing the links. 580 * refcounts and freeing the links.
592 */ 581 */
… …
645 tail = new_link; 634 tail = new_link;
646 } 635 }
647 } 636 }
648 } 637 }
649 638
650 if (speed < 0)
651 dst->speed_left -= rndm ();
652
653 dst->activate (); 639 dst->activate ();
654} 640}
655 641
656void 642void
657object::instantiate () 643object::instantiate ()
658{ 644{
659 if (!uuid.seq) // HACK 645 if (!uuid.seq) // HACK
660 uuid = UUID::gen (); 646 uuid = UUID::gen ();
661 647
648 // TODO: unclean state changes, should nt be done in copy_to AND instantiate
649 if (flag [FLAG_RANDOM_SPEED] && speed)
650 speed_left = - speed - rndm (); // TODO animation
651 else
662 speed_left = -0.1f; 652 speed_left = -1.;
653
663 /* copy the body_info to the body_used - this is only really 654 /* copy the body_info to the body_used - this is only really
664 * need for monsters, but doesn't hurt to do it for everything. 655 * need for monsters, but doesn't hurt to do it for everything.
665 * by doing so, when a monster is created, it has good starting 656 * by doing so, when a monster is created, it has good starting
666 * values for the body_used info, so when items are created 657 * values for the body_used info, so when items are created
667 * for it, they can be properly equipped. 658 * for it, they can be properly equipped.
… …
675object * 666object *
676object::clone () 667object::clone ()
677{ 668{
678 object *neu = create (); 669 object *neu = create ();
679 copy_to (neu); 670 copy_to (neu);
671
672 // TODO: unclean state changes, should not be done in clone AND instantiate
673 if (neu->flag [FLAG_RANDOM_SPEED] && neu->speed)
674 neu->speed_left = - neu->speed - rndm (); // TODO animation
675
680 neu->map = map; // not copied by copy_to 676 neu->map = map; // not copied by copy_to
681 return neu; 677 return neu;
682} 678}
683 679
684/* 680/*
… …
687 * be called to update the face variable, _and_ how it looks on the map. 683 * be called to update the face variable, _and_ how it looks on the map.
688 */ 684 */
689void 685void
690update_turn_face (object *op) 686update_turn_face (object *op)
691{ 687{
692 if (!QUERY_FLAG (op, FLAG_IS_TURNABLE) || !op->arch) 688 if (!op->flag [FLAG_IS_TURNABLE] || !op->arch)
693 return; 689 return;
694 690
695 SET_ANIMATION (op, op->direction); 691 SET_ANIMATION (op, op->direction);
696 update_object (op, UP_OBJ_FACE); 692 update_object (op, UP_OBJ_FACE);
697} 693}
… …
702 * This function needs to be called whenever the speed of an object changes. 698 * This function needs to be called whenever the speed of an object changes.
703 */ 699 */
704void 700void
705object::set_speed (float speed) 701object::set_speed (float speed)
706{ 702{
707 if (flag [FLAG_FREED] && speed)
708 {
709 LOG (llevError, "Object %s is freed but has speed.\n", &name);
710 speed = 0;
711 }
712
713 this->speed = speed; 703 this->speed = speed;
714 704
715 if (has_active_speed ()) 705 if (has_active_speed ())
716 activate (); 706 activate ();
717 else 707 else
… …
767 757
768 if (!(m.flags_ & P_UPTODATE)) 758 if (!(m.flags_ & P_UPTODATE))
769 /* nop */; 759 /* nop */;
770 else if (action == UP_OBJ_INSERT) 760 else if (action == UP_OBJ_INSERT)
771 { 761 {
762#if 0
772 // this is likely overkill, TODO: revisit (schmorp) 763 // this is likely overkill, TODO: revisit (schmorp)
773 if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(m.flags_ & P_BLOCKSVIEW)) 764 if ((op->flag [FLAG_BLOCKSVIEW] && !(m.flags_ & P_BLOCKSVIEW))
774 || (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(m.flags_ & P_NO_MAGIC)) 765 || (op->flag [FLAG_NO_MAGIC] && !(m.flags_ & P_NO_MAGIC))
775 || (op->is_player () && !(m.flags_ & P_PLAYER)) 766 || (op->is_player () && !(m.flags_ & P_PLAYER))
776 || (op->type == SAFE_GROUND && !(m.flags_ & P_SAFE)) 767 || (op->type == SAFE_GROUND && !(m.flags_ & P_SAFE))
777 || (QUERY_FLAG (op, FLAG_ALIVE) && !(m.flags_ & P_IS_ALIVE)) 768 || (op->flag [FLAG_ALIVE] && !(m.flags_ & P_IS_ALIVE))
778 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC)) 769 || (op->flag [FLAG_DAMNED] && !(m.flags_ & P_NO_CLERIC))
779 || (m.move_on | op->move_on ) != m.move_on 770 || (m.move_on | op->move_on ) != m.move_on
780 || (m.move_off | op->move_off ) != m.move_off 771 || (m.move_off | op->move_off ) != m.move_off
781 || (m.move_slow | op->move_slow) != m.move_slow 772 || (m.move_slow | op->move_slow) != m.move_slow
782 /* This isn't perfect, but I don't expect a lot of objects to 773 /* This isn't perfect, but I don't expect a lot of objects to
783 * have move_allow right now. 774 * have move_allow right now.
784 */ 775 */
785 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block 776 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block
786 || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp)
787 m.invalidate (); 777 m.invalidate ();
778#else
779 // the above is not strong enough a test to skip updating. los maybe? TODO (schmorp)
780 m.invalidate ();
781#endif
788 } 782 }
789 /* if the object is being removed, we can't make intelligent 783 /* if the object is being removed, we can't make intelligent
790 * decisions, because remove_ob can't really pass the object 784 * decisions, because remove_ob can't really pass the object
791 * that is being removed. 785 * that is being removed.
792 */ 786 */
… …
801 update_object (op->more, action); 795 update_object (op->more, action);
802} 796}
803 797
804object::object () 798object::object ()
805{ 799{
806 SET_FLAG (this, FLAG_REMOVED); 800 this->set_flag (FLAG_REMOVED);
807 801
808 //expmul = 1.0; declared const for the time being 802 //expmul = 1.0; declared const for the time being
809 face = blank_face; 803 face = blank_face;
804 material = MATERIAL_NULL;
810} 805}
811 806
812object::~object () 807object::~object ()
813{ 808{
814 unlink (); 809 unlink ();
… …
944 map->insert (op, x, y); 939 map->insert (op, x, y);
945 } 940 }
946 } 941 }
947} 942}
948 943
944/*
945 * Remove and free all objects in the inventory of the given object.
946 * Unlike destroy_inv, this assumes the *this is destroyed as well
947 * well, so we can (and have to!) take shortcuts.
948 */
949void
950object::destroy_inv_fast ()
951{
952 while (object *op = inv)
953 {
954 // remove from object the fast way
955 op->flag [FLAG_REMOVED] = true;
956 op->env = 0;
957 if ((inv = inv->below))
958 inv->above = 0;
959
960 // then destroy
961 op->destroy ();
962 }
963}
964
949object *object::create () 965object *object::create ()
950{ 966{
951 object *op = new object; 967 object *op = new object;
952 op->link (); 968 op->link ();
953 return op; 969 return op;
… …
1023 LOG (llevError | logBacktrace, "tried to destroy the tail of an object"); 1039 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1024 head->destroy (); 1040 head->destroy ();
1025 return; 1041 return;
1026 } 1042 }
1027 1043
1028 destroy_inv (false); 1044 destroy_inv_fast ();
1029 1045
1030 if (is_head ()) 1046 if (is_head ())
1031 if (sound_destroy) 1047 if (sound_destroy)
1032 play_sound (sound_destroy); 1048 play_sound (sound_destroy);
1033 else if (flag [FLAG_MONSTER]) 1049 else if (flag [FLAG_MONSTER])
… …
1085 1101
1086 above = 0; 1102 above = 0;
1087 below = 0; 1103 below = 0;
1088 env = 0; 1104 env = 0;
1089 1105
1090 /* NO_FIX_PLAYER is set when a great many changes are being 1106 if (pl && pl->is_player ())
1091 * made to players inventory. If set, avoiding the call
1092 * to save cpu time.
1093 */ 1107 {
1094 if (pl) 1108 if (expect_false (pl->contr->combat_ob == this))
1095 if (pl->is_player () && (glow_radius || !QUERY_FLAG (pl, FLAG_NO_FIX_PLAYER)))
1096 { 1109 {
1097 pl->update_stats (); 1110 pl->apply (pl->contr->combat_ob, AP_UNAPPLY);
1111 pl->contr->combat_ob = 0;
1112 if (pl->contr->ranged_ob) pl->apply (pl->contr->ranged_ob);
1113 }
1098 1114
1115 if (expect_false (pl->contr->ranged_ob == this))
1116 {
1117 pl->apply (pl->contr->ranged_ob, AP_UNAPPLY);
1118 pl->contr->ranged_ob = 0;
1119 if (pl->contr->combat_ob) pl->apply (pl->contr->combat_ob);
1120 }
1121
1122 pl->contr->queue_stats_update ();
1123
1099 if (glow_radius && pl->is_on_map ()) 1124 if (expect_false (glow_radius) && pl->is_on_map ())
1100 update_all_los (pl->map, pl->x, pl->y); 1125 update_all_los (pl->map, pl->x, pl->y);
1101 } 1126 }
1102 } 1127 }
1103 else if (map) 1128 else if (map)
1104 { 1129 {
1105 map->dirty = true; 1130 map->dirty = true;
1106 mapspace &ms = this->ms (); 1131 mapspace &ms = this->ms ();
… …
1226 1251
1227 object *prev = this; 1252 object *prev = this;
1228 1253
1229 for (archetype *at = (archetype *)arch->more; at; at = (archetype *)at->more) 1254 for (archetype *at = (archetype *)arch->more; at; at = (archetype *)at->more)
1230 { 1255 {
1231 object *op = arch_to_object (at); 1256 object *op = at->instance ();
1232 1257
1233 op->name = name; 1258 op->name = name;
1234 op->name_pl = name_pl; 1259 op->name_pl = name_pl;
1235 op->title = title; 1260 op->title = title;
1236 1261
… …
1274 * Passing 0 for flag gives proper default values, so flag really only needs 1299 * Passing 0 for flag gives proper default values, so flag really only needs
1275 * to be set if special handling is needed. 1300 * to be set if special handling is needed.
1276 * 1301 *
1277 * Return value: 1302 * Return value:
1278 * new object if 'op' was merged with other object 1303 * new object if 'op' was merged with other object
1279 * NULL if 'op' was destroyed 1304 * NULL if there was an error (destroyed, blocked etc.)
1280 * just 'op' otherwise 1305 * just 'op' otherwise
1281 */ 1306 */
1282object * 1307object *
1283insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1308insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1284{ 1309{
… …
1321 // from here :/ 1346 // from here :/
1322 op->nrof += tmp->nrof; 1347 op->nrof += tmp->nrof;
1323 tmp->destroy (); 1348 tmp->destroy ();
1324 } 1349 }
1325 1350
1326 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ 1351 op->clr_flag (FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1327 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1352 op->clr_flag (FLAG_INV_LOCKED);
1328 1353
1329 if (!QUERY_FLAG (op, FLAG_ALIVE)) 1354 if (!op->flag [FLAG_ALIVE])
1330 CLEAR_FLAG (op, FLAG_NO_STEAL); 1355 op->clr_flag (FLAG_NO_STEAL);
1331 1356
1332 if (flag & INS_BELOW_ORIGINATOR) 1357 if (flag & INS_BELOW_ORIGINATOR)
1333 { 1358 {
1334 if (originator->map != op->map || originator->x != op->x || originator->y != op->y) 1359 if (originator->map != op->map || originator->x != op->x || originator->y != op->y)
1335 { 1360 {
… …
1370 * when lots of spells are cast in one area. Currently, it is presumed 1395 * when lots of spells are cast in one area. Currently, it is presumed
1371 * that flying non pickable objects are spell objects. 1396 * that flying non pickable objects are spell objects.
1372 */ 1397 */
1373 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1398 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1374 { 1399 {
1375 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || QUERY_FLAG (tmp, FLAG_OVERLAY_FLOOR)) 1400 if (tmp->flag [FLAG_IS_FLOOR] || tmp->flag [FLAG_OVERLAY_FLOOR])
1376 floor = tmp; 1401 floor = tmp;
1377 1402
1378 if (QUERY_FLAG (tmp, FLAG_NO_PICK) && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1403 if (tmp->flag [FLAG_NO_PICK] && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !tmp->flag [FLAG_IS_FLOOR])
1379 { 1404 {
1380 /* We insert above top, so we want this object below this */ 1405 /* We insert above top, so we want this object below this */
1381 top = tmp->below; 1406 top = tmp->below;
1382 break; 1407 break;
1383 } 1408 }
… …
1401 && (op->face && !faces [op->face].visibility)) 1426 && (op->face && !faces [op->face].visibility))
1402 { 1427 {
1403 object *last; 1428 object *last;
1404 1429
1405 for (last = top; last != floor; last = last->below) 1430 for (last = top; last != floor; last = last->below)
1406 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT)) 1431 if (last->flag [FLAG_BLOCKSVIEW] && (last->type != EXIT))
1407 break; 1432 break;
1408 1433
1409 /* Check to see if we found the object that blocks view, 1434 /* Check to see if we found the object that blocks view,
1410 * and make sure we have a below pointer for it so that 1435 * and make sure we have a below pointer for it so that
1411 * we can get inserted below this one, which requires we 1436 * we can get inserted below this one, which requires we
… …
1511 1536
1512 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above) 1537 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1513 if (tmp->arch->archname == archname) /* same archetype */ 1538 if (tmp->arch->archname == archname) /* same archetype */
1514 tmp->destroy (); 1539 tmp->destroy ();
1515 1540
1516 object *tmp = arch_to_object (archetype::find (archname)); 1541 object *tmp = archetype::find (archname)->instance ();
1517 1542
1518 tmp->x = op->x; 1543 tmp->x = op->x;
1519 tmp->y = op->y; 1544 tmp->y = op->y;
1520 1545
1521 insert_ob_in_map (tmp, op->map, op, 0); 1546 insert_ob_in_map (tmp, op->map, op, 0);
… …
1526{ 1551{
1527 if (where->env) 1552 if (where->env)
1528 return where->env->insert (this); 1553 return where->env->insert (this);
1529 else 1554 else
1530 return where->map->insert (this, where->x, where->y, originator, flags); 1555 return where->map->insert (this, where->x, where->y, originator, flags);
1556}
1557
1558// check whether we can put this into the map, respect max_volume, max_items
1559bool
1560object::can_drop_at (maptile *m, int x, int y, object *originator)
1561{
1562 mapspace &ms = m->at (x, y);
1563
1564 int items = ms.items ();
1565
1566 if (!items // testing !items ensures we can drop at least one item
1567 || (items < m->max_items
1568 && ms.volume () < m->max_volume))
1569 return true;
1570
1571 if (originator && originator->is_player ())
1572 originator->contr->failmsgf (
1573 "No matter how hard you try, you just cannot put the %s here H<Try to remove some items from the floor first.>",
1574 query_name ()
1575 );
1576
1577 return false;
1531} 1578}
1532 1579
1533/* 1580/*
1534 * decrease(object, number) decreases a specified number from 1581 * decrease(object, number) decreases a specified number from
1535 * the amount of an object. If the amount reaches 0, the object 1582 * the amount of an object. If the amount reaches 0, the object
… …
1675 if (op->glow_radius && is_on_map ()) 1722 if (op->glow_radius && is_on_map ())
1676 { 1723 {
1677 update_stats (); 1724 update_stats ();
1678 update_all_los (map, x, y); 1725 update_all_los (map, x, y);
1679 } 1726 }
1680 else if (is_player () && !flag [FLAG_NO_FIX_PLAYER]) 1727 else if (is_player ())
1681 // if this is a player's inventory, update stats 1728 // if this is a player's inventory, update stats
1682 update_stats (); 1729 contr->queue_stats_update ();
1683 1730
1684 INVOKE_OBJECT (INSERT, this); 1731 INVOKE_OBJECT (INSERT, this);
1685 1732
1686 return op; 1733 return op;
1687} 1734}
… …
1707 * on top. 1754 * on top.
1708 */ 1755 */
1709int 1756int
1710check_move_on (object *op, object *originator) 1757check_move_on (object *op, object *originator)
1711{ 1758{
1712 if (QUERY_FLAG (op, FLAG_NO_APPLY)) 1759 if (op->flag [FLAG_NO_APPLY])
1713 return 0; 1760 return 0;
1714 1761
1715 object *tmp; 1762 object *tmp;
1716 maptile *m = op->map; 1763 maptile *m = op->map;
1717 int x = op->x, y = op->y; 1764 int x = op->x, y = op->y;
… …
1754 * Second check makes sure that the movement types not being slowed 1801 * Second check makes sure that the movement types not being slowed
1755 * (~slow_move) is not blocked on this space - just because the 1802 * (~slow_move) is not blocked on this space - just because the
1756 * space doesn't slow down swimming (for example), if you can't actually 1803 * space doesn't slow down swimming (for example), if you can't actually
1757 * swim on that space, can't use it to avoid the penalty. 1804 * swim on that space, can't use it to avoid the penalty.
1758 */ 1805 */
1759 if (!QUERY_FLAG (op, FLAG_WIZPASS)) 1806 if (!op->flag [FLAG_WIZPASS])
1760 { 1807 {
1761 if ((!op->move_type && tmp->move_slow & MOVE_WALK) || 1808 if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
1762 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0)) 1809 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
1763 { 1810 {
1764 float diff = tmp->move_slow_penalty * fabs (op->speed); 1811 float diff = tmp->move_slow_penalty * fabs (op->speed);
… …
1895void 1942void
1896flag_inv (object *op, int flag) 1943flag_inv (object *op, int flag)
1897{ 1944{
1898 for (object *tmp = op->inv; tmp; tmp = tmp->below) 1945 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1899 { 1946 {
1900 SET_FLAG (tmp, flag); 1947 tmp->set_flag (flag);
1901 flag_inv (tmp, flag); 1948 flag_inv (tmp, flag);
1902 } 1949 }
1903} 1950}
1904 1951
1905/* 1952/*
… …
1908void 1955void
1909unflag_inv (object *op, int flag) 1956unflag_inv (object *op, int flag)
1910{ 1957{
1911 for (object *tmp = op->inv; tmp; tmp = tmp->below) 1958 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1912 { 1959 {
1913 CLEAR_FLAG (tmp, flag); 1960 tmp->clr_flag (flag);
1914 unflag_inv (tmp, flag); 1961 unflag_inv (tmp, flag);
1915 } 1962 }
1916} 1963}
1917 1964
1918/* 1965/*
… …
2278 * Add a check so we can't pick up invisible objects (0.93.8) 2325 * Add a check so we can't pick up invisible objects (0.93.8)
2279 */ 2326 */
2280int 2327int
2281can_pick (const object *who, const object *item) 2328can_pick (const object *who, const object *item)
2282{ 2329{
2283 return /*QUERY_FLAG(who,FLAG_WIZ)|| */ 2330 return /*who->flag [FLAG_WIZ]|| */
2284 (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) && 2331 (item->weight > 0 && !item->flag [FLAG_NO_PICK] &&
2285 !QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->is_player () || item->weight < who->weight / 3)); 2332 !item->flag [FLAG_ALIVE] && !item->invisible && (who->is_player () || item->weight < who->weight / 3));
2286} 2333}
2287 2334
2288/* 2335/*
2289 * create clone from object to another 2336 * create clone from object to another
2290 */ 2337 */
… …
2455{ 2502{
2456 return map ? map->region (x, y) 2503 return map ? map->region (x, y)
2457 : region::default_region (); 2504 : region::default_region ();
2458} 2505}
2459 2506
2460const materialtype_t *
2461object::dominant_material () const
2462{
2463 if (materialtype_t *mt = name_to_material (materialname))
2464 return mt;
2465
2466 return name_to_material (shstr_unknown);
2467}
2468
2469void 2507void
2470object::open_container (object *new_container) 2508object::open_container (object *new_container)
2471{ 2509{
2472 if (container == new_container) 2510 if (container == new_container)
2473 return; 2511 return;
… …
2507 // TODO: this does not seem to serve any purpose anymore? 2545 // TODO: this does not seem to serve any purpose anymore?
2508#if 0 2546#if 0
2509 // insert the "Close Container" object. 2547 // insert the "Close Container" object.
2510 if (archetype *closer = new_container->other_arch) 2548 if (archetype *closer = new_container->other_arch)
2511 { 2549 {
2512 object *closer = arch_to_object (new_container->other_arch); 2550 object *closer = new_container->other_arch->instance ();
2513 closer->flag [FLAG_NO_MAP_SAVE] = 1; 2551 closer->flag [FLAG_NO_MAP_SAVE] = 1;
2514 new_container->insert (closer); 2552 new_container->insert (closer);
2515 } 2553 }
2516#endif 2554#endif
2517 2555
… …
2623 2661
2624 insert (force); 2662 insert (force);
2625 } 2663 }
2626} 2664}
2627 2665
2666void object::change_move_type (MoveType mt)
2667{
2668 if (move_type == mt)
2669 return;
2670
2671 if (is_on_map ())
2672 {
2673 // we are on the map, so handle move_on/off effects
2674 remove ();
2675 move_type = mt;
2676 map->insert (this, x, y, this);
2677 }
2678 else
2679 move_type = mt;
2680}
2681

Diff Legend

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