[ViewVC] Diff of: cvs/deliantra/server/random_maps/random

Comparing deliantra/server/random_maps/random_map.C (file contents):
Revision 1.11 by root, Sat Dec 30 18:45:28 2006 UTC vs.
Revision 1.43 by root, Fri Nov 6 12:49:19 2009 UTC

…		…
1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3		3	*
		4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4	Copyright (C) 2001 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
8	it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
9	the Free Software Foundation; either version 2 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
10	(at your option) any later version.	11	* option) any later version.
11		12	*
12	This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
18	along with this program; if not, write to the Free Software	19	* and the GNU General Public License along with this program. If not, see
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* <http://www.gnu.org/licenses/>.
20		21	*
21	The authors can be reached via e-mail at <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	#include <time.h>	25	#include <time.h>
25	#include <stdio.h>	26	#include <stdio.h>
26	#include <global.h>	27	#include <global.h>
27	#include <maze_gen.h>
28	#include <room_gen.h>
29	#include <random_map.h>	28	#include <random_map.h>
30	#include <rproto.h>	29	#include <rproto.h>
31	#include <sproto.h>	30	#include <sproto.h>
32		31
		32	#define CEDE coroapi::cede_to_tick ()
		33
		34	static void symmetrize_layout (Layout maze, random_map_params *RP);
		35	static void rotate_layout (Layout maze, int rotation);
		36
