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

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

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.17 by root, Mon Jan 15 15:54:19 2007 UTC vs. Revision 1.43 by root, Mon Sep 29 09:04:51 2008 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.17 by root, Mon Jan 15 15:54:19 2007 UTC vs.
Revision 1.43 by root, Mon Sep 29 09:04:51 2008 UTC