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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.21 by root, Thu Jan 18 19:42:10 2007 UTC vs.
Revision 1.38 by root, Sun May 4 14:12:38 2008 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
9	* 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
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your 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 GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	20	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	22	*/
24		23
25	/* placing treasure in maps, where appropriate. */	24	/* placing treasure in maps, where appropriate. */
26		25
27	#include <global.h>	26	#include <global.h>
41	#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 */
42		41
43	#define NO_PASS_DOORS 0	42	#define NO_PASS_DOORS 0
44	#define PASS_DOORS 1	43	#define PASS_DOORS 1
45		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	}
46		52
47	/* returns true if square x,y has P_NO_PASS set, which is true for walls	53	/* returns true if square x,y has P_NO_PASS set, which is true for walls
48	* and doors but not monsters.	54	* and doors but not monsters.
49	* This function is not map tile aware.	55	* This function is not map tile aware.
50	*/	56	*/
…		…
52	wall_blocked (maptile *m, int x, int y)	58	wall_blocked (maptile *m, int x, int y)
53	{	59	{
54	if (OUT_OF_REAL_MAP (m, x, y))	60	if (OUT_OF_REAL_MAP (m, x, y))
55	return 1;	61	return 1;
56		62
		63	m->at (x, y).update ();
57	int r = GET_MAP_MOVE_BLOCK (m, x, y) & ~MOVE_BLOCK_DEFAULT;	64	return GET_MAP_MOVE_BLOCK (m, x, y) & MOVE_WALK;
58	return r;
59	}	65	}
60		66
61	/* place treasures in the map, given the	67	/* place treasures in the map, given the
62	map, (required)	68	map, (required)
63	layout, (required)	69	layout, (required)
…		…
74		80
75	/* bail out if treasure isn't wanted. */	81	/* bail out if treasure isn't wanted. */
76	if (treasure_style)	82	if (treasure_style)
77	if (!strcmp (treasure_style, "none"))	83	if (!strcmp (treasure_style, "none"))
78	return;	84	return;
		85
79	if (treasureoptions <= 0)	86	if (treasureoptions <= 0)
80	treasureoptions = RANDOM () % (2 * LAST_OPTION);	87	treasureoptions = rmg_rndm (2 * LAST_OPTION);
81		88
82	/* filter out the mutually exclusive options */	89	/* filter out the mutually exclusive options */
83	if ((treasureoptions & RICH) && (treasureoptions & SPARSE))	90	if ((treasureoptions & RICH) && (treasureoptions & SPARSE))
84	{	91	{
85	if (rndm (2))	92	if (rmg_rndm (2))
86	treasureoptions -= 1;	93	treasureoptions -= 1;
87	else	94	else
88	treasureoptions -= 2;	95	treasureoptions -= 2;
89	}	96	}
90		97
91	/* pick the number of treasures */	98	/* pick the number of treasures */
92	if (treasureoptions & SPARSE)	99	if (treasureoptions & SPARSE)
93	num_treasures = BC_RANDOM (RP->total_map_hp / 600 + RP->difficulty / 2 + 1);	100	num_treasures = bc_random (RP->total_map_hp / 600 + RP->difficulty / 2 + 1);
94	else if (treasureoptions & RICH)	101	else if (treasureoptions & RICH)
95	num_treasures = BC_RANDOM (RP->total_map_hp / 150 + 2 * RP->difficulty + 1);	102	num_treasures = bc_random (RP->total_map_hp / 150 + 2 * RP->difficulty + 1);
96	else	103	else
97	num_treasures = BC_RANDOM (RP->total_map_hp / 300 + RP->difficulty + 1);	104	num_treasures = bc_random (RP->total_map_hp / 300 + RP->difficulty + 1);
98		105
99	if (num_treasures <= 0)	106	if (num_treasures <= 0)
100	return;	107	return;
101		108
102	/* get the style map */	109	/* get the style map */
103	sprintf (styledirname, "%s", "/styles/treasurestyles");	110	sprintf (styledirname, "%s", "/styles/treasurestyles");
104	sprintf (stylefilepath, "%s/%s", styledirname, treasure_style);	111	sprintf (stylefilepath, "%s/%s", styledirname, treasure_style);
105	style_map = find_style (styledirname, treasure_style, -1);	112	style_map = find_style (styledirname, treasure_style, -1);
106		113
		114	if (!style_map)
		115	{
		116	LOG (llevError, "unable to load style map %s %s.\n", styledirname, treasure_style);
		117	return;
		118	}
		119
