server/random_maps/exit.C


/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2001 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@schmorp.de>
*/

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

/*  find a character in the layout.  fx and fy are pointers to
    where to find the char.  fx,fy = -1 if not found. */
void
find_in_layout (int mode, char target, int *fx, int *fy, char **layout, random_map_params *RP)
{
  int M;
  int i, j;

  *fx = -1;
  *fy = -1;

  /* if a starting point isn't given, pick one */
  if (mode < 1 || mode > 4)
    M = RANDOM () % 4 + 1;
  else
    M = mode;

  /* four different search starting points and methods so that
     we can do something different for symmetrical maps instead of
     the same damned thing every time. */
  switch (M)
    {
      case 1:
        {                       /* search from top left down/right */
          for (i = 1; i < RP->Xsize; i++)
            for (j = 1; j < RP->Ysize; j++)
              {
                if (layout[i][j] == target)
                  {
                    *fx = i;
                    *fy = j;
                    return;
                  }
              }
          break;
        }
      case 2:
        {                       /* Search from top right down/left */
          for (i = RP->Xsize - 2; i > 0; i--)
            for (j = 1; j < RP->Ysize - 1; j++)
              {
                if (layout[i][j] == target)
                  {
                    *fx = i;
                    *fy = j;
                    return;
                  }
              }
          break;
        }
      case 3:
        {                       /* search from bottom-left up-right */
          for (i = 1; i < RP->Xsize - 1; i++)
            for (j = RP->Ysize - 2; j > 0; j--)
              {
                if (layout[i][j] == target)
                  {
                    *fx = i;
                    *fy = j;
                    return;
                  }
              }
          break;
        }
      case 4:
        {                       /* search from bottom-right up-left */
          for (i = RP->Xsize - 2; i > 0; i--)
            for (j = RP->Ysize - 2; j > 0; j--)
              {
                if (layout[i][j] == target)
                  {
                    *fx = i;
                    *fy = j;
                    return;
                  }
              }
          break;
        }
    }
}

