server/random_maps/wall.C

/*
 * static char *rcsid_wall_c =
 *   "$Id: wall.C,v 1.1 2006-08-13 17:16:03 elmex Exp $";
 */

/*
    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 authors can be reached via e-mail at crossfire-devel@real-time.com
*/

#include <global.h>
#include <random_map.h>
#include <rproto.h>

/*  Put in the walls and autojoin them.  */


/* given a layout and a coordinate, tell me which squares up/down/right/left
        are occupied. */

int surround_flag(char **layout,int i,int j,RMParms *RP){
  /* 1 = wall to left,
          2 = wall to right,
          4 = wall above
          8 = wall below */
  int surround_index = 0;
  if((i > 0) && layout[i-1][j]!=0) surround_index |=1;
  if((i < RP->Xsize-1) && layout[i+1][j]!=0) surround_index |=2;
  if((j > 0) && layout[i][j-1]!=0) surround_index |=4;
  if((j < RP->Ysize-1) && layout[i][j+1]!=0) surround_index |=8;
  return surround_index;
}


/* like surround_flag, but only walls count.
        */

int surround_flag2(char **layout,int i,int j,RMParms *RP){
  /* 1 = wall to left,
          2 = wall to right,
          4 = wall above
          8 = wall below */
  int surround_index = 0;
  if((i > 0) && layout[i-1][j]=='#') surround_index |=1;
  if((i < RP->Xsize-1) && layout[i+1][j]=='#') surround_index |=2;
  if((j > 0) && layout[i][j-1]=='#') surround_index |=4;
  if((j < RP->Ysize-1) && layout[i][j+1]=='#') surround_index |=8;
  return surround_index;
}


/* like surround_flag, except it checks  a map, not a layout.
 * Since this is part of the random map code, presumption
 * is that this is not a tiled map.
 * What is considered blocking and not is somewhat hard coded.
 */
int surround_flag3(mapstruct *map,sint16 i,sint16 j,RMParms *RP){
    /*
     * 1 =  blocked to left,
     * 2 = blocked to right,
     * 4 = blocked above
     * 8 = blocked below 
     */

    int surround_index = 0;

    if((i > 0) && (GET_MAP_MOVE_BLOCK(map, i-1,j) & ~MOVE_BLOCK_DEFAULT))
        surround_index |=1;
    if((i < RP->Xsize-1) && (GET_MAP_MOVE_BLOCK(map, i+1,j) & ~MOVE_BLOCK_DEFAULT))
        surround_index |=2;
    if((j > 0) && (GET_MAP_MOVE_BLOCK(map, i,j-1) & ~MOVE_BLOCK_DEFAULT))
        surround_index |=4;
    if((j < RP->Ysize-1) && (GET_MAP_MOVE_BLOCK(map,i,j+1) & ~MOVE_BLOCK_DEFAULT))
        surround_index |=8;

    return surround_index;
}

/* like surround_flag2, except it checks  a map, not a layout. */

int surround_flag4(mapstruct *map,int i,int j,RMParms *RP){
  /* 1 =  blocked to left,
          2 = blocked to right,
          4 = blocked above
          8 = blocked below */
  int surround_index = 0;

  if((i > 0) && wall_blocked(map,i-1,j)) surround_index |=1;
  if((i < RP->Xsize-1) && wall_blocked(map,i+1,j)) surround_index |=2;
  if((j > 0) && wall_blocked(map,i,j-1)) surround_index |=4;
  if((j < RP->Ysize-1) && wall_blocked(map,i,j+1)) surround_index |=8;

  return surround_index;
}

/* takes a map and a layout, and puts walls in the map (picked from
        w_style) at '#' marks. */

