[ViewVC] Diff of: cvs/deliantra/server/common/object.c

Comparing deliantra/server/common/object.c (file contents):
Revision 1.2 by root, Tue Feb 7 23:29:55 2006 UTC vs.
Revision 1.6 by root, Sun Jun 4 19:46:55 2006 UTC

 /*
  * static char *rcsid_object_c =
- *   "$Id: object.c,v 1.2 2006/02/07 23:29:55 root Exp $";
+ *   "$Id: object.c,v 1.6 2006/06/04 19:46:55 root Exp $";
  */
 /*
     CrossFire, A Multiplayer game for X-windows
   0,1,2,3,4,5,6,7,8,1,2,2,2,3,4,4,4,5,6,6,6,7,8,8,8,
   1,2,2,2,2,2,3,4,4,4,4,4,5,6,6,6,6,6,7,8,8,8,8,8};
 /* Returns TRUE if every key_values in wants has a partner with the same value in has. */
-static int compare_ob_value_lists_one(object * wants, object * has) {
+static int compare_ob_value_lists_one(const object * wants, const object * has) {
     key_value * wants_field;
     /* n-squared behaviour (see get_ob_key_link()), but I'm hoping both
      * objects with lists are rare, and lists stay short. If not, use a
      * different structure or at least keep the lists sorted...
     /* If we get here, every field in wants has a matching field in has. */
     return TRUE;
 }
 /* Returns TRUE if ob1 has the same key_values as ob2. */
-static int compare_ob_value_lists(object * ob1, object * ob2) {
+static int compare_ob_value_lists(const object * ob1, const object * ob2) {
     /* However, there may be fields in has which aren't partnered in wants,
      * so we need to run the comparison *twice*. :(
      */
     return compare_ob_value_lists_one(ob1, ob2) && compare_ob_value_lists_one(ob2, ob1);
 }
 	(ob1->materialname != ob2->materialname) ||
 	(ob1->lore != ob2->lore) ||
 	(ob1->subtype != ob2->subtype) ||
 	(ob1->move_type != ob2->move_type) ||
 	(ob1->move_block != ob2->move_block) ||
+	(ob1->move_allow != ob2->move_allow) ||
 	(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)
 	)
      * some items equipped, and we don't want those to merge.
      */
     if (QUERY_FLAG(ob1, FLAG_APPLIED) || QUERY_FLAG(ob2, FLAG_APPLIED))
 	return 0;
+    switch (ob1->type) {
+	case SCROLL:
+	    if (ob1->level != ob2->level) return 0;
+	    break;
+    }
     if (ob1->key_values != NULL || ob2->key_values != NULL) {
         /* At least one of these has key_values. */
         if ((ob1->key_values == NULL) != (ob2->key_values == NULL)) {
             /* One has fields, but the other one doesn't. */
             return 0;
-        } else {
-            return compare_ob_value_lists(ob1, ob2);
+        } else if (!compare_ob_value_lists(ob1, ob2)) {
+            return 0;
         }
     }
-    switch (ob1->type) {
-	case SCROLL:
-	    if (ob1->level != ob2->level) return 0;
-	    break;
-    }
     /* Everything passes, must be OK. */
     return 1;
 }
 /*
  * 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,object *pl) {
+object *get_nearest_part(object *op, const object *pl) {
   object *tmp,*closest;
   int last_dist,i;
   if(op->more==NULL)
     return op;
   for(last_dist=distance(op,pl),closest=op,tmp=op->more;tmp!=NULL;tmp=tmp->more)
  * 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 <name-of-other-player> food 999"
  */
