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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.15 by root, Mon Jan 15 01:50:33 2007 UTC vs.
Revision 1.47 by root, Fri Nov 6 13:03:34 2009 UTC

…		…
1
2	/*	1	/*
3	CrossFire, A Multiplayer game for X-windows	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
4		3	*
5	Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
6	Copyright (C) 2001 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
7	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
8		7	*
9	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
10	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
11	the Free Software Foundation; either version 2 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
12	(at your option) any later version.	11	* option) any later version.
13		12	*
14	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,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU General Public License for more details.	16	* GNU General Public License for more details.
18		17	*
19	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
20	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
21	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* <http://www.gnu.org/licenses/>.
22		21	*
23	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>
24	*/	23	*/
25		24
26	/* placing treasure in maps, where appropriate. */	25	/* placing treasure in maps, where appropriate. */
27
28
29		26
30	#include <global.h>	27	#include <global.h>
31	#include <random_map.h>	28	#include <random_map.h>
32	#include <rproto.h>	29	#include <rproto.h>
33		30
44	#define LAST_OPTION 64 /* set this to the last real option, for random */	41	#define LAST_OPTION 64 /* set this to the last real option, for random */
45		42
46	#define NO_PASS_DOORS 0	43	#define NO_PASS_DOORS 0
47	#define PASS_DOORS 1	44	#define PASS_DOORS 1
48		45
		46	static object find_closest_monster (maptile map, int x, int y, random_map_params *RP);
		47	static object find_monster_in_room (maptile map, int x, int y, random_map_params *RP);
		48	static void find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP);
		49	static void find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP);
		50	static object place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params RP);
		51	static object *find_doors_in_room (maptile map, int x, int y, random_map_params *RP);
		52	static void lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP);
		53	static void find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP);
		54	static object *surround_by_doors (maptile map, char **layout, int x, int y, int opts);
		55
		56	/* a macro to get a strongly centered random distribution,
		57	from 0 to x, centered at x/2 */
		58	static int
		59	bc_random (int x)
		60	{
		61	return (rmg_rndm (x) + rmg_rndm (x) + rmg_rndm (x)) / 3;
		62	}
		63
		64	static object *
		65	gen_key (const shstr &keycode)
		66	{
		67	/* get a key and set its keycode */
		68	object *key = archetype::get (shstr_key_random_map);
		69	key->slaying = keycode;
		70	return key;
		71	}
		72
		73	/* places keys in the map, preferably in something alive.
		74	keycode is the key's code,
		75	door_flag is either PASS_DOORS or NO_PASS_DOORS.
		76	NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
		77	if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
		78	it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
		79
		80	The idea is that you call keyplace on x,y where a door is, and it'll make
		81	sure a key is placed on both sides of the door.
		82	*/
		83	static int
		84	keyplace (maptile map, int x, int y, const shstr &keycode, int door_flag, int n_keys, random_map_params RP)
		85	{
		86	int i, j;
		87	int kx = 0, ky = 0;
		88	object the_keymaster; / the monster that gets the key. */
		89	object *the_key = gen_key (keycode);
		90
		91	if (door_flag == PASS_DOORS)
		92	{
		93	int tries = 0;
		94
		95	the_keymaster = 0;
		96	while (tries < 15 && !the_keymaster)
		97	{
		98	i = rmg_rndm (RP->Xsize - 2) + 1;
		99	j = rmg_rndm (RP->Ysize - 2) + 1;
		100	tries++;
		101	the_keymaster = find_closest_monster (map, i, j, RP);
		102	}
		103
		104	/* if we don't find a good keymaster, drop the key on the ground. */
		105	if (!the_keymaster)
		106	{
		107	int freeindex;
		108
		109	freeindex = -1;
		110	for (tries = 0; tries < 15 && freeindex == -1; tries++)
		111	{
		112	kx = rmg_rndm (RP->Xsize - 2) + 1;
		113	ky = rmg_rndm (RP->Ysize - 2) + 1;
		114	freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
		115	}
		116
		117	// can freeindex ever be < 0?
		118	if (freeindex >= 0)
		119	{
		120	kx += freearr_x [freeindex];
		121	ky += freearr_y [freeindex];
		122	}
		123	}
		124	}
		125	else
		126	{ /* NO_PASS_DOORS --we have to work harder. */
		127	/* don't try to keyplace if we're sitting on a blocked square and
		128	NO_PASS_DOORS is set. */
		129	if (n_keys == 1)
		130	{
		131	if (wall_blocked (map, x, y))
		132	{
		133	the_key->destroy ();
		134	return 0;
		135	}
		136
		137	the_keymaster = find_monster_in_room (map, x, y, RP);
		138	if (!the_keymaster) /* if fail, find a spot to drop the key. */
		139	find_spot_in_room (map, x, y, &kx, &ky, RP);
		140	}
		141	else
		142	{
		143	int sum = 0; /* count how many keys we actually place */
		144
		145	/* I'm lazy, so just try to place in all 4 directions. */
		146	sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
		147	sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
		148	sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
		149	sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
		150
		151	if (sum < 2) /* we might have made a disconnected map-place more keys. */
		152	{ /* diagonally this time. */
		153	keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
		154	keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
		155	keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
		156	keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
		157	}
		158
		159	the_key->destroy ();
		160	return 1;
		161	}
		162	}
		163
		164	if (the_keymaster)
		165	the_keymaster->head_ ()->insert (the_key);
		166	else
		167	{
		168	the_key->x = kx;
		169	the_key->y = ky;
		170	insert_ob_in_map (the_key, map, NULL, 0);
		171	}
		172
		173	return 1;
		174	}