/* orientation:  0 means random,
  1 means descending dungeon
  2 means ascending dungeon
  3 means rightward
  4 means leftward
  5 means northward
  6 means southward
*/
void
place_exits (maptile *map, char **maze, char *exitstyle, int orientation, random_map_params *RP)
{
  char styledirname[256];
  maptile *style_map_down = 0;  /* harder maze */
  maptile *style_map_up = 0;    /* easier maze */
  object *the_exit_down;        /* harder maze */
  object *the_exit_up;          /* easier maze */
  object *random_sign;          /* magic mouth saying this is a random map. */
  char buf[512];
  int cx = -1, cy = -1;         /* location of a map center */
  int upx = -1, upy = -1;       /* location of up exit */
  int downx = -1, downy = -1;
  int final_map_exit = 1;

  if (RP->exit_on_final_map)
    if (strstr (RP->exit_on_final_map, "no"))
      final_map_exit = 0;

  if (!orientation)
    orientation = RANDOM () % 6 + 1;

  switch (orientation)
    {
      case 1:
        {
          sprintf (styledirname, "/styles/exitstyles/up");
          style_map_up = find_style (styledirname, exitstyle, -1);
          sprintf (styledirname, "/styles/exitstyles/down");
          style_map_down = find_style (styledirname, exitstyle, -1);
          break;
        }

      case 2:
        {
          sprintf (styledirname, "/styles/exitstyles/down");
          style_map_up = find_style (styledirname, exitstyle, -1);
          sprintf (styledirname, "/styles/exitstyles/up");
          style_map_down = find_style (styledirname, exitstyle, -1);
          break;
        }

      default:
        {
          sprintf (styledirname, "/styles/exitstyles/generic");
          style_map_up = find_style (styledirname, exitstyle, -1);
          style_map_down = style_map_up;
          break;
        }
    }

  if (style_map_up == 0)
    the_exit_up = arch_to_object (archetype::find ("exit"));

  else
    {
      object *tmp;

      tmp = pick_random_object (style_map_up);
      the_exit_up = arch_to_object (tmp->arch);
    }

  /* we need a down exit only if we're recursing. */
  if (RP->dungeon_level < RP->dungeon_depth || RP->final_map[0] != 0)
    if (style_map_down == 0)
      the_exit_down = arch_to_object (archetype::find ("exit"));

    else
      {
        object *tmp;

        tmp = pick_random_object (style_map_down);
        the_exit_down = arch_to_object (tmp->arch);
      }
  else
    the_exit_down = 0;

  /* set up the up exit */
  the_exit_up->stats.hp = RP->origin_x;
  the_exit_up->stats.sp = RP->origin_y;
  the_exit_up->slaying = RP->origin_map;

  /* figure out where to put the entrance */
  /* begin a logical block */
  {
    int i, j;

    /* First, look for a '<' char */
    find_in_layout (0, '<', &upx, &upy, maze, RP);

    /* next, look for a C, the map center.  */
    find_in_layout (0, 'C', &cx, &cy, maze, RP);


    /* if we didn't find an up, find an empty place far from the center */
    if (upx == -1 && cx != -1)
      {
        if (cx > RP->Xsize / 2)
          upx = 1;
        else
          upx = RP->Xsize - 2;
        if (cy > RP->Ysize / 2)
          upy = 1;
        else
          upy = RP->Ysize - 2;
        /* find an empty place far from the center */
        if (upx == 1 && upy == 1)
          find_in_layout (1, 0, &upx, &upy, maze, RP);
        else if (upx == 1 && upy > 1)
          find_in_layout (3, 0, &upx, &upy, maze, RP);
        else if (upx > 1 && upy == 1)
          find_in_layout (2, 0, &upx, &upy, maze, RP);
        else if (upx > 1 && upy > 1)
          find_in_layout (4, 0, &upx, &upy, maze, RP);
      }

    /* no indication of where to place the exit, so just place it. */
    if (upx == -1)
      find_in_layout (0, 0, &upx, &upy, maze, RP);

    the_exit_up->x = upx;
    the_exit_up->y = upy;

    /* surround the exits with notices that this is a random map. */
    for (j = 1; j < 9; j++)
      {
        if (!wall_blocked (map, the_exit_up->x + freearr_x[j], the_exit_up->y + freearr_y[j]))
          {
            random_sign = get_archetype ("sign");
            random_sign->x = the_exit_up->x + freearr_x[j];
            random_sign->y = the_exit_up->y + freearr_y[j];

            sprintf (buf, "This is a random map.\nLevel: %d\n", (RP->dungeon_level) - 1);

            random_sign->msg = buf;
            insert_ob_in_map (random_sign, map, NULL, 0);
          }
      }
    /* Block the exit so things don't get dumped on top of it. */
    the_exit_up->move_block = MOVE_ALL;

    insert_ob_in_map (the_exit_up, map, NULL, 0);
    maze[the_exit_up->x][the_exit_up->y] = '<';

    /* set the starting x,y for this map */
    map->enter_x = the_exit_up->x;
    map->enter_y = the_exit_up->y;

    /* first, look for a '>' character */
    find_in_layout (0, '>', &downx, &downy, maze, RP);
    /* if no > is found use C */
    if (downx == -1)
      {
        downx = cx;
        downy = cy;
      };

    /* make the other exit far away from this one if
       there's no center. */
    if (downx == -1)
      {
        if (upx > RP->Xsize / 2)
          downx = 1;
        else
          downx = RP->Xsize - 2;
        if (upy > RP->Ysize / 2)
          downy = 1;
        else
          downy = RP->Ysize - 2;
        /* find an empty place far from the entrance */
        if (downx == 1 && downy == 1)
          find_in_layout (1, 0, &downx, &downy, maze, RP);
        else if (downx == 1 && downy > 1)
          find_in_layout (3, 0, &downx, &downy, maze, RP);
        else if (downx > 1 && downy == 1)
          find_in_layout (2, 0, &downx, &downy, maze, RP);
        else if (downx > 1 && downy > 1)
          find_in_layout (4, 0, &downx, &downy, maze, RP);

      }
    /* no indication of where to place the down exit, so just place it */
    if (downx == -1)
      find_in_layout (0, 0, &downx, &downy, maze, RP);

    if (the_exit_down)
      {
        char buf[2048];

        i = find_first_free_spot (the_exit_down, map, downx, downy);
        the_exit_down->x = downx + freearr_x[i];
        the_exit_down->y = downy + freearr_y[i];
        RP->origin_x = the_exit_down->x;
        RP->origin_y = the_exit_down->y;
        write_map_parameters_to_string (buf, RP);
        the_exit_down->msg = buf;

        /* the identifier for making a random map. */
        if (RP->dungeon_level >= RP->dungeon_depth && *RP->final_map)
          {
            maptile *new_map;
            object *the_exit_back = arch_to_object (the_exit_up->arch), *tmp;

            /* load it */
            if (!(new_map = maptile::load_map_sync (RP->final_map)))
              return;

            the_exit_down->slaying = RP->final_map;

            for (tmp = new_map->at (new_map->enter_x, new_map->enter_y).bot; tmp; tmp = tmp->above)
              /* Remove exit back to previous random map.  There should only be one
               * which is why we break out.  To try to process more than one
               * would require keeping a 'next' pointer, ad free_object kills tmp, which
               * breaks the for loop.
               */
              if (tmp->type == EXIT && EXIT_PATH (tmp) && !strncmp (EXIT_PATH (tmp), "/random/", 8))
                {
                  tmp->destroy ();
                  break;
                }

            if (final_map_exit == 1)
              {
                /* setup the exit back */
                the_exit_back->slaying = map->path;
                the_exit_back->stats.hp = the_exit_down->x;
                the_exit_back->stats.sp = the_exit_down->y;
                the_exit_back->x = new_map->enter_x;
                the_exit_back->y = new_map->enter_y;

                insert_ob_in_map (the_exit_back, new_map, NULL, 0);
              }
          }
        else
          the_exit_down->slaying = "/!";

        /* Block the exit so things don't get dumped on top of it. */
        the_exit_down->move_block = MOVE_ALL;
        insert_ob_in_map (the_exit_down, map, NULL, 0);
        maze[the_exit_down->x][the_exit_down->y] = '>';
      }
  }

}