-object *find_object_name(char *str) {
+object *find_object_name(const char *str) {
   const char *name=add_string(str);
   object *op;
   for(op=objects;op!=NULL;op=op->next)
     if(op->name==name)
       break;
         if (QUERY_FLAG(op, FLAG_ALIVE) && !(flags & P_IS_ALIVE))
             update_now=1;
 	if ((move_on | op->move_on) != move_on) update_now=1;
 	if ((move_off | op->move_off) != move_off) update_now=1;
+	/* This isn't perfect, but I don't expect a lot of objects to
+	 * to have move_allow right now.
+	 */
-	if ((move_block | op->move_block) != move_block) update_now=1;
+	if (((move_block | op->move_block) & ~op->move_allow) != move_block)
+	    update_now=1;
 	if ((move_slow | op->move_slow) != move_slow) update_now=1;
     }
     /* 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.
     if(op->more!=NULL) {
 	/* The part may be on a different map. */
 	object *more = op->more;
+	/* We really need the caller to normalize coordinates - if
+	 * we set the map, that doesn't work if the location is within
+	 * a map and this is straddling an edge.  So only if coordinate
+	 * is clear wrong do we normalize it.
+	 */
+	if (OUT_OF_REAL_MAP(more->map, more->x, more->y)) {
-	/* Debugging information so you can see the last coordinates this object had */
+	    /* Debugging information so you can see the last coordinates this object had */
-	more->ox = more->x;
+	    more->ox = more->x;
-	more->oy = more->y;
+	    more->oy = more->y;
-	more->map = get_map_from_coord(m, &more->x, &more->y);
+	    more->map = get_map_from_coord(m, &more->x, &more->y);
+	} else if (!more->map) {
+	    /* For backwards compatibility - when not dealing with tiled maps,
+	     * more->map should always point to the parent.
+	     */
+	    more->map = m;
+	}
 	if (insert_ob_in_map(more, more->map, originator, flag) == NULL) {
 	    if ( ! op->head)
 		LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
 	    return NULL;
     CLEAR_FLAG(op,FLAG_REMOVED);
     /* Debugging information so you can see the last coordinates this object had */
     op->ox=op->x;
     op->oy=op->y;
+    /* 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
+     */
+    op->map=get_map_from_coord(m, &op->x, &op->y);
     x = op->x;
     y = op->y;
-    op->map=get_map_from_coord(m, &x, &y);
     /* this has to be done after we translate the coordinates.
      */
     if(op->nrof && !(flag & INS_NO_MERGE)) {
 	for(tmp=GET_MAP_OB(op->map,x,y);tmp!=NULL;tmp=tmp->above)
 	    if (CAN_MERGE(op,tmp)) {
 		op->nrof+=tmp->nrof;
 		remove_ob(tmp);
 		free_object(tmp);
 	    }
-    }
-    /* 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 (op->map != m) {
-	/* coordinates should not change unless map also changes */
-	op->x = x;
-	op->y = y;
     }
     CLEAR_FLAG(op,FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
     CLEAR_FLAG(op, FLAG_INV_LOCKED);
     if (!QUERY_FLAG(op, FLAG_ALIVE))
 /* this function inserts an object in the map, but if it
  *  finds an object of its own type, it'll remove that one first.
  *  op is the object to insert it under:  supplies x and the map.
  */
-void replace_insert_ob_in_map(char *arch_string, object *op) {
+void replace_insert_ob_in_map(const char *arch_string, object *op) {
     object *tmp;
     object *tmp1;
     /* first search for itself and remove any old instances */
  * present_arch(arch, map, x, y) searches for any objects with
  * a matching archetype at the given map and coordinates.
  * The first matching object is returned, or NULL if none.
  */
-object *present_arch(archetype *at, mapstruct *m, int x, int y) {
+object *present_arch(const archetype *at, mapstruct *m, int x, int y) {
   object *tmp;
   if(m==NULL || out_of_map(m,x,y)) {
     LOG(llevError,"Present_arch called outside map.\n");
     return NULL;
   }
  * present_in_ob(type, object) searches for any objects with
  * a matching type variable in the inventory of the given object.
  * The first matching object is returned, or NULL if none.
  */
-object *present_in_ob(unsigned char type,object *op) {
+object *present_in_ob(unsigned char type, const object *op) {
   object *tmp;
   for(tmp=op->inv;tmp!=NULL;tmp=tmp->below)
     if(tmp->type==type)
       return tmp;
   return NULL;
  * the object name, not the archetype name.  this is so that the
  * spell code can use one object type (force), but change it's name
  * to be unique.
  */
-object *present_in_ob_by_name(int type, char *str,object *op) {
+object *present_in_ob_by_name(int type, const char *str, const object *op) {
     object *tmp;
     for(tmp=op->inv; tmp!=NULL; tmp=tmp->below) {
 	if ((type==-1 || tmp->type==type) && (!strcmp(str, tmp->name)))
 	    return tmp;
  * present_arch_in_ob(archetype, object) searches for any objects with
  * a matching archetype in the inventory of the given object.
  * The first matching object is returned, or NULL if none.
  */
-object *present_arch_in_ob(archetype *at, object *op)  {
+object *present_arch_in_ob(const archetype *at, const object *op)  {
   object *tmp;
   for(tmp=op->inv;tmp!=NULL;tmp=tmp->below)
     if( tmp->arch == at)
       return tmp;
   return NULL;
  * to know if the space in question will block the object.  We can't use
  * the archetype because that isn't correct if the monster has been
  * customized, changed states, etc.
  */
-int find_free_spot(object *ob, mapstruct *m,int x,int y,int start,int stop) {
+int find_free_spot(const object *ob, mapstruct *m,int x,int y,int start,int stop) {
     int i,index=0, flag;
     static int altern[SIZEOFFREE];
     for(i=start;i<stop;i++) {
 	flag = ob_blocked(ob,m,x+freearr_x[i],y+freearr_y[i]);
  * find_free_spot(), but it will search max number of squares.
  * But it will return the first available spot, not a random choice.
  * Changed 0.93.2: Have it return -1 if there is no free spot available.
  */
-int find_first_free_spot(object *ob, mapstruct *m,int x,int y) {
+int find_first_free_spot(const object *ob, mapstruct *m,int x,int y) {
     int i;
     for(i=0;i<SIZEOFFREE;i++) {
 	if(!ob_blocked(ob,m,x+freearr_x[i],y+freearr_y[i]))
 	    return i;
     }
 /*
  * distance(object 1, object 2) will return the square of the
  * distance between the two given objects.
  */
-int distance(object *ob1,object *ob2) {
+int distance(const object *ob1, const object *ob2) {
   int i;
   i= (ob1->x - ob2->x)*(ob1->x - ob2->x)+
          (ob1->y - ob2->y)*(ob1->y - ob2->y);
   return i;
 }
  * core dumps if they do.
  *
  * Add a check so we can't pick up invisible objects (0.93.8)
  */
-int can_pick(object *who,object *item) {
+int can_pick(const object *who, const object *item) {
   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));
 }
     return dst;
 }
 /* return true if the object was destroyed, 0 otherwise */
-int was_destroyed (object *op, tag_t old_tag)
+int was_destroyed (const object *op, tag_t old_tag)
 {
     /* checking for FLAG_FREED isn't necessary, but makes this function more
      * robust */
     return op->count != old_tag || QUERY_FLAG (op, FLAG_FREED);
 }
 /* load_object on it. I admit it is a highly inefficient way to make things, */
 /* but it was simple to make and allows reusing the load_object function.    */
 /* Remember not to use load_object_str in a time-critical situation.         */
 /* Also remember that multiparts objects are not supported for now.          */
-object* load_object_str(char *obstr)
+object* load_object_str(const char *obstr)
 {
     object *op;
     FILE *tempfile;
     char filename[MAX_BUF];
     sprintf(filename,"%s/cfloadobstr2044",settings.tmpdir);
 /* This returns the first object in who's inventory that
  * has the same type and subtype match.
  * returns NULL if no match.
  */
-object *find_obj_by_type_subtype(object *who, int type, int subtype)
+object *find_obj_by_type_subtype(const object *who, int type, int subtype)
 {
     object *tmp;
     for (tmp=who->inv; tmp; tmp=tmp->below)
 	if (tmp->type == type && tmp->subtype == subtype) return tmp;
  * otherwise return NULL.
  *
  * key must be a passed in shared string - otherwise, this won't
  * do the desired thing.
  */
-key_value * get_ob_key_link(object * ob, const char * key) {
+key_value * get_ob_key_link(const object * ob, const char * key) {
     key_value * link;
     for (link = ob->key_values; link != NULL; link = link->next) {
         if (link->key == key) {
             return link;
  *
  * The argument doesn't need to be a shared string.
  *
  * The returned string is shared.
  */
-const char * get_ob_key_value(object * op, const char * const key) {
+const char * get_ob_key_value(const object * op, const char * const key) {
     key_value * link;
     const char * canonical_key;
     canonical_key = find_string(key);
  * Returns TRUE on success.
  */
 int set_ob_key_value_s(object * op, const char * canonical_key, const char * value, int add_key) {
     key_value * field = NULL, *last=NULL;
-    LOG(llevDebug, "set_ob_value_s: '%s' '%s' %d\n", canonical_key, value, add_key);
     for (field=op->key_values; field != NULL; field=field->next) {
 	if (field->key != canonical_key) {
 	    last = field;
 	    continue;
 	}

Diff Legend

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

Comparing deliantra/server/common/object.c (file contents): Revision 1.2 by root, Tue Feb 7 23:29:55 2006 UTC vs. Revision 1.6 by root, Sun Jun 4 19:46:55 2006 UTC

Diff Legend

Comparing deliantra/server/common/object.c (file contents):
Revision 1.2 by root, Tue Feb 7 23:29:55 2006 UTC vs.
Revision 1.6 by root, Sun Jun 4 19:46:55 2006 UTC