49		175
50	/* returns true if square x,y has P_NO_PASS set, which is true for walls	176	/* returns true if square x,y has P_NO_PASS set, which is true for walls
51	* and doors but not monsters.	177	* and doors but not monsters.
52	* This function is not map tile aware.	178	* This function is not map tile aware.
53	*/	179	*/
54
55	int	180	int
56	wall_blocked (maptile *m, int x, int y)	181	wall_blocked (maptile *m, int x, int y)
57	{	182	{
58	int r;
59
60	if (OUT_OF_REAL_MAP (m, x, y))	183	if (OUT_OF_REAL_MAP (m, x, y))
61	return 1;	184	return 1;
		185
		186	m->at (x, y).update ();
62	r = GET_MAP_MOVE_BLOCK (m, x, y) & ~MOVE_BLOCK_DEFAULT;	187	return GET_MAP_MOVE_BLOCK (m, x, y) & MOVE_WALK;
63	return r;
64	}	188	}
65		189
66	/* place treasures in the map, given the	190	/* place treasures in the map, given the
67	map, (required)	191	map, (required)
68	layout, (required)	192	layout, (required)
69	treasure style (may be empty or NULL, or "none" to cause no treasure.)	193	treasure style (may be empty or NULL, or "none" to cause no treasure.)
70	treasureoptions (may be 0 for random choices or positive)	194	treasureoptions (may be 0 for random choices or positive)
71	*/	195	*/
72
73	void	196	void
74	place_treasure (maptile map, char layout, char treasure_style, int treasureoptions, random_map_params *RP)	197	place_treasure (maptile map, char layout, char treasure_style, int treasureoptions, random_map_params *RP)
75	{	198	{
76	char styledirname[1024];	199	char styledirname[1024];
77	char stylefilepath[1024];	200	char stylefilepath[1024];
…		…
80		203
81	/* bail out if treasure isn't wanted. */	204	/* bail out if treasure isn't wanted. */
82	if (treasure_style)	205	if (treasure_style)
83	if (!strcmp (treasure_style, "none"))	206	if (!strcmp (treasure_style, "none"))
84	return;	207	return;
		208
85	if (treasureoptions <= 0)	209	if (treasureoptions <= 0)
86	treasureoptions = RANDOM () % (2 * LAST_OPTION);	210	treasureoptions = rmg_rndm (2 * LAST_OPTION);
87		211
88	/* filter out the mutually exclusive options */	212	/* filter out the mutually exclusive options */
89	if ((treasureoptions & RICH) && (treasureoptions & SPARSE))	213	if ((treasureoptions & RICH) && (treasureoptions & SPARSE))
90	{	214	{
91	if (RANDOM () % 2)	215	if (rmg_rndm (2))
92	treasureoptions -= 1;	216	treasureoptions -= 1;
93	else	217	else
94	treasureoptions -= 2;	218	treasureoptions -= 2;
95	}	219	}
96		220
97	/* pick the number of treasures */	221	/* pick the number of treasures */
98	if (treasureoptions & SPARSE)	222	if (treasureoptions & SPARSE)
99	num_treasures = BC_RANDOM (RP->total_map_hp / 600 + RP->difficulty / 2 + 1);	223	num_treasures = bc_random (RP->total_map_hp / 600 + RP->difficulty / 2 + 1);
100	else if (treasureoptions & RICH)	224	else if (treasureoptions & RICH)
101	num_treasures = BC_RANDOM (RP->total_map_hp / 150 + 2 * RP->difficulty + 1);	225	num_treasures = bc_random (RP->total_map_hp / 150 + 2 * RP->difficulty + 1);
102	else	226	else
103	num_treasures = BC_RANDOM (RP->total_map_hp / 300 + RP->difficulty + 1);	227	num_treasures = bc_random (RP->total_map_hp / 300 + RP->difficulty + 1);
104		228
105	if (num_treasures <= 0)	229	if (num_treasures <= 0)
106	return;	230	return;
107		231
108	/* get the style map */	232	/* get the style map */
109	sprintf (styledirname, "%s", "/styles/treasurestyles");	233	sprintf (styledirname, "%s", "/styles/treasurestyles");
110	sprintf (stylefilepath, "%s/%s", styledirname, treasure_style);	234	sprintf (stylefilepath, "%s/%s", styledirname, treasure_style);
111	style_map = find_style (styledirname, treasure_style, -1);	235	style_map = find_style (styledirname, treasure_style, -1);
112		236
		237	if (!style_map)
		238	{
		239	LOG (llevError, "unable to load style map %s %s.\n", styledirname, treasure_style);
		240	return;
		241	}
		242
113	/* all the treasure at one spot in the map. */	243	/* all the treasure at one spot in the map. */
114	if (treasureoptions & CONCENTRATED)	244	if (treasureoptions & CONCENTRATED)
115	{	245	{
116
117	/* map_layout_style global, and is previously set */	246	/* map_layout_style global, and is previously set */
118	switch (RP->map_layout_style)	247	switch (RP->map_layout_style)
119	{	248	{
120	case LAYOUT_ONION:	249	case LAYOUT_ONION:
121	case LAYOUT_SPIRAL:	250	case LAYOUT_SPIRAL:
…		…
129	for (j = 0; j < RP->Ysize; j++)	258	for (j = 0; j < RP->Ysize; j++)
130	{	259	{
131	if (layout[i][j] == 'C' \|\| layout[i][j] == '>')	260	if (layout[i][j] == 'C' \|\| layout[i][j] == '>')
132	{	261	{
133	int tdiv = RP->symmetry_used;	262	int tdiv = RP->symmetry_used;
134	object **doorlist;
135	object *chest;	263	object *chest;
136		264
137	if (tdiv == 3)	265	if (tdiv == 3)
138	tdiv = 2; /* this symmetry uses a divisor of 2 */	266	tdiv = 2; /* this symmetry uses a divisor of 2 */
		267
139	/* don't put a chest on an exit. */	268	/* don't put a chest on an exit. */
140	chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP);	269	chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP);
		270
141	if (!chest)	271	if (!chest)
142	continue; /* if no chest was placed NEXT */	272	continue; /* if no chest was placed NEXT */
		273
143	if (treasureoptions & (DOORED \| HIDDEN))	274	if (treasureoptions & (DOORED \| HIDDEN))
144	{	275	{
145	doorlist = find_doors_in_room (map, i, j, RP);	276	object **doorlist = find_doors_in_room (map, i, j, RP);
146	lock_and_hide_doors (doorlist, map, treasureoptions, RP);	277	lock_and_hide_doors (doorlist, map, treasureoptions, RP);
147	free (doorlist);	278	free (doorlist);
148	}	279	}
149	}	280	}
150	}	281	}
151	}	282	}
152	break;	283	break;
153	}	284	}
		285