33	void	37	void
34	dump_layout (char *layout, random_map_params RP)	38	dump_layout (Layout layout)
35	{	39	{
36	{	40	for (int j = 0; j < layout->h; j++)
37	int i, j;
38
39	for (i = 0; i < RP->Xsize; i++)
40	{	41	{
41	for (j = 0; j < RP->Ysize; j++)	42	for (int i = 0; i < layout->w; i++)
42	{	43	putc (layout[i][j] ? layout[i][j] : ' ', stdout);
43	if (layout[i][j] == 0)	44
44	layout[i][j] = ' ';	45	putc ('\n', stdout);
45	printf ("%c", layout[i][j]);
46	if (layout[i][j] == ' ')
47	layout[i][j] = 0;
48	}
49	printf ("\n");
50	}	46	}
51	}
52	printf ("\n");
53	}
54		47
55	extern FILE *logfile;	48	putc ('\n', stdout);
56
57	maptile *
58	generate_random_map (const char OutFileName, random_map_params RP)
59	{
60	char **layout, buf[HUGE_BUF];
61	maptile *theMap;
62	int i;
63
64	/* pick a random seed, or use the one from the input file */
65	if (RP->random_seed == 0)
66	RP->random_seed = time (0);
67
68	SRANDOM (RP->random_seed);
69
70	write_map_parameters_to_string (buf, RP);
71
72	if (RP->difficulty == 0)
73	{
74	RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
75
76	if (RP->difficulty_increase > 0.001)
77	RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
78
79	if (RP->difficulty < 1)
80	RP->difficulty = 1;
81	}
82	else
83	RP->difficulty_given = 1;
84
85	if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
86	RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5;
87
88	if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
89	RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5;
90
91	if (RP->expand2x > 0)
92	{
93	RP->Xsize /= 2;
94	RP->Ysize /= 2;
95	}
96
97	layout = layoutgen (RP);
98
99	#ifdef RMAP_DEBUG
100	dump_layout (layout, RP);
101	#endif
102
103	/* increment these for the current map */
104	RP->dungeon_level += 1;
105	/* allow constant-difficulty maps. */
106	/* difficulty+=1; */
107
108	/* rotate the layout randomly */
109	layout = rotate_layout (layout, RANDOM () % 4, RP);
110	#ifdef RMAP_DEBUG
111	dump_layout (layout, RP);
112	#endif
113
114	/* allocate the map and set the floor */
115	theMap = make_map_floor (layout, RP->floorstyle, RP);
116
117	/* set the name of the map. */
118	theMap->path = OutFileName;
119
120	/* set region */
121	theMap->region = RP->region;
122
123	/* create walls unless the wallstyle is "none" */
124	if (strcmp (RP->wallstyle, "none"))
125	{
126	make_map_walls (theMap, layout, RP->wallstyle, RP);
127
128	/* place doors unless doorstyle or wallstyle is "none" */
129	if (strcmp (RP->doorstyle, "none"))
130	put_doors (theMap, layout, RP->doorstyle, RP);
131
132	}
133
134	/* create exits unless the exitstyle is "none" */
135	if (strcmp (RP->exitstyle, "none"))
136	place_exits (theMap, layout, RP->exitstyle, RP->orientation, RP);
137
138	place_specials_in_map (theMap, layout, RP);
139
140	/* create monsters unless the monsterstyle is "none" */
141	if (strcmp (RP->monsterstyle, "none"))
142	place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP);
143
144	/* treasures needs to have a proper difficulty set for the map. */
145	theMap->difficulty = theMap->estimate_difficulty ();
146
147	/* create treasure unless the treasurestyle is "none" */
148	if (strcmp (RP->treasurestyle, "none"))
149	place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP);
150
151	/* create decor unless the decorstyle is "none" */
152	if (strcmp (RP->decorstyle, "none"))
153	put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP);
154
155	/* generate treasures, etc. */
156	theMap->fix_auto_apply ();
157
158	unblock_exits (theMap, layout, RP);
159
160	/* free the layout */
161	for (i = 0; i < RP->Xsize; i++)
162	free (layout[i]);
163	free (layout);
164
165	theMap->msg = strdup (buf);
166
167	return theMap;
168	}	49	}
169		50
170	/* function selects the layout function and gives it whatever
171	arguments it needs. */
172	char **
173	layoutgen (random_map_params * RP)
174	{
175	char **maze = 0;
176	int oxsize = RP->Xsize, oysize = RP->Ysize;
177
178	if (RP->symmetry == SYMMETRY_RANDOM)
179	RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1;
180	else
181	RP->symmetry_used = RP->symmetry;
182
183	if (RP->symmetry_used == SYMMETRY_Y \|\| RP->symmetry_used == SYMMETRY_XY)
184	RP->Ysize = RP->Ysize / 2 + 1;
185	if (RP->symmetry_used == SYMMETRY_X \|\| RP->symmetry_used == SYMMETRY_XY)
186	RP->Xsize = RP->Xsize / 2 + 1;
187
188	if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
189	RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
190	if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
191	RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
192	RP->map_layout_style = 0;
193
194	/* Redo this - there was a lot of redundant code of checking for preset
195	* layout style and then random layout style. Instead, figure out
196	* the numeric layoutstyle, so there is only one area that actually
197	* calls the code to make the maps.
198	*/
199	if (strstr (RP->layoutstyle, "onion"))
200	RP->map_layout_style = LAYOUT_ONION;
201
202	if (strstr (RP->layoutstyle, "maze"))
203	RP->map_layout_style = LAYOUT_MAZE;
204
205	if (strstr (RP->layoutstyle, "spiral"))
206	RP->map_layout_style = LAYOUT_SPIRAL;
207
208	if (strstr (RP->layoutstyle, "rogue"))
209	RP->map_layout_style = LAYOUT_ROGUELIKE;
210
211	if (strstr (RP->layoutstyle, "snake"))
212	RP->map_layout_style = LAYOUT_SNAKE;
213
214	if (strstr (RP->layoutstyle, "squarespiral"))
215	RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
216
217	/* No style found - choose one ranomdly */
218	if (RP->map_layout_style == LAYOUT_NONE)
219	RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1;
220
221	switch (RP->map_layout_style)
222	{
223	case LAYOUT_ONION:
224	maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);
225	if (!(RANDOM () % 3) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
226	roomify_layout (maze, RP);
227	break;
228
229	case LAYOUT_MAZE:
230	maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2);
231	if (!(RANDOM () % 2))
232	doorify_layout (maze, RP);
233	break;
234
235	case LAYOUT_SPIRAL:
236	maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
237	if (!(RANDOM () % 2))
238	doorify_layout (maze, RP);
239	break;
240
241	case LAYOUT_ROGUELIKE:
242	/* Don't put symmetry in rogue maps. There isn't much reason to
243	* do so in the first place (doesn't make it any more interesting),
244	* but more importantly, the symmetry code presumes we are symmetrizing
245	* spirals, or maps with lots of passages - making a symmetric rogue
246	* map fails because its likely that the passages the symmetry process
247	* creates may not connect the rooms.
248	*/
249	RP->symmetry_used = SYMMETRY_NONE;
250	RP->Ysize = oysize;
251	RP->Xsize = oxsize;
252	maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1);
253	/* no doorifying... done already */
254	break;
255
256	case LAYOUT_SNAKE:
257	maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
258	if (RANDOM () % 2)
259	roomify_layout (maze, RP);
260	break;
261
262	case LAYOUT_SQUARE_SPIRAL:
263	maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
264	if (RANDOM () % 2)
265	roomify_layout (maze, RP);
266	break;
267	}
268
269	maze = symmetrize_layout (maze, RP->symmetry_used, RP);
270
271	#ifdef RMAP_DEBUG
272	dump_layout (maze, RP);
273	#endif
274
275	if (RP->expand2x)
276	{
277	maze = expand2x (maze, RP->Xsize, RP->Ysize);
278	RP->Xsize = RP->Xsize * 2 - 1;
279	RP->Ysize = RP->Ysize * 2 - 1;
280	}
281
282	return maze;
283	}
284
285	/* takes a map and makes it symmetric: adjusts Xsize and	51	/* takes a map and makes it symmetric: adjusts Xsize and
286	Ysize to produce a symmetric map. */	52	* Ysize to produce a symmetric map.
287	char **	53	*/
		54	static void