107	/* all the treasure at one spot in the map. */	120	/* all the treasure at one spot in the map. */
108	if (treasureoptions & CONCENTRATED)	121	if (treasureoptions & CONCENTRATED)
109	{	122	{
110
111	/* map_layout_style global, and is previously set */	123	/* map_layout_style global, and is previously set */
112	switch (RP->map_layout_style)	124	switch (RP->map_layout_style)
113	{	125	{
114	case LAYOUT_ONION:	126	case LAYOUT_ONION:
115	case LAYOUT_SPIRAL:	127	case LAYOUT_SPIRAL:
…		…
123	for (j = 0; j < RP->Ysize; j++)	135	for (j = 0; j < RP->Ysize; j++)
124	{	136	{
125	if (layout[i][j] == 'C' \|\| layout[i][j] == '>')	137	if (layout[i][j] == 'C' \|\| layout[i][j] == '>')
126	{	138	{
127	int tdiv = RP->symmetry_used;	139	int tdiv = RP->symmetry_used;
128	object **doorlist;
129	object *chest;	140	object *chest;
130		141
131	if (tdiv == 3)	142	if (tdiv == 3)
132	tdiv = 2; /* this symmetry uses a divisor of 2 */	143	tdiv = 2; /* this symmetry uses a divisor of 2 */
		144
133	/* don't put a chest on an exit. */	145	/* don't put a chest on an exit. */
134	chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP);	146	chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP);
		147
135	if (!chest)	148	if (!chest)
136	continue; /* if no chest was placed NEXT */	149	continue; /* if no chest was placed NEXT */
		150
137	if (treasureoptions & (DOORED \| HIDDEN))	151	if (treasureoptions & (DOORED \| HIDDEN))
138	{	152	{
139	doorlist = find_doors_in_room (map, i, j, RP);	153	object **doorlist = find_doors_in_room (map, i, j, RP);
140	lock_and_hide_doors (doorlist, map, treasureoptions, RP);	154	lock_and_hide_doors (doorlist, map, treasureoptions, RP);
141	free (doorlist);	155	free (doorlist);
142	}	156	}
143	}	157	}
144	}	158	}
145	}	159	}
146	break;	160	break;
147	}	161	}
		162
148	default:	163	default:
149	{	164	{
150	int i, j, tries;	165	int i, j, tries;
151	object *chest;	166	object *chest;
152	object **doorlist;	167	object **doorlist;
153		168
154	i = j = -1;	169	i = j = -1;
155	tries = 0;	170	tries = 0;
156	while (i == -1 && tries < 100)	171	while (i == -1 && tries < 100)
157	{	172	{
158	i = RANDOM () % (RP->Xsize - 2) + 1;	173	i = rmg_rndm (RP->Xsize - 2) + 1;
159	j = RANDOM () % (RP->Ysize - 2) + 1;	174	j = rmg_rndm (RP->Ysize - 2) + 1;
160	find_enclosed_spot (map, &i, &j, RP);	175	find_enclosed_spot (map, &i, &j, RP);
		176
161	if (wall_blocked (map, i, j))	177	if (wall_blocked (map, i, j))
162	i = -1;	178	i = -1;
		179
163	tries++;	180	tries++;
164	}	181	}
		182
165	chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP);	183	chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP);
		184
166	if (!chest)	185	if (!chest)
167	return;	186	return;
		187