154	default:	286	default:
155	{	287	{
156	int i, j, tries;	288	int i, j, tries;
157	object *chest;	289	object *chest;
158	object **doorlist;	290	object **doorlist;
159		291
160	i = j = -1;	292	i = j = -1;
161	tries = 0;	293	tries = 0;
162	while (i == -1 && tries < 100)	294	while (i == -1 && tries < 100)
163	{	295	{
164	i = RANDOM () % (RP->Xsize - 2) + 1;	296	i = rmg_rndm (RP->Xsize - 2) + 1;
165	j = RANDOM () % (RP->Ysize - 2) + 1;	297	j = rmg_rndm (RP->Ysize - 2) + 1;
166	find_enclosed_spot (map, &i, &j, RP);	298	find_enclosed_spot (map, &i, &j, RP);
		299
167	if (wall_blocked (map, i, j))	300	if (wall_blocked (map, i, j))
168	i = -1;	301	i = -1;
		302
169	tries++;	303	tries++;
170	}	304	}
		305
171	chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP);	306	chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP);
		307
172	if (!chest)	308	if (!chest)
173	return;	309	return;
		310
174	i = chest->x;	311	i = chest->x;
175	j = chest->y;	312	j = chest->y;
176	if (treasureoptions & (DOORED \| HIDDEN))	313	if (treasureoptions & (DOORED \| HIDDEN))
177	{	314	{
178	doorlist = surround_by_doors (map, layout, i, j, treasureoptions);	315	doorlist = surround_by_doors (map, layout, i, j, treasureoptions);
…		…
186	{ /* DIFFUSE treasure layout */	323	{ /* DIFFUSE treasure layout */
187	int ti, i, j;	324	int ti, i, j;
188		325
189	for (ti = 0; ti < num_treasures; ti++)	326	for (ti = 0; ti < num_treasures; ti++)
190	{	327	{
191	i = RANDOM () % (RP->Xsize - 2) + 1;	328	i = rmg_rndm (RP->Xsize - 2) + 1;
192	j = RANDOM () % (RP->Ysize - 2) + 1;	329	j = rmg_rndm (RP->Ysize - 2) + 1;
193	place_chest (treasureoptions, i, j, map, style_map, 1, RP);	330	place_chest (treasureoptions, i, j, map, style_map, 1, RP);
194	}	331	}
195	}	332	}
196	}	333	}
197		334
198	/* put a chest into the map, near x and y, with the treasure style	335	/* put a chest into the map, near x and y, with the treasure style
199	determined (may be null, or may be a treasure list from lib/treasures,	336	determined (may be null, or may be a treasure list from lib/treasures,
200	if the global variable "treasurestyle" is set to that treasure list's name */	337	if the global variable "treasurestyle" is set to that treasure list's name */
201		338	static object *
202	object *
203	place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params *RP)	339	place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params *RP)
204	{	340	{
205	object *the_chest;
206	int i, xl, yl;
207
208	the_chest = get_archetype ("chest"); /* was "chest_2" */	341	object the_chest = archetype::get (shstr_chest); / was "chest_2" */
209		342
210	/* first, find a place to put the chest. */	343	/* first, find a place to put the chest. */
211	i = find_first_free_spot (the_chest, map, x, y);	344	int i = find_first_free_spot (the_chest, map, x, y); // this call uses the main rng
212	if (i == -1)	345	if (i == -1)
213	{	346	{
214	the_chest->destroy ();	347	the_chest->destroy ();
215	return NULL;	348	return NULL;
216	}	349	}
		350
217	xl = x + freearr_x[i];	351	int xl = x + freearr_x[i];
218	yl = y + freearr_y[i];	352	int yl = y + freearr_y[i];
219		353
220	/* if the placement is blocked, return a fail. */	354	/* if the placement is blocked, return a fail. */
221	if (wall_blocked (map, xl, yl))	355	if (wall_blocked (map, xl, yl))
222	return 0;	356	return 0;
223		357
…		…
230	treasurelist *tlist = find_treasurelist (RP->treasurestyle);	364	treasurelist *tlist = find_treasurelist (RP->treasurestyle);
231		365
232	if (tlist != NULL)	366	if (tlist != NULL)
233	for (ti = 0; ti < n_treasures; ti++)	367	for (ti = 0; ti < n_treasures; ti++)
234	{ /* use the treasure list */	368	{ /* use the treasure list */
235	object *new_treasure = pick_random_object (style_map);	369	object *new_treasure = style_map->pick_random_object (rmg_rndm);
236		370
237	insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);	371	insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);
238	}	372	}
239	else	373	else
240	{ /* use the style map */	374	{ /* use the style map */
241	the_chest->randomitems = tlist;	375	the_chest->randomitems = tlist;
242	the_chest->stats.hp = n_treasures;	376	the_chest->stats.hp = n_treasures;
243	}	377	}
244	#endif	378	#endif
245	{ /* neither style_map no treasure list given */	379	{ /* neither style_map no treasure list given */
246	treasurelist *tlist = find_treasurelist ("chest");	380	treasurelist *tlist = treasurelist::find ("chest");
247		381
248	the_chest->randomitems = tlist;	382	the_chest->randomitems = tlist;
249	the_chest->stats.hp = n_treasures;	383	the_chest->stats.hp = n_treasures;
250	}	384	}
251		385
252	/* stick a trap in the chest if required */	386	/* stick a trap in the chest if required */
253	if (treasureoptions & TRAPPED)	387	if (treasureoptions & TRAPPED)
254	{	388	{
255	maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);	389	maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);
256	object *the_trap;
257		390
258	if (trap_map)	391	if (trap_map)
259	{	392	{
260	the_trap = pick_random_object (trap_map);	393	object *the_trap = trap_map->pick_random_object (rmg_rndm);
		394
261	the_trap->stats.Cha = 10 + RP->difficulty;	395	the_trap->stats.Cha = 10 + RP->difficulty;
262	the_trap->level = BC_RANDOM ((3 * RP->difficulty) / 2);	396	the_trap->level = bc_random ((3 * RP->difficulty) / 2);
		397
263	if (the_trap)	398	if (the_trap)
264	{	399	{
265	object *new_trap;	400	object *new_trap = the_trap->arch->instance ();//TODO: why not clone?
266		401
267	new_trap = arch_to_object (the_trap->arch);
268	new_trap->copy_to (the_trap);
269	new_trap->x = x;	402	new_trap->x = x;
270	new_trap->y = y;	403	new_trap->y = y;
271	insert_ob_in_ob (new_trap, the_chest);	404	insert_ob_in_ob (new_trap, the_chest);
272	}	405	}
273	}	406	}
274	}	407	}
275		408
276	/* set the chest lock code, and call the keyplacer routine with	409	/* set the chest lock code, and call the keyplacer routine with
277	the lockcode. It's not worth bothering to lock the chest if	410	the lockcode. It's not worth bothering to lock the chest if
278	there's only 1 treasure.... */	411	there's only 1 treasure.... */
279
280	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)	412	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
281	{	413	{
282	char keybuf[1024];	414	the_chest->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
283
284	sprintf (keybuf, "%d", (int) RANDOM ());
285	the_chest->slaying = keybuf;
286	keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP);	415	keyplace (map, x, y, the_chest->slaying, PASS_DOORS, 1, RP);
287	}	416	}
288		417
289	/* actually place the chest. */	418	/* actually place the chest. */
290	the_chest->x = xl;	419	the_chest->x = xl;
291	the_chest->y = yl;	420	the_chest->y = yl;
292	insert_ob_in_map (the_chest, map, NULL, 0);	421	insert_ob_in_map (the_chest, map, NULL, 0);
293	return the_chest;	422	return the_chest;
294	}	423	}
295		424
296
297	/* finds the closest monster and returns him, regardless of doors	425	/* finds the closest monster and returns him, regardless of doors or walls */
298	or walls */	426	static object *
299	object *
300	find_closest_monster (maptile map, int x, int y, random_map_params RP)	427	find_closest_monster (maptile map, int x, int y, random_map_params RP)
301	{	428	{
302	int i;	429	int i;
303		430
304	for (i = 0; i < SIZEOFFREE; i++)	431	for (i = 0; i < SIZEOFFREE; i++)
…		…
320	}	447	}
321	}	448	}
322	return NULL;	449	return NULL;
323	}	450	}
324		451
325
326
327	/* places keys in the map, preferably in something alive.
328	keycode is the key's code,
329	door_flag is either PASS_DOORS or NO_PASS_DOORS.
330	NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
331	if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
332	it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
333
334	The idea is that you call keyplace on x,y where a door is, and it'll make
335	sure a key is placed on both sides of the door.
336	*/
337
338	int
339	keyplace (maptile map, int x, int y, char keycode, int door_flag, int n_keys, random_map_params *RP)
340	{
341	int i, j;
342	int kx, ky;
343	object the_keymaster; / the monster that gets the key. */
344	object *the_key;
345
346	/* get a key and set its keycode */
347	the_key = get_archetype ("key2");
348	the_key->slaying = keycode;
349
350	if (door_flag == PASS_DOORS)
351	{
352	int tries = 0;
353
354	the_keymaster = NULL;
355	while (tries < 15 && the_keymaster == NULL)
356	{
357	i = (RANDOM () % (RP->Xsize - 2)) + 1;
358	j = (RANDOM () % (RP->Ysize - 2)) + 1;
359	tries++;
360	the_keymaster = find_closest_monster (map, i, j, RP);
361	}
362	/* if we don't find a good keymaster, drop the key on the ground. */
363	if (the_keymaster == NULL)
364	{
365	int freeindex;
366
367	freeindex = -1;
368	for (tries = 0; tries < 15 && freeindex == -1; tries++)
369	{
370	kx = (RANDOM () % (RP->Xsize - 2)) + 1;
371	ky = (RANDOM () % (RP->Ysize - 2)) + 1;
372	freeindex = find_first_free_spot (the_key, map, kx, ky);
373	}
374
375	if (freeindex != -1)
376	{
377	kx += freearr_x[freeindex];
378	ky += freearr_y[freeindex];
379	}
380	}
381	}
382	else
383	{ /* NO_PASS_DOORS --we have to work harder. */
384	/* don't try to keyplace if we're sitting on a blocked square and
385	NO_PASS_DOORS is set. */
386	if (n_keys == 1)
387	{
388	if (wall_blocked (map, x, y))
389	return 0;
390
391	the_keymaster = find_monster_in_room (map, x, y, RP);
392	if (the_keymaster == NULL) /* if fail, find a spot to drop the key. */
393	find_spot_in_room (map, x, y, &kx, &ky, RP);
394	}
395	else
396	{
397	int sum = 0; /* count how many keys we actually place */
398
399	/* I'm lazy, so just try to place in all 4 directions. */
400	sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
401	sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
402	sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
403	sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
404	if (sum < 2) /* we might have made a disconnected map-place more keys. */
405	{ /* diagnoally this time. */
406	keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
407	keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
408	keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
409	keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
410	}
411	return 1;
412	}
413	}
414
415	if (the_keymaster == NULL)
416	{
417	the_key->x = kx;
418	the_key->y = ky;
419	insert_ob_in_map (the_key, map, NULL, 0);
420	return 1;
421	}
422
423	insert_ob_in_ob (the_key, the_keymaster);
424	return 1;
425	}
426
427
428
429	/* both find_monster_in_room routines need to have access to this. */	452	/* both find_monster_in_room routines need to have access to this. */
430		453
431	object *theMonsterToFind;	454	static object *theMonsterToFind;
432		455
433	/* a recursive routine which will return a monster, eventually,if there is one.	456	/* a recursive routine which will return a monster, eventually,if there is one.
434	it does a check-off on the layout, converting 0's to 1's */	457	it does a check-off on the layout, converting 0's to 1's */
435		458	static object *
436	object *
437	find_monster_in_room_recursive (char *layout, maptile map, int x, int y, random_map_params *RP)	459	find_monster_in_room_recursive (char *layout, maptile map, int x, int y, random_map_params *RP)
438	{	460	{
439	int i, j;	461	int i, j;
440		462
441	/* if we've found a monster already, leave */	463	/* if we've found a monster already, leave */
…		…
465	return theMonsterToFind;	487	return theMonsterToFind;
466	}	488	}
467	}	489	}
468		490
469	/* now search all the 8 squares around recursively for a monster,in random order */	491	/* now search all the 8 squares around recursively for a monster,in random order */
470	for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)	492	for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
471	{	493	{
472	theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);	494	theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
473	if (theMonsterToFind != NULL)	495	if (theMonsterToFind != NULL)
474	return theMonsterToFind;	496	return theMonsterToFind;
475	}	497	}
		498