288	symmetrize_layout (char *maze, int sym, random_map_params RP)	55	symmetrize_layout (Layout layout, random_map_params *RP)
289	{	56	{
290	int i, j;
291	char **sym_maze;
292	int Xsize_orig, Ysize_orig;
293
294	Xsize_orig = RP->Xsize;
295	Ysize_orig = RP->Ysize;
296	RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
297	if (sym == SYMMETRY_NONE)	57	if (RP->symmetry_used == SYMMETRY_NONE)
298	{
299	RP->Xsize = Xsize_orig;
300	RP->Ysize = Ysize_orig;
301	return maze;	58	return;
302	}
303	/* pick new sizes */
304	RP->Xsize = ((sym == SYMMETRY_X \|\| sym == SYMMETRY_XY) ? RP->Xsize * 2 - 3 : RP->Xsize);
305	RP->Ysize = ((sym == SYMMETRY_Y \|\| sym == SYMMETRY_XY) ? RP->Ysize * 2 - 3 : RP->Ysize);
306		59
307	sym_maze = (char *) calloc (sizeof (char ), RP->Xsize);	60	Layout sym_layout (
308	for (i = 0; i < RP->Xsize; i++)	61	RP->symmetry_used == SYMMETRY_X \|\| RP->symmetry_used == SYMMETRY_XY ? layout->w * 2 - 3 : layout->w,
309	sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize);	62	RP->symmetry_used == SYMMETRY_Y \|\| RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
		63	);
310		64
311	if (sym == SYMMETRY_X)	65	if (RP->symmetry_used == SYMMETRY_X)
312	for (i = 0; i < RP->Xsize / 2 + 1; i++)	66	for (int i = 0; i < sym_layout->w / 2 + 1; i++)
313	for (j = 0; j < RP->Ysize; j++)	67	for (int j = 0; j < sym_layout->h; j++)
314	{	68	{
315	sym_maze[i][j] = maze[i][j];	69	sym_layout[i ][j] =
316	sym_maze[RP->Xsize - i - 1][j] = maze[i][j];	70	sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
317	};	71	}
		72
318	if (sym == SYMMETRY_Y)	73	if (RP->symmetry_used == SYMMETRY_Y)
319	for (i = 0; i < RP->Xsize; i++)	74	for (int i = 0; i < sym_layout->w; i++)
320	for (j = 0; j < RP->Ysize / 2 + 1; j++)	75	for (int j = 0; j < sym_layout->h / 2 + 1; j++)
321	{
322	sym_maze[i][j] = maze[i][j];
323	sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
324	}	76	{
325	if (sym == SYMMETRY_XY)	77	sym_layout[i][j ] =
326	for (i = 0; i < RP->Xsize / 2 + 1; i++)	78	sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
327	for (j = 0; j < RP->Ysize / 2 + 1; j++)
328	{	79	}
329	sym_maze[i][j] = maze[i][j];	80
330	sym_maze[i][RP->Ysize - j - 1] = maze[i][j];	81	if (RP->symmetry_used == SYMMETRY_XY)
331	sym_maze[RP->Xsize - i - 1][j] = maze[i][j];	82	for (int i = 0; i < sym_layout->w / 2 + 1; i++)
332	sym_maze[RP->Xsize - i - 1][RP->Ysize - j - 1] = maze[i][j];	83	for (int j = 0; j < sym_layout->h / 2 + 1; j++)
333	}	84	{
334	/* delete the old maze */	85	sym_layout[i ][j ] =
335	for (i = 0; i < Xsize_orig; i++)	86	sym_layout[i ][sym_layout->h - j - 1] =
336	free (maze[i]);	87	sym_layout[sym_layout->w - i - 1][j ] =
337	free (maze);	88	sym_layout[sym_layout->w - i - 1][sym_layout->h - j - 1] = layout[i][j];
		89	}
		90
		91	layout.swap (sym_layout);
		92	sym_layout.free ();
		93
338	/* reconnect disjointed spirals */	94	/* reconnect disjointed spirals */
339	if (RP->map_layout_style == LAYOUT_SPIRAL)
340	connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
341	/* reconnect disjointed nethackmazes: the routine for	95	/* reconnect disjointed nethacklayouts: the routine for
342	spirals will do the trick? */	96	spirals will do the trick? */
		97	if (RP->map_layout_style == LAYOUT_SPIRAL
343	if (RP->map_layout_style == LAYOUT_ROGUELIKE)	98	\|\| RP->map_layout_style == LAYOUT_ROGUELIKE)
344	connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);	99	connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
345
346	return sym_maze;
347	}	100	}
348
349		101
350	/* takes a map and rotates it. This completes the	102	/* takes a map and rotates it. This completes the
351	onion layouts, making them possibly centered on any wall.	103	onion layouts, making them possibly centered on any wall.
352	It'll modify Xsize and Ysize if they're swapped.	104	It'll modify Xsize and Ysize if they're swapped.
353	*/	105	*/
354		106	static void
355	char **	107	rotate_layout (Layout layout, int rotation)
356	rotate_layout (char *maze, int rotation, random_map_params RP)
357	{	108	{
358	char **new_maze;	109	int w = layout->w;
359	int i, j;	110	int h = layout->h;
360		111
361	switch (rotation)	112	switch (rotation)
362	{	113	{
363	case 0:	114	case 2: /* a reflection */
364	return maze;	115	{
		116	Layout new_layout (w, h);
		117
		118	for (int i = 0; i < w; i++) /* copy a reflection back */
		119	for (int j = 0; j < h; j++)
		120	new_layout[i][j] = layout[w - i - 1][h - j - 1];
		121
		122	layout.swap (new_layout);
		123	new_layout.free ();
		124	}
365	break;	125	break;
366	case 2: /* a reflection */
367	{
368	char newmaze = (char ) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
369		126
370	for (i = 0; i < RP->Xsize; i++)
371	{ /* make a copy */
372	for (j = 0; j < RP->Ysize; j++)
373	{
374	newmaze[i * RP->Ysize + j] = maze[i][j];
375	}
376	}
377	for (i = 0; i < RP->Xsize; i++)
378	{ /* copy a reflection back */
379	for (j = 0; j < RP->Ysize; j++)
380	{
381	maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
382	}
383	}
384	free (newmaze);
385	return maze;
386	break;
387	}
388	case 1:	127	case 1:
389	case 3:	128	case 3:
390	{	129	{
391	int swap;	130	Layout new_layout (h, w);
392	new_maze = (char *) calloc (sizeof (char ), RP->Ysize);	131
393	for (i = 0; i < RP->Ysize; i++)
394	{
395	new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
396	}
397	if (rotation == 1) /* swap x and y */	132	if (rotation == 1) /* swap x and y */
398	for (i = 0; i < RP->Xsize; i++)	133	for (int i = 0; i < w; i++)
399	for (j = 0; j < RP->Ysize; j++)	134	for (int j = 0; j < h; j++)
400	new_maze[j][i] = maze[i][j];	135	new_layout[j][i] = layout[i][j];
401		136
402	if (rotation == 3)	137	if (rotation == 3) /* swap x and y */
403	{ /* swap x and y */
404	for (i = 0; i < RP->Xsize; i++)	138	for (int i = 0; i < w; i++)
405	for (j = 0; j < RP->Ysize; j++)	139	for (int j = 0; j < h; j++)
406	new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];	140	new_layout[j][i] = layout[w - i - 1][h - j - 1];
		141
		142	layout.swap (new_layout);
		143	new_layout.free ();
407	}	144	}
408
409	/* delete the old layout */
410	for (i = 0; i < RP->Xsize; i++)
411	free (maze[i]);
412	free (maze);
413
414	swap = RP->Ysize;
415	RP->Ysize = RP->Xsize;
416	RP->Xsize = swap;
417	return new_maze;
418	break;	145	break;
419	}
420	}
421	return NULL;
422	}
423
424	/* take a layout and make some rooms in it.
425	--works best on onions.*/
426	void
427	roomify_layout (char *maze, random_map_params RP)
428	{
429	int tries = RP->Xsize * RP->Ysize / 30;
430	int ti;
431
432	for (ti = 0; ti < tries; ti++)
433	{
434	int dx, dy; /* starting location for looking at creating a door */
435	int cx, cy; /* results of checking on creating walls. */
436
437	dx = RANDOM () % RP->Xsize;
438	dy = RANDOM () % RP->Ysize;
439	cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
440	cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
441	if (cx == -1)
442	{
443	if (cy != -1)
444	make_wall (maze, dx, dy, 1);
445	continue;
446	}
447	if (cy == -1)
448	{
449	make_wall (maze, dx, dy, 0);
450	continue;
451	}
452	if (cx < cy)
453	make_wall (maze, dx, dy, 0);
454	else
455	make_wall (maze, dx, dy, 1);
456	}	146	}
457	}	147	}
458		148
459	/* checks the layout to see if I can stick a horizontal(dir = 0) wall	149	/* checks the layout to see if I can stick a horizontal(dir = 0) wall
460	(or vertical, dir == 1)	150	(or vertical, dir == 1)
461	here which ends up on other walls sensibly. */	151	here which ends up on other walls sensibly. */
462
463	int	152	int
464	can_make_wall (char *maze, int dx, int dy, int dir, random_map_params RP)	153	can_make_wall (char *maze, int dx, int dy, int dir, random_map_params RP)
465	{	154	{
466	int i1;	155	int i1;
467	int length = 0;	156	int length = 0;
468		157
469	/* dont make walls if we're on the edge. */	158	/* dont make walls if we're on the edge. */
532	return -1; /* can't make verti. wall here */	221	return -1; /* can't make verti. wall here */
533	if (maze[x][i1] != 0)	222	if (maze[x][i1] != 0)
534	return -1; /* can't make horiz. wall here */	223	return -1; /* can't make horiz. wall here */
535	length++;	224	length++;
536	}	225	}
		226
