server/server/move.c

/*
 * static char *rcsid_move_c =
 *    "$Id$";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2002 Mark Wedel & Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    This program 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 2 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, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The author can be reached via e-mail to crossfire-devel@real-time.com
*/

#include <global.h>
#ifndef __CEXTRACT__
#include <sproto.h>
#endif

#ifdef COZY_SERVER
// use a ptotoype
extern int same_party (partylist *a, partylist *b);
#endif

/*
 * move_object() tries to move object op in the direction "dir".
 * If it fails (something blocks the passage), it returns 0,
 * otherwise 1.
 * This is an improvement from the previous move_ob(), which
 * removed and inserted objects even if they were unable to move.
 */

int move_object(object *op, int dir) {
    return move_ob(op, dir, op);
}


/* object op is trying to move in direction dir.
 * originator is typically the same as op, but
 * can be different if originator is causing op to
 * move (originator is pushing op)
 * returns 0 if the object is not able to move to the
 * desired space, 1 otherwise (in which case we also 
 * move the object accordingly.  This function is
 * very similiar to move_object.
  */
int move_ob (object *op, int dir, object *originator)
{
    sint16 newx = op->x+freearr_x[dir];
    sint16 newy = op->y+freearr_y[dir];
    object *tmp;
    mapstruct *m;
    int mflags;

    if(op==NULL) {
        LOG(llevError,"Trying to move NULL.\n");
        return 0;
    }

    m = op->map;
    mflags = get_map_flags(m, &m, newx, newy, &newx, &newy);

    /* If the space the player is trying to is out of the map,
     * bail now - we know it can't work.
     */
    if (mflags & P_OUT_OF_MAP) return 0;


    /* Is this space blocked?  Players with wizpass are immune to
     * this condition.
     */
    if(blocked_link(op, m, newx, newy) &&
       !QUERY_FLAG(op, FLAG_WIZPASS))
        return 0;

    /* 0.94.2 - we need to set the direction for the new animation code.
     * it uses it to figure out face to use - I can't see it
     * breaking anything, but it might.
     */
    if(op->more != NULL && !move_ob(op->more, dir, op->more->head))
        return 0;

    op->direction = dir;

    if(op->will_apply&4)
        check_earthwalls(op,m, newx,newy);
    if(op->will_apply&8)
        check_doors(op,m, newx,newy);

    /* 0.94.1 - I got a stack trace that showed it crash with remove_ob trying
     * to remove a removed object, and this function was the culprit.  A possible
     * guess I have is that check_doors above ran into a trap, killing the
     * monster.
     *
     * Unfortunately, it doesn't appear that the calling functions of move_object
     * deal very well with op being killed, so all this might do is just
     * migrate the problem someplace else.
     */

    if (QUERY_FLAG(op, FLAG_REMOVED)) {
        LOG(llevDebug,"move_object: monster has been removed - will not process further\n");
        /* Was not successful, but don't want to try and move again */
        return 1;
    }

    /* If this is a tail portion, just want to tell caller that move is
     * ok - the caller will deal with actual object removal/insertion
     */
    if(op->head)
        return 1;

    remove_ob(op);

    /* we already have newx, newy, and m, so lets use them.
     * In addition, this fixes potential crashes, because multipart object was
     * on edge of map, +=x, +=y doesn't make correct coordinates.
     */
    for(tmp = op; tmp != NULL; tmp = tmp->more) {
        tmp->x += freearr_x[dir];
        tmp->y += freearr_y[dir];
        tmp->map =  get_map_from_coord(tmp->map, &tmp->x, &tmp->y);
    }

    /* insert_ob_in_map will deal with any tiling issues */
    insert_ob_in_map(op, m, originator,0);

    /* Hmmm.  Should be possible for multispace players now */
    if (op->type==PLAYER) {
        esrv_map_scroll(&op->contr->socket, freearr_x[dir],freearr_y[dir]);
        op->contr->socket.update_look=1;
        op->contr->socket.look_position=0;
    }
    else if (op->type == TRANSPORT) {
        object *pl;

        for (pl=op->inv; pl; pl=pl->below) {
            if (pl->type == PLAYER) {
                pl->contr->do_los=1;
                pl->map = op->map;
                pl->x = op->x;
                pl->y = op->y;
                esrv_map_scroll(&pl->contr->socket, freearr_x[dir],freearr_y[dir]);
                pl->contr->socket.update_look=1;
                pl->contr->socket.look_position=0;
            }
        }
    }

    return 1;   /* this shouldn't be reached */
}