void make_map_walls(mapstruct *map,char **layout, char *w_style,RMParms *RP) {
    char styledirname[256];
    char stylefilepath[256];
    mapstruct *style_map=0;
    object *the_wall;
  
    /* get the style map */
    if(!strcmp(w_style,"none")) return;
    sprintf(styledirname,"%s","/styles/wallstyles");
    sprintf(stylefilepath,"%s/%s",styledirname,w_style);
    style_map = find_style(styledirname,w_style,-1);
    if(style_map == 0) return;

    /* fill up the map with the given floor style */
    if((the_wall=pick_random_object(style_map))!=NULL) {
        int i,j;
        char *cp;
        int joinedwalls=0;
        object *thiswall;

        sprintf(RP->wall_name,"%s",the_wall->arch->name);
        if ((cp=strchr(RP->wall_name,'_'))!=NULL) {
                *cp=0;
                joinedwalls=1;
        }

        for(i=0;i<RP->Xsize;i++)
            for(j=0;j<RP->Ysize;j++) {
                if(layout[i][j]=='#') {
                        if(joinedwalls)
                                thiswall=pick_joined_wall(the_wall,layout,i,j,RP);
                        else
                                thiswall=arch_to_object(the_wall->arch);
                    thiswall->x = i;
                    thiswall->y = j;
                    thiswall->move_block = MOVE_ALL;
                    insert_ob_in_map(thiswall,map,thiswall,INS_NO_MERGE | INS_NO_WALK_ON);
                }
            }
    }
}


/* picks the right wall type for this square, to make it look nice,
        and have everything nicely joined.  It uses the layout.  */

object *pick_joined_wall(object *the_wall,char **layout,int i,int j,RMParms *RP) {
  /* 1 = wall to left,
          2 = wall to right,
          4 = wall above
          8 = wall below */
  int surround_index=0;
  int l;
  char wall_name[64];
  archetype *wall_arch=0;

  strcpy(wall_name,the_wall->arch->name);

  /* conventionally, walls are named like this:
          wallname_wallcode, where wallcode indicates
          a joinedness, and wallname is the wall.
          this code depends on the convention for
          finding the right wall. */

  /* extract the wall name, which is the text up to the leading _ */
  for(l=0;l<64;l++) {
         if(wall_name[l]=='_') {
                wall_name[l] = 0;
                break;
         }
  }

  surround_index = surround_flag2(layout,i,j,RP);

  switch(surround_index) {
  case 0:
         strcat(wall_name,"_0");
         break;
  case 1:
         strcat(wall_name,"_1_3");
         break;
  case 2:
         strcat(wall_name,"_1_4");
         break;
  case 3:
         strcat(wall_name,"_2_1_2");
         break;
  case 4:
         strcat(wall_name,"_1_2");
         break;
  case 5:
         strcat(wall_name,"_2_2_4");
         break;
  case 6:
         strcat(wall_name,"_2_2_1");
         break;
  case 7:
         strcat(wall_name,"_3_1");
         break;
  case 8:
         strcat(wall_name,"_1_1");
         break;
  case 9:
         strcat(wall_name,"_2_2_3");
         break;
  case 10:
         strcat(wall_name,"_2_2_2");
         break;
  case 11:
         strcat(wall_name,"_3_3");
         break;
  case 12:
         strcat(wall_name,"_2_1_1");
         break;
  case 13:
         strcat(wall_name,"_3_4");
         break;
  case 14:
         strcat(wall_name,"_3_2");
         break;
  case 15:
         strcat(wall_name,"_4");
         break;
  }
  wall_arch = find_archetype(wall_name);
  if(wall_arch) return arch_to_object(wall_arch);
  else {
    nroferrors--;
    return arch_to_object(the_wall->arch);
  }

  
}
  

/* this takes a map, and changes an existing wall to match what's blocked
 * around it, counting only doors and walls as blocked.  If insert_flag is
 * 1, it will go ahead and insert the wall into the map.  If not, it
 * will only return the wall which would belong there, and doesn't
 * remove anything.  It depends on the
 * global, previously-set variable, "wall_name"  
 */

object * retrofit_joined_wall(mapstruct *the_map,int i,int j,int insert_flag,RMParms *RP) {
    /* 1 = wall to left,
     * 2 = wall to right,
     * 4 = wall above
     * 8 = wall below 
     */
    int surround_index=0;
    int l;
    object *the_wall=0;
    object *new_wall=0;
    archetype * wall_arch=0;

