server/random_maps/room_gen_spiral.C

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * Copyright (©) 1994,2007 Mark Wedel
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Crossfire TRT 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 <crossfire@schmorp.de>
 */

/*  The onion room generator:
Onion rooms are like this:

char **map_gen_spiral(int xsize, int ysize, int option);


*/
#include <global.h>
#include <random_map.h>

#define RANDOM_OPTIONS 0        /* Pick random options below */
#define REGULAR_SPIRAL 1        /* Regular spiral--distance increases constantly */
#define FINE_SPIRAL 2           /* uses the min. separation:  most coiling */
#define FIT_SPIRAL 4            /* scale to a rectangular region, not square */
#define MAX_SPIRAL_OPT 8        /* this should be 2x the last real option */
#include <math.h>

#ifndef MIN
# define MIN(x,y) (((x)<(y))? (x):(y))
#endif
#ifndef MAX
# define MAX(x,y) (((x)<(y))? (y):(x))
#endif

#define MINDIST 3

#define MAX_FINE .454545

extern int surround_check (char **maze, int i, int j, int xsize, int ysize);

char **
map_gen_spiral (int xsize, int ysize, int option)
{
  int i, j;
  float parm = 0;
  float x = 0, y = 0;
  int ic, jc;
  float SizeX, SizeY;
  float xscale, yscale;

  /* allocate that array, set it up */
  char **maze = (char **) calloc (sizeof (char *), xsize);

  for (i = 0; i < xsize; i++)
    {
      maze[i] = (char *) calloc (sizeof (char), ysize);
    }

  /* slightly easier to fill and then cut */
  for (i = 0; i < xsize; i++)
    for (j = 0; j < ysize; j++)
      maze[i][j] = '#';

  ic = xsize / 2;
  jc = ysize / 2;
  SizeX = xsize / 2 - 2;
  SizeY = ysize / 2 - 2;

  /* select random options if necessary */
  if (option == 0)
    {
      option = rndm (MAX_SPIRAL_OPT);
    }

  /* the order in which these are evaluated matters */

  /* the following two are mutually exclusive.  
     pick one if they're both set. */
  if ((option & REGULAR_SPIRAL) && (option & FIT_SPIRAL))
    {
      /* unset REGULAR_SPIRAL half the time */
      if (rndm (2) && (option & REGULAR_SPIRAL))
        option -= REGULAR_SPIRAL;
      else
        option -= FIT_SPIRAL;
    }

  xscale = yscale = MAX_FINE;   /* fine spiral */

  /* choose the spiral pitch */
  if (!(option & FINE_SPIRAL))
    {
      float pitch = (rndm (5)) / 10. + 10. / 22.;

      xscale = yscale = pitch;
    }

  if ((option & FIT_SPIRAL) && (xsize != ysize))
    {
      if (xsize > ysize)
        xscale *= (float) xsize / (float) ysize;
      else
        yscale *= (float) ysize / (float) xsize;
    }

  if (option & REGULAR_SPIRAL)
    {
      float scale = MIN (xscale, yscale);

      xscale = yscale = scale;
    }

  /* cut out the spiral */
  while ((fabs (x) < SizeX) && (fabs (y) < SizeY))
    {
      x = parm * cos (parm) * xscale;
      y = parm * sin (parm) * yscale;
      maze[(int) (ic + x)][(int) (jc + y)] = '\0';
      parm += 0.01;
    };

  maze[(int) (ic + x + 0.5)][(int) (jc + y + 0.5)] = '<';


  /* cut out the center in a 2x2 and place the center and downexit */
  maze[ic][jc + 1] = '>';
  maze[ic][jc] = 'C';


  return maze;
}

/* the following function connects disjoint spirals which may
   result from the symmetrization process. */
