server/random_maps/exit.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992 Frank Tore Johansen
 * 
 * Deliantra is free software: you can redistribute it and/or modify it under
 * the terms of the Affero 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 Affero GNU General Public License
 * and 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 maze.  fx and fy are pointers to
    where to find the char.  fx,fy = -1 if not found. */
static void
find_in_layout (int mode, char target, int *fx, int *fy, char **maze, 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 (maze[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 (maze[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 (maze[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 (maze[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, const char *exitstyle, int orientation, random_map_params *RP)
{
  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 (const char *eofm = RP->get_str ("exit_on_final_map", 0))
    if (strstr (eofm, "no"))
      final_map_exit = 0;

  if (!orientation)
    orientation = rmg_rndm (6) + 1;

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

      case 2:
        {
          style_map_up   = find_style ("/styles/exitstyles/down", exitstyle, RP->difficulty);
          style_map_down = find_style ("/styles/exitstyles/up"  , exitstyle, RP->difficulty);
          break;
        }

      default:
        {
          style_map_up   =
          style_map_down = find_style ("/styles/exitstyles/generic", exitstyle, RP->difficulty);
          break;
        }
    }

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

  const char *final_map = RP->get_str ("final_map", 0);

  /* we need a down exit only if we're recursing. */
  if (RP->dungeon_level < RP->dungeon_depth || 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->get_iv  ("origin_x", -1);
  the_exit_up->stats.sp = RP->get_iv  ("origin_y", -1);
  the_exit_up->slaying  = RP->get_str ("origin_map", 0);

  /* 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 of %d.\n", RP->dungeon_level - 1, RP->dungeon_depth);
          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)
      {
        int i = rmg_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->set ("origin_x", (IV)the_exit_down->x);
        RP->set ("origin_y", (IV)the_exit_down->y);

        the_exit_down->msg = RP->as_shstr ();

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

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

            new_map->load_sync ();

            the_exit_down->slaying = 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).starts_with ("?random/"))
                {
                  tmp->destroy ();
                  break;
                }

            if (final_map_exit)
              {
                /* 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 = shstr_random_map_exit;

        /* 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.47
Committed:	Sat Jul 3 13:14:35 2010 UTC (13 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.46:	+6 -8 lines
Log Message:	* empty log message *
#	Content
1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*
4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992 Frank Tore Johansen
7	*
8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* the terms of the Affero GNU General Public License as published by the
10	* Free Software Foundation, either version 3 of the License, or (at your
11	* 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 Affero GNU General Public License
19	* and the GNU General Public License along with this program. If not, see
20	* <http://www.gnu.org/licenses/>.
21	*
22	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/
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 maze. fx and fy are pointers to
31	where to find the char. fx,fy = -1 if not found. */
32	static void
33	find_in_layout (int mode, char target, int fx, int fy, char *maze, random_map_params RP)
34	{
35	int M;
36	int i, j;
37
38	*fx = -1;
39	*fy = -1;
40
41	/* if a starting point isn't given, pick one */
42	if (mode < 1 \|\| mode > 4)
43	M = rmg_rndm (4) + 1;
44	else
45	M = mode;
46
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	switch (M)
51	{
52	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 (maze[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 (maze[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 (maze[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 (maze[i][j] == target)
100	{
101	*fx = i;
102	*fy = j;
103	return;
104	}
105	}
106	break;
107
108	}
109	}
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	void
120	place_exits (maptile map, char maze, const char exitstyle, int orientation, random_map_params *RP)
121	{
122	maptile style_map_down = 0; / harder maze */
123	maptile style_map_up = 0; / easier maze */
124	object the_exit_down; / harder maze */
125	object the_exit_up; / easier maze */
126	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 (const char *eofm = RP->get_str ("exit_on_final_map", 0))
132	if (strstr (eofm, "no"))
133	final_map_exit = 0;
134
135	if (!orientation)
136	orientation = rmg_rndm (6) + 1;
137
138	switch (orientation)
139	{
140	case 1:
141	{
142	style_map_up = find_style ("/styles/exitstyles/up" , exitstyle, RP->difficulty);
143	style_map_down = find_style ("/styles/exitstyles/down", exitstyle, RP->difficulty);
144	break;
145	}
146
147	case 2:
148	{
149	style_map_up = find_style ("/styles/exitstyles/down", exitstyle, RP->difficulty);
150	style_map_down = find_style ("/styles/exitstyles/up" , exitstyle, RP->difficulty);
151	break;
152	}
153
154	default:
155	{
156	style_map_up =
157	style_map_down = find_style ("/styles/exitstyles/generic", exitstyle, RP->difficulty);
158	break;
159	}
160	}
161
162	the_exit_up = style_map_up
163	? style_map_up->pick_random_object (rmg_rndm)->clone ()
164	: archetype::get (shstr_exit);
165
166	const char *final_map = RP->get_str ("final_map", 0);
167
168	/* we need a down exit only if we're recursing. */
169	if (RP->dungeon_level < RP->dungeon_depth \|\| final_map)
170	the_exit_down = style_map_down
171	? style_map_down->pick_random_object (rmg_rndm)->clone ()
172	: archetype::get (shstr_exit);
173	else
174	the_exit_down = 0;
175
176	/* set up the up exit */
177	the_exit_up->stats.hp = RP->get_iv ("origin_x", -1);
178	the_exit_up->stats.sp = RP->get_iv ("origin_y", -1);
179	the_exit_up->slaying = RP->get_str ("origin_map", 0);
180
181	/* figure out where to put the entrance */
182	/* begin a logical block */
183	{
184	/* First, look for a '<' char */
185	find_in_layout (0, '<', &upx, &upy, maze, RP);
186
187	/* next, look for a C, the map center. */
188	find_in_layout (0, 'C', &cx, &cy, maze, RP);
189
190	/* if we didn't find an up, find an empty place far from the center */
191	if (upx == -1 && cx != -1)
192	{
193	if (cx > RP->Xsize / 2)
194	upx = 1;
195	else
196	upx = RP->Xsize - 2;
197
198	if (cy > RP->Ysize / 2)
199	upy = 1;
200	else
201	upy = RP->Ysize - 2;
202
203	/* find an empty place far from the center */
204	if (upx == 1 && upy == 1)
205	find_in_layout (1, 0, &upx, &upy, maze, RP);
206	else if (upx == 1 && upy > 1)
207	find_in_layout (3, 0, &upx, &upy, maze, RP);
208	else if (upx > 1 && upy == 1)
209	find_in_layout (2, 0, &upx, &upy, maze, RP);
210	else if (upx > 1 && upy > 1)
211	find_in_layout (4, 0, &upx, &upy, maze, RP);
212	}
213
214	/* no indication of where to place the exit, so just place it. */
215	if (upx == -1)
216	find_in_layout (0, 0, &upx, &upy, maze, RP);
217
218	the_exit_up->x = upx;
219	the_exit_up->y = upy;
220
221	/* surround the exits with notices that this is a random map. */
222	for (int j = 1; j < 9; j++)
223	if (!wall_blocked (map, the_exit_up->x + freearr_x[j], the_exit_up->y + freearr_y[j]))
224	{
225	object *random_sign = archetype::get (shstr_sign);
226	random_sign->msg = format ("This is a random map.\nLevel: %d of %d.\n", RP->dungeon_level - 1, RP->dungeon_depth);
227	map->insert (random_sign, the_exit_up->x + freearr_x[j], the_exit_up->y + freearr_y[j], 0, 0);
228	}
229
230	/* Block the exit so things don't get dumped on top of it. */
231	the_exit_up->move_block = MOVE_ALL;
232
233	insert_ob_in_map (the_exit_up, map, NULL, 0);
234	maze[the_exit_up->x][the_exit_up->y] = '<';
235
236	/* set the starting x,y for this map */
237	map->enter_x = the_exit_up->x;
238	map->enter_y = the_exit_up->y;
239
240	/* first, look for a '>' character */
241	find_in_layout (0, '>', &downx, &downy, maze, RP);
242
243	/* if no > is found use C */
244	if (downx == -1)
245	{
246	downx = cx;
247	downy = cy;
248	};
249
250	/* make the other exit far away from this one if
251	there's no center. */
252	if (downx == -1)
253	{
254	if (upx > RP->Xsize / 2)
255	downx = 1;
256	else
257	downx = RP->Xsize - 2;
258
259	if (upy > RP->Ysize / 2)
260	downy = 1;
261	else
262	downy = RP->Ysize - 2;
263
264	/* find an empty place far from the entrance */
265	if (downx == 1 && downy == 1)
266	find_in_layout (1, 0, &downx, &downy, maze, RP);
267	else if (downx == 1 && downy > 1)
268	find_in_layout (3, 0, &downx, &downy, maze, RP);
269	else if (downx > 1 && downy == 1)
270	find_in_layout (2, 0, &downx, &downy, maze, RP);
271	else if (downx > 1 && downy > 1)
272	find_in_layout (4, 0, &downx, &downy, maze, RP);
273	}
274
275	/* no indication of where to place the down exit, so just place it */
276	if (downx == -1)
277	find_in_layout (0, 0, &downx, &downy, maze, RP);
278
279	if (the_exit_down)
280	{
281	int i = rmg_find_free_spot (the_exit_down, map, downx, downy, 1, SIZEOFFREE1 + 1);
282	the_exit_down->x = downx + freearr_x[i];
283	the_exit_down->y = downy + freearr_y[i];
284	RP->set ("origin_x", (IV)the_exit_down->x);
285	RP->set ("origin_y", (IV)the_exit_down->y);
286
287	the_exit_down->msg = RP->as_shstr ();
288
289	/* the identifier for making a random map. */
290	if (RP->dungeon_level >= RP->dungeon_depth && final_map)
291	{
292	maptile *new_map;
293	object *the_exit_back = the_exit_up->arch->instance ();
294
295	/* load it */
296	if (!(new_map = maptile::find_sync (final_map)))
297	return;
298
299	new_map->load_sync ();
300
301	the_exit_down->slaying = final_map;
302
303	for (object *tmp = new_map->at (new_map->enter_x, new_map->enter_y).bot; tmp; tmp = tmp->above)
304	/* Remove exit back to previous random map. There should only be one
305	* which is why we break out. To try to process more than one
306	* would require keeping a 'next' pointer, ad free_object kills tmp, which
307	* breaks the for loop.
308	*/
309	if (tmp->type == EXIT && EXIT_PATH (tmp).starts_with ("?random/"))
310	{
311	tmp->destroy ();
312	break;
313	}
314
315	if (final_map_exit)
316	{
317	/* setup the exit back */
318	the_exit_back->slaying = map->path;
319	the_exit_back->stats.hp = the_exit_down->x;
320	the_exit_back->stats.sp = the_exit_down->y;
321	the_exit_back->x = new_map->enter_x;
322	the_exit_back->y = new_map->enter_y;
323
324	insert_ob_in_map (the_exit_back, new_map, NULL, 0);
325	}
326	}
327	else
328	the_exit_down->slaying = shstr_random_map_exit;
329
330	/* Block the exit so things don't get dumped on top of it. */
331	the_exit_down->move_block = MOVE_ALL;
332	insert_ob_in_map (the_exit_down, map, NULL, 0);
333	maze[the_exit_down->x][the_exit_down->y] = '>';
334	}
335	}
336	}
337
338	/* this function unblocks the exits. We blocked them to
339	keep things from being dumped on them during the other
340	phases of random map generation. */
341	void
342	unblock_exits (maptile map, char maze, random_map_params RP)
343	{
344	int i = 0, j = 0;
345	object *walk;
346
347	for (i = 0; i < RP->Xsize; i++)
348	for (j = 0; j < RP->Ysize; j++)
349	if (maze[i][j] == '>' \|\| maze[i][j] == '<')
350	{
351	for (walk = GET_MAP_OB (map, i, j); walk != NULL; walk = walk->above)
352	{
353	if (walk->move_block == MOVE_ALL && walk->type != LOCKED_DOOR)
354	{
355	walk->move_block = 0;
356	update_object (walk, UP_OBJ_CHANGE);
357	}
358	}
359	}
360	}
361