--- deliantra/server/common/object.C 2008/05/06 21:04:37 1.237 +++ deliantra/server/common/object.C 2010/03/26 21:43:43 1.315 @@ -1,22 +1,23 @@ /* * This file is part of Deliantra, the Roguelike Realtime MMORPG. * - * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team - * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team - * Copyright (©) 1992,2007 Frank Tore Johansen + * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team + * Copyright (©) 2001 Mark Wedel & Crossfire Development Team + * Copyright (©) 1992 Frank Tore Johansen * - * Deliantra is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. + * Deliantra is free software: you can redistribute it and/or modify it under + * the terms of the Affero GNU General Public License as published by the + * Free Software Foundation, either version 3 of the License, or (at your + * option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . + * You should have received a copy of the Affero GNU General Public License + * and the GNU General Public License along with this program. If not, see + * . * * The authors can be reached via e-mail to */ @@ -27,17 +28,19 @@ #include #include #include -#include #include UUID UUID::cur; static uint64_t seq_next_save; static const uint64 UUID_GAP = 1<<19; +uint32_t mapspace::smellcount = 10000; objectvec objects; activevec actives; +//+GPL + short freearr_x[SIZEOFFREE] = { 0, 0, 1, 1, 1, 0, -1, -1, -1, @@ -50,12 +53,6 @@ -2, -2, -2, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, -3, -3, -3, -3, -2, -1, 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3 }; -int maxfree[SIZEOFFREE] = { - 0, - 9, 10, 13, 14, 17, 18, 21, 22, - 25, 26, 27, 30, 31, 32, 33, 36, 37, 39, 39, 42, 43, 44, 45, 48, - 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49 -}; int freedir[SIZEOFFREE] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, @@ -63,6 +60,13 @@ 1, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8 }; +static int maxfree[SIZEOFFREE] = { + 0, + 9, 10, 13, 14, 17, 18, 21, 22, + 25, 26, 27, 30, 31, 32, 33, 36, 37, 39, 39, 42, 43, 44, 45, 48, + 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49 +}; + static void write_uuid (uval64 skip, bool sync) { @@ -74,7 +78,7 @@ } static void -read_uuid (void) +read_uuid () { char filename[MAX_BUF]; @@ -98,7 +102,7 @@ _exit (1); } - UUID::BUF buf; + char buf [UUID::MAX_LEN]; buf[0] = 0; fgets (buf, sizeof (buf), fp); @@ -137,6 +141,71 @@ read_uuid (); } +bool +UUID::parse (const char *s) +{ + if (*s++ != '<' || *s++ != '1' || *s++ != '.') + return false; + + seq = 0; + + while (*s != '>') + { + if (*s < '0') + return false; + + // this gives nice branchless code with gcc + assert ('0' < 'a' && '0' == 48 && 'a' == 97); + int digit = (*s + (*s & 0x40 ? 9 : 0)) & 15; + + seq = (seq << 4) | digit; + + ++s; + } + + return true; +} + +char * +UUID::append (char *buf) const +{ + *buf++ = '<'; + *buf++ = '1'; + *buf++ = '.'; + + uint64_t seq = this->seq; + const int bits = 64; + char nz = 0; + static const char tohex [] = "0123456789abcdef"; + + // assert (len >= 3 + bits / 4 + 1 + 1); + for (int i = bits / 4; --i; ) + { + uint8_t digit = seq >> (bits - 4); + + *buf = tohex [digit]; + nz |= digit; + buf += nz ? 1 : 0; + seq <<= 4; + } + + // last digit is special - always emit + uint8_t digit = seq >> (bits - 4); + *buf++ = tohex [digit]; + + *buf++ = '>'; + + return buf; +} + +char * +UUID::c_str () const +{ + static char buf [MAX_LEN]; + *append (buf) = 0; + return buf; +} + /* Returns TRUE if every key_values in wants has a partner with the same value in has. */ static bool compare_ob_value_lists_one (const object *wants, const object *has) @@ -180,20 +249,17 @@ */ bool object::can_merge_slow (object *ob1, object *ob2) { - /* A couple quicksanity checks */ + /* A couple quick sanity checks */ if (ob1 == ob2 || ob1->type != ob2->type - || ob1->speed != ob2->speed || ob1->value != ob2->value - || ob1->name != ob2->name) + || ob1->name != ob2->name + || fabs (ob1->speed - ob2->speed) >= MIN_ACTIVE_SPEED) return 0; - /* Do not merge objects if nrof would overflow. First part checks - * for unsigned overflow (2c), second part checks whether the result - * would fit into a 32 bit signed int, which is often used to hold - * nrof values. - */ - if (~ob1->nrof < ob2->nrof || ob1->nrof + ob2->nrof > (1UL << 31)) + /* Do not merge objects if nrof would overflow, assume nrof + * is always 0 .. 2**31-1 */ + if (ob1->nrof > 0x7fffffff - ob2->nrof) return 0; /* If the objects have been identified, set the BEEN_APPLIED flag. @@ -208,7 +274,7 @@ if (QUERY_FLAG (ob2, FLAG_IDENTIFIED)) SET_FLAG (ob2, FLAG_BEEN_APPLIED); - if (ob1->arch->name != ob2->arch->name + if (ob1->arch->archname != ob2->arch->archname || ob1->name != ob2->name || ob1->title != ob2->title || ob1->msg != ob2->msg @@ -219,8 +285,9 @@ || ob1->skill != ob2->skill || ob1->value != ob2->value || ob1->animation_id != ob2->animation_id + || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependend on each other || ob1->client_type != ob2->client_type - || ob1->materialname != ob2->materialname + || ob1->material != ob2->material || ob1->lore != ob2->lore || ob1->subtype != ob2->subtype || ob1->move_type != ob2->move_type @@ -229,14 +296,13 @@ || ob1->move_on != ob2->move_on || ob1->move_off != ob2->move_off || ob1->move_slow != ob2->move_slow - || ob1->move_slow_penalty != ob2->move_slow_penalty + || fabs (ob1->move_slow_penalty - ob2->move_slow_penalty) >= (1.f / 1024.f) || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist)) || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats))) return 0; if ((ob1->flag ^ ob2->flag) .reset (FLAG_INV_LOCKED) - .reset (FLAG_CLIENT_SENT) .reset (FLAG_REMOVED) .any ()) return 0; @@ -328,17 +394,17 @@ if (env) { // the player inventory itself is always visible - if (env->type == PLAYER) + if (env->is_player ()) return env; // else a player could have our env open - object *envest = env->outer_env (); + object *envest = env->outer_env_or_self (); // the player itself is always on a map, so we will find him here // even if our inv is in a player. if (envest->is_on_map ()) if (object *pl = envest->ms ().player ()) - if (pl->container == env) + if (pl->container_ () == env) return pl; } else @@ -346,7 +412,8 @@ // maybe there is a player standing on the same mapspace // this will catch the case where "this" is a player if (object *pl = ms ().player ()) - if (!pl->container || this == pl->container) + if ((pl->contr->ns && !pl->container_ () && !pl->contr->ns->update_look) + || pl->container_ () == this) return pl; } } @@ -434,27 +501,10 @@ return freezer.as_string (); } -/* - * get_nearest_part(multi-object, object 2) returns the part of the - * multi-object 1 which is closest to the second object. - * If it's not a multi-object, it is returned. - */ -object * -get_nearest_part (object *op, const object *pl) +char * +object::as_string () { - object *tmp, *closest; - int last_dist, i; - - if (!op->more) - return op; - - for (last_dist = distance (op, pl), closest = op, tmp = op->more; - tmp; - tmp = tmp->more) - if ((i = distance (tmp, pl)) < last_dist) - closest = tmp, last_dist = i; - - return closest; + return dump_object (this); } /* @@ -472,6 +522,21 @@ } /* + * Returns the object which has the uuid equal to the argument. + * MOAR VERRRY slow. + */ + +object * +find_object_uuid (UUID i) +{ + for_all_objects (op) + if (op->uuid == i) + return op; + + return 0; +} + +/* * Returns the first object which has a name equal to the argument. * Used only by the patch command, but not all that useful. * Enables features like "patch food 999" @@ -480,13 +545,13 @@ find_object_name (const char *str) { shstr_cmp str_ (str); - object *op; - for_all_objects (op) - if (op->name == str_) - break; + if (str_) + for_all_objects (op) + if (op->name == str_) + return op; - return op; + return 0; } /* @@ -558,7 +623,8 @@ new_draw_info_format (NDI_UNIQUE, 0, this, "You try to balance all your items at once, " "but the %s is just too much for your body. " - "[You need to unapply some items first.]", &ob->name); + "[You need to unapply some items first - use the 'body' command to see " + "how many items you can wear on a specific body part.]", &ob->name); return false; } @@ -637,10 +703,7 @@ } } - if (speed < 0) - dst->speed_left -= rndm (); - - dst->set_speed (dst->speed); + dst->activate (); } void @@ -649,7 +712,12 @@ if (!uuid.seq) // HACK uuid = UUID::gen (); - speed_left = -0.1f; + // TODO: unclean state changes, should nt be done in copy_to AND instantiate + if (flag [FLAG_RANDOM_SPEED] && speed) + speed_left = - speed - rndm (); // TODO animation + else + speed_left = -1.; + /* copy the body_info to the body_used - this is only really * need for monsters, but doesn't hurt to do it for everything. * by doing so, when a monster is created, it has good starting @@ -667,6 +735,11 @@ { object *neu = create (); copy_to (neu); + + // TODO: unclean state changes, should not be done in clone AND instantiate + if (neu->flag [FLAG_RANDOM_SPEED] && neu->speed) + neu->speed_left = - neu->speed - rndm (); // TODO animation + neu->map = map; // not copied by copy_to return neu; } @@ -694,12 +767,6 @@ void object::set_speed (float speed) { - if (flag [FLAG_FREED] && speed) - { - LOG (llevError, "Object %s is freed but has speed.\n", &name); - speed = 0; - } - this->speed = speed; if (has_active_speed ()) @@ -759,10 +826,11 @@ /* nop */; else if (action == UP_OBJ_INSERT) { +#if 0 // this is likely overkill, TODO: revisit (schmorp) if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(m.flags_ & P_BLOCKSVIEW)) || (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(m.flags_ & P_NO_MAGIC)) - || (op->type == PLAYER && !(m.flags_ & P_PLAYER)) + || (op->is_player () && !(m.flags_ & P_PLAYER)) || (op->type == SAFE_GROUND && !(m.flags_ & P_SAFE)) || (QUERY_FLAG (op, FLAG_ALIVE) && !(m.flags_ & P_IS_ALIVE)) || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC)) @@ -770,18 +838,21 @@ || (m.move_off | op->move_off ) != m.move_off || (m.move_slow | op->move_slow) != m.move_slow /* This isn't perfect, but I don't expect a lot of objects to - * to have move_allow right now. + * have move_allow right now. */ || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block - || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp) - m.flags_ = 0; + m.invalidate (); +#else + // the above is not strong enough a test to skip updating. los maybe? TODO (schmorp) + m.invalidate (); +#endif } /* if the object is being removed, we can't make intelligent * decisions, because remove_ob can't really pass the object * that is being removed. */ else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) - m.flags_ = 0; + m.invalidate (); else if (action == UP_OBJ_FACE) /* Nothing to do for that case */ ; else @@ -795,8 +866,9 @@ { SET_FLAG (this, FLAG_REMOVED); - expmul = 1.0; - face = blank_face; + //expmul = 1.0; declared const for the time being + face = blank_face; + material = MATERIAL_NULL; } object::~object () @@ -835,7 +907,12 @@ return; if (has_active_speed ()) - actives.insert (this); + { + if (flag [FLAG_FREED]) + LOG (llevError | logBacktrace, "BUG: tried to activate freed object %s\n", debug_desc ());//D + + actives.insert (this); + } } void @@ -906,14 +983,11 @@ if (!drop_to_ground || !map || map->in_memory != MAP_ACTIVE - || map->nodrop + || map->no_drop || ms ().move_block == MOVE_ALL) { while (inv) - { - inv->destroy_inv (false); - inv->destroy (); - } + inv->destroy (); } else { /* Put objects in inventory onto this space */ @@ -927,7 +1001,7 @@ || op->type == TRAP || op->flag [FLAG_IS_A_TEMPLATE] || op->flag [FLAG_DESTROY_ON_DEATH]) - op->destroy (true); + op->destroy (); else map->insert (op, x, y); } @@ -945,11 +1019,12 @@ { freed_map () { - path = ""; - name = "/internal/freed_objects_map"; - width = 3; - height = 3; - nodrop = 1; + path = ""; + name = "/internal/freed_objects_map"; + width = 3; + height = 3; + no_drop = 1; + no_reset = 1; alloc (); in_memory = MAP_ACTIVE; @@ -965,7 +1040,7 @@ object::do_destroy () { if (flag [FLAG_IS_LINKED]) - remove_button_link (this); + remove_link (); if (flag [FLAG_FRIENDLY]) remove_friendly_object (this); @@ -1000,7 +1075,7 @@ } void -object::destroy (bool destroy_inventory) +object::destroy () { if (destroyed ()) return; @@ -1008,11 +1083,11 @@ if (!is_head () && !head->destroyed ()) { LOG (llevError | logBacktrace, "tried to destroy the tail of an object"); - head->destroy (destroy_inventory); + head->destroy (); return; } - destroy_inv (!destroy_inventory); + destroy_inv (false); if (is_head ()) if (sound_destroy) @@ -1033,9 +1108,6 @@ void object::do_remove () { - object *tmp, *last = 0; - object *otmp; - if (flag [FLAG_REMOVED]) return; @@ -1059,6 +1131,8 @@ adjust_weight (env, -total_weight ()); + object *pl = in_player (); + /* we set up values so that it could be inserted into * the map, but we don't actually do that - it is up * to the caller to decide what we want to do. @@ -1075,12 +1149,13 @@ below = 0; env = 0; - /* NO_FIX_PLAYER is set when a great many changes are being - * made to players inventory. If set, avoiding the call - * to save cpu time. - */ - if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER)) - otmp->update_stats (); + if (pl && pl->is_player ()) + { + pl->contr->queue_stats_update (); + + if (glow_radius && pl->is_on_map ()) + update_all_los (pl->map, pl->x, pl->y); + } } else if (map) { @@ -1089,8 +1164,11 @@ if (object *pl = ms.player ()) { - if (type == PLAYER) // this == pl(!) + if (is_player ()) { + if (!flag [FLAG_WIZPASS]) + ms.smell = ++mapspace::smellcount; // remember the smell of the player + // leaving a spot always closes any open container on the ground if (container && !container->env) // this causes spurious floorbox updates, but it ensures @@ -1100,7 +1178,7 @@ --map->players; map->touch (); } - else if (pl->container == this) + else if (pl->container_ () == this) { // removing a container should close it close_container (); @@ -1117,6 +1195,8 @@ above = 0; below = 0; + ms.invalidate (); + if (map->in_memory == MAP_SAVING) return; @@ -1124,7 +1204,7 @@ if (object *pl = ms.player ()) { - if (pl->container == this) + if (pl->container_ () == this) /* If a container that the player is currently using somehow gets * removed (most likely destroyed), update the player view * appropriately. @@ -1138,34 +1218,22 @@ pl->contr->ns->floorbox_update (); } - for (tmp = ms.bot; tmp; tmp = tmp->above) - { - /* No point updating the players look faces if he is the object - * being removed. - */ - - /* See if object moving off should effect something */ - if (check_walk_off - && ((move_type & tmp->move_off) - && (move_type & ~tmp->move_off & ~tmp->move_block) == 0)) - { - move_apply (tmp, this, 0); - - if (destroyed ()) - LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ()); - } + if (check_walk_off) + for (object *above, *tmp = ms.bot; tmp; tmp = above) + { + above = tmp->above; - last = tmp; - } + /* No point updating the players look faces if he is the object + * being removed. + */ - /* last == NULL if there are no objects on this space */ - //TODO: this makes little sense, why only update the topmost object? - if (!last) - map->at (x, y).flags_ = 0; - else - update_object (last, UP_OBJ_REMOVE); + /* See if object moving off should effect something */ + if ((move_type & tmp->move_off) + && (move_type & ~tmp->move_off & ~tmp->move_block) == 0) + move_apply (tmp, this, 0); + } - if (flag [FLAG_BLOCKSVIEW] || glow_radius) + if (affects_los ()) update_all_los (map, x, y); } } @@ -1199,7 +1267,7 @@ op->weight = 0; // cancel the addition above op->carrying = 0; // must be 0 already - op->destroy (1); + op->destroy (); return top; } @@ -1217,7 +1285,7 @@ for (archetype *at = (archetype *)arch->more; at; at = (archetype *)at->more) { - object *op = arch_to_object (at); + object *op = at->instance (); op->name = name; op->name_pl = name_pl; @@ -1237,6 +1305,8 @@ object * insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y) { + op->remove (); + for (object *tmp = op->head_ (); tmp; tmp = tmp->more) { tmp->x = x + tmp->arch->x; @@ -1263,7 +1333,7 @@ * * Return value: * new object if 'op' was merged with other object - * NULL if 'op' was destroyed + * NULL if there was an error (destroyed, blocked etc.) * just 'op' otherwise */ object * @@ -1271,13 +1341,19 @@ { op->remove (); + if (m == &freed_map)//D TODO: remove soon + {//D + LOG (llevError | logBacktrace, "tries to insret object on freed objects map: %s", op->debug_desc ());//D + }//D + /* Ideally, the caller figures this out. However, it complicates a lot * of areas of callers (eg, anything that uses find_free_spot would now * need extra work */ - if (!xy_normalise (m, op->x, op->y)) + maptile *newmap = m; + if (!xy_normalise (newmap, op->x, op->y)) { - op->head_ ()->destroy (1);// remove head_ once all tail object destroyers found + op->head_ ()->destroy ();// remove head_ once all tail object destroyers found return 0; } @@ -1285,9 +1361,10 @@ if (!insert_ob_in_map (more, m, originator, flag)) return 0; - CLEAR_FLAG (op, FLAG_REMOVED); + op->flag [FLAG_REMOVED] = false; + op->env = 0; + op->map = newmap; - op->map = m; mapspace &ms = op->ms (); /* this has to be done after we translate the coordinates. @@ -1300,7 +1377,7 @@ // but some caller surely breaks when we return tmp // from here :/ op->nrof += tmp->nrof; - tmp->destroy (1); + tmp->destroy (); } CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ @@ -1311,12 +1388,19 @@ if (flag & INS_BELOW_ORIGINATOR) { - if (originator->map != op->map || originator->x != op->x || originator->y != op->y || !originator->is_on_map ()) + if (originator->map != op->map || originator->x != op->x || originator->y != op->y) { LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n"); abort (); } + if (!originator->is_on_map ()) + { + LOG (llevError, "insert_ob_in_map(%s) called with INS_BELOW_ORIGINATOR when originator '%s' not on map", + op->debug_desc (), originator->debug_desc ()); + abort (); + } + op->above = originator; op->below = originator->below; originator->below = op; @@ -1392,29 +1476,26 @@ if (flag & INS_ABOVE_FLOOR_ONLY) top = floor; - /* Top is the object that our object (op) is going to get inserted above. - */ - - /* no top found, insert on top */ + // insert object above top, or bottom-most if top = 0 if (!top) { - op->above = 0; - op->below = ms.top; - ms.top = op; + op->below = 0; + op->above = ms.bot; + ms.bot = op; - *(op->below ? &op->below->above : &ms.bot) = op; + *(op->above ? &op->above->below : &ms.top) = op; } else - { /* get inserted into the stack above top */ + { op->above = top->above; top->above = op; op->below = top; *(op->above ? &op->above->below : &ms.top) = op; } - } /* else not INS_BELOW_ORIGINATOR */ + } - if (op->type == PLAYER) + if (op->is_player ()) { op->contr->do_los = 1; ++op->map->players; @@ -1439,8 +1520,11 @@ * or just updating the P_UPTODATE for spaces within this area * of effect may be sufficient. */ - if (op->map->darkness && (op->glow_radius != 0)) - update_all_los (op->map, op->x, op->y); + if (op->affects_los ()) + { + op->ms ().invalidate (); + update_all_los (op->map, op->x, op->y); + } /* updates flags (blocked, alive, no magic, etc) for this map space */ update_object (op, UP_OBJ_INSERT); @@ -1457,7 +1541,7 @@ */ /* if this is not the head or flag has been passed, don't check walk on status */ - if (!(flag & INS_NO_WALK_ON) && op->head_ () == op) + if (!(flag & INS_NO_WALK_ON) && op->is_head ()) { if (check_move_on (op, originator)) return 0; @@ -1478,15 +1562,15 @@ * op is the object to insert it under: supplies x and the map. */ void -replace_insert_ob_in_map (const char *arch_string, object *op) +replace_insert_ob_in_map (shstr_tmp archname, object *op) { /* first search for itself and remove any old instances */ for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above) - if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */ - tmp->destroy (1); + if (tmp->arch->archname == archname) /* same archetype */ + tmp->destroy (); - object *tmp = arch_to_object (archetype::find (arch_string)); + object *tmp = archetype::find (archname)->instance (); tmp->x = op->x; tmp->y = op->y; @@ -1503,6 +1587,28 @@ return where->map->insert (this, where->x, where->y, originator, flags); } +// check whether we can put this into the map, respect max_volume, max_items +bool +object::can_drop_at (maptile *m, int x, int y, object *originator) +{ + mapspace &ms = m->at (x, y); + + int items = ms.items (); + + if (!items // testing !items ensures we can drop at least one item + || (items < m->max_items + && ms.volume () < m->max_volume)) + return true; + + if (originator && originator->is_player ()) + originator->contr->failmsg (format ( + "No matter how hard you try, you just cannot put the %s here H", + query_name () + )); + + return false; +} + /* * decrease(object, number) decreases a specified number from * the amount of an object. If the amount reaches 0, the object @@ -1518,11 +1624,10 @@ nr = min (nr, nrof); - nrof -= nr; - - if (nrof) + if (nrof > nr) { - adjust_weight (env, -weight * nr); // carrying == 0 + nrof -= nr; + adjust_weight (env, -weight * max (1, nr)); // carrying == 0 if (object *pl = visible_to ()) esrv_update_item (UPD_NROF, pl, this); @@ -1531,7 +1636,7 @@ } else { - destroy (1); + destroy (); return false; } } @@ -1618,7 +1723,7 @@ adjust_weight (this, op->total_weight ()); - op->destroy (1); + op->destroy (); op = tmp; goto inserted; } @@ -1646,12 +1751,14 @@ inserted: /* reset the light list and los of the players on the map */ - if (op->glow_radius && map && map->darkness) - update_all_los (map, x, y); - - // if this is a player's inventory, update stats - if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER]) - update_stats (); + if (op->glow_radius && is_on_map ()) + { + update_stats (); + update_all_los (map, x, y); + } + else if (is_player ()) + // if this is a player's inventory, update stats + contr->queue_stats_update (); INVOKE_OBJECT (INSERT, this); @@ -1681,18 +1788,20 @@ int check_move_on (object *op, object *originator) { + if (QUERY_FLAG (op, FLAG_NO_APPLY)) + return 0; + object *tmp; maptile *m = op->map; int x = op->x, y = op->y; - MoveType move_on, move_slow, move_block; + mapspace &ms = m->at (x, y); - if (QUERY_FLAG (op, FLAG_NO_APPLY)) - return 0; + ms.update (); - move_on = GET_MAP_MOVE_ON (op->map, op->x, op->y); - move_slow = GET_MAP_MOVE_SLOW (op->map, op->x, op->y); - move_block = GET_MAP_MOVE_BLOCK (op->map, op->x, op->y); + MoveType move_on = ms.move_on; + MoveType move_slow = ms.move_slow; + MoveType move_block = ms.move_block; /* if nothing on this space will slow op down or be applied, * no need to do checking below. have to make sure move_type @@ -1713,19 +1822,10 @@ /* The objects have to be checked from top to bottom. * Hence, we first go to the top: */ - - for (tmp = op->ms ().bot; tmp && tmp->above; tmp = tmp->above) + for (object *next, *tmp = ms.top; tmp; tmp = next) { - /* Trim the search when we find the first other spell effect - * this helps performance so that if a space has 50 spell objects, - * we don't need to check all of them. - */ - if ((tmp->move_type & MOVE_FLY_LOW) && QUERY_FLAG (tmp, FLAG_NO_PICK)) - break; - } + next = tmp->below; - for (; tmp; tmp = tmp->below) - { if (tmp == op) continue; /* Can't apply yourself */ @@ -1740,13 +1840,11 @@ if ((!op->move_type && tmp->move_slow & MOVE_WALK) || ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0)) { + float diff = tmp->move_slow_penalty * fabs (op->speed); - float - diff = tmp->move_slow_penalty * fabs (op->speed); - - if (op->type == PLAYER) - if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) || - (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN))) + if (op->is_player ()) + if ((tmp->flag [FLAG_IS_HILLY ] && find_skill_by_number (op, SK_CLIMBING)) || + (tmp->flag [FLAG_IS_WOODED] && find_skill_by_number (op, SK_WOODSMAN))) diff /= 4.0; op->speed_left -= diff; @@ -1962,7 +2060,7 @@ if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block)) continue; - if (ob->blocked (m, pos.x, pos.y)) + if (ob->blocked (pos.m, pos.x, pos.y)) continue; altern [index++] = i; @@ -2040,13 +2138,8 @@ int find_dir (maptile *m, int x, int y, object *exclude) { - int i, max = SIZEOFFREE, mflags; - - sint16 nx, ny; - object *tmp; - maptile *mp; - - MoveType blocked, move_type; + int max = SIZEOFFREE, mflags; + MoveType move_type; if (exclude && exclude->head_ () != exclude) { @@ -2059,33 +2152,25 @@ move_type = MOVE_ALL; } - for (i = 1; i < max; i++) + for (int i = 1; i < max; i++) { - mp = m; - nx = x + freearr_x[i]; - ny = y + freearr_y[i]; + mapxy pos (m, x, y); + pos.move (i); - mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny); - - if (mflags & P_OUT_OF_MAP) + if (!pos.normalise ()) max = maxfree[i]; else { - mapspace &ms = mp->at (nx, ny); - - blocked = ms.move_block; + mapspace &ms = *pos; - if ((move_type & blocked) == move_type) - max = maxfree[i]; - else if (mflags & P_IS_ALIVE) + if ((move_type & ms.move_block) == move_type) + max = maxfree [i]; + else if (ms.flags () & P_IS_ALIVE) { - for (tmp = ms.bot; tmp; tmp = tmp->above) - if ((tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER) + for (object *tmp = ms.bot; tmp; tmp = tmp->above) + if ((tmp->flag [FLAG_MONSTER] || tmp->is_player ()) && (tmp != exclude || (tmp->head_ () != tmp && tmp->head_ () != exclude))) - break; - - if (tmp) - return freedir[i]; + return freedir [i]; } } } @@ -2170,7 +2255,7 @@ * Moved from spell_util.c to object.c with the other related direction * functions. */ -int reduction_dir[SIZEOFFREE][3] = { +static const int reduction_dir[SIZEOFFREE][3] = { {0, 0, 0}, /* 0 */ {0, 0, 0}, /* 1 */ {0, 0, 0}, /* 2 */ @@ -2276,7 +2361,7 @@ { return /*QUERY_FLAG(who,FLAG_WIZ)|| */ (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) && - !QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->type == PLAYER || item->weight < who->weight / 3)); + !QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->is_player () || item->weight < who->weight / 3)); } /* @@ -2318,18 +2403,18 @@ return 0; } -const shstr & -object::kv_get (const shstr &key) const +shstr_tmp +object::kv_get (shstr_tmp key) const { for (key_value *kv = key_values; kv; kv = kv->next) if (kv->key == key) return kv->value; - return shstr_null; + return shstr (); } void -object::kv_set (const shstr &key, const shstr &value) +object::kv_set (shstr_tmp key, shstr_tmp value) { for (key_value *kv = key_values; kv; kv = kv->next) if (kv->key == key) @@ -2348,7 +2433,7 @@ } void -object::kv_del (const shstr &key) +object::kv_del (shstr_tmp key) { for (key_value **kvp = &key_values; *kvp; kvp = &(*kvp)->next) if ((*kvp)->key == key) @@ -2417,12 +2502,13 @@ char info2[256 * 4]; char *p = info; - p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s,flags:[%s],type:%d}", + p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s%s,flags:[%s],type:%d}", count, uuid.c_str (), &name, - title ? "\",title:\"" : "", + title ? ",title:\"" : "", title ? (const char *)title : "", + title ? "\"" : "", flag_desc (flagdesc, 512), type); if (!flag[FLAG_REMOVED] && env) @@ -2450,15 +2536,6 @@ : region::default_region (); } -const materialtype_t * -object::dominant_material () const -{ - if (materialtype_t *mt = name_to_material (materialname)) - return mt; - - return name_to_material (shstr_unknown); -} - void object::open_container (object *new_container) { @@ -2488,7 +2565,7 @@ // client needs item update to make it work, client bug requires this to be separate esrv_update_item (UPD_FLAGS, this, old_container); - new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container)); + new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", old_container->query_name ()); play_sound (sound_find ("chest_close")); } @@ -2502,13 +2579,13 @@ // insert the "Close Container" object. if (archetype *closer = new_container->other_arch) { - object *closer = arch_to_object (new_container->other_arch); + object *closer = new_container->other_arch->instance (); closer->flag [FLAG_NO_MAP_SAVE] = 1; new_container->insert (closer); } #endif - new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container)); + new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", new_container->query_name ()); // make sure the container is available, client bug requires this to be separate esrv_send_item (this, new_container); @@ -2526,7 +2603,7 @@ } object * -object::force_find (const shstr name) +object::force_find (shstr_tmp name) { /* cycle through his inventory to look for the MARK we want to * place @@ -2538,40 +2615,99 @@ return 0; } +//-GPL + void -object::force_add (const shstr name, int duration) +object::force_set_timer (int duration) +{ + this->duration = 1; + this->speed_left = -1.f; + + this->set_speed (duration ? 1.f / duration : 0.f); +} + +object * +object::force_add (shstr_tmp name, int duration) { if (object *force = force_find (name)) force->destroy (); object *force = get_archetype (FORCE_NAME); - force->slaying = name; - force->stats.food = 1; - force->speed_left = -1.f; + force->slaying = name; + force->force_set_timer (duration); + force->flag [FLAG_APPLIED] = true; - force->set_speed (duration ? 1.f / duration : 0.f); - force->flag [FLAG_IS_USED_UP] = true; - force->flag [FLAG_APPLIED] = true; - - insert (force); + return insert (force); } void -object::play_sound (faceidx sound) +object::play_sound (faceidx sound) const { if (!sound) return; - if (flag [FLAG_REMOVED]) + if (is_on_map ()) + map->play_sound (sound, x, y); + else if (object *pl = in_player ()) + pl->contr->play_sound (sound); +} + +void +object::say_msg (const char *msg) const +{ + if (is_on_map ()) + map->say_msg (msg, x, y); + else if (object *pl = in_player ()) + pl->contr->play_sound (sound); +} + +void +object::make_noise () +{ + // we do not model noise in the map, so instead put + // a temporary light into the noise source + // could use the map instead, but that's less reliable for our + // goal, which is to make invisibility a bit harder to exploit + + // currently only works sensibly for players + if (!is_player ()) return; - if (env) + // find old force, or create new one + object *force = force_find (shstr_noise_force); + + if (force) + force->speed_left = -1.f; // patch old speed up + else + { + force = archetype::get (shstr_noise_force); + + force->slaying = shstr_noise_force; + force->stats.food = 1; + force->speed_left = -1.f; + + force->set_speed (1.f / 4.f); + force->flag [FLAG_IS_USED_UP] = true; + force->flag [FLAG_APPLIED] = true; + + insert (force); + } +} + +void object::change_move_type (MoveType mt) +{ + if (move_type == mt) + return; + + if (is_on_map ()) { - if (object *pl = in_player ()) - pl->contr->play_sound (sound); + // we are on the map, so handle move_on/off effects + remove (); + move_type = mt; + map->insert (this, x, y, this); } else - map->play_sound (sound, x, y); + move_type = mt; }