/*
 * transfer_ob(): Move an object (even linked objects) to another spot
 * on the same map.
 *
 * Does nothing if there is no free spot.
 *
 * randomly: If true, use find_free_spot() to find the destination, otherwise
 * use find_first_free_spot().
 *
 * Return value: 1 if object was destroyed, 0 otherwise.
 */

int transfer_ob (object *op, int x, int y, int randomly, object *originator)
{
    int i;
    object *tmp;

    if (randomly)
        i = find_free_spot (op,op->map,x,y,0,SIZEOFFREE);
    else
        i = find_first_free_spot(op,op->map,x,y);

    if (i==-1)
        return 0;       /* No free spot */

    if(op->head!=NULL)
        op=op->head;
    remove_ob(op);
    for(tmp=op;tmp!=NULL;tmp=tmp->more)
        tmp->x=x+freearr_x[i]+(tmp->arch==NULL?0:tmp->arch->clone.x),
        tmp->y=y+freearr_y[i]+(tmp->arch==NULL?0:tmp->arch->clone.y);

    tmp = insert_ob_in_map(op,op->map,originator,0);
    if (op && op->type == PLAYER) MapNewmapCmd(op->contr);
    if (tmp) return 0;
    else return 1;
}

/*
 * Return value: 1 if object was destroyed, 0 otherwise.
 * Modified so that instead of passing the 'originator' that had no
 * real use, instead we pass the 'user' of the teleporter.  All the
 * callers know what they wanted to teleporter (move_teleporter or
 * shop map code)
 * tele_type is the type of teleporter we want to match against -
 * currently, this is either set to SHOP_MAT or TELEPORTER.
 * It is basically used so that shop_mats and normal teleporters can
 * be used close to each other and not have the player put to the
 * one of another type.
 */
int teleport (object *teleporter, uint8 tele_type, object *user)
{
    object *altern;
    int i,j,k,nrofalt=0;
    object *other_teleporter, *tmp;
    mapstruct *m;
    sint16  sx, sy;

    if(user==NULL) return 0;
    if(user->head!=NULL)
        user=user->head;

    /* Find all other teleporters within range.  This range
     * should really be setable by some object attribute instead of
     * using hard coded values.
     */
    for(i= -5;i<6;i++)
        for(j= -5;j<6;j++) {
            if(i==0&&j==0)
                continue;
            /* Perhaps this should be extended to support tiled maps */
            if(OUT_OF_REAL_MAP(teleporter->map,teleporter->x+i,teleporter->y+j))
                continue;
            other_teleporter=get_map_ob(teleporter->map,
                                  teleporter->x+i,teleporter->y+j);

            while (other_teleporter) {
                if (other_teleporter->type == tele_type) break;
                other_teleporter = other_teleporter->above;
            }
            if (other_teleporter && !(RANDOM() % ++nrofalt))
                altern = other_teleporter;
        }

    if(!nrofalt) {
        LOG(llevError,"No alternative teleporters around!\n");
        return 0;
    }

    other_teleporter=altern;
    k=find_free_spot(user,other_teleporter->map,
                        other_teleporter->x,other_teleporter->y,1,9);

    /* if k==-1, unable to find a free spot.  If this is shop
     * mat that the player is using, find someplace to move
     * the player - otherwise, player can get trapped in the shops
     * that appear in random dungeons.  We basically just make
     * sure the space isn't no pass (eg wall), and don't care
     * about is alive.
     */
    if (k==-1) {
        if (tele_type == SHOP_MAT && user->type == PLAYER) {
            for (k=1; k<9; k++) {
                if (get_map_flags(other_teleporter->map, &m, 
                        other_teleporter->x + freearr_x[k],
                        other_teleporter->y + freearr_y[k], &sx,&sy) &
                        P_OUT_OF_MAP) continue;

                if (!OB_TYPE_MOVE_BLOCK(user, GET_MAP_MOVE_BLOCK(m, sx, sy))) break;

            }
            if (k==9) {
                LOG(llevError,"Shop mat %s (%d, %d) is in solid rock?\n",
                    other_teleporter->name, other_teleporter->x, other_teleporter->y);
                return 0;
            }
        }
        else return 0;
    }

    remove_ob(user);

    /* Update location for the object */
    for(tmp=user;tmp!=NULL;tmp=tmp->more) {
        tmp->x=other_teleporter->x+freearr_x[k]+
           (tmp->arch==NULL?0:tmp->arch->clone.x);
        tmp->y=other_teleporter->y+freearr_y[k]+
           (tmp->arch==NULL?0:tmp->arch->clone.y);
    }
    tmp = insert_ob_in_map(user,other_teleporter->map,NULL,0);
    if (tmp && tmp->type == PLAYER) MapNewmapCmd(tmp->contr);
    return (tmp == NULL);
}