476	return theMonsterToFind;	499	return theMonsterToFind;
477	}	500	}
478
479		501
480	/* sets up some data structures: the _recursive form does the	502	/* sets up some data structures: the _recursive form does the
481	real work. */	503	real work. */
482		504	static object *
483	object *
484	find_monster_in_room (maptile map, int x, int y, random_map_params RP)	505	find_monster_in_room (maptile map, int x, int y, random_map_params RP)
485	{	506	{
486	char **layout2;	507	Layout layout2 (RP);
487	int i, j;	508
		509	layout2->clear ();
		510
		511	/* allocate and copy the layout, converting C to 0. */
		512	for (int i = 0; i < layout2->w; i++)
		513	for (int j = 0; j < layout2->h; j++)
		514	if (wall_blocked (map, i, j))
		515	layout2[i][j] = '#';
488		516
489	theMonsterToFind = 0;	517	theMonsterToFind = 0;
490	layout2 = (char *) calloc (sizeof (char ), RP->Xsize);
491	/* allocate and copy the layout, converting C to 0. */
492	for (i = 0; i < RP->Xsize; i++)
493	{
494	layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
495	for (j = 0; j < RP->Ysize; j++)
496	{
497	if (wall_blocked (map, i, j))
498	layout2[i][j] = '#';
499	}
500	}
501	theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);	518	theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);
502		519
503	/* deallocate the temp. layout */	520	layout2.free ();
504	for (i = 0; i < RP->Xsize; i++)
505	{
506	free (layout2[i]);
507	}
508	free (layout2);
509		521
510	return theMonsterToFind;	522	return theMonsterToFind;
511	}	523	}
512		524
513
514
515
516	/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */	525	/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
517	int *room_free_spots_x;	526	static int *room_free_spots_x;
518	int *room_free_spots_y;	527	static int *room_free_spots_y;
519	int number_of_free_spots_in_room;	528	static int number_of_free_spots_in_room;
520		529
521	/* the workhorse routine, which finds the free spots in a room:	530	/* the workhorse routine, which finds the free spots in a room:
522	a datastructure of free points is set up, and a position chosen from	531	a datastructure of free points is set up, and a position chosen from
523	that datastructure. */	532	that datastructure. */
524		533	static void
525	void
526	find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP)	534	find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP)
527	{	535	{
528	int i, j;	536	int i, j;
529		537
530	/* bounds check x and y */	538	/* bounds check x and y */
…		…
540	/* check off this point */	548	/* check off this point */
541	layout[x][y] = 1;	549	layout[x][y] = 1;
542	room_free_spots_x[number_of_free_spots_in_room] = x;	550	room_free_spots_x[number_of_free_spots_in_room] = x;
543	room_free_spots_y[number_of_free_spots_in_room] = y;	551	room_free_spots_y[number_of_free_spots_in_room] = y;
544	number_of_free_spots_in_room++;	552	number_of_free_spots_in_room++;
		553
545	/* now search all the 8 squares around recursively for free spots,in random order */	554	/* now search all the 8 squares around recursively for free spots,in random order */
546	for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)	555	for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
547	{
548	find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);	556	find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
549	}
550		557
551	}	558	}
552		559
553	/* find a random non-blocked spot in this room to drop a key. */	560	/* find a random non-blocked spot in this room to drop a key. */
554	void	561	static void
555	find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP)	562	find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP)
556	{	563	{
557	char **layout2;	564	char **layout2;
558	int i, j;	565	int i, j;
559		566
…		…
565	/* allocate and copy the layout, converting C to 0. */	572	/* allocate and copy the layout, converting C to 0. */
566	for (i = 0; i < RP->Xsize; i++)	573	for (i = 0; i < RP->Xsize; i++)
567	{	574	{
568	layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);	575	layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
569	for (j = 0; j < RP->Ysize; j++)	576	for (j = 0; j < RP->Ysize; j++)
570	{
571	if (wall_blocked (map, i, j))	577	if (wall_blocked (map, i, j))
572	layout2[i][j] = '#';	578	layout2[i][j] = '#';
573	}
574	}	579	}
575		580
576	/* setup num_free_spots and room_free_spots */	581	/* setup num_free_spots and room_free_spots */
577	find_spot_in_room_recursive (layout2, x, y, RP);	582	find_spot_in_room_recursive (layout2, x, y, RP);
578		583
579	if (number_of_free_spots_in_room > 0)	584	if (number_of_free_spots_in_room > 0)
580	{	585	{
581	i = RANDOM () % number_of_free_spots_in_room;	586	i = rmg_rndm (number_of_free_spots_in_room);
582	*kx = room_free_spots_x[i];	587	*kx = room_free_spots_x[i];
583	*ky = room_free_spots_y[i];	588	*ky = room_free_spots_y[i];
584	}	589	}
585		590
586	/* deallocate the temp. layout */	591	/* deallocate the temp. layout */
587	for (i = 0; i < RP->Xsize; i++)	592	for (i = 0; i < RP->Xsize; i++)
588	{
589	free (layout2[i]);	593	free (layout2[i]);
590	}	594
591	free (layout2);	595	free (layout2);
592	free (room_free_spots_x);	596	free (room_free_spots_x);
593	free (room_free_spots_y);	597	free (room_free_spots_y);
594	}	598	}
595		599
596		600
597	/* searches the map for a spot with walls around it. The more	601	/* searches the map for a spot with walls around it. The more
598	walls the better, but it'll settle for 1 wall, or even 0, but	602	walls the better, but it'll settle for 1 wall, or even 0, but
599	it'll return 0 if no FREE spots are found.*/	603	it'll return 0 if no FREE spots are found.*/
600		604	static void
601	void
602	find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP)	605	find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP)
603	{	606	{
604	int x, y;	607	int x, y;
605	int i;	608	int i;
606		609
…		…
656	*cy = ly;	659	*cy = ly;
657	return;	660	return;
658	}	661	}
659	}	662	}
660	/* give up and return the closest free spot. */	663	/* give up and return the closest free spot. */
661	i = find_first_free_spot (&archetype::find ("chest")->clone, map, x, y);	664	i = find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1);
662	if (i != -1 && i <= SIZEOFFREE1)	665
		666	if (i != -1)