537	return length;	227	return length;
538	}	228	}
		229
539	return -1;	230	return -1;
540	}	231	}
541		232
		233	/* take a layout and make some rooms in it.
		234	--works best on onions.*/
		235	void
		236	roomify_layout (char *maze, random_map_params RP)
		237	{
		238	int tries = RP->Xsize * RP->Ysize / 30;
		239	int ti;
		240
		241	for (ti = 0; ti < tries; ti++)
		242	{
		243	int dx, dy; /* starting location for looking at creating a door */
		244	int cx, cy; /* results of checking on creating walls. */
		245
		246	dx = rmg_rndm (RP->Xsize);
		247	dy = rmg_rndm (RP->Ysize);
		248
		249	cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
		250	cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
		251	if (cx == -1)
		252	{
		253	if (cy != -1)
		254	make_wall (maze, dx, dy, 1);
		255
		256	continue;
		257	}
		258
		259	if (cy == -1)
		260	{
		261	make_wall (maze, dx, dy, 0);
		262	continue;
		263	}
		264
		265	if (cx < cy)
		266	make_wall (maze, dx, dy, 0);
		267	else
		268	make_wall (maze, dx, dy, 1);
		269	}
		270	}
542		271
543	int	272	int
544	make_wall (char **maze, int x, int y, int dir)	273	make_wall (char **maze, int x, int y, int dir)
545	{	274	{
546	maze[x][y] = 'D'; /* mark a door */	275	maze[x][y] = 'D'; /* mark a door */
547	switch (dir)	276	switch (dir)
548	{	277	{
549	case 0: /* horizontal */	278	case 0: /* horizontal */
550	{	279	{
551	int i1;	280	int i1;
552		281
553	for (i1 = x - 1; maze[i1][y] == 0; i1--)	282	for (i1 = x - 1; maze[i1][y] == 0; i1--)
554	maze[i1][y] = '#';	283	maze[i1][y] = '#';
555	for (i1 = x + 1; maze[i1][y] == 0; i1++)	284	for (i1 = x + 1; maze[i1][y] == 0; i1++)
556	maze[i1][y] = '#';	285	maze[i1][y] = '#';
557	break;	286	break;
558	}	287	}
559	case 1: /* vertical */	288	case 1: /* vertical */
560	{	289	{
561	int i1;	290	int i1;
562		291
563	for (i1 = y - 1; maze[x][i1] == 0; i1--)	292	for (i1 = y - 1; maze[x][i1] == 0; i1--)
564	maze[x][i1] = '#';	293	maze[x][i1] = '#';
565	for (i1 = y + 1; maze[x][i1] == 0; i1++)	294	for (i1 = y + 1; maze[x][i1] == 0; i1++)
566	maze[x][i1] = '#';	295	maze[x][i1] = '#';
567	break;	296	break;
568	}	297	}
569	}	298	}
570		299
571	return 0;	300	return 0;
572	}	301	}
573		302
574	/* puts doors at appropriate locations in a layout. */	303	/* puts doors at appropriate locations in a layout. */
575
576	void	304	void
577	doorify_layout (char *maze, random_map_params RP)	305	doorify_layout (char *maze, random_map_params RP)
578	{	306	{
579	int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */	307	int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
580	char *doorlist_x;
581	char *doorlist_y;
582	int doorlocs = 0; /* # of available doorlocations */	308	int doorlocs = 0; /* # of available doorlocations */
583	int i, j;
584		309
585	doorlist_x = (char ) malloc (sizeof (int) RP->Xsize * RP->Ysize);	310	uint16 doorlist_x = salloc<uint16> (RP->Xsize RP->Ysize);
586	doorlist_y = (char ) malloc (sizeof (int) RP->Xsize * RP->Ysize);	311	uint16 doorlist_y = salloc<uint16> (RP->Xsize RP->Ysize);
587
588		312
589	/* make a list of possible door locations */	313	/* make a list of possible door locations */
590	for (i = 1; i < RP->Xsize - 1; i++)	314	for (int i = 1; i < RP->Xsize - 1; i++)
591	for (j = 1; j < RP->Ysize - 1; j++)	315	for (int j = 1; j < RP->Ysize - 1; j++)
592	{	316	{
593	int sindex = surround_flag (maze, i, j, RP);	317	int sindex = surround_flag (maze, i, j, RP);
594		318
595	if (sindex == 3 \|\| sindex == 12) /* these are possible door sindex */	319	if (sindex == 3 \|\| sindex == 12) /* these are possible door sindex */
596	{	320	{
597	doorlist_x[doorlocs] = i;	321	doorlist_x[doorlocs] = i;
598	doorlist_y[doorlocs] = j;	322	doorlist_y[doorlocs] = j;
599	doorlocs++;	323	doorlocs++;
600	}	324	}
601	}	325	}
		326
602	while (ndoors > 0 && doorlocs > 0)	327	while (ndoors > 0 && doorlocs > 0)
603	{	328	{
604	int di;	329	int di = rmg_rndm (doorlocs);
605	int sindex;
606
607	di = RANDOM () % doorlocs;
608	i = doorlist_x[di];	330	int i = doorlist_x[di];
609	j = doorlist_y[di];	331	int j = doorlist_y[di];
610	sindex = surround_flag (maze, i, j, RP);	332	int sindex = surround_flag (maze, i, j, RP);
		333
611	if (sindex == 3 \|\| sindex == 12) /* these are possible door sindex */	334	if (sindex == 3 \|\| sindex == 12) /* these are possible door sindex */
612	{	335	{
613	maze[i][j] = 'D';	336	maze[i][j] = 'D';
614	ndoors--;	337	ndoors--;
615	}	338	}
		339
616	/* reduce the size of the list */	340	/* reduce the size of the list */
617	doorlocs--;	341	doorlocs--;
618	doorlist_x[di] = doorlist_x[doorlocs];	342	doorlist_x[di] = doorlist_x[doorlocs];
619	doorlist_y[di] = doorlist_y[doorlocs];	343	doorlist_y[di] = doorlist_y[doorlocs];
620	}	344	}
621	free (doorlist_x);
622	free (doorlist_y);
623	}
624		345
		346	sfree (doorlist_x, RP->Xsize * RP->Ysize);
		347	sfree (doorlist_y, RP->Xsize * RP->Ysize);
		348	}