168	i = chest->x;	188	i = chest->x;
169	j = chest->y;	189	j = chest->y;
170	if (treasureoptions & (DOORED \| HIDDEN))	190	if (treasureoptions & (DOORED \| HIDDEN))
171	{	191	{
172	doorlist = surround_by_doors (map, layout, i, j, treasureoptions);	192	doorlist = surround_by_doors (map, layout, i, j, treasureoptions);
…		…
180	{ /* DIFFUSE treasure layout */	200	{ /* DIFFUSE treasure layout */
181	int ti, i, j;	201	int ti, i, j;
182		202
183	for (ti = 0; ti < num_treasures; ti++)	203	for (ti = 0; ti < num_treasures; ti++)
184	{	204	{
185	i = RANDOM () % (RP->Xsize - 2) + 1;	205	i = rmg_rndm (RP->Xsize - 2) + 1;
186	j = RANDOM () % (RP->Ysize - 2) + 1;	206	j = rmg_rndm (RP->Ysize - 2) + 1;
187	place_chest (treasureoptions, i, j, map, style_map, 1, RP);	207	place_chest (treasureoptions, i, j, map, style_map, 1, RP);
188	}	208	}
189	}	209	}
190	}	210	}
191		211
192	/* put a chest into the map, near x and y, with the treasure style	212	/* 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,	213	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 */	214	if the global variable "treasurestyle" is set to that treasure list's name */
195
196	object *	215	object *
197	place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params *RP)	216	place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params *RP)
198	{	217	{
199	object *the_chest;
200	int i, xl, yl;
201
202	the_chest = get_archetype ("chest"); /* was "chest_2" */	218	object the_chest = archetype::get (shstr_chest); / was "chest_2" */
203		219
204	/* first, find a place to put the chest. */	220	/* first, find a place to put the chest. */
205	i = find_first_free_spot (the_chest, map, x, y);	221	int i = find_first_free_spot (the_chest, map, x, y); // this call uses the main rng
206	if (i == -1)	222	if (i == -1)
207	{	223	{
208	the_chest->destroy ();	224	the_chest->destroy ();
209	return NULL;	225	return NULL;
210	}	226	}
211		227
212	xl = x + freearr_x[i];	228	int xl = x + freearr_x[i];
213	yl = y + freearr_y[i];	229	int yl = y + freearr_y[i];
214		230
215	/* if the placement is blocked, return a fail. */	231	/* if the placement is blocked, return a fail. */
216	if (wall_blocked (map, xl, yl))	232	if (wall_blocked (map, xl, yl))
217	return 0;	233	return 0;
218		234
…		…
225	treasurelist *tlist = find_treasurelist (RP->treasurestyle);	241	treasurelist *tlist = find_treasurelist (RP->treasurestyle);
226		242
227	if (tlist != NULL)	243	if (tlist != NULL)
228	for (ti = 0; ti < n_treasures; ti++)	244	for (ti = 0; ti < n_treasures; ti++)
229	{ /* use the treasure list */	245	{ /* use the treasure list */
230	object *new_treasure = pick_random_object (style_map);	246	object *new_treasure = style_map->pick_random_object (rmg_rndm);
231		247
232	insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);	248	insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);
233	}	249	}
234	else	250	else
235	{ /* use the style map */	251	{ /* use the style map */
236	the_chest->randomitems = tlist;	252	the_chest->randomitems = tlist;
237	the_chest->stats.hp = n_treasures;	253	the_chest->stats.hp = n_treasures;
238	}	254	}
239	#endif	255	#endif
240	{ /* neither style_map no treasure list given */	256	{ /* neither style_map no treasure list given */
241	treasurelist *tlist = find_treasurelist ("chest");	257	treasurelist *tlist = treasurelist::find ("chest");
242		258
243	the_chest->randomitems = tlist;	259	the_chest->randomitems = tlist;
244	the_chest->stats.hp = n_treasures;	260	the_chest->stats.hp = n_treasures;
245	}	261	}
246		262
247	/* stick a trap in the chest if required */	263	/* stick a trap in the chest if required */
248	if (treasureoptions & TRAPPED)	264	if (treasureoptions & TRAPPED)
249	{	265	{
250	maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);	266	maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);
251	object *the_trap;
252		267
253	if (trap_map)	268	if (trap_map)
254	{	269	{
255	the_trap = pick_random_object (trap_map);	270	object *the_trap = trap_map->pick_random_object (rmg_rndm);
		271
256	the_trap->stats.Cha = 10 + RP->difficulty;	272	the_trap->stats.Cha = 10 + RP->difficulty;
257	the_trap->level = BC_RANDOM ((3 * RP->difficulty) / 2);	273	the_trap->level = bc_random ((3 * RP->difficulty) / 2);
		274
258	if (the_trap)	275	if (the_trap)
259	{	276	{
260	object *new_trap;	277	object *new_trap = the_trap->arch->instance ();//TODO: why not clone?
261		278
262	new_trap = arch_to_object (the_trap->arch);
263	new_trap->copy_to (the_trap);
264	new_trap->x = x;	279	new_trap->x = x;
265	new_trap->y = y;	280	new_trap->y = y;
266	insert_ob_in_ob (new_trap, the_chest);	281	insert_ob_in_ob (new_trap, the_chest);
267	}	282	}
268	}	283	}
269	}	284	}
270		285
271	/* set the chest lock code, and call the keyplacer routine with	286	/* set the chest lock code, and call the keyplacer routine with
272	the lockcode. It's not worth bothering to lock the chest if	287	the lockcode. It's not worth bothering to lock the chest if
273	there's only 1 treasure.... */	288	there's only 1 treasure.... */
274
275	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)	289	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
276	{	290	{
277	char keybuf[1024];	291	char keybuf[1024];
278		292
279	sprintf (keybuf, "%d", (int) RANDOM ());	293	sprintf (keybuf, "%d", rmg_rndm (1000000000));
280	the_chest->slaying = keybuf;	294	the_chest->slaying = keybuf;
281	keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP);	295	keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP);
282	}	296	}
283		297
284	/* actually place the chest. */	298	/* actually place the chest. */
…		…
333	keyplace (maptile map, int x, int y, char keycode, int door_flag, int n_keys, random_map_params *RP)	347	keyplace (maptile map, int x, int y, char keycode, int door_flag, int n_keys, random_map_params *RP)
334	{	348	{
335	int i, j;	349	int i, j;
336	int kx = 0, ky = 0;	350	int kx = 0, ky = 0;
337	object the_keymaster; / the monster that gets the key. */	351	object the_keymaster; / the monster that gets the key. */
338	object *the_key;
339		352
340	/* get a key and set its keycode */	353	/* get a key and set its keycode */
341	the_key = get_archetype ("key2");	354	object *the_key = archetype::get (shstr_key2);
342	the_key->slaying = keycode;	355	the_key->slaying = keycode;
343		356
344	if (door_flag == PASS_DOORS)	357	if (door_flag == PASS_DOORS)
345	{	358	{
346	int tries = 0;	359	int tries = 0;
347		360
348	the_keymaster = 0;	361	the_keymaster = 0;
349	while (tries < 15 && !the_keymaster)	362	while (tries < 15 && !the_keymaster)
350	{	363	{
351	i = (RANDOM () % (RP->Xsize - 2)) + 1;	364	i = rmg_rndm (RP->Xsize - 2) + 1;
352	j = (RANDOM () % (RP->Ysize - 2)) + 1;	365	j = rmg_rndm (RP->Ysize - 2) + 1;
353	tries++;	366	tries++;
354	the_keymaster = find_closest_monster (map, i, j, RP);	367	the_keymaster = find_closest_monster (map, i, j, RP);
355	}	368	}
356		369
357	/* if we don't find a good keymaster, drop the key on the ground. */	370	/* if we don't find a good keymaster, drop the key on the ground. */
…		…
360	int freeindex;	373	int freeindex;
361		374
362	freeindex = -1;	375	freeindex = -1;
363	for (tries = 0; tries < 15 && freeindex == -1; tries++)	376	for (tries = 0; tries < 15 && freeindex == -1; tries++)
364	{	377	{
365	kx = (RANDOM () % (RP->Xsize - 2)) + 1;	378	kx = rmg_rndm (RP->Xsize - 2) + 1;
366	ky = (RANDOM () % (RP->Ysize - 2)) + 1;	379	ky = rmg_rndm (RP->Ysize - 2) + 1;
367	freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);	380	freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
368	}	381	}
369		382
370	// can freeindex ever be < 0?	383	// can freeindex ever be < 0?
371	if (freeindex >= 0)	384	if (freeindex >= 0)
…		…
416	the_key->y = ky;	429	the_key->y = ky;
417	insert_ob_in_map (the_key, map, NULL, 0);	430	insert_ob_in_map (the_key, map, NULL, 0);
418	return 1;	431	return 1;
419	}	432	}
420		433
421	insert_ob_in_ob (the_key, the_keymaster);	434	insert_ob_in_ob (the_key, the_keymaster->head_ ());
422	return 1;	435	return 1;
423	}	436	}
424		437
425		438
426		439
…		…
463	return theMonsterToFind;	476	return theMonsterToFind;
464	}	477	}
465	}	478	}
466		479
467	/* now search all the 8 squares around recursively for a monster,in random order */	480	/* now search all the 8 squares around recursively for a monster,in random order */
468	for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)	481	for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
469	{	482	{
470	theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);	483	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)	484	if (theMonsterToFind != NULL)
472	return theMonsterToFind;	485	return theMonsterToFind;
473	}	486	}
		487
