[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.50 by root, Fri Mar 26 01:04:44 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.
…		…
210	}	333	}
211		334
212	/* put a chest into the map, near x and y, with the treasure style	335	/* put a chest into the map, near x and y, with the treasure style
213	determined (may be null, or may be a treasure list from lib/treasures,	336	determined (may be null, or may be a treasure list from lib/treasures,
214	if the global variable "treasurestyle" is set to that treasure list's name */	337	if the global variable "treasurestyle" is set to that treasure list's name */
215	object *	338	static object *
216	place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params *RP)	339	place_chest (int treasureoptions, int x, int y, maptile map, maptile style_map, int n_treasures, random_map_params *RP)
217	{	340	{
218	object the_chest = archetype::get (shstr_chest); / was "chest_2" */	341	object the_chest = archetype::get (shstr_chest); / was "chest_2" */
219		342
220	/* first, find a place to put the chest. */	343	/* first, find a place to put the chest. */
…		…
243	if (tlist != NULL)	366	if (tlist != NULL)
244	for (ti = 0; ti < n_treasures; ti++)	367	for (ti = 0; ti < n_treasures; ti++)
245	{ /* use the treasure list */	368	{ /* use the treasure list */
246	object *new_treasure = style_map->pick_random_object (rmg_rndm);	369	object *new_treasure = style_map->pick_random_object (rmg_rndm);
247		370
248	insert_ob_in_ob (arch_to_object (new_treasure->arch), the_chest);	371	insert_ob_in_ob (new_treasure->arch->instance (), the_chest);
249	}	372	}
250	else	373	else
251	{ /* use the style map */	374	{ /* use the style map */
252	the_chest->randomitems = tlist;	375	the_chest->randomitems = tlist;
253	the_chest->stats.hp = n_treasures;	376	the_chest->stats.hp = n_treasures;
…		…
286	/* set the chest lock code, and call the keyplacer routine with	409	/* set the chest lock code, and call the keyplacer routine with
287	the lockcode. It's not worth bothering to lock the chest if	410	the lockcode. It's not worth bothering to lock the chest if
288	there's only 1 treasure.... */	411	there's only 1 treasure.... */
289	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)	412	if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
290	{	413	{
291	char keybuf[1024];	414	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);	415	keyplace (map, x, y, the_chest->slaying, PASS_DOORS, 1, RP);
296	}	416	}
297		417
298	/* actually place the chest. */	418	/* actually place the chest. */
299	the_chest->x = xl;	419	the_chest->x = xl;
300	the_chest->y = yl;	420	the_chest->y = yl;
301	insert_ob_in_map (the_chest, map, NULL, 0);	421	insert_ob_in_map (the_chest, map, NULL, 0);
302	return the_chest;	422	return the_chest;
303	}	423	}
304		424
305
306	/* finds the closest monster and returns him, regardless of doors	425	/* finds the closest monster and returns him, regardless of doors or walls */
307	or walls */	426	static object *
308	object *
309	find_closest_monster (maptile map, int x, int y, random_map_params RP)	427	find_closest_monster (maptile map, int x, int y, random_map_params RP)
310	{	428	{
311	int i;	429	int i;
312		430
313	for (i = 0; i < SIZEOFFREE; i++)	431	for (i = 0; i < SIZEOFFREE; i++)
…		…
329	}	447	}
330	}	448	}
331	return NULL;	449	return NULL;
332	}	450	}
333		451
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. */	452	/* both find_monster_in_room routines need to have access to this. */
441		453
442	object *theMonsterToFind;	454	static object *theMonsterToFind;
443		455
444	/* a recursive routine which will return a monster, eventually,if there is one.	456	/* a recursive routine which will return a monster, eventually,if there is one.
445	it does a check-off on the layout, converting 0's to 1's */	457	it does a check-off on the layout, converting 0's to 1's */
446		458	static object *
447	object *
448	find_monster_in_room_recursive (char *layout, maptile map, int x, int y, random_map_params *RP)	459	find_monster_in_room_recursive (char *layout, maptile map, int x, int y, random_map_params *RP)
449	{	460	{
450	int i, j;	461	int i, j;
451		462
452	/* if we've found a monster already, leave */	463	/* if we've found a monster already, leave */
…		…
488	return theMonsterToFind;	499	return theMonsterToFind;
489	}	500	}
490		501
491	/* sets up some data structures: the _recursive form does the	502	/* sets up some data structures: the _recursive form does the
492	real work. */	503	real work. */
493	object *	504	static object *
494	find_monster_in_room (maptile map, int x, int y, random_map_params RP)	505	find_monster_in_room (maptile map, int x, int y, random_map_params RP)
495	{	506	{
496	Layout layout2 (RP);	507	Layout layout2 (RP);
497		508
498	layout2->clear ();	509	layout2->clear ();
…		…
510		521
511	return theMonsterToFind;	522	return theMonsterToFind;
512	}	523	}
513		524
514	/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */	525	/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
515	int *room_free_spots_x;	526	static int *room_free_spots_x;
516	int *room_free_spots_y;	527	static int *room_free_spots_y;
517	int number_of_free_spots_in_room;	528	static int number_of_free_spots_in_room;
518		529
519	/* the workhorse routine, which finds the free spots in a room:	530	/* 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	531	a datastructure of free points is set up, and a position chosen from
521	that datastructure. */	532	that datastructure. */
522	void	533	static void
523	find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP)	534	find_spot_in_room_recursive (char *layout, int x, int y, random_map_params RP)
524	{	535	{
525	int i, j;	536	int i, j;
526		537
527	/* bounds check x and y */	538	/* 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);	556	find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
546		557
547	}	558	}
548		559
549	/* find a random non-blocked spot in this room to drop a key. */	560	/* find a random non-blocked spot in this room to drop a key. */
550	void	561	static void
551	find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP)	562	find_spot_in_room (maptile map, int x, int y, int kx, int ky, random_map_params RP)
552	{	563	{
553	char **layout2;	564	char **layout2;
554	int i, j;	565	int i, j;
555		566
…		…
588		599
589		600
590	/* searches the map for a spot with walls around it. The more	601	/* searches the map for a spot with walls around it. The more
591	walls the better, but it'll settle for 1 wall, or even 0, but	602	walls the better, but it'll settle for 1 wall, or even 0, but
592	it'll return 0 if no FREE spots are found.*/	603	it'll return 0 if no FREE spots are found.*/
593	void	604	static void
594	find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP)	605	find_enclosed_spot (maptile map, int cx, int cy, random_map_params RP)
595	{	606	{
596	int x, y;	607	int x, y;
597	int i;	608	int i;
598		609
…		…
663	*cx = -1;	674	*cx = -1;
664	*cy = -1;	675	*cy = -1;
665	}	676	}
666	}	677	}
667		678
668	void	679	static void
669	remove_monsters (int x, int y, maptile *map)	680	remove_monsters (int x, int y, maptile *map)
670	{	681	{
671	object *tmp;
672
673	for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)	682	for (object *tmp = GET_MAP_OB (map, x, y); tmp; )
674	if (QUERY_FLAG (tmp, FLAG_ALIVE))
675	{	683	{
676	if (tmp->head)	684	object *next = tmp->above;
677	tmp = tmp->head;	685
678	tmp->remove ();	686	if (tmp->flag [FLAG_ALIVE])
679	tmp->destroy ();	687	tmp->head_ ()->destroy ();
680	tmp = GET_MAP_OB (map, x, y);	688
681	if (tmp == NULL)	689	tmp = next;
682	break;
683	};	690	}
684	}	691	}
685		692
686	/* surrounds the point x,y by doors, so as to enclose something, like	693	/* surrounds the point x,y by doors, so as to enclose something, like
687	a chest. It only goes as far as the 8 squares surrounding, and	694	a chest. It only goes as far as the 8 squares surrounding, and
688	it'll remove any monsters it finds.*/	695	it'll remove any monsters it finds.*/
689	object **	696	static object **
690	surround_by_doors (maptile map, char *layout, int x, int y, int opts)	697	surround_by_doors (maptile map, char *layout, int x, int y, int opts)
691	{	698	{
692	int i;	699	int i;
693	const char *doors[2];	700	const char *doors[2];
694	object **doorlist;	701	object **doorlist;
…		…
724	}	731	}
725		732
726	return doorlist;	733	return doorlist;
727	}	734	}
728		735
729
730	/* returns the first door in this square, or NULL if there isn't a door. */	736	/* returns the first door in this square, or NULL if there isn't a door. */
731	object *	737	static object *
732	door_in_square (maptile *map, int x, int y)	738	door_in_square (maptile *map, int x, int y)
733	{	739	{
734	object *tmp;
735
736	for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)	740	for (object *tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)
737	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)	741	if (tmp->type == DOOR \|\| tmp->type == LOCKED_DOOR)
738	return tmp;	742	return tmp;
		743