    /* first find the wall */
    for(the_wall = get_map_ob(the_map,i,j);the_wall!=NULL;the_wall=the_wall->above)
        if ((the_wall->move_type & MOVE_WALK) && the_wall->type!=EXIT && the_wall->type!=TELEPORTER)
            break;

  
    /* if what we found is a door, don't remove it, set the_wall to NULL to
     * signal that later. 
     */
    if(the_wall && (the_wall->type==DOOR || the_wall->type==LOCKED_DOOR) ) {
        the_wall=NULL;
        /* if we're not supposed to insert a new wall where there wasn't one, 
         * we've gotta leave. 
         */
        if(insert_flag==0) return 0;
    }
    else if(the_wall==NULL) return NULL;

    /* canonicalize the wall name */
    for(l=0;l<64;l++) {
        if(RP->wall_name[l]=='_') {
            RP->wall_name[l] = 0;
            break;
        }
    }

    surround_index = surround_flag4(the_map,i,j,RP);
    /* This would be a lot cleaner to just us a lookup table,
     * eg, wall_suffix[surround_index]
     */
    switch(surround_index) {
        case 0:
            strcat(RP->wall_name,"_0");
            break;
        case 1:
            strcat(RP->wall_name,"_1_3");
            break;
        case 2:
            strcat(RP->wall_name,"_1_4");
            break;
        case 3:
            strcat(RP->wall_name,"_2_1_2");
            break;
        case 4:
            strcat(RP->wall_name,"_1_2");
            break;
        case 5:
            strcat(RP->wall_name,"_2_2_4");
            break;
        case 6:
            strcat(RP->wall_name,"_2_2_1");
            break;
        case 7:
            strcat(RP->wall_name,"_3_1");
            break;
        case 8:
            strcat(RP->wall_name,"_1_1");
            break;
        case 9:
            strcat(RP->wall_name,"_2_2_3");
            break;
        case 10:
            strcat(RP->wall_name,"_2_2_2");
            break;
        case 11:
            strcat(RP->wall_name,"_3_3");
            break;
        case 12:
            strcat(RP->wall_name,"_2_1_1");
            break;
        case 13:
            strcat(RP->wall_name,"_3_4");
            break;
        case 14:
            strcat(RP->wall_name,"_3_2");
            break;
        case 15:
            strcat(RP->wall_name,"_4");
            break;
    }
    wall_arch = find_archetype(RP->wall_name);
    if(wall_arch!=NULL) {
        new_wall=arch_to_object(wall_arch);
        new_wall->x = i;
        new_wall->y = j;
        if(the_wall && the_wall->map) {
            remove_ob(the_wall);
            free_object(the_wall);
        }
        the_wall->move_block = MOVE_ALL;
        insert_ob_in_map(new_wall,the_map,new_wall,INS_NO_MERGE | INS_NO_WALK_ON);
    }
    else
        nroferrors--;  /* it's OK not to find an arch. */
    return new_wall;
}
  