474	return theMonsterToFind;	488	return theMonsterToFind;
475	}	489	}
476
477		490
478	/* sets up some data structures: the _recursive form does the	491	/* sets up some data structures: the _recursive form does the
479	real work. */	492	real work. */
480
481	object *	493	object *
482	find_monster_in_room (maptile map, int x, int y, random_map_params RP)	494	find_monster_in_room (maptile map, int x, int y, random_map_params RP)
483	{	495	{
484	char **layout2;	496	Layout layout2 (RP);
485	int i, j;	497
		498	layout2->clear ();
		499
		500	/* allocate and copy the layout, converting C to 0. */
		501	for (int i = 0; i < layout2->w; i++)
		502	for (int j = 0; j < layout2->h; j++)
		503	if (wall_blocked (map, i, j))
		504	layout2[i][j] = '#';
486		505
487	theMonsterToFind = 0;	506	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);	507	theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP);
500		508
501	/* deallocate the temp. layout */	509	layout2.free ();
502	for (i = 0; i < RP->Xsize; i++)
503	{
504	free (layout2[i]);
505	}
506	free (layout2);
507		510
508	return theMonsterToFind;	511	return theMonsterToFind;
509	}	512	}
510		513
511	/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */	514	/* 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;	539	room_free_spots_x[number_of_free_spots_in_room] = x;
537	room_free_spots_y[number_of_free_spots_in_room] = y;	540	room_free_spots_y[number_of_free_spots_in_room] = y;
538	number_of_free_spots_in_room++;	541	number_of_free_spots_in_room++;
539		542
540	/* now search all the 8 squares around recursively for free spots,in random order */	543	/* now search all the 8 squares around recursively for free spots,in random order */
541	for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)	544	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);	545	find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
543		546
544	}	547	}
545		548
546	/* find a random non-blocked spot in this room to drop a key. */	549	/* find a random non-blocked spot in this room to drop a key. */
…		…
567	/* setup num_free_spots and room_free_spots */	570	/* setup num_free_spots and room_free_spots */
568	find_spot_in_room_recursive (layout2, x, y, RP);	571	find_spot_in_room_recursive (layout2, x, y, RP);
569		572
570	if (number_of_free_spots_in_room > 0)	573	if (number_of_free_spots_in_room > 0)
571	{	574	{
572	i = RANDOM () % number_of_free_spots_in_room;	575	i = rmg_rndm (number_of_free_spots_in_room);
573	*kx = room_free_spots_x[i];	576	*kx = room_free_spots_x[i];
574	*ky = room_free_spots_y[i];	577	*ky = room_free_spots_y[i];
575	}	578	}
576		579
577	/* deallocate the temp. layout */	580	/* deallocate the temp. layout */
…		…
645	*cy = ly;	648	*cy = ly;
646	return;	649	return;
647	}	650	}
648	}	651	}
649	/* give up and return the closest free spot. */	652	/* give up and return the closest free spot. */
650	i = find_free_spot (&archetype::find ("chest")->clone, map, x, y, 1, SIZEOFFREE1 + 1);	653	i = find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1);
651		654
652	if (i != -1)	655	if (i != -1)
653	{	656	{
654	*cx = x + freearr_x[i];	657	*cx = x + freearr_x[i];
655	*cy = y + freearr_y[i];	658	*cy = y + freearr_y[i];
…		…
660	*cx = -1;	663	*cx = -1;
661	*cy = -1;	664	*cy = -1;
662	}	665	}
663	}	666	}
664		667
665
666	void	668	void
667	remove_monsters (int x, int y, maptile *map)	669	remove_monsters (int x, int y, maptile *map)
668	{	670	{
669	object *tmp;	671	object *tmp;
670		672
671	for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)	673	for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)
672	if (QUERY_FLAG (tmp, FLAG_ALIVE))	674	if (QUERY_FLAG (tmp, FLAG_ALIVE))
673	{	675	{
674	if (tmp->head)	676	if (tmp->head)
675	tmp = tmp->head;	677	tmp = tmp->head;
676	tmp->remove ();	678	tmp->remove ();
…		…
679	if (tmp == NULL)	681	if (tmp == NULL)
680	break;	682	break;
681	};	683	};
682	}	684	}
683		685
684
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 = rndm (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;
…		…
842	new_door->y = door->y;	830	new_door->y = door->y;
843	door->remove ();	831	door->remove ();
844	door->destroy ();	832	door->destroy ();
845	doorlist[i] = new_door;	833	doorlist[i] = new_door;
846	insert_ob_in_map (new_door, map, NULL, 0);	834	insert_ob_in_map (new_door, map, NULL, 0);
847	sprintf (keybuf, "%d", (int) RANDOM ());	835	sprintf (keybuf, "%d", rmg_rndm (1000000000));
848	new_door->slaying = keybuf;	836	new_door->slaying = keybuf;
849	keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP);	837	keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP);
850	}	838	}
851	}	839	}
852		840
…		…
863	{	851	{
864	retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);	852	retrofit_joined_wall (map, door->x - 1, door->y, 0, RP);
865	retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);	853	retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
866	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);	854	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
867	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);	855	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
		856
868	door->face = wallface->face;	857	door->face = wallface->face;
		858
869	if (!QUERY_FLAG (wallface, FLAG_REMOVED))	859	if (!QUERY_FLAG (wallface, FLAG_REMOVED))
870	wallface->remove ();	860	wallface->remove ();
		861
871	wallface->destroy ();	862	wallface->destroy ();
872	}	863	}
873	}	864	}
874	}	865	}
875	}	866	}

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.21 by root, Thu Jan 18 19:42:10 2007 UTC vs. Revision 1.38 by root, Sun May 4 14:12:38 2008 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.21 by root, Thu Jan 18 19:42:10 2007 UTC vs.
Revision 1.38 by root, Sun May 4 14:12:38 2008 UTC