663	{	667	{
664	*cx = x + freearr_x[i];	668	*cx = x + freearr_x[i];
665	*cy = y + freearr_y[i];	669	*cy = y + freearr_y[i];
666	return;	670	}
		671	else
667	}	672	{
668	/* indicate failure */	673	/* indicate failure */
		674	*cx = -1;
669	cx = cy = -1;	675	*cy = -1;
		676	}
670	}	677	}
671		678
672		679	static void
673	void
674	remove_monsters (int x, int y, maptile *map)	680	remove_monsters (int x, int y, maptile *map)
675	{	681	{
676	object *tmp;	682	for (object *tmp = GET_MAP_OB (map, x, y); tmp; )
677
678	for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
679	if (QUERY_FLAG (tmp, FLAG_ALIVE))
680	{	683	{
681	if (tmp->head)	684	object *next = tmp->above;
682	tmp = tmp->head;	685
683	tmp->remove ();	686	if (tmp->flag [FLAG_ALIVE])
684	tmp->destroy ();	687	tmp->head_ ()->destroy ();
685	tmp = GET_MAP_OB (map, x, y);	688
686	if (tmp == NULL)	689	tmp = next;
687	break;
688	};	690	}
689	}	691	}
690
691		692
692	/* surrounds the point x,y by doors, so as to enclose something, like	693	/* surrounds the point x,y by doors, so as to enclose something, like
693	a chest. It only goes as far as the 8 squares surrounding, and	694	a chest. It only goes as far as the 8 squares surrounding, and
694	it'll remove any monsters it finds.*/	695	it'll remove any monsters it finds.*/
695		696	static object **
696	object **
697	surround_by_doors (maptile map, char *layout, int x, int y, int opts)	697	surround_by_doors (maptile map, char *layout, int x, int y, int opts)
698	{	698	{
699	int i;	699	int i;
700	char *doors[2];	700	const char *doors[2];
701	object **doorlist;	701	object **doorlist;
702	int ndoors_made = 0;	702	int ndoors_made = 0;
703	doorlist = (object *) calloc (9, sizeof (object )); /* 9 doors so we can hold termination null */	703	doorlist = (object *) calloc (9, sizeof (object )); /* 9 doors so we can hold termination null */
704		704
705	/* this is a list we pick from, for horizontal and vertical doors */	705	/* this is a list we pick from, for horizontal and vertical doors */
…		…
717	/* place doors in all the 8 adjacent unblocked squares. */	717	/* place doors in all the 8 adjacent unblocked squares. */
718	for (i = 1; i < 9; i++)	718	for (i = 1; i < 9; i++)
719	{	719	{
720	int x1 = x + freearr_x[i], y1 = y + freearr_y[i];	720	int x1 = x + freearr_x[i], y1 = y + freearr_y[i];
721		721
722	if (!wall_blocked (map, x1, y1) \|\| layout[x1][y1] == '>')	722	if (!wall_blocked (map, x1, y1) && layout[x1][y1] == '>')
723	{ /* place a door */	723	{ /* place a door */
		724	remove_monsters (x1, y1, map);
		725
724	object *new_door = get_archetype ((freearr_x[i] == 0) ? doors[1] : doors[0]);	726	object *new_door = get_archetype (freearr_x[i] == 0 ? doors[1] : doors[0]);
725		727	map->insert (new_door, x1, y1);
726	new_door->x = x + freearr_x[i];
727	new_door->y = y + freearr_y[i];
728	remove_monsters (new_door->x, new_door->y, map);
729	insert_ob_in_map (new_door, map, NULL, 0);
730	doorlist[ndoors_made] = new_door;	728	doorlist[ndoors_made] = new_door;
731	ndoors_made++;	729	ndoors_made++;
732	}	730	}
733	}	731	}
		732
734	return doorlist;	733	return doorlist;
735	}	734	}
736		735
737
738	/* returns the first door in this square, or NULL if there isn't a door. */	736	/* returns the first door in this square, or NULL if there isn't a door. */
739	object *	737	static object *
740	door_in_square (maptile *map, int x, int y)	738	door_in_square (maptile *map, int x, int y)
741	{	739	{
742	object *tmp;
743
744	for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)	740	for (object *tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)
745	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)	741	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)
746	return tmp;	742	return tmp;
		743
