server/random_maps/exit.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Deliantra is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

#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 = rmg_rndm (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[1024];
  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 */
  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 = rmg_rndm (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;
        }
    }

  the_exit_up = style_map_up
    ? style_map_up->pick_random_object (rmg_rndm)->clone ()
    : archetype::get (shstr_exit);

  /* we need a down exit only if we're recursing. */
  if (RP->dungeon_level < RP->dungeon_depth || *RP->final_map)
    the_exit_down = style_map_down
      ? style_map_down->pick_random_object (rmg_rndm)->clone ()
      : archetype::get (shstr_exit);
  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 */
  {
    /* 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 (int j = 1; j < 9; j++)
      {
        if (!wall_blocked (map, the_exit_up->x + freearr_x[j], the_exit_up->y + freearr_y[j]))
          {
            object *random_sign = archetype::get (shstr_sign);
            random_sign->msg = format ("This is a random map.\nLevel: %d\n", RP->dungeon_level - 1);
            map->insert (random_sign, the_exit_up->x + freearr_x[j], the_exit_up->y + freearr_y[j], 0, 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[16384];

        int i = find_free_spot (the_exit_down, map, downx, downy, 1, SIZEOFFREE1 + 1);
        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);

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

            new_map->load_sync ();

            the_exit_down->slaying = RP->final_map;

            for (object *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 = 0;
                  update_object (walk, UP_OBJ_CHANGE);
                }
            }
        }
}

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