739	return NULL;	744	return NULL;
740	}	745	}
741		746
742	/* the workhorse routine, which finds the doors in a room */	747	/* the workhorse routine, which finds the doors in a room */
743	void	748	static void
744	find_doors_in_room_recursive (char *layout, maptile map, int x, int y, object *doorlist, int ndoors, random_map_params *RP)	749	find_doors_in_room_recursive (char *layout, maptile map, int x, int y, object *doorlist, int ndoors, random_map_params *RP)
745	{	750	{
746	int i, j;	751	int i, j;
747	object *door;	752	object *door;
748		753
…		…
783	doorlist, ndoors, RP);	788	doorlist, ndoors, RP);
784	}	789	}
785	}	790	}
786		791
787	/* find a random non-blocked spot in this room to drop a key. */	792	/* find a random non-blocked spot in this room to drop a key. */
788	object **	793	static object **
789	find_doors_in_room (maptile map, int x, int y, random_map_params RP)	794	find_doors_in_room (maptile map, int x, int y, random_map_params RP)
790	{	795	{
791	int i, j;	796	int i, j;
792	int ndoors = 0;	797	int ndoors = 0;
793		798
…		…
807	return doorlist;	812	return doorlist;
808	}	813	}
809		814
810	/* locks and/or hides all the doors in doorlist, or does nothing if	815	/* locks and/or hides all the doors in doorlist, or does nothing if
811	opts doesn't say to lock/hide doors. */	816	opts doesn't say to lock/hide doors. */
812	void	817	static void
813	lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP)	818	lock_and_hide_doors (object *doorlist, maptile map, int opts, random_map_params *RP)
814	{	819	{
815	object *door;	820	object *door;
816	int i;	821	int i;
817		822
818	/* lock the doors and hide the keys. */	823	/* lock the doors and hide the keys. */
819		824
820	if (opts & DOORED)	825	if (opts & DOORED)
821	{	826	{
822	for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)	827	for (i = 0, door = doorlist[0]; doorlist[i]; i++)
823	{	828	{
824	object *new_door = get_archetype ("locked_door1");	829	object *new_door = get_archetype (shstr_locked_door1);
825	char keybuf[1024];
826		830
827	door = doorlist[i];	831	door = doorlist[i];
828	new_door->face = door->face;	832	new_door->face = door->face;
829	new_door->x = door->x;	833	new_door->x = door->x;
830	new_door->y = door->y;	834	new_door->y = door->y;
831	door->remove ();
832	door->destroy ();	835	door->destroy ();
833	doorlist[i] = new_door;	836	doorlist[i] = new_door;
834	insert_ob_in_map (new_door, map, NULL, 0);	837	insert_ob_in_map (new_door, map, NULL, 0);
835	sprintf (keybuf, "%d", rmg_rndm (1000000000));	838	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);	839	keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);
838	}	840	}
839	}	841	}
840		842
841	/* change the faces of the doors and surrounding walls to hide them. */	843	/* change the faces of the doors and surrounding walls to hide them. */
842	if (opts & HIDDEN)	844	if (opts & HIDDEN)
…		…
854	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);	856	retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
855	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);	857	retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
856		858
857	door->face = wallface->face;	859	door->face = wallface->face;
858		860
859	if (!QUERY_FLAG (wallface, FLAG_REMOVED))
860	wallface->remove ();
861
862	wallface->destroy ();	861	wallface->destroy ();
863	}	862	}
864	}	863	}
865	}	864	}
866	}	865	}

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.50 by root, Fri Mar 26 01:04:44 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.50 by root, Fri Mar 26 01:04:44 2010 UTC