747	return NULL;	744	return NULL;
748	}	745	}
749		746
750
751	/* the workhorse routine, which finds the doors in a room */	747	/* the workhorse routine, which finds the doors in a room */
752	void	748	static void
753	find_doors_in_room_recursive (char *layout, maptile map, int x, int y, object *doorlist, int ndoors, random_map_params *RP)	749	find_doors_in_room_recursive (char *layout, maptile map, int x, int y, object *doorlist, int ndoors, random_map_params *RP)
754	{	750	{
755	int i, j;	751	int i, j;
756	object *door;	752	object *door;
757		753
…		…
769	layout[x][y] = 1;	765	layout[x][y] = 1;
770	door = door_in_square (map, x, y);	766	door = door_in_square (map, x, y);
771	if (door)	767	if (door)
772	{	768	{
773	doorlist[*ndoors] = door;	769	doorlist[*ndoors] = door;
		770
774	if (ndoors > 1022) / eek! out of memory */	771	if (ndoors > 1022) / eek! out of memory */
775	{	772	{
776	LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n");	773	LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n");
777	return;	774	return;
778	}	775	}
…		…
781	}	778	}
782	}	779	}
783	else	780	else
784	{	781	{
785	layout[x][y] = 1;	782	layout[x][y] = 1;
		783
786	/* now search all the 8 squares around recursively for free spots,in random order */	784	/* now search all the 8 squares around recursively for free spots,in random order */
787	for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)	785	for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
788	find_doors_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], doorlist, ndoors, RP);	786	find_doors_in_room_recursive (layout, map,
		787	x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1],
		788	doorlist, ndoors, RP);
