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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.20 by root, Thu Jan 18 00:06:56 2007 UTC vs.
Revision 1.45 by root, Mon Oct 12 14:00:58 2009 UTC

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.20 by root, Thu Jan 18 00:06:56 2007 UTC vs. Revision 1.45 by root, Mon Oct 12 14:00:58 2009 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.20 by root, Thu Jan 18 00:06:56 2007 UTC vs.
Revision 1.45 by root, Mon Oct 12 14:00:58 2009 UTC