/* this function unblocks the exits.  We blocked them to
   keep things from being dumped on them during the other
   phases of random map generation. */
void
unblock_exits (maptile *map, char **maze, random_map_params *RP)
{
  int i = 0, j = 0;
  object *walk;

  for (i = 0; i < RP->Xsize; i++)
    for (j = 0; j < RP->Ysize; j++)
      if (maze[i][j] == '>' || maze[i][j] == '<')
        {
          for (walk = GET_MAP_OB (map, i, j); walk != NULL; walk = walk->above)
            {
              if (walk->move_block == MOVE_ALL && walk->type != LOCKED_DOOR)
                {
                  walk->move_block = MOVE_BLOCK_DEFAULT;
                  update_object (walk, UP_OBJ_CHANGE);
                }
            }
        }
}
Revision:	1.16
Committed:	Sun Dec 31 19:02:24 2006 UTC (17 years, 4 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.15:	+70 -80 lines
Log Message:	reindent, minor changes
#	User	Rev	Content
1	root	1.16
2	elmex	1.1	/*
3			CrossFire, A Multiplayer game for X-windows
4
5			Copyright (C) 2001 Mark Wedel & Crossfire Development Team
6			Copyright (C) 1992 Frank Tore Johansen
7
8			This program is free software; you can redistribute it and/or modify
9			it under the terms of the GNU General Public License as published by
10			the Free Software Foundation; either version 2 of the License, or
11			(at your option) any later version.
12
13			This program is distributed in the hope that it will be useful,
14			but WITHOUT ANY WARRANTY; without even the implied warranty of
15			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			GNU General Public License for more details.
17
18			You should have received a copy of the GNU General Public License
19			along with this program; if not, write to the Free Software
20			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21
22	root	1.6	The authors can be reached via e-mail at <crossfire@schmorp.de>
23	elmex	1.1	*/
24
25			#include <global.h>
26			#include <random_map.h>
27			#include <sproto.h>
28			#include <rproto.h>
29
30			/* find a character in the layout. fx and fy are pointers to
31			where to find the char. fx,fy = -1 if not found. */
32	root	1.4	void
33	root	1.16	find_in_layout (int mode, char target, int fx, int fy, char *layout, random_map_params RP)
34	root	1.4	{
35	elmex	1.1	int M;
36	root	1.4	int i, j;
37
38			*fx = -1;
39			*fy = -1;
40	elmex	1.1
41			/* if a starting point isn't given, pick one */
42	root	1.4	if (mode < 1 \|\| mode > 4)
43			M = RANDOM () % 4 + 1;
44			else
45			M = mode;
46	elmex	1.1
47			/* four different search starting points and methods so that
48			we can do something different for symmetrical maps instead of
49			the same damned thing every time. */
50	root	1.4	switch (M)
51			{
52	root	1.16	case 1:
53			{ /* search from top left down/right */
54			for (i = 1; i < RP->Xsize; i++)
55			for (j = 1; j < RP->Ysize; j++)
56			{
57			if (layout[i][j] == target)
58			{
59			*fx = i;
60			*fy = j;
61			return;
62			}
63			}
64			break;
65			}
66			case 2:
67			{ /* Search from top right down/left */
68			for (i = RP->Xsize - 2; i > 0; i--)
69			for (j = 1; j < RP->Ysize - 1; j++)
70			{
71			if (layout[i][j] == target)
72			{
73			*fx = i;
74			*fy = j;
75			return;
76			}
77			}
78			break;
79			}
80			case 3:
81			{ /* search from bottom-left up-right */
82			for (i = 1; i < RP->Xsize - 1; i++)
83			for (j = RP->Ysize - 2; j > 0; j--)
84			{
85			if (layout[i][j] == target)
86			{
87			*fx = i;
88			*fy = j;
89			return;
90			}
91			}
92			break;
93			}
94			case 4:
95			{ /* search from bottom-right up-left */
96			for (i = RP->Xsize - 2; i > 0; i--)
97			for (j = RP->Ysize - 2; j > 0; j--)
98			{
99			if (layout[i][j] == target)
100			{
101			*fx = i;
102			*fy = j;
103			return;
104			}
105			}
106			break;
107			}
108	root	1.4	}
109	elmex	1.1	}
110
111			/* orientation: 0 means random,
112			1 means descending dungeon
113			2 means ascending dungeon
114			3 means rightward
115			4 means leftward
116			5 means northward
117			6 means southward
118			*/
119	root	1.4	void
120	root	1.13	place_exits (maptile map, char maze, char exitstyle, int orientation, random_map_params *RP)
121	root	1.4	{
122	elmex	1.1	char styledirname[256];
123	root	1.16	maptile style_map_down = 0; / harder maze */
124			maptile style_map_up = 0; / easier maze */
125	elmex	1.1	object the_exit_down; / harder maze */
126			object the_exit_up; / easier maze */
127			object random_sign; / magic mouth saying this is a random map. */
128			char buf[512];
129	root	1.4	int cx = -1, cy = -1; /* location of a map center */
130			int upx = -1, upy = -1; /* location of up exit */
131			int downx = -1, downy = -1;
132			int final_map_exit = 1;
133
134			if (RP->exit_on_final_map)
135	root	1.16	if (strstr (RP->exit_on_final_map, "no"))
136			final_map_exit = 0;
137	elmex	1.1
138	root	1.16	if (!orientation)
139	root	1.4	orientation = RANDOM () % 6 + 1;
140	elmex	1.1
141	root	1.4	switch (orientation)
142	elmex	1.1	{
143	root	1.15	case 1:
144			{
145			sprintf (styledirname, "/styles/exitstyles/up");
146			style_map_up = find_style (styledirname, exitstyle, -1);
147			sprintf (styledirname, "/styles/exitstyles/down");
148			style_map_down = find_style (styledirname, exitstyle, -1);
149			break;
150			}
151
152			case 2:
153			{
154			sprintf (styledirname, "/styles/exitstyles/down");
155			style_map_up = find_style (styledirname, exitstyle, -1);
156			sprintf (styledirname, "/styles/exitstyles/up");
157			style_map_down = find_style (styledirname, exitstyle, -1);
158			break;
159			}
160
161			default:
162			{
163			sprintf (styledirname, "/styles/exitstyles/generic");
164			style_map_up = find_style (styledirname, exitstyle, -1);
165			style_map_down = style_map_up;
166			break;
167			}
168	elmex	1.1	}
169	root	1.15
170	root	1.4	if (style_map_up == 0)
171	root	1.5	the_exit_up = arch_to_object (archetype::find ("exit"));
172	root	1.16
173	root	1.4	else
174	elmex	1.1	{
175	root	1.4	object *tmp;
176
177			tmp = pick_random_object (style_map_up);
178			the_exit_up = arch_to_object (tmp->arch);
179	elmex	1.1	}
180
181			/* we need a down exit only if we're recursing. */
182	root	1.4	if (RP->dungeon_level < RP->dungeon_depth \|\| RP->final_map[0] != 0)
183			if (style_map_down == 0)
184	root	1.5	the_exit_down = arch_to_object (archetype::find ("exit"));
185	root	1.16
186	root	1.4	else
187			{
188			object *tmp;
189
190			tmp = pick_random_object (style_map_down);
191			the_exit_down = arch_to_object (tmp->arch);
192			}
193			else
194			the_exit_down = 0;
195	elmex	1.1
196			/* set up the up exit */
197			the_exit_up->stats.hp = RP->origin_x;
198			the_exit_up->stats.sp = RP->origin_y;
199	root	1.16	the_exit_up->slaying = RP->origin_map;
200	elmex	1.1
201			/* figure out where to put the entrance */
202			/* begin a logical block */
203			{
204	root	1.4	int i, j;
205
206	elmex	1.1	/* First, look for a '<' char */
207	root	1.4	find_in_layout (0, '<', &upx, &upy, maze, RP);
208	elmex	1.1
209			/* next, look for a C, the map center. */
210	root	1.4	find_in_layout (0, 'C', &cx, &cy, maze, RP);
211
212	elmex	1.1
213			/* if we didn't find an up, find an empty place far from the center */
214	root	1.4	if (upx == -1 && cx != -1)
215			{
216			if (cx > RP->Xsize / 2)
217			upx = 1;
218	elmex	1.1	else
219	root	1.4	upx = RP->Xsize - 2;
220			if (cy > RP->Ysize / 2)
221			upy = 1;
222			else
223			upy = RP->Ysize - 2;
224			/* find an empty place far from the center */
225			if (upx == 1 && upy == 1)
226			find_in_layout (1, 0, &upx, &upy, maze, RP);
227			else if (upx == 1 && upy > 1)
228			find_in_layout (3, 0, &upx, &upy, maze, RP);
229			else if (upx > 1 && upy == 1)
230			find_in_layout (2, 0, &upx, &upy, maze, RP);
231			else if (upx > 1 && upy > 1)
232			find_in_layout (4, 0, &upx, &upy, maze, RP);
233			}
234
235	elmex	1.1	/* no indication of where to place the exit, so just place it. */
236	root	1.4	if (upx == -1)
237			find_in_layout (0, 0, &upx, &upy, maze, RP);
238	elmex	1.1
239			the_exit_up->x = upx;
240			the_exit_up->y = upy;
241
242			/* surround the exits with notices that this is a random map. */
243	root	1.4	for (j = 1; j < 9; j++)
244			{
245			if (!wall_blocked (map, the_exit_up->x + freearr_x[j], the_exit_up->y + freearr_y[j]))
246			{
247			random_sign = get_archetype ("sign");
248			random_sign->x = the_exit_up->x + freearr_x[j];
249			random_sign->y = the_exit_up->y + freearr_y[j];
250
251			sprintf (buf, "This is a random map.\nLevel: %d\n", (RP->dungeon_level) - 1);
252
253			random_sign->msg = buf;
254			insert_ob_in_map (random_sign, map, NULL, 0);
255			}
256	elmex	1.1	}
257			/* Block the exit so things don't get dumped on top of it. */
258			the_exit_up->move_block = MOVE_ALL;
259
260	root	1.4	insert_ob_in_map (the_exit_up, map, NULL, 0);
261			maze[the_exit_up->x][the_exit_up->y] = '<';
262	elmex	1.1
263			/* set the starting x,y for this map */
264	root	1.11	map->enter_x = the_exit_up->x;
265			map->enter_y = the_exit_up->y;
266	elmex	1.1
267			/* first, look for a '>' character */
268	root	1.4	find_in_layout (0, '>', &downx, &downy, maze, RP);
269	elmex	1.1	/* if no > is found use C */
270	root	1.4	if (downx == -1)
271			{
272			downx = cx;
273			downy = cy;
274			};
275
276	elmex	1.1	/* make the other exit far away from this one if
277			there's no center. */
278	root	1.4	if (downx == -1)
279			{
280			if (upx > RP->Xsize / 2)
281			downx = 1;
282	elmex	1.1	else
283	root	1.4	downx = RP->Xsize - 2;
284			if (upy > RP->Ysize / 2)
285			downy = 1;
286			else
287			downy = RP->Ysize - 2;
288			/* find an empty place far from the entrance */
289			if (downx == 1 && downy == 1)
290			find_in_layout (1, 0, &downx, &downy, maze, RP);
291			else if (downx == 1 && downy > 1)
292			find_in_layout (3, 0, &downx, &downy, maze, RP);
293			else if (downx > 1 && downy == 1)
294			find_in_layout (2, 0, &downx, &downy, maze, RP);
295			else if (downx > 1 && downy > 1)
296			find_in_layout (4, 0, &downx, &downy, maze, RP);
297
298			}
299	elmex	1.1	/* no indication of where to place the down exit, so just place it */
300	root	1.4	if (downx == -1)
301			find_in_layout (0, 0, &downx, &downy, maze, RP);
302	root	1.16
303	root	1.4	if (the_exit_down)
304			{
305			char buf[2048];
306
307			i = find_first_free_spot (the_exit_down, map, downx, downy);
308			the_exit_down->x = downx + freearr_x[i];
309			the_exit_down->y = downy + freearr_y[i];
310			RP->origin_x = the_exit_down->x;
311			RP->origin_y = the_exit_down->y;
312			write_map_parameters_to_string (buf, RP);
313			the_exit_down->msg = buf;
314	root	1.16
315	root	1.4	/* the identifier for making a random map. */
316	root	1.16	if (RP->dungeon_level >= RP->dungeon_depth && *RP->final_map)
317	root	1.4	{
318	root	1.7	maptile *new_map;
319	root	1.4	object the_exit_back = arch_to_object (the_exit_up->arch), tmp;
320
321			/* load it */
322	root	1.14	if (!(new_map = maptile::load_map_sync (RP->final_map)))
323	root	1.4	return;
324
325			the_exit_down->slaying = RP->final_map;
326
327	root	1.12	for (tmp = new_map->at (new_map->enter_x, new_map->enter_y).bot; tmp; tmp = tmp->above)
328	root	1.4	/* Remove exit back to previous random map. There should only be one
329			* which is why we break out. To try to process more than one
330			* would require keeping a 'next' pointer, ad free_object kills tmp, which
331			* breaks the for loop.
332			*/
333			if (tmp->type == EXIT && EXIT_PATH (tmp) && !strncmp (EXIT_PATH (tmp), "/random/", 8))
334			{
335	root	1.9	tmp->destroy ();
336	root	1.4	break;
337			}
338
339			if (final_map_exit == 1)
340			{
341			/* setup the exit back */
342			the_exit_back->slaying = map->path;
343			the_exit_back->stats.hp = the_exit_down->x;
344			the_exit_back->stats.sp = the_exit_down->y;
345	root	1.11	the_exit_back->x = new_map->enter_x;
346			the_exit_back->y = new_map->enter_y;
347	root	1.4
348			insert_ob_in_map (the_exit_back, new_map, NULL, 0);
349			}
350			}
351			else
352			the_exit_down->slaying = "/!";
353	elmex	1.1
354	root	1.4	/* Block the exit so things don't get dumped on top of it. */
355			the_exit_down->move_block = MOVE_ALL;
356			insert_ob_in_map (the_exit_down, map, NULL, 0);
357			maze[the_exit_down->x][the_exit_down->y] = '>';
358	elmex	1.1	}
359	root	1.4	}
360	root	1.3
361	elmex	1.1	}
362
363			/* this function unblocks the exits. We blocked them to
364			keep things from being dumped on them during the other
365			phases of random map generation. */
366	root	1.4	void
367	root	1.16	unblock_exits (maptile map, char maze, random_map_params RP)
368	root	1.4	{
369			int i = 0, j = 0;
370	elmex	1.1	object *walk;
371
372	root	1.4	for (i = 0; i < RP->Xsize; i++)
373			for (j = 0; j < RP->Ysize; j++)
374			if (maze[i][j] == '>' \|\| maze[i][j] == '<')
375			{
376	root	1.10	for (walk = GET_MAP_OB (map, i, j); walk != NULL; walk = walk->above)
377	root	1.4	{
378			if (walk->move_block == MOVE_ALL && walk->type != LOCKED_DOOR)
379			{
380			walk->move_block = MOVE_BLOCK_DEFAULT;
381			update_object (walk, UP_OBJ_CHANGE);
382			}
383			}
384	elmex	1.1	}
385			}