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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.38 by root, Sun May 4 14:12:38 2008 UTC vs.
Revision 1.52 by root, Sun Apr 11 00:34:06 2010 UTC

…		…
1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* Deliantra 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 3 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, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	/* placing treasure in maps, where appropriate. */	25	/* placing treasure in maps, where appropriate. */
40	#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 */
41		42
42	#define NO_PASS_DOORS 0	43	#define NO_PASS_DOORS 0
43	#define PASS_DOORS 1	44	#define PASS_DOORS 1
44		45
		46	static object find_closest_monster (maptile map, int x, int y, random_map_params *RP);
		47	static object find_monster_in_room (maptile map, int x, int y, random_map_params *RP);
		48	static void find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP);
		49	static void find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP);
		50	static object place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params RP);
		51	static object *find_doors_in_room (maptile map, int x, int y, random_map_params *RP);
		52	static void lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP);
		53	static void find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP);
		54	static object *surround_by_doors (maptile map, char **layout, int x, int y, int opts);
		55
45	/* a macro to get a strongly centered random distribution,	56	/* a macro to get a strongly centered random distribution,
46	from 0 to x, centered at x/2 */	57	from 0 to x, centered at x/2 */
47	static int	58	static int
48	bc_random (int x)	59	bc_random (int x)
49	{	60	{
50	return (rmg_rndm (x) + rmg_rndm (x) + rmg_rndm (x)) / 3;	61	return (rmg_rndm (x) + rmg_rndm (x) + rmg_rndm (x)) / 3;
		62	}
		63
		64	static object *
		65	gen_key (const shstr &keycode)
		66	{
		67	/* get a key and set its keycode */
		68	object *key = archetype::get (shstr_key_random_map);
		69	key->slaying = keycode;
		70	return key;
		71	}
		72
		73	/* places keys in the map, preferably in something alive.
		74	keycode is the key's code,
		75	door_flag is either PASS_DOORS or NO_PASS_DOORS.
		76	NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
		77	if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
		78	it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
		79
		80	The idea is that you call keyplace on x,y where a door is, and it'll make
		81	sure a key is placed on both sides of the door.
		82	*/
		83	static int
		84	keyplace (maptile map, int x, int y, const shstr &keycode, int door_flag, int n_keys, random_map_params RP)
		85	{
		86	int i, j;
		87	int kx = 0, ky = 0;
		88	object the_keymaster; / the monster that gets the key. */
		89	object *the_key = gen_key (keycode);
		90
		91	if (door_flag == PASS_DOORS)
		92	{
		93	int tries = 0;
		94
		95	the_keymaster = 0;
		96	while (tries < 15 && !the_keymaster)
		97	{
		98	i = rmg_rndm (RP->Xsize - 2) + 1;
		99	j = rmg_rndm (RP->Ysize - 2) + 1;
		100	tries++;
		101	the_keymaster = find_closest_monster (map, i, j, RP);
		102	}
		103
		104	/* if we don't find a good keymaster, drop the key on the ground. */
		105	if (!the_keymaster)
		106	{
		107	int freeindex;
		108
		109	freeindex = -1;
		110	for (tries = 0; tries < 15 && freeindex == -1; tries++)
		111	{
		112	kx = rmg_rndm (RP->Xsize - 2) + 1;
		113	ky = rmg_rndm (RP->Ysize - 2) + 1;
		114	freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
		115	}
		116
		117	// can freeindex ever be < 0?
		118	if (freeindex >= 0)
		119	{
		120	kx += freearr_x [freeindex];
		121	ky += freearr_y [freeindex];
		122	}
		123	}
		124	}
		125	else
		126	{ /* NO_PASS_DOORS --we have to work harder. */
		127	/* don't try to keyplace if we're sitting on a blocked square and
		128	NO_PASS_DOORS is set. */
		129	if (n_keys == 1)
		130	{
		131	if (wall_blocked (map, x, y))
		132	{
		133	the_key->destroy ();
		134	return 0;
		135	}
		136
		137	the_keymaster = find_monster_in_room (map, x, y, RP);
		138	if (!the_keymaster) /* if fail, find a spot to drop the key. */
		139	find_spot_in_room (map, x, y, &kx, &ky, RP);
		140	}
		141	else
		142	{
		143	int sum = 0; /* count how many keys we actually place */
		144
		145	/* I'm lazy, so just try to place in all 4 directions. */
		146	sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
		147	sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
		148	sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
		149	sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
		150
		151	if (sum < 2) /* we might have made a disconnected map-place more keys. */
		152	{ /* diagonally this time. */
		153	keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
		154	keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
		155	keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
		156	keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
		157	}
		158
		159	the_key->destroy ();
		160	return 1;
		161	}
		162	}
		163
		164	if (the_keymaster)
		165	the_keymaster->head_ ()->insert (the_key);
		166	else
		167	{
		168	the_key->x = kx;
		169	the_key->y = ky;
		170	insert_ob_in_map (the_key, map, NULL, 0);
		171	}
		172
		173	return 1;
51	}	174	}
52		175
53	/* returns true if square x,y has P_NO_PASS set, which is true for walls	176	/* returns true if square x,y has P_NO_PASS set, which is true for walls
54	* and doors but not monsters.	177	* and doors but not monsters.
55	* This function is not map tile aware.	178	* This function is not map tile aware.
…		…
71	treasureoptions (may be 0 for random choices or positive)	194	treasureoptions (may be 0 for random choices or positive)
72	*/	195	*/
73	void	196	void
74	place_treasure (maptile map, char layout, char treasure_style, int treasureoptions, random_map_params *RP)	197	place_treasure (maptile map, char layout, char treasure_style, int treasureoptions, random_map_params *RP)
75	{	198	{
76	char styledirname[1024];
77	char stylefilepath[1024];
78	maptile *style_map = 0;
79	int num_treasures;	199	int num_treasures;
80		200
81	/* bail out if treasure isn't wanted. */	201	/* bail out if treasure isn't wanted. */
82	if (treasure_style)	202	if (treasure_style)
83	if (!strcmp (treasure_style, "none"))	203	if (!strcmp (treasure_style, "none"))
…		…
105		225
106	if (num_treasures <= 0)	226	if (num_treasures <= 0)
107	return;	227	return;
108		228
109	/* get the style map */	229	/* get the style map */
110	sprintf (styledirname, "%s", "/styles/treasurestyles");
111	sprintf (stylefilepath, "%s/%s", styledirname, treasure_style);
112	style_map = find_style (styledirname, treasure_style, -1);	230	maptile *style_map = find_style ("/styles/treasurestyles", treasure_style, -1);
113		231
114	if (!style_map)	232	if (!style_map)
115	{	233	{
116	LOG (llevError, "unable to load style map %s %s.\n", styledirname, treasure_style);	234	LOG (llevError, "unable to load style map %s %s.\n", "/styles/treasurestyles", treasure_style);
117	return;	235	return;
118	}	236	}
119		237
120	/* all the treasure at one spot in the map. */	238	/* all the treasure at one spot in the map. */
121	if (treasureoptions & CONCENTRATED)	239	if (treasureoptions & CONCENTRATED)
…		…
210	}	328	}
211		329
212	/* put a chest into the map, near x and y, with the treasure style	330	/* put a chest into the map, near x and y, with the treasure style
213	determined (may be null, or may be a treasure list from lib/treasures,	331	determined (may be null, or may be a treasure list from lib/treasures,
214	if the global variable "treasurestyle" is set to that treasure list's name */	332	if the global variable "treasurestyle" is set to that treasure list's name */
215	object *	333	static object *
216	place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params *RP)	334	place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params *RP)
217	{	335	{
218	object the_chest = archetype::get (shstr_chest); / was "chest_2" */	336	object the_chest = archetype::get (shstr_chest); / was "chest_2" */
219		337
220	/* first, find a place to put the chest. */	338	/* first, find a place to put the chest. */
…		…
243	if (tlist != NULL)	361	if (tlist != NULL)
244	for (ti = 0; ti < n_treasures; ti++)	362	for (ti = 0; ti < n_treasures; ti++)
245	{ /* use the treasure list */	363	{ /* use the treasure list */
246	object *new_treasure = style_map->pick_random_object (rmg_rndm);	364	object *new_treasure = style_map->pick_random_object (rmg_rndm);
247		365
248	insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);	366	insert_ob_in_ob (new_treasure->arch->instance (), the_chest);
249	}	367	}
250	else	368	else
251	{ /* use the style map */	369	{ /* use the style map */
252	the_chest->randomitems = tlist;	370	the_chest->randomitems = tlist;
253	the_chest->stats.hp = n_treasures;	371	the_chest->stats.hp = n_treasures;
…		…
286	/* set the chest lock code, and call the keyplacer routine with	404	/* set the chest lock code, and call the keyplacer routine with
287	the lockcode. It's not worth bothering to lock the chest if	405	the lockcode. It's not worth bothering to lock the chest if
288	there's only 1 treasure.... */	406	there's only 1 treasure.... */
289	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)	407	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
290	{	408	{
291	char keybuf[1024];	409	the_chest->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
292
293	sprintf (keybuf, "%d", rmg_rndm (1000000000));
294	the_chest->slaying = keybuf;
295	keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP);	410	keyplace (map, x, y, the_chest->slaying, PASS_DOORS, 1, RP);
296	}	411	}
297		412
298	/* actually place the chest. */	413	/* actually place the chest. */
299	the_chest->x = xl;	414	the_chest->x = xl;
300	the_chest->y = yl;	415	the_chest->y = yl;
301	insert_ob_in_map (the_chest, map, NULL, 0);	416	insert_ob_in_map (the_chest, map, NULL, 0);
302	return the_chest;	417	return the_chest;
303	}	418	}
304		419
305
306	/* finds the closest monster and returns him, regardless of doors	420	/* finds the closest monster and returns him, regardless of doors or walls */
307	or walls */	421	static object *
308	object *
309	find_closest_monster (maptile map, int x, int y, random_map_params RP)	422	find_closest_monster (maptile map, int x, int y, random_map_params RP)
310	{	423	{
311	int i;	424	int i;
312		425
313	for (i = 0; i < SIZEOFFREE; i++)	426	for (i = 0; i < SIZEOFFREE; i++)
…		…
321	/* don't bother searching this square unless the map says life exists. */	434	/* don't bother searching this square unless the map says life exists. */
322	if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)	435	if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)
323	{	436	{
324	object *the_monster = GET_MAP_OB (map, lx, ly);	437	object *the_monster = GET_MAP_OB (map, lx, ly);
325		438
326	for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_MONSTER)); the_monster = the_monster->above);	439	for (; the_monster != NULL && (!the_monster->flag [FLAG_MONSTER]); the_monster = the_monster->above);
327	if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER))	440	if (the_monster && the_monster->flag [FLAG_MONSTER])
328	return the_monster;	441	return the_monster;
329	}	442	}
330	}	443	}
331	return NULL;	444	return NULL;
332	}	445	}
333		446
334
335
336	/* places keys in the map, preferably in something alive.
337	keycode is the key's code,
338	door_flag is either PASS_DOORS or NO_PASS_DOORS.
339	NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
340	if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
341	it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
342
343	The idea is that you call keyplace on x,y where a door is, and it'll make
344	sure a key is placed on both sides of the door.
345	*/
346	int
347	keyplace (maptile map, int x, int y, char keycode, int door_flag, int n_keys, random_map_params *RP)
348	{
349	int i, j;
350	int kx = 0, ky = 0;
351	object the_keymaster; / the monster that gets the key. */
352
353	/* get a key and set its keycode */
354	object *the_key = archetype::get (shstr_key2);
355	the_key->slaying = keycode;
356
357	if (door_flag == PASS_DOORS)
358	{
359	int tries = 0;
360
361	the_keymaster = 0;
362	while (tries < 15 && !the_keymaster)
363	{
364	i = rmg_rndm (RP->Xsize - 2) + 1;
365	j = rmg_rndm (RP->Ysize - 2) + 1;
366	tries++;
367	the_keymaster = find_closest_monster (map, i, j, RP);
368	}
369
370	/* if we don't find a good keymaster, drop the key on the ground. */
371	if (!the_keymaster)
372	{
373	int freeindex;
374
375	freeindex = -1;
376	for (tries = 0; tries < 15 && freeindex == -1; tries++)
377	{
378	kx = rmg_rndm (RP->Xsize - 2) + 1;
379	ky = rmg_rndm (RP->Ysize - 2) + 1;
380	freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
381	}
382
383	// can freeindex ever be < 0?
384	if (freeindex >= 0)
385	{
386	kx += freearr_x [freeindex];
387	ky += freearr_y [freeindex];
388	}
389	}
390	}
391	else
392	{ /* NO_PASS_DOORS --we have to work harder. */
393	/* don't try to keyplace if we're sitting on a blocked square and
394	NO_PASS_DOORS is set. */
395	if (n_keys == 1)
396	{
397	if (wall_blocked (map, x, y))
398	return 0;
399
400	the_keymaster = find_monster_in_room (map, x, y, RP);
401	if (!the_keymaster) /* if fail, find a spot to drop the key. */
402	find_spot_in_room (map, x, y, &kx, &ky, RP);
403	}
404	else
405	{
406	int sum = 0; /* count how many keys we actually place */
407
408	/* I'm lazy, so just try to place in all 4 directions. */
409	sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
410	sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
411	sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
412	sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
413
414	if (sum < 2) /* we might have made a disconnected map-place more keys. */
415	{ /* diagonally this time. */
416	keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
417	keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
418	keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
419	keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
420	}
421
422	return 1;
423	}
424	}
425
426	if (!the_keymaster)
427	{
428	the_key->x = kx;
429	the_key->y = ky;
430	insert_ob_in_map (the_key, map, NULL, 0);
431	return 1;
432	}
433
434	insert_ob_in_ob (the_key, the_keymaster->head_ ());
435	return 1;
436	}
437
438
439
440	/* both find_monster_in_room routines need to have access to this. */	447	/* both find_monster_in_room routines need to have access to this. */
441		448
442	object *theMonsterToFind;	449	static object *theMonsterToFind;
443		450
444	/* a recursive routine which will return a monster, eventually,if there is one.	451	/* a recursive routine which will return a monster, eventually,if there is one.
445	it does a check-off on the layout, converting 0's to 1's */	452	it does a check-off on the layout, converting 0's to 1's */
446		453	static object *
447	object *
448	find_monster_in_room_recursive (char *layout, maptile map, int x, int y, random_map_params *RP)	454	find_monster_in_room_recursive (char *layout, maptile map, int x, int y, random_map_params *RP)
449	{	455	{
450	int i, j;	456	int i, j;
451		457
452	/* if we've found a monster already, leave */	458	/* if we've found a monster already, leave */
…		…
467	if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)	473	if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)
468	{	474	{
469	object *the_monster = GET_MAP_OB (map, x, y);	475	object *the_monster = GET_MAP_OB (map, x, y);
470		476
471	/* check off this point */	477	/* check off this point */
472	for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_ALIVE)); the_monster = the_monster->above);	478	for (; the_monster != NULL && (!the_monster->flag [FLAG_ALIVE]); the_monster = the_monster->above);
473	if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE))	479	if (the_monster && the_monster->flag [FLAG_ALIVE])
474	{	480	{
475	theMonsterToFind = the_monster;	481	theMonsterToFind = the_monster;
476	return theMonsterToFind;	482	return theMonsterToFind;
477	}	483	}
478	}	484	}
…		…
488	return theMonsterToFind;	494	return theMonsterToFind;
489	}	495	}
490		496
491	/* sets up some data structures: the _recursive form does the	497	/* sets up some data structures: the _recursive form does the
492	real work. */	498	real work. */
493	object *	499	static object *
494	find_monster_in_room (maptile map, int x, int y, random_map_params RP)	500	find_monster_in_room (maptile map, int x, int y, random_map_params RP)
495	{	501	{
496	Layout layout2 (RP);	502	Layout layout2 (RP);
497		503
498	layout2->clear ();	504	layout2->clear ();
…		…
510		516
511	return theMonsterToFind;	517	return theMonsterToFind;
512	}	518	}
513		519
514	/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */	520	/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
515	int *room_free_spots_x;	521	static int *room_free_spots_x;
516	int *room_free_spots_y;	522	static int *room_free_spots_y;
517	int number_of_free_spots_in_room;	523	static int number_of_free_spots_in_room;
518		524
519	/* the workhorse routine, which finds the free spots in a room:	525	/* the workhorse routine, which finds the free spots in a room:
520	a datastructure of free points is set up, and a position chosen from	526	a datastructure of free points is set up, and a position chosen from
521	that datastructure. */	527	that datastructure. */
522	void	528	static void
523	find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP)	529	find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP)
524	{	530	{
525	int i, j;	531	int i, j;
526		532
527	/* bounds check x and y */	533	/* bounds check x and y */
…		…
545	find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);	551	find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
546		552
547	}	553	}
548		554
549	/* find a random non-blocked spot in this room to drop a key. */	555	/* find a random non-blocked spot in this room to drop a key. */
550	void	556	static void
551	find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP)	557	find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP)
552	{	558	{
553	char **layout2;	559	char **layout2;
554	int i, j;	560	int i, j;
555		561
…		…
588		594
589		595
590	/* searches the map for a spot with walls around it. The more	596	/* searches the map for a spot with walls around it. The more
591	walls the better, but it'll settle for 1 wall, or even 0, but	597	walls the better, but it'll settle for 1 wall, or even 0, but
592	it'll return 0 if no FREE spots are found.*/	598	it'll return 0 if no FREE spots are found.*/
593	void	599	static void
594	find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP)	600	find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP)
595	{	601	{
596	int x, y;	602	int x, y;
597	int i;	603	int i;
598		604
…		…
663	*cx = -1;	669	*cx = -1;
664	*cy = -1;	670	*cy = -1;
665	}	671	}
666	}	672	}
667		673
668	void	674	static void
669	remove_monsters (int x, int y, maptile *map)	675	remove_monsters (int x, int y, maptile *map)
670	{	676	{
671	object *tmp;
672
673	for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)	677	for (object *tmp = GET_MAP_OB (map, x, y); tmp; )
674	if (QUERY_FLAG (tmp, FLAG_ALIVE))
675	{	678	{
676	if (tmp->head)	679	object *next = tmp->above;
677	tmp = tmp->head;	680
678	tmp->remove ();	681	if (tmp->flag [FLAG_ALIVE])
679	tmp->destroy ();	682	tmp->head_ ()->destroy ();
680	tmp = GET_MAP_OB (map, x, y);	683
681	if (tmp == NULL)	684	tmp = next;
682	break;
683	};	685	}
684	}	686	}
685		687
686	/* surrounds the point x,y by doors, so as to enclose something, like	688	/* surrounds the point x,y by doors, so as to enclose something, like
687	a chest. It only goes as far as the 8 squares surrounding, and	689	a chest. It only goes as far as the 8 squares surrounding, and
688	it'll remove any monsters it finds.*/	690	it'll remove any monsters it finds.*/
689	object **	691	static object **
690	surround_by_doors (maptile map, char *layout, int x, int y, int opts)	692	surround_by_doors (maptile map, char *layout, int x, int y, int opts)
691	{	693	{
692	int i;	694	int i;
693	const char *doors[2];	695	const char *doors[2];
694	object **doorlist;	696	object **doorlist;
…		…
724	}	726	}
725		727
726	return doorlist;	728	return doorlist;
727	}	729	}
728		730
729
730	/* returns the first door in this square, or NULL if there isn't a door. */	731	/* returns the first door in this square, or NULL if there isn't a door. */
731	object *	732	static object *
732	door_in_square (maptile *map, int x, int y)	733	door_in_square (maptile *map, int x, int y)
733	{	734	{
734	object *tmp;
735
736	for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)	735	for (object *tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)
737	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)	736	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)
738	return tmp;	737	return tmp;
		738