Revision:	1.2
Committed:	Tue Aug 29 08:01:36 2006 UTC (20 years ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.1:	+154 -154 lines
Log Message:	expand initial tabs to spaces
#	User	Rev	Content
1	elmex	1.1	/*
2			* static char *rcsid_wall_c =
3	root	1.2	* "$Id: wall.C,v 1.1 2006-08-13 17:16:03 elmex Exp $";
4	elmex	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 authors can be reached via e-mail at crossfire-devel@real-time.com
27			*/
28
29			#include <global.h>
30			#include <random_map.h>
31			#include <rproto.h>
32
33			/* Put in the walls and autojoin them. */
34
35
36			/* given a layout and a coordinate, tell me which squares up/down/right/left
37	root	1.2	are occupied. */
38	elmex	1.1
39			int surround_flag(char *layout,int i,int j,RMParms RP){
40			/* 1 = wall to left,
41	root	1.2	2 = wall to right,
42			4 = wall above
43			8 = wall below */
44	elmex	1.1	int surround_index = 0;
45			if((i > 0) && layout[i-1][j]!=0) surround_index \|=1;
46			if((i < RP->Xsize-1) && layout[i+1][j]!=0) surround_index \|=2;
47			if((j > 0) && layout[i][j-1]!=0) surround_index \|=4;
48			if((j < RP->Ysize-1) && layout[i][j+1]!=0) surround_index \|=8;
49			return surround_index;
50			}
51
52
53			/* like surround_flag, but only walls count.
54	root	1.2	*/
55	elmex	1.1
56			int surround_flag2(char *layout,int i,int j,RMParms RP){
57			/* 1 = wall to left,
58	root	1.2	2 = wall to right,
59			4 = wall above
60			8 = wall below */
61	elmex	1.1	int surround_index = 0;
62			if((i > 0) && layout[i-1][j]=='#') surround_index \|=1;
63			if((i < RP->Xsize-1) && layout[i+1][j]=='#') surround_index \|=2;
64			if((j > 0) && layout[i][j-1]=='#') surround_index \|=4;
65			if((j < RP->Ysize-1) && layout[i][j+1]=='#') surround_index \|=8;
66			return surround_index;
67			}
68
69
70			/* like surround_flag, except it checks a map, not a layout.
71			* Since this is part of the random map code, presumption
72			* is that this is not a tiled map.
73			* What is considered blocking and not is somewhat hard coded.
74			*/
75			int surround_flag3(mapstruct map,sint16 i,sint16 j,RMParms RP){
76			/*
77			* 1 = blocked to left,
78			* 2 = blocked to right,
79			* 4 = blocked above
80			* 8 = blocked below
81			*/
82
83			int surround_index = 0;
84
85			if((i > 0) && (GET_MAP_MOVE_BLOCK(map, i-1,j) & ~MOVE_BLOCK_DEFAULT))
86	root	1.2	surround_index \|=1;
87	elmex	1.1	if((i < RP->Xsize-1) && (GET_MAP_MOVE_BLOCK(map, i+1,j) & ~MOVE_BLOCK_DEFAULT))
88	root	1.2	surround_index \|=2;
89	elmex	1.1	if((j > 0) && (GET_MAP_MOVE_BLOCK(map, i,j-1) & ~MOVE_BLOCK_DEFAULT))
90	root	1.2	surround_index \|=4;
91	elmex	1.1	if((j < RP->Ysize-1) && (GET_MAP_MOVE_BLOCK(map,i,j+1) & ~MOVE_BLOCK_DEFAULT))
92	root	1.2	surround_index \|=8;
93	elmex	1.1
94			return surround_index;
95			}
96
97			/* like surround_flag2, except it checks a map, not a layout. */
98
99			int surround_flag4(mapstruct map,int i,int j,RMParms RP){
100			/* 1 = blocked to left,
101	root	1.2	2 = blocked to right,
102			4 = blocked above
103			8 = blocked below */
104	elmex	1.1	int surround_index = 0;
105
106			if((i > 0) && wall_blocked(map,i-1,j)) surround_index \|=1;
107			if((i < RP->Xsize-1) && wall_blocked(map,i+1,j)) surround_index \|=2;
108			if((j > 0) && wall_blocked(map,i,j-1)) surround_index \|=4;
109			if((j < RP->Ysize-1) && wall_blocked(map,i,j+1)) surround_index \|=8;
110
111			return surround_index;
112			}
113
114			/* takes a map and a layout, and puts walls in the map (picked from
115	root	1.2	w_style) at '#' marks. */
116	elmex	1.1
117			void make_map_walls(mapstruct map,char layout, char w_style,RMParms *RP) {
118			char styledirname[256];
119			char stylefilepath[256];
120			mapstruct *style_map=0;
121			object *the_wall;
122
123			/* get the style map */
124			if(!strcmp(w_style,"none")) return;
125			sprintf(styledirname,"%s","/styles/wallstyles");
126			sprintf(stylefilepath,"%s/%s",styledirname,w_style);
127			style_map = find_style(styledirname,w_style,-1);
128			if(style_map == 0) return;
129
130			/* fill up the map with the given floor style */
131			if((the_wall=pick_random_object(style_map))!=NULL) {
132	root	1.2	int i,j;
133			char *cp;
134			int joinedwalls=0;
135			object *thiswall;
136
137			sprintf(RP->wall_name,"%s",the_wall->arch->name);
138			if ((cp=strchr(RP->wall_name,'_'))!=NULL) {
139			*cp=0;
140			joinedwalls=1;
141			}
142
143			for(i=0;i<RP->Xsize;i++)
144			for(j=0;j<RP->Ysize;j++) {
145			if(layout[i][j]=='#') {
146			if(joinedwalls)
147			thiswall=pick_joined_wall(the_wall,layout,i,j,RP);
148			else
149			thiswall=arch_to_object(the_wall->arch);
150			thiswall->x = i;
151			thiswall->y = j;
152			thiswall->move_block = MOVE_ALL;
153			insert_ob_in_map(thiswall,map,thiswall,INS_NO_MERGE \| INS_NO_WALK_ON);
154			}
155			}
156	elmex	1.1	}
157			}
158
159
160			/* picks the right wall type for this square, to make it look nice,
161	root	1.2	and have everything nicely joined. It uses the layout. */
162	elmex	1.1
163			object pick_joined_wall(object the_wall,char *layout,int i,int j,RMParms RP) {
164			/* 1 = wall to left,
165	root	1.2	2 = wall to right,
166			4 = wall above
167			8 = wall below */
168	elmex	1.1	int surround_index=0;
169			int l;
170			char wall_name[64];
171			archetype *wall_arch=0;
172
173			strcpy(wall_name,the_wall->arch->name);
174
175			/* conventionally, walls are named like this:
176	root	1.2	wallname_wallcode, where wallcode indicates
177			a joinedness, and wallname is the wall.
178			this code depends on the convention for
179			finding the right wall. */
180	elmex	1.1
181			/* extract the wall name, which is the text up to the leading _ */
182			for(l=0;l<64;l++) {
183	root	1.2	if(wall_name[l]=='_') {
184			wall_name[l] = 0;
185			break;
186			}
187	elmex	1.1	}
188
189			surround_index = surround_flag2(layout,i,j,RP);
190
191			switch(surround_index) {
192			case 0:
193	root	1.2	strcat(wall_name,"_0");
194			break;
195	elmex	1.1	case 1:
196	root	1.2	strcat(wall_name,"_1_3");
197			break;
198	elmex	1.1	case 2:
199	root	1.2	strcat(wall_name,"_1_4");
200			break;
201	elmex	1.1	case 3:
202	root	1.2	strcat(wall_name,"_2_1_2");
203			break;
204	elmex	1.1	case 4:
205	root	1.2	strcat(wall_name,"_1_2");
206			break;
207	elmex	1.1	case 5:
208	root	1.2	strcat(wall_name,"_2_2_4");
209			break;
210	elmex	1.1	case 6:
211	root	1.2	strcat(wall_name,"_2_2_1");
212			break;
213	elmex	1.1	case 7:
214	root	1.2	strcat(wall_name,"_3_1");
215			break;
216	elmex	1.1	case 8:
217	root	1.2	strcat(wall_name,"_1_1");
218			break;
219	elmex	1.1	case 9:
220	root	1.2	strcat(wall_name,"_2_2_3");
221			break;
222	elmex	1.1	case 10:
223	root	1.2	strcat(wall_name,"_2_2_2");
224			break;
225	elmex	1.1	case 11:
226	root	1.2	strcat(wall_name,"_3_3");
227			break;
228	elmex	1.1	case 12:
229	root	1.2	strcat(wall_name,"_2_1_1");
230			break;
231	elmex	1.1	case 13:
232	root	1.2	strcat(wall_name,"_3_4");
233			break;
234	elmex	1.1	case 14:
235	root	1.2	strcat(wall_name,"_3_2");
236			break;
237	elmex	1.1	case 15:
238	root	1.2	strcat(wall_name,"_4");
239			break;
240	elmex	1.1	}
241			wall_arch = find_archetype(wall_name);
242			if(wall_arch) return arch_to_object(wall_arch);
243			else {
244			nroferrors--;
245			return arch_to_object(the_wall->arch);
246			}
247
248
249			}
250
251
252			/* this takes a map, and changes an existing wall to match what's blocked
253			* around it, counting only doors and walls as blocked. If insert_flag is
254			* 1, it will go ahead and insert the wall into the map. If not, it
255			* will only return the wall which would belong there, and doesn't
256			* remove anything. It depends on the
257			* global, previously-set variable, "wall_name"
258			*/
259
260			object * retrofit_joined_wall(mapstruct the_map,int i,int j,int insert_flag,RMParms RP) {
261			/* 1 = wall to left,
262			* 2 = wall to right,
263			* 4 = wall above
264			* 8 = wall below
265			*/
266			int surround_index=0;
267			int l;
268			object *the_wall=0;
269			object *new_wall=0;
270			archetype * wall_arch=0;
271
272			/* first find the wall */
273			for(the_wall = get_map_ob(the_map,i,j);the_wall!=NULL;the_wall=the_wall->above)
274	root	1.2	if ((the_wall->move_type & MOVE_WALK) && the_wall->type!=EXIT && the_wall->type!=TELEPORTER)
275			break;
276	elmex	1.1
277
278			/* if what we found is a door, don't remove it, set the_wall to NULL to
279			* signal that later.
280			*/
281			if(the_wall && (the_wall->type==DOOR \|\| the_wall->type==LOCKED_DOOR) ) {
282	root	1.2	the_wall=NULL;
283			/* if we're not supposed to insert a new wall where there wasn't one,
284			* we've gotta leave.
285			*/
286			if(insert_flag==0) return 0;
287	elmex	1.1	}
288			else if(the_wall==NULL) return NULL;
289
290			/* canonicalize the wall name */
291			for(l=0;l<64;l++) {
292	root	1.2	if(RP->wall_name[l]=='_') {
293			RP->wall_name[l] = 0;
294			break;
295			}
296	elmex	1.1	}
297
298			surround_index = surround_flag4(the_map,i,j,RP);
299			/* This would be a lot cleaner to just us a lookup table,
300			* eg, wall_suffix[surround_index]
301			*/
302			switch(surround_index) {
303	root	1.2	case 0:
304			strcat(RP->wall_name,"_0");
305			break;
306			case 1:
307			strcat(RP->wall_name,"_1_3");
308			break;
309			case 2:
310			strcat(RP->wall_name,"_1_4");
311			break;
312			case 3:
313			strcat(RP->wall_name,"_2_1_2");
314			break;
315			case 4:
316			strcat(RP->wall_name,"_1_2");
317			break;
318			case 5:
319			strcat(RP->wall_name,"_2_2_4");
320			break;
321			case 6:
322			strcat(RP->wall_name,"_2_2_1");
323			break;
324			case 7:
325			strcat(RP->wall_name,"_3_1");
326			break;
327			case 8:
328			strcat(RP->wall_name,"_1_1");
329			break;
330			case 9:
331			strcat(RP->wall_name,"_2_2_3");
332			break;
333			case 10:
334			strcat(RP->wall_name,"_2_2_2");
335			break;
336			case 11:
337			strcat(RP->wall_name,"_3_3");
338			break;
339			case 12:
340			strcat(RP->wall_name,"_2_1_1");
341			break;
342			case 13:
343			strcat(RP->wall_name,"_3_4");
344			break;
345			case 14:
346			strcat(RP->wall_name,"_3_2");
347			break;
348			case 15:
349			strcat(RP->wall_name,"_4");
350			break;
351	elmex	1.1	}
352			wall_arch = find_archetype(RP->wall_name);
353			if(wall_arch!=NULL) {
354	root	1.2	new_wall=arch_to_object(wall_arch);
355			new_wall->x = i;
356			new_wall->y = j;
357			if(the_wall && the_wall->map) {
358			remove_ob(the_wall);
359			free_object(the_wall);
360			}
361			the_wall->move_block = MOVE_ALL;
362			insert_ob_in_map(new_wall,the_map,new_wall,INS_NO_MERGE \| INS_NO_WALK_ON);
363	elmex	1.1	}
364			else
365	root	1.2	nroferrors--; /* it's OK not to find an arch. */
366	elmex	1.1	return new_wall;
367			}
368
369