625		349
626	void	350	void
627	write_map_parameters_to_string (char buf, random_map_params RP)	351	write_map_parameters_to_string (char buf, random_map_params RP)
628	{	352	{
629	char small_buf[256];	353	char small_buf[16384];
630		354
631	sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize);	355	sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
632		356
633	if (RP->wallstyle[0])	357	if (RP->wallstyle[0])
634	{	358	{
635	sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);	359	sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
636	strcat (buf, small_buf);	360	strcat (buf, small_buf);
…		…
676	{	400	{
677	sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);	401	sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
678	strcat (buf, small_buf);	402	strcat (buf, small_buf);
679	}	403	}
680		404
681	if (RP->final_map[0])	405	if (RP->final_map.length ())
682	{	406	{
683	sprintf (small_buf, "final_map %s\n", RP->final_map);	407	sprintf (small_buf, "final_map %s\n", &RP->final_map);
684	strcat (buf, small_buf);	408	strcat (buf, small_buf);
685	}	409	}
686		410
687	if (RP->exit_on_final_map[0])	411	if (RP->exit_on_final_map[0])
688	{	412	{
689	sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);	413	sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
690	strcat (buf, small_buf);	414	strcat (buf, small_buf);
691	}	415	}
692		416
693	if (RP->this_map[0])	417	if (RP->this_map.length ())
694	{	418	{
695	sprintf (small_buf, "origin_map %s\n", RP->this_map);	419	sprintf (small_buf, "origin_map %s\n", &RP->this_map);
696	strcat (buf, small_buf);	420	strcat (buf, small_buf);
697	}	421	}
698		422
699	if (RP->expand2x)	423	if (RP->expand2x)
700	{	424	{
…		…
706	{	430	{
707	sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);	431	sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
708	strcat (buf, small_buf);	432	strcat (buf, small_buf);
709	}	433	}
710		434
711
712	if (RP->layoutoptions2)	435	if (RP->layoutoptions2)
713	{	436	{
714	sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);	437	sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
715	strcat (buf, small_buf);	438	strcat (buf, small_buf);
716	}	439	}
717		440
718
719	if (RP->layoutoptions3)	441	if (RP->layoutoptions3)
720	{	442	{
721	sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);	443	sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
722	strcat (buf, small_buf);	444	strcat (buf, small_buf);
723	}	445	}
…		…
725	if (RP->symmetry)	447	if (RP->symmetry)
726	{	448	{
727	sprintf (small_buf, "symmetry %d\n", RP->symmetry);	449	sprintf (small_buf, "symmetry %d\n", RP->symmetry);
728	strcat (buf, small_buf);	450	strcat (buf, small_buf);
729	}	451	}
730
731		452
732	if (RP->difficulty && RP->difficulty_given)	453	if (RP->difficulty && RP->difficulty_given)
733	{	454	{
734	sprintf (small_buf, "difficulty %d\n", RP->difficulty);	455	sprintf (small_buf, "difficulty %d\n", RP->difficulty);
735	strcat (buf, small_buf);	456	strcat (buf, small_buf);
…		…
772	{	493	{
773	sprintf (small_buf, "origin_y %d\n", RP->origin_y);	494	sprintf (small_buf, "origin_y %d\n", RP->origin_y);
774	strcat (buf, small_buf);	495	strcat (buf, small_buf);
775	}	496	}
776		497
		498	if (RP->treasureoptions)
		499	{
		500	sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
		501	strcat (buf, small_buf);
		502	}
		503
777	if (RP->random_seed)	504	if (RP->random_seed)
778	{	505	{
779	/* Add one so that the next map is a bit different */
780	sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1);	506	sprintf (small_buf, "random_seed %u\n", RP->random_seed);
781	strcat (buf, small_buf);	507	strcat (buf, small_buf);
782	}
783
784	if (RP->treasureoptions)
785	{	508	}
786	sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);	509
		510	if (RP->custom)
		511	{
		512	sprintf (small_buf, "custom %s\n", RP->custom);
787	strcat (buf, small_buf);	513	strcat (buf, small_buf);
788	}	514	}
789	}	515	}
790		516
791	void	517	void
792	write_parameters_to_string (char *buf,	518	write_parameters_to_string (char *buf,
793	int xsize_n,	519	int xsize_n,
794	int ysize_n,	520	int ysize_n,
795	char *wallstyle_n,	521	const char *wallstyle_n,
796	char *floorstyle_n,	522	const char *floorstyle_n,
797	char *monsterstyle_n,	523	const char *monsterstyle_n,
798	char *treasurestyle_n,	524	const char *treasurestyle_n,
799	char *layoutstyle_n,	525	const char *layoutstyle_n,
800	char *decorstyle_n,	526	const char *decorstyle_n,
801	char *doorstyle_n,	527	const char *doorstyle_n,
802	char *exitstyle_n,	528	const char *exitstyle_n,
803	char *final_map_n,	529	const char *final_map_n,
804	char *exit_on_final_map_n,	530	const char *exit_on_final_map_n,
805	char *this_map_n,	531	const char *this_map_n,
806	int layoutoptions1_n,	532	int layoutoptions1_n,
807	int layoutoptions2_n,	533	int layoutoptions2_n,
808	int layoutoptions3_n,	534	int layoutoptions3_n,
809	int symmetry_n,	535	int symmetry_n,
810	int dungeon_depth_n,	536	int dungeon_depth_n,
811	int dungeon_level_n,	537	int dungeon_level_n,
812	int difficulty_n,	538	int difficulty_n,
813	int difficulty_given_n,	539	int difficulty_given_n,
814	int decoroptions_n,	540	int decoroptions_n,
815	int orientation_n,	541	int orientation_n,
816	int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase)	542	int origin_x_n,
		543	int origin_y_n,
		544	uint32_t random_seed_n,
		545	int treasureoptions_n,
		546	float difficulty_increase)