739	return NULL;	739	return NULL;
740	}	740	}
741		741
742	/* the workhorse routine, which finds the doors in a room */	742	/* the workhorse routine, which finds the doors in a room */
743	void	743	static void
744	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)
745	{	745	{
746	int i, j;	746	int i, j;
747	object *door;	747	object *door;
748		748
…		…
783	doorlist, ndoors, RP);	783	doorlist, ndoors, RP);
784	}	784	}
785	}	785	}
786		786
787	/* 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. */
788	object **	788	static object **
789	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)
790	{	790	{
791	int i, j;	791	int i, j;
792	int ndoors = 0;	792	int ndoors = 0;
793		793
…		…
807	return doorlist;	807	return doorlist;
808	}	808	}
809		809
810	/* 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
811	opts doesn't say to lock/hide doors. */	811	opts doesn't say to lock/hide doors. */
812	void	812	static void
813	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)
814	{	814	{
815	object *door;	815	object *door;
816	int i;	816	int i;
817		817
818	/* lock the doors and hide the keys. */	818	/* lock the doors and hide the keys. */
819		819
820	if (opts & DOORED)	820	if (opts & DOORED)
821	{	821	{
822	for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)	822	for (i = 0, door = doorlist[0]; doorlist[i]; i++)
823	{	823	{
824	object *new_door = get_archetype ("locked_door1");	824	object *new_door = get_archetype (shstr_locked_door1);
825	char keybuf[1024];
826		825
827	door = doorlist[i];	826	door = doorlist[i];
828	new_door->face = door->face;	827	new_door->face = door->face;
829	new_door->x = door->x;	828	new_door->x = door->x;
830	new_door->y = door->y;	829	new_door->y = door->y;
831	door->remove ();
832	door->destroy ();	830	door->destroy ();
833	doorlist[i] = new_door;	831	doorlist[i] = new_door;
834	insert_ob_in_map (new_door, map, NULL, 0);	832	insert_ob_in_map (new_door, map, NULL, 0);
835	sprintf (keybuf, "%d", rmg_rndm (1000000000));	833	new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
836	new_door->slaying = keybuf;
837	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);
838	}	835	}
839	}	836	}
840		837
841	/* 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. */
842	if (opts & HIDDEN)	839	if (opts & HIDDEN)
…		…
854	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);	851	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
855	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);	852	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
856		853
857	door->face = wallface->face;	854	door->face = wallface->face;
858		855
859	if (!QUERY_FLAG (wallface, FLAG_REMOVED))
860	wallface->remove ();
861
862	wallface->destroy ();	856	wallface->destroy ();
863	}	857	}
864	}	858	}
865	}	859	}
866	}	860	}

Diff Legend

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

Comparing deliantra/server/random_maps/treasure.C (file contents): Revision 1.38 by root, Sun May 4 14:12:38 2008 UTC vs. Revision 1.52 by root, Sun Apr 11 00:34:06 2010 UTC

Diff Legend

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.38 by root, Sun May 4 14:12:38 2008 UTC vs.
Revision 1.52 by root, Sun Apr 11 00:34:06 2010 UTC