void
connect_spirals (int xsize, int ysize, int sym, char **layout)
{

  int i, j, ic = xsize / 2, jc = ysize / 2;

  if (sym == SYMMETRY_X)
    {
      layout[ic][jc] = 0;
      /* go left from map center */
      for (i = ic - 1, j = jc; i > 0 && layout[i][j] == '#'; i--)
        layout[i][j] = 0;
      /* go right */
      for (i = ic + 1, j = jc; i < xsize - 1 && layout[i][j] == '#'; i++)
        layout[i][j] = 0;
    }

  if (sym == SYMMETRY_Y)
    {

      layout[ic][jc] = 0;
      /* go up */
      for (i = ic, j = jc - 1; j > 0 && layout[i][j] == '#'; j--)
        layout[i][j] = 0;
      /* go down */
      for (i = ic, j = jc + 1; j < ysize - 1 && layout[i][j] == '#'; j++)
        layout[i][j] = 0;
    }

  if (sym == SYMMETRY_XY)
    {
      /* go left from map center */
      layout[ic][jc / 2] = 0;
      layout[ic / 2][jc] = 0;
      layout[ic][jc / 2 + jc] = 0;
      layout[ic / 2 + ic][jc] = 0;
      for (i = ic - 1, j = jc / 2; i > 0 && layout[i][j] == '#'; i--)
        {
          layout[i][j + jc] = 0;
          layout[i][j] = 0;
        }
      /* go right */
      for (i = ic + 1, j = jc / 2; i < xsize - 1 && layout[i][j] == '#'; i++)
        {
          layout[i][j + jc] = 0;
          layout[i][j] = 0;
        }
      /* go up */
      for (i = ic / 2, j = jc - 1; j > 0 && layout[i][j] == '#'; j--)
        {
          layout[i][j] = 0;
          layout[i + ic][j] = 0;
        }
      /* go down */
      for (i = ic / 2, j = jc + 1; j < ysize - 1 && layout[i][j] == '#'; j++)
        {
          layout[i][j] = 0;
          layout[i + ic][j] = 0;
        }

    }

  /* get rid of bad doors. */
  for (i = 0; i < xsize; i++)
    for (j = 0; j < ysize; j++)
      {
        if (layout[i][j] == 'D')
          {                     /* remove bad door. */
            int si = surround_check (layout, i, j, xsize, ysize);

            if (si != 3 && si != 12)
              {
                layout[i][j] = 0;
                /* back up and recheck any nearby doors */
                i = 0;
                j = 0;
              }
          }
      }


}
Revision:	1.10
Committed:	Sun Jul 1 05:00:19 2007 UTC (16 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_2, rel-2_3
Changes since 1.9:	+10 -12 lines
Log Message:	- upgrade crossfire trt to the GPL version 3 (hopefully correctly). - add a single file covered by the GNU Affero General Public License (which is not yet released, so I used the current draft, which is legally a bit wavy, but its likely better than nothing as it expresses direct intent by the authors, and we can upgrade as soon as it has been released). * this should ensure availability of source code for the server at least and hopefully also archetypes and maps even when modified versions are not being distributed, in accordance of section 13 of the agplv3.
#	Content
1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5	* Copyright (©) 1994,2007 Mark Wedel
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*
8	* Crossfire TRT 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 3 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, see <http://www.gnu.org/licenses/>.
20	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	*/
23
24	/* The onion room generator:
25	Onion rooms are like this:
26
27	char **map_gen_spiral(int xsize, int ysize, int option);
28
29
30	*/
31	#include <global.h>
32	#include <random_map.h>
33
34	#define RANDOM_OPTIONS 0 /* Pick random options below */
35	#define REGULAR_SPIRAL 1 /* Regular spiral--distance increases constantly */
36	#define FINE_SPIRAL 2 /* uses the min. separation: most coiling */
37	#define FIT_SPIRAL 4 /* scale to a rectangular region, not square */
38	#define MAX_SPIRAL_OPT 8 /* this should be 2x the last real option */
39	#include <math.h>
40
41	#ifndef MIN
42	# define MIN(x,y) (((x)<(y))? (x):(y))
43	#endif
44	#ifndef MAX
45	# define MAX(x,y) (((x)<(y))? (y):(x))
46	#endif
47
48	#define MINDIST 3
49
50	#define MAX_FINE .454545
51
52	extern int surround_check (char **maze, int i, int j, int xsize, int ysize);
53
54	char **
55	map_gen_spiral (int xsize, int ysize, int option)
56	{
57	int i, j;
58	float parm = 0;
59	float x = 0, y = 0;
60	int ic, jc;
61	float SizeX, SizeY;
62	float xscale, yscale;
63
64	/* allocate that array, set it up */
65	char maze = (char ) calloc (sizeof (char *), xsize);
66
67	for (i = 0; i < xsize; i++)
68	{
69	maze[i] = (char *) calloc (sizeof (char), ysize);
70	}
71
72	/* slightly easier to fill and then cut */
73	for (i = 0; i < xsize; i++)
74	for (j = 0; j < ysize; j++)
75	maze[i][j] = '#';
76
77	ic = xsize / 2;
78	jc = ysize / 2;
79	SizeX = xsize / 2 - 2;
80	SizeY = ysize / 2 - 2;
81
82	/* select random options if necessary */
83	if (option == 0)
84	{
85	option = rndm (MAX_SPIRAL_OPT);
86	}
87
88	/* the order in which these are evaluated matters */
89
90	/* the following two are mutually exclusive.
91	pick one if they're both set. */
92	if ((option & REGULAR_SPIRAL) && (option & FIT_SPIRAL))
93	{
94	/* unset REGULAR_SPIRAL half the time */
95	if (rndm (2) && (option & REGULAR_SPIRAL))
96	option -= REGULAR_SPIRAL;
97	else
98	option -= FIT_SPIRAL;
99	}
100
101	xscale = yscale = MAX_FINE; /* fine spiral */
102
103	/* choose the spiral pitch */
104	if (!(option & FINE_SPIRAL))
105	{
106	float pitch = (rndm (5)) / 10. + 10. / 22.;
107
108	xscale = yscale = pitch;
109	}
110
111	if ((option & FIT_SPIRAL) && (xsize != ysize))
112	{
113	if (xsize > ysize)
114	xscale *= (float) xsize / (float) ysize;
115	else
116	yscale *= (float) ysize / (float) xsize;
117	}
118
119	if (option & REGULAR_SPIRAL)
120	{
121	float scale = MIN (xscale, yscale);
122
123	xscale = yscale = scale;
124	}
125
126	/* cut out the spiral */
127	while ((fabs (x) < SizeX) && (fabs (y) < SizeY))
128	{
129	x = parm * cos (parm) * xscale;
130	y = parm * sin (parm) * yscale;
131	maze[(int) (ic + x)][(int) (jc + y)] = '\0';
132	parm += 0.01;
133	};
134
135	maze[(int) (ic + x + 0.5)][(int) (jc + y + 0.5)] = '<';
136
137
138	/* cut out the center in a 2x2 and place the center and downexit */
139	maze[ic][jc + 1] = '>';
140	maze[ic][jc] = 'C';
141
142
143	return maze;
144	}
145
146	/* the following function connects disjoint spirals which may
147	result from the symmetrization process. */
148	void
149	connect_spirals (int xsize, int ysize, int sym, char **layout)
150	{
151
152	int i, j, ic = xsize / 2, jc = ysize / 2;
153
154	if (sym == SYMMETRY_X)
155	{
156	layout[ic][jc] = 0;
157	/* go left from map center */
158	for (i = ic - 1, j = jc; i > 0 && layout[i][j] == '#'; i--)
159	layout[i][j] = 0;
160	/* go right */
161	for (i = ic + 1, j = jc; i < xsize - 1 && layout[i][j] == '#'; i++)
162	layout[i][j] = 0;
163	}
164
165	if (sym == SYMMETRY_Y)
166	{
167
168	layout[ic][jc] = 0;
169	/* go up */
170	for (i = ic, j = jc - 1; j > 0 && layout[i][j] == '#'; j--)
171	layout[i][j] = 0;
172	/* go down */
173	for (i = ic, j = jc + 1; j < ysize - 1 && layout[i][j] == '#'; j++)
174	layout[i][j] = 0;
175	}
176
177	if (sym == SYMMETRY_XY)
178	{
179	/* go left from map center */
180	layout[ic][jc / 2] = 0;
181	layout[ic / 2][jc] = 0;
182	layout[ic][jc / 2 + jc] = 0;
183	layout[ic / 2 + ic][jc] = 0;
184	for (i = ic - 1, j = jc / 2; i > 0 && layout[i][j] == '#'; i--)
185	{
186	layout[i][j + jc] = 0;
187	layout[i][j] = 0;
188	}
189	/* go right */
190	for (i = ic + 1, j = jc / 2; i < xsize - 1 && layout[i][j] == '#'; i++)
191	{
192	layout[i][j + jc] = 0;
193	layout[i][j] = 0;
194	}
195	/* go up */
196	for (i = ic / 2, j = jc - 1; j > 0 && layout[i][j] == '#'; j--)
197	{
198	layout[i][j] = 0;
199	layout[i + ic][j] = 0;
200	}
201	/* go down */
202	for (i = ic / 2, j = jc + 1; j < ysize - 1 && layout[i][j] == '#'; j++)
203	{
204	layout[i][j] = 0;
205	layout[i + ic][j] = 0;
206	}
207
208	}
209
210	/* get rid of bad doors. */
211	for (i = 0; i < xsize; i++)
212	for (j = 0; j < ysize; j++)
213	{
214	if (layout[i][j] == 'D')
215	{ /* remove bad door. */
216	int si = surround_check (layout, i, j, xsize, ysize);
217
218	if (si != 3 && si != 12)
219	{
220	layout[i][j] = 0;
221	/* back up and recheck any nearby doors */
222	i = 0;
223	j = 0;
224	}
225	}
226	}
227
228
229
230	}