817	{	547	{
818
819	char small_buf[256];	548	char small_buf[16384];
820		549
821	sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);	550	sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
822		551
823	if (wallstyle_n && wallstyle_n[0])	552	if (wallstyle_n && wallstyle_n[0])
824	{	553	{
…		…
889	if (layoutoptions1_n)	618	if (layoutoptions1_n)
890	{	619	{
891	sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);	620	sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
892	strcat (buf, small_buf);	621	strcat (buf, small_buf);
893	}	622	}
894
895		623
896	if (layoutoptions2_n)	624	if (layoutoptions2_n)
897	{	625	{
898	sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);	626	sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
899	strcat (buf, small_buf);	627	strcat (buf, small_buf);
…		…
959	}	687	}
960		688
961	if (random_seed_n)	689	if (random_seed_n)
962	{	690	{
963	/* Add one so that the next map is a bit different */	691	/* Add one so that the next map is a bit different */
964	sprintf (small_buf, "random_seed %d\n", random_seed_n + 1);	692	sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
965	strcat (buf, small_buf);	693	strcat (buf, small_buf);
966	}	694	}
967		695
968	if (treasureoptions_n)	696	if (treasureoptions_n)
969	{	697	{
970	sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);	698	sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
971	strcat (buf, small_buf);	699	strcat (buf, small_buf);
972	}	700	}
973
974
975	}	701	}
976		702
977	/* copy an object with an inventory... i.e., duplicate the inv too. */	703	/////////////////////////////////////////////////////////////////////////////
978	void
979	copy_object_with_inv (object src_ob, object dest_ob)
980	{
981	object walk, tmp;
982		704
983	src_ob->copy_to (dest_ob);	705	LayoutData::LayoutData (int w, int h)
		706	: w(w), h(h)
		707	{
		708	int size = (sizeof (char ) + sizeof (char) h) * w;
984		709
985	for (walk = src_ob->inv; walk != NULL; walk = walk->below)	710	col = (char **)salloc<char> (size);
986	{	711
987	tmp = object::create ();	712	char data = (char )(col + w);
988	walk->copy_to (tmp);	713
989	insert_ob_in_ob (tmp, dest_ob);	714	for (int x = w; x--; )
		715	col [x] = data + x * h;
		716	}
		717
		718	LayoutData::~LayoutData ()
		719	{
		720	int size = (sizeof (char ) + sizeof (char) h) * w;
		721
		722	sfree ((char *)col, size);
		723	}
		724
		725	void LayoutData::clear (char fill)
		726	{
		727	memset (col [0], fill, w * h);
		728	}
		729
		730	void LayoutData::border (char fill)
		731	{
		732	for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
		733	for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
		734	}
		735
		736	/* function selects the layout function and gives it whatever
		737	arguments it needs. */
		738	Layout
		739	layoutgen (random_map_params *RP)
		740	{
		741	Layout layout (RP);
		742
		743	switch (RP->map_layout_style)
990	}	744	{
		745	case LAYOUT_ONION:
		746	map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
		747
		748	if (!(rmg_rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
		749	roomify_layout (layout, RP);
		750
		751	break;
		752
		753	case LAYOUT_MAZE:
		754	maze_gen (layout, rmg_rndm (2));
		755
		756	if (!(rmg_rndm (2)))
		757	doorify_layout (layout, RP);
		758
		759	break;
		760
		761	case LAYOUT_SPIRAL:
		762	map_gen_spiral (layout, RP->layoutoptions1);
		763
		764	if (!(rmg_rndm (2)))
		765	doorify_layout (layout, RP);
		766
		767	break;
		768
		769	case LAYOUT_ROGUELIKE:
		770	/* Don't put symmetry in rogue maps. There isn't much reason to
		771	* do so in the first place (doesn't make it any more interesting),
		772	* but more importantly, the symmetry code presumes we are symmetrizing
		773	* spirals, or maps with lots of passages - making a symmetric rogue
		774	* map fails because its likely that the passages the symmetry process
		775	* creates may not connect the rooms.
		776	*/
		777	RP->symmetry_used = SYMMETRY_NONE;
		778	roguelike_layout_gen (layout, RP->layoutoptions1);
		779	/* no doorifying... done already */
		780	break;
		781
		782	case LAYOUT_SNAKE:
		783	make_snake_layout (layout, RP->layoutoptions1);
		784
		785	if (rmg_rndm (2))
		786	roomify_layout (layout, RP);
		787
		788	break;
		789
		790	case LAYOUT_SQUARE_SPIRAL:
		791	make_square_spiral_layout (layout, RP->layoutoptions1);
		792
		793	if (rmg_rndm (2))
		794	roomify_layout (layout, RP);
		795
		796	break;
		797
		798	default:
		799	abort ();
		800	}
		801
		802	/* rotate the layout randomly */
		803	rotate_layout (layout, rmg_rndm (4));
		804
		805	symmetrize_layout (layout, RP);
		806
		807	#ifdef RMAP_DEBUG
		808	dump_layout (layout);
		809	#endif
		810
		811	if (RP->expand2x)
		812	expand2x (layout);
		813
		814	return layout;
991	}	815	}
		816
		817	bool
		818	maptile::generate_random_map (random_map_params *RP)
		819	{
		820	char buf[16384];
		821	int i;
		822
		823	RP->Xsize = RP->xsize;
		824	RP->Ysize = RP->ysize;
		825
		826	/* pick a random seed, or use the one from the input file */
		827	RP->random_seed = RP->random_seed
		828	? RP->random_seed + RP->dungeon_level
		829	: time (0);
		830
		831	// we run "single-threaded"
		832	rmg_rndm.seed (RP->random_seed);
		833
		834	write_map_parameters_to_string (buf, RP);
		835
		836	if (RP->difficulty == 0)
		837	{
		838	RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
		839
		840	if (RP->difficulty_increase > 0.001)
		841	RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
		842
		843	if (RP->difficulty < 1)
		844	RP->difficulty = 1;
		845	}
		846	else
		847	RP->difficulty_given = 1;
		848
		849	if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
		850	RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
		851
		852	if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
		853	RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
		854
		855	if (RP->symmetry == SYMMETRY_RANDOM)
		856	RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
		857	else
		858	RP->symmetry_used = RP->symmetry;
		859
		860	if (RP->symmetry_used == SYMMETRY_Y \|\| RP->symmetry_used == SYMMETRY_XY)
		861	RP->Ysize = RP->Ysize / 2 + 1;
		862
		863	if (RP->symmetry_used == SYMMETRY_X \|\| RP->symmetry_used == SYMMETRY_XY)
		864	RP->Xsize = RP->Xsize / 2 + 1;
		865
		866	if (RP->expand2x > 0)
		867	{
		868	RP->Xsize /= 2;
		869	RP->Ysize /= 2;
		870	}
		871
		872	RP->map_layout_style = LAYOUT_NONE;
		873
		874	/* Redo this - there was a lot of redundant code of checking for preset
		875	* layout style and then random layout style. Instead, figure out
		876	* the numeric layoutstyle, so there is only one area that actually
		877	* calls the code to make the maps.
		878	*/
		879	if (strstr (RP->layoutstyle, "onion"))
		880	RP->map_layout_style = LAYOUT_ONION;
		881	else if (strstr (RP->layoutstyle, "maze"))
		882	RP->map_layout_style = LAYOUT_MAZE;
		883	else if (strstr (RP->layoutstyle, "spiral"))
		884	RP->map_layout_style = LAYOUT_SPIRAL;
		885	else if (strstr (RP->layoutstyle, "rogue"))
		886	RP->map_layout_style = LAYOUT_ROGUELIKE;
		887	else if (strstr (RP->layoutstyle, "snake"))
		888	RP->map_layout_style = LAYOUT_SNAKE;
		889	else if (strstr (RP->layoutstyle, "squarespiral"))
		890	RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
		891	else if (RP->map_layout_style == LAYOUT_NONE)
		892	RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
		893	else
		894	abort ();
		895
		896	Layout layout = layoutgen (RP);
		897
		898	#ifdef RMAP_DEBUG
		899	dump_layout (layout);
		900	#endif
		901
		902	/* increment these for the current map */
		903	++RP->dungeon_level;
		904
		905	// need to patch RP becasue following code doesn't use the Layout object
		906	RP->Xsize = layout->w;
		907	RP->Ysize = layout->h;
		908
		909	/* allocate the map and set the floor */
		910	make_map_floor (layout, RP->floorstyle, RP);
		911
		912	/* set region */
		913	default_region = RP->region;
		914
		915	CEDE;
		916
		917	place_specials_in_map (this, layout, RP);
		918
		919	CEDE;
		920
		921	/* create walls unless the wallstyle is "none" */
		922	if (strcmp (RP->wallstyle, "none"))
		923	{
		924	make_map_walls (this, layout, RP->wallstyle, RP);
		925
		926	/* place doors unless doorstyle or wallstyle is "none" */
		927	if (strcmp (RP->doorstyle, "none"))
		928	put_doors (this, layout, RP->doorstyle, RP);
		929	}
		930
		931	CEDE;
		932
		933	/* create exits unless the exitstyle is "none" */
		934	if (strcmp (RP->exitstyle, "none"))
		935	place_exits (this, layout, RP->exitstyle, RP->orientation, RP);
		936
		937	CEDE;
		938
		939	/* create monsters unless the monsterstyle is "none" */
		940	if (strcmp (RP->monsterstyle, "none"))
		941	place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
		942
		943	CEDE;
		944
		945	/* treasures needs to have a proper difficulty set for the map. */
		946	difficulty = estimate_difficulty ();
		947
		948	CEDE;
		949
		950	/* create treasure unless the treasurestyle is "none" */
		951	place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
		952
		953	CEDE;
		954
		955	/* create decor unless the decorstyle is "none" */
		956	if (strcmp (RP->decorstyle, "none"))
		957	put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP);
		958
		959	CEDE;
		960
		961	/* generate treasures, etc. */
		962	fix_auto_apply ();
		963
		964	CEDE;
		965
		966	unblock_exits (this, layout, RP);
		967
		968	msg = strdup (buf);
		969	in_memory = MAP_ACTIVE;
		970
		971	CEDE;
		972
		973	return 1;
		974	}
		975

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/random_maps/random_map.C (file contents): Revision 1.11 by root, Sat Dec 30 18:45:28 2006 UTC vs. Revision 1.43 by root, Fri Nov 6 12:49:19 2009 UTC

Diff Legend

Comparing deliantra/server/random_maps/random_map.C (file contents):
Revision 1.11 by root, Sat Dec 30 18:45:28 2006 UTC vs.
Revision 1.43 by root, Fri Nov 6 12:49:19 2009 UTC