server/random_maps/exit.C


/*
 * static char *rcsid_exit_c =
 *   "$Id: exit.C,v 1.4 2006-09-10 16:06:37 root Exp $";
 */

/*
    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-devel@real-time.com
*/

#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, RMParms * 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 (mapstruct *map, char **maze, char *exitstyle, int orientation, RMParms * RP)
{
  char styledirname[256];
  mapstruct *style_map_down = 0;        /* harder maze */
  mapstruct *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 == 0)
    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 (map) = the_exit_up->x;
    MAP_ENTER_Y (map) = 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[0] != 0)
          {
            mapstruct *new_map;
            object *the_exit_back = arch_to_object (the_exit_up->arch), *tmp;

#if 0
            /* I'm not sure if there was any reason to change the path to the
             * map other than to maybe make it more descriptive in the 'maps'
             * command.  But changing the map name makes life more complicated,
             * (has_been_loaded needs to use the new name)
             */

            char new_map_name[MAX_BUF];

            /* give the final map a name */
            sprintf (new_map_name, "%sfinal_map", RP->final_map);
            /* set the exit down. */
#endif
            /* load it */
            if ((new_map = ready_map_name (RP->final_map, 0)) == NULL)
              return;

            the_exit_down->slaying = RP->final_map;
            strcpy (new_map->path, RP->final_map);

            for (tmp = GET_MAP_OB (new_map, MAP_ENTER_X (new_map), MAP_ENTER_Y (new_map)); 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))
                {
                  remove_ob (tmp);
                  free_object (tmp);
                  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 = MAP_ENTER_X (new_map);
                the_exit_back->y = MAP_ENTER_Y (new_map);

                insert_ob_in_map (the_exit_back, new_map, NULL, 0);
              }

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