void recursive_roll(object *op,int dir,object *pusher) {
  if(!roll_ob(op,dir,pusher)) {
    new_draw_info_format(NDI_UNIQUE, 0, pusher,
        "You fail to push the %s.",query_name(op));
    return;
  }
  (void) move_ob(pusher,dir,pusher);
  new_draw_info_format(NDI_BLACK, 0, pusher,
        "You move the %s.",query_name(op));
  return;
}

/*
 * This is a new version of blocked, this one handles objects
 * that can be passed through by monsters with the CAN_PASS_THRU defined.
 *
 * very new version handles also multipart objects
 * This is currently only used for the boulder roll code.
 * Returns 1 if object does not fit, 0 if it does.
 */

int try_fit (object *op, mapstruct *m, int x, int y) 
{
    object *tmp, *more;
    sint16 tx, ty;
    int mflags;
    mapstruct *m2;

    if (op->head) 
        op = op->head;

    for (more = op; more ; more = more->more) {
        tx = x + more->x - op->x;
        ty = y + more->y - op->y;

        mflags = get_map_flags(m, &m2, tx, ty, &tx, &ty);

        if (mflags & P_OUT_OF_MAP)
            return 1;

        for (tmp = get_map_ob (m2, tx, ty); tmp; tmp=tmp->above) {
            if (tmp->head == op || tmp == op)
                continue;

            if ((QUERY_FLAG(tmp,FLAG_ALIVE) && tmp->type!=DOOR))
                return 1;

            if (OB_MOVE_BLOCK(op, tmp)) return 1;

        }
    }
    return 0;
}

/*
 * this is not perfect yet. 
 * it does not roll objects behind multipart objects properly.
 * Support for rolling multipart objects is questionable.
 */

int roll_ob(object *op,int dir, object *pusher) {
    object *tmp;
    sint16 x, y;
    int flags;
    mapstruct *m;
    MoveType    move_block;

    if (op->head) 
        op = op->head;

    x=op->x+freearr_x[dir];
    y=op->y+freearr_y[dir];

    if(!QUERY_FLAG(op,FLAG_CAN_ROLL) || 
       (op->weight &&
       random_roll(0, op->weight/50000-1, pusher, PREFER_LOW) > pusher->stats.Str))
        return 0;

    m = op->map;
    flags = get_map_flags(m, &m, x, y, &x, &y);

    if (flags & (P_OUT_OF_MAP | P_IS_ALIVE))
        return 0;

    move_block = GET_MAP_MOVE_BLOCK(m, x, y);

    /* If the target space is not blocked, no need to look at the objects on it */
    if ((op->move_type & move_block) == op->move_type) {
        for (tmp=get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) {
        if (tmp->head == op)
            continue;
        if (OB_MOVE_BLOCK(op, tmp) && !roll_ob(tmp,dir,pusher))
            return 0;
        }
    }
    if (try_fit (op, m, x, y))
        return 0;

    remove_ob(op);
    for(tmp=op; tmp!=NULL; tmp=tmp->more)
        tmp->x+=freearr_x[dir],tmp->y+=freearr_y[dir];
    insert_ob_in_map(op,op->map,pusher,0);
    return 1;
}