789	}	789	}
790	}	790	}
791		791
792	/* find a random non-blocked spot in this room to drop a key. */	792	/* find a random non-blocked spot in this room to drop a key. */
793	object **	793	static object **
794	find_doors_in_room (maptile map, int x, int y, random_map_params RP)	794	find_doors_in_room (maptile map, int x, int y, random_map_params RP)
795	{	795	{
796	char **layout2;
797	object **doorlist;
798	int i, j;	796	int i, j;
799	int ndoors = 0;	797	int ndoors = 0;
800		798
801	doorlist = (object **) calloc (sizeof (int), 1024);	799	object doorlist = (object )calloc (sizeof (int), 1024);
802		800
803	layout2 = (char *) calloc (sizeof (char ), RP->Xsize);	801	LayoutData layout2 (RP->Xsize, RP->Ysize);
		802	layout2.clear ();
		803
804	/* allocate and copy the layout, converting C to 0. */	804	/* allocate and copy the layout, converting C to 0. */
805	for (i = 0; i < RP->Xsize; i++)	805	for (i = 0; i < RP->Xsize; i++)
806	{
807	layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
808	for (j = 0; j < RP->Ysize; j++)	806	for (j = 0; j < RP->Ysize; j++)
809	{	807	layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
810	if (wall_blocked (map, i, j))
811	layout2[i][j] = '#';
812	}
813	}
814		808
815	/* setup num_free_spots and room_free_spots */	809	/* setup num_free_spots and room_free_spots */
816	find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP);	810	find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP);
817		811
818	/* deallocate the temp. layout */
819	for (i = 0; i < RP->Xsize; i++)
820	free (layout2[i]);
821
822	free (layout2);
823	return doorlist;	812	return doorlist;
824	}	813	}
825
826
827		814
828	/* locks and/or hides all the doors in doorlist, or does nothing if	815	/* locks and/or hides all the doors in doorlist, or does nothing if
829	opts doesn't say to lock/hide doors. */	816	opts doesn't say to lock/hide doors. */
830		817	static void
831	void
832	lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP)	818	lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP)
833	{	819	{
834	object *door;	820	object *door;
835	int i;	821	int i;
836		822
837	/* lock the doors and hide the keys. */	823	/* lock the doors and hide the keys. */
838		824
839	if (opts & DOORED)	825	if (opts & DOORED)
840	{	826	{
841	for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)	827	for (i = 0, door = doorlist[0]; doorlist[i]; i++)
842	{	828	{
843	object *new_door = get_archetype ("locked_door1");	829	object *new_door = get_archetype (shstr_locked_door1);
844	char keybuf[1024];
845		830
846	door = doorlist[i];	831	door = doorlist[i];
847	new_door->face = door->face;	832	new_door->face = door->face;
848	new_door->x = door->x;	833	new_door->x = door->x;
849	new_door->y = door->y;	834	new_door->y = door->y;
850	door->remove ();
851	door->destroy ();	835	door->destroy ();
852	doorlist[i] = new_door;	836	doorlist[i] = new_door;
853	insert_ob_in_map (new_door, map, NULL, 0);	837	insert_ob_in_map (new_door, map, NULL, 0);
854	sprintf (keybuf, "%d", (int) RANDOM ());	838	new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
855	new_door->slaying = keybuf;
856	keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP);	839	keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);
857	}	840	}
858	}	841	}
859		842
860	/* change the faces of the doors and surrounding walls to hide them. */	843	/* change the faces of the doors and surrounding walls to hide them. */
861	if (opts & HIDDEN)	844	if (opts & HIDDEN)
…		…
870	{	853	{
871	retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);	854	retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);
872	retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);	855	retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
873	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);	856	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
874	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);	857	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
		858
875	door->face = wallface->face;	859	door->face = wallface->face;
876	if (!QUERY_FLAG (wallface, FLAG_REMOVED))	860
877	wallface->remove ();
878	wallface->destroy ();	861	wallface->destroy ();
879	}	862	}
880	}	863	}
881	}	864	}
882	}	865	}

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.15 by root, Mon Jan 15 01:50:33 2007 UTC vs. Revision 1.47 by root, Fri Nov 6 13:03:34 2009 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.15 by root, Mon Jan 15 01:50:33 2007 UTC vs.
Revision 1.47 by root, Fri Nov 6 13:03:34 2009 UTC