/* returns 1 if pushing invokes a attack, 0 when not */
int push_ob(object *who, int dir, object *pusher) {
    int str1, str2;
    object *owner;

    if (who->head != NULL)
        who = who->head;
    owner = get_owner(who);

    /* Wake up sleeping monsters that may be pushed */
    CLEAR_FLAG(who,FLAG_SLEEP);
  
    /* player change place with his pets or summoned creature */
    /* TODO: allow multi arch pushing. Can't be very difficult */
    if (who->more == NULL 
#ifdef COZY_SERVER
        &&
        (
          (owner && owner->contr && pusher->contr 
           && same_party (owner->contr->party, pusher->contr->party))
          || owner == pusher
        )
#else
        && owner == pusher
#endif
        ) {
        int temp;
        mapstruct *m;

        remove_ob(who);
        remove_ob(pusher);
        temp = pusher->x;
        pusher->x = who->x;
        who->x = temp;

        temp = pusher->y;
        pusher->y = who->y;
        who->y = temp;

        m = pusher->map;
        pusher->map = who->map;
        who->map = m;

        insert_ob_in_map (who,who->map,pusher,0);
        insert_ob_in_map (pusher,pusher->map,pusher,0);

        /* we presume that if the player is pushing his put, he moved in
         * direction 'dir'.  I can' think of any case where this would not be
         * the case.  Putting the map_scroll should also improve performance some.
         */
        if (pusher->type == PLAYER ) {
            esrv_map_scroll(&pusher->contr->socket, freearr_x[dir],freearr_y[dir]);
            pusher->contr->socket.update_look=1;
            pusher->contr->socket.look_position=0;
        }
        return 0;
    }


    /* We want ONLY become enemy of evil, unaggressive monster. We must RUN in them */
    /* In original we have here a unaggressive check only - that was the reason why */
    /* we so often become an enemy of friendly monsters... */
    /* funny: was they set to unaggressive 0 (= not so nice) they don't attack */

    if(owner != pusher &&  pusher->type == PLAYER && who->type != PLAYER &&
      !QUERY_FLAG(who,FLAG_FRIENDLY)&& !QUERY_FLAG(who,FLAG_NEUTRAL)) {
        if(pusher->contr->run_on) /* only when we run */ {
            new_draw_info_format(NDI_UNIQUE, 0, pusher,
              "You start to attack %s !!",who->name);
            CLEAR_FLAG(who,FLAG_UNAGGRESSIVE); /* the sucker don't like you anymore */
            who->enemy = pusher;
            return 1;
        }
        else 
        {
            new_draw_info_format(NDI_UNIQUE, 0, pusher,
                                 "You avoid attacking %s .",who->name);
        }
    }

    /* now, lets test stand still. we NEVER can push stand_still monsters. */
    if(QUERY_FLAG(who,FLAG_STAND_STILL))
    {
        new_draw_info_format(NDI_UNIQUE, 0, pusher,
          "You can't push %s.",who->name);
        return 0;
    }
  
    /* This block is basically if you are pushing friendly but
     * non pet creaturs.
     * It basically does a random strength comparision to
     * determine if you can push someone around.  Note that
     * this pushes the other person away - its not a swap.
     */

    str1 = (who->stats.Str>0?who->stats.Str:who->level);
    str2 = (pusher->stats.Str>0?pusher->stats.Str:pusher->level);
    if(QUERY_FLAG(who,FLAG_WIZ) ||
       random_roll(str1, str1/2+str1*2, who, PREFER_HIGH) >= 
       random_roll(str2, str2/2+str2*2, pusher, PREFER_HIGH) ||
       !move_object(who,dir))
    {
        if (who ->type == PLAYER) {
            new_draw_info_format(NDI_UNIQUE, 0, who,
                 "%s tried to push you.",pusher->name);
        }
        return 0;
    }

    /* If we get here, the push succeeded.
     * Let everyone know the status.
     */
    if (who->type == PLAYER) {
        new_draw_info_format(NDI_UNIQUE, 0, who,
                             "%s pushed you.",pusher->name);
    }
    if (pusher->type == PLAYER) {
        new_draw_info_format(NDI_UNIQUE, 0, pusher,
                "You pushed %s back.", who->name);
    }
  
    return 1;
}
Revision:	1.6
Committed:	Sun Aug 13 17:16:04 2006 UTC (17 years, 9 months ago) by elmex
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.5:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	Made server compile with C++. Removed cfanim plugin and crossedit. C++ here we come.
#	User	Rev	Content
1	root	1.1	/*
2			* static char *rcsid_move_c =
3	elmex	1.4	* "$Id$";
4	root	1.1	*/
5
6			/*
7			CrossFire, A Multiplayer game for X-windows
8
9			Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10			Copyright (C) 1992 Frank Tore Johansen
11
12			This program is free software; you can redistribute it and/or modify
13			it under the terms of the GNU General Public License as published by
14			the Free Software Foundation; either version 2 of the License, or
15			(at your option) any later version.
16
17			This program is distributed in the hope that it will be useful,
18			but WITHOUT ANY WARRANTY; without even the implied warranty of
19			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20			GNU General Public License for more details.
21
22			You should have received a copy of the GNU General Public License
23			along with this program; if not, write to the Free Software
24			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25
26			The author can be reached via e-mail to crossfire-devel@real-time.com
27			*/
28
29			#include <global.h>
30			#ifndef __CEXTRACT__
31			#include <sproto.h>
32			#endif
33
34	root	1.3	#ifdef COZY_SERVER
35			// use a ptotoype
36	root	1.2	extern int same_party (partylist a, partylist b);
37	root	1.3	#endif
38	root	1.2
39	root	1.1	/*
40			* move_object() tries to move object op in the direction "dir".
41			* If it fails (something blocks the passage), it returns 0,
42			* otherwise 1.
43			* This is an improvement from the previous move_ob(), which
44			* removed and inserted objects even if they were unable to move.
45			*/
46
47			int move_object(object *op, int dir) {
48			return move_ob(op, dir, op);
49			}
50
51
52			/* object op is trying to move in direction dir.
53			* originator is typically the same as op, but
54			* can be different if originator is causing op to
55			* move (originator is pushing op)
56			* returns 0 if the object is not able to move to the
57			* desired space, 1 otherwise (in which case we also
58			* move the object accordingly. This function is
59			* very similiar to move_object.
60			*/
61			int move_ob (object op, int dir, object originator)
62			{
63			sint16 newx = op->x+freearr_x[dir];
64			sint16 newy = op->y+freearr_y[dir];
65			object *tmp;
66			mapstruct *m;
67			int mflags;
68
69			if(op==NULL) {
70			LOG(llevError,"Trying to move NULL.\n");
71			return 0;
72			}
73
74			m = op->map;
75			mflags = get_map_flags(m, &m, newx, newy, &newx, &newy);
76
77			/* If the space the player is trying to is out of the map,
78			* bail now - we know it can't work.
79			*/
80			if (mflags & P_OUT_OF_MAP) return 0;
81
82
83			/* Is this space blocked? Players with wizpass are immune to
84			* this condition.
85			*/
86			if(blocked_link(op, m, newx, newy) &&
87			!QUERY_FLAG(op, FLAG_WIZPASS))
88			return 0;
89
90			/* 0.94.2 - we need to set the direction for the new animation code.
91			* it uses it to figure out face to use - I can't see it
92			* breaking anything, but it might.
93			*/
94			if(op->more != NULL && !move_ob(op->more, dir, op->more->head))
95			return 0;
96
97			op->direction = dir;
98
99			if(op->will_apply&4)
100			check_earthwalls(op,m, newx,newy);
101			if(op->will_apply&8)
102			check_doors(op,m, newx,newy);
103
104			/* 0.94.1 - I got a stack trace that showed it crash with remove_ob trying
105			* to remove a removed object, and this function was the culprit. A possible
106			* guess I have is that check_doors above ran into a trap, killing the
107			* monster.
108			*
109			* Unfortunately, it doesn't appear that the calling functions of move_object
110			* deal very well with op being killed, so all this might do is just
111			* migrate the problem someplace else.
112			*/
113
114			if (QUERY_FLAG(op, FLAG_REMOVED)) {
115			LOG(llevDebug,"move_object: monster has been removed - will not process further\n");
116			/* Was not successful, but don't want to try and move again */
117			return 1;
118			}
119
120			/* If this is a tail portion, just want to tell caller that move is
121			* ok - the caller will deal with actual object removal/insertion
122			*/
123			if(op->head)
124			return 1;
125
126			remove_ob(op);
127
128			/* we already have newx, newy, and m, so lets use them.
129			* In addition, this fixes potential crashes, because multipart object was
130			* on edge of map, +=x, +=y doesn't make correct coordinates.
131			*/
132			for(tmp = op; tmp != NULL; tmp = tmp->more) {
133	elmex	1.4	tmp->x += freearr_x[dir];
134			tmp->y += freearr_y[dir];
135			tmp->map = get_map_from_coord(tmp->map, &tmp->x, &tmp->y);
136	root	1.1	}
137
138			/* insert_ob_in_map will deal with any tiling issues */
139			insert_ob_in_map(op, m, originator,0);
140
141			/* Hmmm. Should be possible for multispace players now */
142			if (op->type==PLAYER) {
143			esrv_map_scroll(&op->contr->socket, freearr_x[dir],freearr_y[dir]);
144			op->contr->socket.update_look=1;
145			op->contr->socket.look_position=0;
146			}
147	elmex	1.4	else if (op->type == TRANSPORT) {
148			object *pl;
149
150			for (pl=op->inv; pl; pl=pl->below) {
151			if (pl->type == PLAYER) {
152			pl->contr->do_los=1;
153			pl->map = op->map;
154			pl->x = op->x;
155			pl->y = op->y;
156			esrv_map_scroll(&pl->contr->socket, freearr_x[dir],freearr_y[dir]);
157			pl->contr->socket.update_look=1;
158			pl->contr->socket.look_position=0;
159			}
160			}
161			}
162	root	1.1
163			return 1; /* this shouldn't be reached */
164			}
165
166
167			/*
168			* transfer_ob(): Move an object (even linked objects) to another spot
169			* on the same map.
170			*
171			* Does nothing if there is no free spot.
172			*
173			* randomly: If true, use find_free_spot() to find the destination, otherwise
174			* use find_first_free_spot().
175			*
176			* Return value: 1 if object was destroyed, 0 otherwise.
177			*/
178
179			int transfer_ob (object op, int x, int y, int randomly, object originator)
180			{
181			int i;
182			object *tmp;
183
184			if (randomly)
185			i = find_free_spot (op,op->map,x,y,0,SIZEOFFREE);
186			else
187			i = find_first_free_spot(op,op->map,x,y);
188
189			if (i==-1)
190			return 0; /* No free spot */
191
192			if(op->head!=NULL)
193			op=op->head;
194			remove_ob(op);
195			for(tmp=op;tmp!=NULL;tmp=tmp->more)
196			tmp->x=x+freearr_x[i]+(tmp->arch==NULL?0:tmp->arch->clone.x),
197			tmp->y=y+freearr_y[i]+(tmp->arch==NULL?0:tmp->arch->clone.y);
198
199			tmp = insert_ob_in_map(op,op->map,originator,0);
200			if (op && op->type == PLAYER) MapNewmapCmd(op->contr);
201			if (tmp) return 0;
202			else return 1;
203			}
204
205			/*
206			* Return value: 1 if object was destroyed, 0 otherwise.
207			* Modified so that instead of passing the 'originator' that had no
208			* real use, instead we pass the 'user' of the teleporter. All the
209			* callers know what they wanted to teleporter (move_teleporter or
210			* shop map code)
211			* tele_type is the type of teleporter we want to match against -
212			* currently, this is either set to SHOP_MAT or TELEPORTER.
213			* It is basically used so that shop_mats and normal teleporters can
214			* be used close to each other and not have the player put to the
215			* one of another type.
216			*/
217			int teleport (object teleporter, uint8 tele_type, object user)
218			{
219	root	1.5	object *altern;
220	root	1.1	int i,j,k,nrofalt=0;
221			object other_teleporter, tmp;
222			mapstruct *m;
223			sint16 sx, sy;
224
225			if(user==NULL) return 0;
226			if(user->head!=NULL)
227			user=user->head;
228
229			/* Find all other teleporters within range. This range
230			* should really be setable by some object attribute instead of
231			* using hard coded values.
232			*/
233			for(i= -5;i<6;i++)
234			for(j= -5;j<6;j++) {
235			if(i==0&&j==0)
236			continue;
237			/* Perhaps this should be extended to support tiled maps */
238			if(OUT_OF_REAL_MAP(teleporter->map,teleporter->x+i,teleporter->y+j))
239			continue;
240			other_teleporter=get_map_ob(teleporter->map,
241			teleporter->x+i,teleporter->y+j);
242
243			while (other_teleporter) {
244			if (other_teleporter->type == tele_type) break;
245			other_teleporter = other_teleporter->above;
246			}
247	root	1.5	if (other_teleporter && !(RANDOM() % ++nrofalt))
248			altern = other_teleporter;
249	root	1.1	}
250
251			if(!nrofalt) {
252			LOG(llevError,"No alternative teleporters around!\n");
253			return 0;
254			}
255
256	root	1.5	other_teleporter=altern;
257	root	1.1	k=find_free_spot(user,other_teleporter->map,
258			other_teleporter->x,other_teleporter->y,1,9);
259
260			/* if k==-1, unable to find a free spot. If this is shop
261			* mat that the player is using, find someplace to move
262			* the player - otherwise, player can get trapped in the shops
263			* that appear in random dungeons. We basically just make
264			* sure the space isn't no pass (eg wall), and don't care
265			* about is alive.
266			*/
267			if (k==-1) {
268			if (tele_type == SHOP_MAT && user->type == PLAYER) {
269			for (k=1; k<9; k++) {
270			if (get_map_flags(other_teleporter->map, &m,
271			other_teleporter->x + freearr_x[k],
272			other_teleporter->y + freearr_y[k], &sx,&sy) &
273			P_OUT_OF_MAP) continue;
274
275			if (!OB_TYPE_MOVE_BLOCK(user, GET_MAP_MOVE_BLOCK(m, sx, sy))) break;
276
277			}
278			if (k==9) {
279			LOG(llevError,"Shop mat %s (%d, %d) is in solid rock?\n",
280			other_teleporter->name, other_teleporter->x, other_teleporter->y);
281			return 0;
282			}
283			}
284			else return 0;
285			}
286
287			remove_ob(user);
288
289			/* Update location for the object */
290			for(tmp=user;tmp!=NULL;tmp=tmp->more) {
291			tmp->x=other_teleporter->x+freearr_x[k]+
292			(tmp->arch==NULL?0:tmp->arch->clone.x);
293			tmp->y=other_teleporter->y+freearr_y[k]+
294			(tmp->arch==NULL?0:tmp->arch->clone.y);
295			}
296			tmp = insert_ob_in_map(user,other_teleporter->map,NULL,0);
297			if (tmp && tmp->type == PLAYER) MapNewmapCmd(tmp->contr);
298			return (tmp == NULL);
299			}
300
301			void recursive_roll(object op,int dir,object pusher) {
302			if(!roll_ob(op,dir,pusher)) {
303			new_draw_info_format(NDI_UNIQUE, 0, pusher,
304			"You fail to push the %s.",query_name(op));
305			return;
306			}
307			(void) move_ob(pusher,dir,pusher);
308			new_draw_info_format(NDI_BLACK, 0, pusher,
309			"You move the %s.",query_name(op));
310			return;
311			}
312
313			/*
314			* This is a new version of blocked, this one handles objects
315			* that can be passed through by monsters with the CAN_PASS_THRU defined.
316			*
317			* very new version handles also multipart objects
318			* This is currently only used for the boulder roll code.
319			* Returns 1 if object does not fit, 0 if it does.
320			*/
321
322			int try_fit (object op, mapstruct m, int x, int y)
323			{
324			object tmp, more;
325			sint16 tx, ty;
326			int mflags;
327			mapstruct *m2;
328
329			if (op->head)
330			op = op->head;
331
332			for (more = op; more ; more = more->more) {
333			tx = x + more->x - op->x;
334			ty = y + more->y - op->y;
335
336			mflags = get_map_flags(m, &m2, tx, ty, &tx, &ty);
337
338			if (mflags & P_OUT_OF_MAP)
339			return 1;
340
341			for (tmp = get_map_ob (m2, tx, ty); tmp; tmp=tmp->above) {
342			if (tmp->head == op \|\| tmp == op)
343			continue;
344
345			if ((QUERY_FLAG(tmp,FLAG_ALIVE) && tmp->type!=DOOR))
346			return 1;
347
348			if (OB_MOVE_BLOCK(op, tmp)) return 1;
349
350			}
351			}
352			return 0;
353			}
354
355			/*
356			* this is not perfect yet.
357			* it does not roll objects behind multipart objects properly.
358			* Support for rolling multipart objects is questionable.
359			*/
360
361			int roll_ob(object op,int dir, object pusher) {
362			object *tmp;
363			sint16 x, y;
364			int flags;
365			mapstruct *m;
366			MoveType move_block;
367
368			if (op->head)
369			op = op->head;
370
371			x=op->x+freearr_x[dir];
372			y=op->y+freearr_y[dir];
373
374			if(!QUERY_FLAG(op,FLAG_CAN_ROLL) \|\|
375			(op->weight &&
376			random_roll(0, op->weight/50000-1, pusher, PREFER_LOW) > pusher->stats.Str))
377			return 0;
378
379			m = op->map;
380			flags = get_map_flags(m, &m, x, y, &x, &y);
381
382			if (flags & (P_OUT_OF_MAP \| P_IS_ALIVE))
383			return 0;
384
385			move_block = GET_MAP_MOVE_BLOCK(m, x, y);
386
387			/* If the target space is not blocked, no need to look at the objects on it */
388			if ((op->move_type & move_block) == op->move_type) {
389			for (tmp=get_map_ob(m, x, y); tmp!=NULL; tmp=tmp->above) {
390			if (tmp->head == op)
391			continue;
392			if (OB_MOVE_BLOCK(op, tmp) && !roll_ob(tmp,dir,pusher))
393			return 0;
394			}
395			}
396			if (try_fit (op, m, x, y))
397			return 0;
398
399			remove_ob(op);
400			for(tmp=op; tmp!=NULL; tmp=tmp->more)
401			tmp->x+=freearr_x[dir],tmp->y+=freearr_y[dir];
402			insert_ob_in_map(op,op->map,pusher,0);
403			return 1;
404			}
405
406			/* returns 1 if pushing invokes a attack, 0 when not */
407			int push_ob(object who, int dir, object pusher) {
408			int str1, str2;
409			object *owner;
410
411			if (who->head != NULL)
412			who = who->head;
413			owner = get_owner(who);
414
415			/* Wake up sleeping monsters that may be pushed */
416			CLEAR_FLAG(who,FLAG_SLEEP);
417
418			/* player change place with his pets or summoned creature */
419			/* TODO: allow multi arch pushing. Can't be very difficult */
420	root	1.2	if (who->more == NULL
421	root	1.3	#ifdef COZY_SERVER
422	root	1.2	&&
423			(
424			(owner && owner->contr && pusher->contr
425			&& same_party (owner->contr->party, pusher->contr->party))
426			\|\| owner == pusher
427			)
428	root	1.3	#else
429			&& owner == pusher
430			#endif
431	root	1.2	) {
432	root	1.1	int temp;
433			mapstruct *m;
434
435			remove_ob(who);
436			remove_ob(pusher);
437			temp = pusher->x;
438			pusher->x = who->x;
439			who->x = temp;
440
441			temp = pusher->y;
442			pusher->y = who->y;
443			who->y = temp;
444
445			m = pusher->map;
446			pusher->map = who->map;
447			who->map = m;
448
449			insert_ob_in_map (who,who->map,pusher,0);
450			insert_ob_in_map (pusher,pusher->map,pusher,0);
451
452			/* we presume that if the player is pushing his put, he moved in
453			* direction 'dir'. I can' think of any case where this would not be
454			* the case. Putting the map_scroll should also improve performance some.
455			*/
456			if (pusher->type == PLAYER ) {
457			esrv_map_scroll(&pusher->contr->socket, freearr_x[dir],freearr_y[dir]);
458			pusher->contr->socket.update_look=1;
459			pusher->contr->socket.look_position=0;
460			}
461			return 0;
462			}
463
464
465			/* We want ONLY become enemy of evil, unaggressive monster. We must RUN in them */
466			/* In original we have here a unaggressive check only - that was the reason why */
467			/* we so often become an enemy of friendly monsters... */
468			/* funny: was they set to unaggressive 0 (= not so nice) they don't attack */
469
470			if(owner != pusher && pusher->type == PLAYER && who->type != PLAYER &&
471			!QUERY_FLAG(who,FLAG_FRIENDLY)&& !QUERY_FLAG(who,FLAG_NEUTRAL)) {
472			if(pusher->contr->run_on) /* only when we run */ {
473			new_draw_info_format(NDI_UNIQUE, 0, pusher,
474			"You start to attack %s !!",who->name);
475			CLEAR_FLAG(who,FLAG_UNAGGRESSIVE); /* the sucker don't like you anymore */
476			who->enemy = pusher;
477			return 1;
478			}
479			else
480			{
481			new_draw_info_format(NDI_UNIQUE, 0, pusher,
482			"You avoid attacking %s .",who->name);
483			}
484			}
485
486			/* now, lets test stand still. we NEVER can push stand_still monsters. */
487			if(QUERY_FLAG(who,FLAG_STAND_STILL))
488			{
489			new_draw_info_format(NDI_UNIQUE, 0, pusher,
490			"You can't push %s.",who->name);
491			return 0;
492			}
493
494			/* This block is basically if you are pushing friendly but
495			* non pet creaturs.
496			* It basically does a random strength comparision to
497			* determine if you can push someone around. Note that
498			* this pushes the other person away - its not a swap.
499			*/
500
501			str1 = (who->stats.Str>0?who->stats.Str:who->level);
502			str2 = (pusher->stats.Str>0?pusher->stats.Str:pusher->level);
503			if(QUERY_FLAG(who,FLAG_WIZ) \|\|
504			random_roll(str1, str1/2+str1*2, who, PREFER_HIGH) >=
505			random_roll(str2, str2/2+str2*2, pusher, PREFER_HIGH) \|\|
506			!move_object(who,dir))
507			{
508			if (who ->type == PLAYER) {
509			new_draw_info_format(NDI_UNIQUE, 0, who,
510			"%s tried to push you.",pusher->name);
511			}
512			return 0;
513			}
514
515			/* If we get here, the push succeeded.
516			* Let everyone know the status.
517			*/
518			if (who->type == PLAYER) {
519			new_draw_info_format(NDI_UNIQUE, 0, who,
520			"%s pushed you.",pusher->name);
521			}
522			if (pusher->type == PLAYER) {
523			new_draw_info_format(NDI_UNIQUE, 0, pusher,
524			"You pushed %s back.", who->name);
525			}
526
527			return 1;
528			}