ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/common/readable.C

Comparing deliantra/server/common/readable.C (file contents):
Revision 1.30 by root, Sun Jul 1 05:00:17 2007 UTC vs.
Revision 1.66 by root, Mon Nov 12 03:14:32 2012 UTC

1	/*	1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* Crossfire TRT 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 <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	/* This file contains code relevant to the BOOKS hack -- designed	25	/* This file contains code relevant to the BOOKS hack -- designed
25	* to allow randomly occuring messages in non-magical texts.	26	* to allow randomly occuring messages in non-magical texts.
26	*/	27	*/
…		…
29		30
30	#include <global.h>	31	#include <global.h>
31	#include <book.h>	32	#include <book.h>
32	#include <living.h>	33	#include <living.h>
33	#include <spells.h>	34	#include <spells.h>
34
35		35
36	/* Define this if you want to archive book titles by contents.	36	/* Define this if you want to archive book titles by contents.
37	* This option should enforce UNIQUE combinations of titles,authors and	37	* This option should enforce UNIQUE combinations of titles,authors and
38	* msg contents during and *between* game sessions.	38	* msg contents during and *between* game sessions.
39	* Note: a slight degeneracy exists since books are archived based on an integer	39	* Note: a slight degeneracy exists since books are archived based on an integer
…		…
108	/* these are needed for creation of a linked list of	108	/* these are needed for creation of a linked list of
109	* pointers to all (hostile) monster objects */	109	* pointers to all (hostile) monster objects */
110		110
111	static int nrofmon = 0, need_to_write_bookarchive = 0;	111	static int nrofmon = 0, need_to_write_bookarchive = 0;
112		112
113
114	/* this is needed to keep track of status of initialisation
115	* of the message file */
116	static int nrofmsg = 0;
117
118	/* first_msg is the started of the linked list of messages as read from
119	* the messages file
120	*/
121	static linked_char *first_msg = NULL;
122
123	/*	113	/*
124	* Spellpath information	114	* Spellpath information
125	*/	115	*/
126
127	static uint32 spellpathdef[NRSPELLPATHS] = {	116	static uint32 spellpathdef[NRSPELLPATHS] = {
128	PATH_PROT,	117	PATH_PROT,
129	PATH_FIRE,	118	PATH_FIRE,
130	PATH_FROST,	119	PATH_FROST,
131	PATH_ELEC,	120	PATH_ELEC,
…		…
412	static const char *const book_descrpt[] = {	401	static const char *const book_descrpt[] = {
413	"ancient",	402	"ancient",
414	"cryptic",	403	"cryptic",
415	"cryptical",	404	"cryptical",
416	"dusty",	405	"dusty",
417	"hiearchical",	406	"hierarchical",
418	"grizzled",	407	"grizzled",
419	"gold-guilt",	408	"gold-guilt",
420	"great",	409	"great",
421	"lost",	410	"lost",
422	"magnificent",	411	"magnificent",
…		…
497	/*subtype 50 */ {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_3, "readable-monument-gravestone-3"},	486	/*subtype 50 */ {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_3, "readable-monument-gravestone-3"},
498	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_1, "readable-monument-wall-1"},	487	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_1, "readable-monument-wall-1"},
499	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_2, "readable-monument-wall-2"},	488	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_2, "readable-monument-wall-2"},
500	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_3, "readable-monument-wall-3"}	489	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_3, "readable-monument-wall-3"}
501	};	490	};
502	int last_readable_subtype = sizeof (readable_message_types) / sizeof (readable_message_type);	491	static int last_readable_subtype = sizeof (readable_message_types) / sizeof (readable_message_type);
503		492
504	static int max_titles[6] = {	493	static int max_titles[6] = {
505	((sizeof (light_book_name) / sizeof (char *)) + (sizeof (heavy_book_name) / sizeof (char *))) * (sizeof (book_author) / sizeof (char *)),	494	((sizeof (light_book_name) / sizeof (char *)) + (sizeof (heavy_book_name) / sizeof (char *))) * (sizeof (book_author) / sizeof (char *)),
506	(sizeof (mon_book_name) / sizeof (char *)) * (sizeof (mon_author) / sizeof (char *)),	495	(sizeof (mon_book_name) / sizeof (char *)) * (sizeof (mon_author) / sizeof (char *)),
507	(sizeof (art_book_name) / sizeof (char *)) * (sizeof (art_author) / sizeof (char *)),	496	(sizeof (art_book_name) / sizeof (char *)) * (sizeof (art_author) / sizeof (char *)),
…		…
515	* Start of misc. readable functions used by others functions in this file	504	* Start of misc. readable functions used by others functions in this file
516	*	505	*
517	*****************************************************************************/	506	*****************************************************************************/
518		507
519	static titlelist *	508	static titlelist *
520	get_empty_booklist (void)	509	get_empty_booklist ()
521	{	510	{
522	titlelist *bl = new titlelist;	511	titlelist *bl = new titlelist;
523		512
524	bl->number = 0;	513	bl->number = 0;
525	bl->first_book = NULL;	514	bl->first_book = NULL;
526	bl->next = NULL;	515	bl->next = NULL;
527	return bl;	516	return bl;
528	}	517	}
529		518
530	static title *	519	static title *
531	get_empty_book (void)	520	get_empty_book ()
532	{	521	{
533	title *t = new title;	522	title *t = new title;
534		523
535	t->name = NULL;	524	t->name = NULL;
536	t->archname = NULL;	525	t->archname = NULL;
…		…
545	/* get_titlelist() - returns pointer to the title list referanced by i */	534	/* get_titlelist() - returns pointer to the title list referanced by i */
546		535
547	static titlelist *	536	static titlelist *
548	get_titlelist (int i)	537	get_titlelist (int i)
549	{	538	{
		539	if (!booklist)
		540	booklist = get_empty_booklist ();
		541
550	titlelist *tl = booklist;	542	titlelist *tl = booklist;
551	int number = i;	543	int number = i;
552		544
553	if (number < 0)	545	if (number < 0)
554	return tl;	546	return tl;
…		…
557	{	549	{
558	if (!tl->next)	550	if (!tl->next)
559	tl->next = get_empty_booklist ();	551	tl->next = get_empty_booklist ();
560		552
561	tl = tl->next;	553	tl = tl->next;
562	number--;	554	--number;
563	}	555	}
564		556
565	return tl;	557	return tl;
566	}	558	}
567		559
…		…
569	* (shstr.c ?), but the quantity BOOK_BUF will need to be defined. */	561	* (shstr.c ?), but the quantity BOOK_BUF will need to be defined. */
570		562
571	/* nstrtok() - simple routine to return the number of list	563	/* nstrtok() - simple routine to return the number of list
572	* items in buf1 as separated by the value of buf2	564	* items in buf1 as separated by the value of buf2
573	*/	565	*/
574		566	static int
575	int
576	nstrtok (const char *buf1, const char *buf2)	567	nstrtok (const char *buf1, const char *buf2)
577	{	568	{
578	char *tbuf, sbuf[12], buf[MAX_BUF];	569	char *tbuf, sbuf[12], buf[MAX_BUF];
579	int number = 0;	570	int number = 0;
580		571
581	if (!buf1 || !buf2)	572	if (!buf1 || !buf2)
582	return 0;	573	return 0;
583	sprintf (buf, "%s", buf1);	574
584	sprintf (sbuf, "%s", buf2);	575	strcpy (buf, buf1);
		576	strcpy (sbuf, buf2);
		577
585	tbuf = strtok (buf, sbuf);	578	tbuf = strtok (buf, sbuf);
586	while (tbuf)	579	while (tbuf)
587	{	580	{
588	number++;	581	number++;
589	tbuf = strtok (NULL, sbuf);	582	tbuf = strtok (NULL, sbuf);
…		…
593		586
594	/* strtoktolin() - takes a string in buf1 and separates it into	587	/* strtoktolin() - takes a string in buf1 and separates it into
595	* a list of strings delimited by buf2. Then returns a comma	588	* a list of strings delimited by buf2. Then returns a comma
596	* separated string w/ decent punctuation.	589	* separated string w/ decent punctuation.
597	*/	590	*/
598		591	static char *
599	char *
600	strtoktolin (const char *buf1, const char *buf2)	592	strtoktolin (const char *buf1, const char *buf2)
601	{	593	{
602	int maxi, i = nstrtok (buf1, buf2);	594	int maxi, i = nstrtok (buf1, buf2);
603	char *tbuf, buf[MAX_BUF], sbuf[12];	595	char *tbuf, buf[MAX_BUF], sbuf[12];
604	static char rbuf[BOOK_BUF];	596	static char rbuf[BOOK_BUF];
…		…
609	strcpy (rbuf, " ");	601	strcpy (rbuf, " ");
610	tbuf = strtok (buf, sbuf);	602	tbuf = strtok (buf, sbuf);
611	while (tbuf && i > 0)	603	while (tbuf && i > 0)
612	{	604	{
613	strcat (rbuf, tbuf);	605	strcat (rbuf, tbuf);
		606
614	i--;	607	i--;
615	if (i == 1 && maxi > 1)	608	if (i == 1 && maxi > 1)
616	strcat (rbuf, " and ");	609	strcat (rbuf, " and ");
617	else if (i > 0 && maxi > 1)	610	else if (i > 0 && maxi > 1)
618	strcat (rbuf, ", ");	611	strcat (rbuf, ", ");
619	else	612	else
620	strcat (rbuf, ".");	613	strcat (rbuf, ".");
		614
621	tbuf = strtok (NULL, sbuf);	615	tbuf = strtok (NULL, sbuf);
622	}	616	}
623	return (char *) rbuf;
624	}
625		617
626	int
627	book_overflow (const char *buf1, const char *buf2, int booksize)
628	{
629
630	if (buf_overflow (buf1, buf2, BOOK_BUF - 2) /* 2 less so always room for trailing \n */
631	|| buf_overflow (buf1, buf2, booksize))
632	return 1;
633	return 0;	618	return rbuf;
634
635
636	}	619	}
637		620
638	/*****************************************************************************	621	/*****************************************************************************
639	*	622	*
640	* Start of initialisation related functions.	623	* Start of initialisation related functions.
…		…
644	/* init_book_archive() - if not called before, initialise the info list	627	/* init_book_archive() - if not called before, initialise the info list
645	* This reads in the bookarch file into memory. bookarch is the file	628	* This reads in the bookarch file into memory. bookarch is the file
646	* created and updated across multiple runs of the program.	629	* created and updated across multiple runs of the program.
647	*/	630	*/
648	static void	631	static void
649	init_book_archive (void)	632	init_book_archive ()
650	{	633	{
651	FILE *fp;
652	int comp, nroftitle = 0;	634	int nroftitle = 0;
653	char buf[MAX_BUF], fname[MAX_BUF], *cp;
654	title *book = NULL;
655	titlelist *bl = get_empty_booklist ();	635	titlelist *bl = get_empty_booklist ();
656	static int did_init_barch;
657		636
658	if (did_init_barch)	637	object_thawer thawer (settings.localdir, "bookarch");
		638
		639	if (!thawer)
		640	{
		641	LOG (llevDebug, "could not read bookarch file\n");
659	return;	642	return;
660
661	did_init_barch = 1;
662
663	if (!booklist)
664	booklist = bl;
665
666	sprintf (fname, "%s/bookarch", settings.localdir);
667	LOG (llevDebug, " Reading bookarch from %s...\n", fname);
668
669	if ((fp = open_and_uncompress (fname, 0, &comp)) != NULL)
670	{	643	}
		644
		645	while (thawer.kw)
		646	{
		647	if (thawer.kw != KW_title)
		648	if (!thawer.parse_error ("bookarch file"))
		649	break;
		650
		651	title *book = get_empty_book (); /* init new book entry */
		652	thawer.get (book->name);
		653
671	int value, type = 0;	654	int type = -1;
672	size_t i;
673		655
674	while (fgets (buf, MAX_BUF, fp) != NULL)	656	for (;;)
675	{	657	{
676	if (*buf == '#')	658	thawer.next ();
677	continue;	659
678	if ((cp = strchr (buf, '\n')) != NULL)	660	switch (thawer.kw)
679	*cp = '\0';
680	cp = buf;
681	while (*cp == ' ') /* Skip blanks */
682	cp++;
683	if (!strncmp (cp, "title", 4))
684	{	661	{
685	book = get_empty_book (); /* init new book entry */	662	case KW_type: thawer.get (type ); break;
686	book->name = strchr (cp, ' ') + 1;	663	case KW_authour: thawer.get (book->authour ); break;
687	type = -1;	664	case KW_arch: thawer.get (book->archname ); break;
688	nroftitle++;	665	case KW_level: thawer.get (book->level ); break;
689	continue;	666	case KW_size: thawer.get (book->size ); break;
690	}	667	case KW_index: thawer.get (book->msg_index); break;
691	if (!strncmp (cp, "authour", 4))	668
692	{	669	case KW_end:
693	book->authour = strchr (cp, ' ') + 1;
694	}
695	if (!strncmp (cp, "arch", 4))
696	{
697	book->archname = strchr (cp, ' ') + 1;
698	}
699	else if (sscanf (cp, "level %d", &value))
700	{
701	book->level = (uint16) value;
702	}
703	else if (sscanf (cp, "type %d", &value))
704	{
705	type = (uint16) value;
706	}
707	else if (sscanf (cp, "size %d", &value))
708	{
709	book->size = (uint16) value;
710	}
711	else if (sscanf (cp, "index %d", &value))
712	{
713	book->msg_index = (uint16) value;
714	}
715	else if (!strncmp (cp, "end", 3))
716	{ /* link it */	670	/* link it */
717	bl = get_titlelist (type);	671	bl = get_titlelist (type);
718	book->next = bl->first_book;	672	book->next = bl->first_book;
719	bl->first_book = book;	673	bl->first_book = book;
720	bl->number++;	674	bl->number++;
		675	++nroftitle;
		676	goto book_done;
		677
		678	default:
		679	delete book;
		680	goto book_done;
721	}	681	}
722	}	682	}
		683
		684	book_done:
		685	thawer.next ();
		686	}
		687
723	LOG (llevDebug, "book archives(used/avail): \n");	688	LOG (llevDebug, "book archives(used/avail): \n");
		689	int i;
724	for (bl = booklist, i = 0; bl != NULL && i < sizeof (max_titles) / sizeof (*max_titles); bl = bl->next, i++)	690	for (bl = booklist, i = 0; bl && i < sizeof (max_titles) / sizeof (*max_titles); bl = bl->next, i++)
725	{
726	LOG (llevDebug, " (%d/%d)\n", bl->number, max_titles[i]);	691	LOG (llevDebug, " (%d/%d)\n", bl->number, max_titles[i]);
727	}
728	close_and_delete (fp, comp);
729	}
730		692
731	#ifdef BOOK_MSG_DEBUG
732	LOG (llevDebug, "init_book_archive() got %d titles.\n", nroftitle);	693	LOG (llevDebug, "init_book_archive() got %d titles.\n", nroftitle);
733	#endif
734	LOG (llevDebug, " done.\n");
735	}	694	}
736		695
737	/* init_mon_info() - creates the linked list of pointers to	696	/* init_mon_info() - creates the linked list of pointers to
738	* monster archetype objects if not called previously	697	* monster archetype objects if not called previously
739	*/	698	*/
740
741	static void	699	static void
742	init_mon_info (void)	700	init_mon_info ()
743	{	701	{
744	archetype *at;	702	archetype *at;
745	static int did_init_mon_info = 0;	703	static int did_init_mon_info = 0;
746		704
747	if (did_init_mon_info)	705	if (did_init_mon_info)
748	return;	706	return;
749		707
750	did_init_mon_info = 1;	708	did_init_mon_info = 1;
751		709
752	for_all_archetypes (at)	710	for_all_archetypes (at)
753	{	711	if (at->flag [FLAG_MONSTER]
754	if (QUERY_FLAG (at, FLAG_MONSTER) && (!QUERY_FLAG (at, FLAG_CHANGING) || QUERY_FLAG (at, FLAG_UNAGGRESSIVE)))	712	&& at->is_head ()
		713	&& (!at->flag [FLAG_CHANGING] || at->flag [FLAG_UNAGGRESSIVE]))
755	{	714	{
756	objectlink *mon = new objectlink;	715	objectlink *mon = new objectlink;
757		716
758	mon->ob = at;	717	mon->ob = at;
759	mon->next = first_mon_info;	718	mon->next = first_mon_info;
760	first_mon_info = mon;	719	first_mon_info = mon;
761	nrofmon++;	720	nrofmon++;
762	}	721	}
763	}
764		722
765	LOG (llevDebug, "init_mon_info() got %d monsters\n", nrofmon);	723	LOG (llevDebug, "init_mon_info() got %d monsters\n", nrofmon);
766	}	724	}
767		725
768	/* init_readable() - initialise linked lists utilized by	726	/* init_readable() - initialise linked lists utilized by
…		…
770	*	728	*
771	* This is the function called by the main routine to initialise	729	* This is the function called by the main routine to initialise
772	* all the readable information.	730	* all the readable information.
773	*/	731	*/
774	void	732	void
775	init_readable (void)	733	init_readable ()
776	{	734	{
777	static int did_this;	735	static int did_this;
778		736
779	if (did_this)	737	if (did_this)
780	return;	738	return;
…		…
817	else	775	else
818	t = t->next;	776	t = t->next;
819		777
820	#ifdef ARCHIVE_DEBUG	778	#ifdef ARCHIVE_DEBUG
821	if (t)	779	if (t)
822	LOG (llevDebug, "Found title match (list %d): %s %s (%d)\n", msgtype, t->name, t->authour, t->msg_index);	780	LOG (llevDebug, "Found title match (list %d): %s %s (%d)\n", msgtype, &t->name, &t->authour, t->msg_index);
823	#endif	781	#endif
824		782
825	return t;	783	return t;
826	}	784	}
827		785
…		…
829	* handled directly in change_book_name(). Names are based on text	787	* handled directly in change_book_name(). Names are based on text
830	* msgtype	788	* msgtype
831	* this sets book book->name based on msgtype given. What name	789	* this sets book book->name based on msgtype given. What name
832	* is given is based on various criteria	790	* is given is based on various criteria
833	*/	791	*/
834
835	static void	792	static void
836	new_text_name (object *book, int msgtype)	793	new_text_name (object *book, int msgtype)
837	{	794	{
838	int nbr;	795	const char *name;
839	char name[MAX_BUF];
840		796
841	if (book->type != BOOK)	797	if (book->type != BOOK)
842	return;	798	return;
843		799
844	switch (msgtype)	800	switch (msgtype)
845	{	801	{
846	case 1: /*monster */	802	case 1: /*monster */
847	nbr = sizeof (mon_book_name) / sizeof (char *);	803	name = mon_book_name[rndm (array_length (mon_book_name))];
848	assign (name, mon_book_name[rndm (nbr)]);
849	break;	804	break;
850	case 2: /*artifact */	805	case 2: /*artifact */
851	nbr = sizeof (art_book_name) / sizeof (char *);	806	name = art_book_name[rndm (array_length (art_book_name))];
852	assign (name, art_book_name[rndm (nbr)]);
853	break;	807	break;
854	case 3: /*spellpath */	808	case 3: /*spellpath */
855	nbr = sizeof (path_book_name) / sizeof (char *);	809	name = path_book_name[rndm (array_length (path_book_name))];
856	assign (name, path_book_name[rndm (nbr)]);
857	break;	810	break;
858	case 4: /*alchemy */	811	case 4: /*alchemy */
859	nbr = sizeof (formula_book_name) / sizeof (char *);	812	name = formula_book_name[rndm (array_length (formula_book_name))];
860	assign (name, formula_book_name[rndm (nbr)]);
861	break;	813	break;
862	case 5: /*gods */	814	case 5: /*gods */
863	nbr = sizeof (gods_book_name) / sizeof (char *);	815	name = gods_book_name[rndm (array_length (gods_book_name))];
864	assign (name, gods_book_name[rndm (nbr)]);
865	break;	816	break;
866	case 6: /*msg file */	817	case 6: /*msg file */
867	default:	818	default:
868	if (book->weight > 2000)	819	name = book->weight > 2000 /* based on weight */
869	{ /* based on weight */	820	? heavy_book_name [rndm (array_length (heavy_book_name))]
870	nbr = sizeof (heavy_book_name) / sizeof (char *);	821	: light_book_name [rndm (array_length (light_book_name))];
871	assign (name, heavy_book_name[rndm (nbr)]);
872	}
873	else if (book->weight < 2001)
874	{
875	nbr = sizeof (light_book_name) / sizeof (char *);
876	assign (name, light_book_name[rndm (nbr)]);
877	}
878	break;	822	break;
879	}	823	}
880		824
881	book->name = name;	825	book->name = name;
882	}	826	}
883		827
884	/* add_book_author()	828	/* add_book_author()
885	* A lot like new_text_name above, but instead chooses an author	829	* A lot like new_text_name above, but instead chooses an author
886	* and sets op->title to that value	830	* and sets op->title to that value
887	*/	831	*/
888		832
889	static void	833	static void
890	add_author (object *op, int msgtype)	834	add_author (object *op, int msgtype)
891	{	835	{
892	char title[MAX_BUF], name[MAX_BUF];	836	const char *name;
893	int nbr = sizeof (book_author) / sizeof (char *);
894		837
895	if (msgtype < 0 || strlen (op->msg) < 5)	838	if (msgtype < 0 || strlen (op->msg) < 5)
896	return;	839	return;
897		840
898	switch (msgtype)	841	switch (msgtype)
899	{	842	{
900	case 1: /* monster */	843	case 1: /* monster */
901	nbr = sizeof (mon_author) / sizeof (char *);	844	name = mon_author[rndm (array_length (mon_author))];
902	assign (name, mon_author[rndm (nbr)]);
903	break;	845	break;
904	case 2: /* artifacts */	846	case 2: /* artifacts */
905	nbr = sizeof (art_author) / sizeof (char *);	847	name = art_author[rndm (array_length (art_author))];
906	assign (name, art_author[rndm (nbr)]);
907	break;	848	break;
908	case 3: /* spellpath */	849	case 3: /* spellpath */
909	nbr = sizeof (path_author) / sizeof (char *);	850	name = path_author[rndm (array_length (path_author))];
910	assign (name, path_author[rndm (nbr)]);
911	break;	851	break;
912	case 4: /* alchemy */	852	case 4: /* alchemy */
913	nbr = sizeof (formula_author) / sizeof (char *);	853	name = formula_author[rndm (array_length (formula_author))];
914	assign (name, formula_author[rndm (nbr)]);
915	break;	854	break;
916	case 5: /* gods */	855	case 5: /* gods */
917	nbr = sizeof (gods_author) / sizeof (char *);	856	name = gods_author[rndm (array_length (gods_author))];
918	assign (name, gods_author[rndm (nbr)]);
919	break;	857	break;
920	case 6: /* msg file */	858	case 6: /* msg file */
921	default:	859	default:
922	assign (name, book_author[rndm (nbr)]);	860	name = book_author[rndm (array_length (book_author))];
923	}	861	}
924		862
925	sprintf (title, "of %s", name);	863	op->title = format ("of %s", name);
926	op->title = title;
927	}	864	}
928		865
929	/* unique_book() - check to see if the book title/msg is unique. We	866	/* unique_book() - check to see if the book title/msg is unique. We
930	* go through the entire list of possibilities each time. If we find	867	* go through the entire list of possibilities each time. If we find
931	* a match, then unique_book returns true (because inst unique).	868	* a match, then unique_book returns true (because inst unique).
932	*/	869	*/
933		870
934	static int	871	static int
935	unique_book (const object *book, int msgtype)	872	unique_book (const object *book, int msgtype)
936	{	873	{
937	title *test;
938
939	if (!booklist)	874	if (!booklist)
940	return 1; /* No archival entries! Must be unique! */	875	return 1; /* No archival entries! Must be unique! */
941		876
942	/* Go through the booklist. If the author and name match, not unique so	877	/* Go through the booklist. If the author and name match, not unique so
943	* return 0.	878	* return 0.
944	*/	879	*/
945	for (test = get_titlelist (msgtype)->first_book; test; test = test->next)	880	for (title *test = get_titlelist (msgtype)->first_book; test; test = test->next)
946	{
947	if (!strcmp (test->name, book->name) && !strcmp (book->title, test->authour))	881	if (test->name == book->name && book->title == test->authour)
948	return 0;	882	return 0;
949	}	883
950	return 1;	884	return 1;
951	}	885	}
952		886
953	/* add_book_to_list() */	887	/* add_book_to_list() */
954		888
…		…
978		912
979	/* We have stuff we need to write now */	913	/* We have stuff we need to write now */
980	need_to_write_bookarchive = 1;	914	need_to_write_bookarchive = 1;
981		915
982	#ifdef ARCHIVE_DEBUG	916	#ifdef ARCHIVE_DEBUG
983	LOG (llevDebug, "Archiving new title: %s %s (%d)\n", book->name, book->title, msgtype);	917	LOG (llevDebug, "Archiving new title: %s %s (%d)\n", &book->name, &book->title, msgtype);
984	#endif	918	#endif
985		919
986	}	920	}
987		921
988		922
…		…
994	* levels and architypes. -b.t.	928	* levels and architypes. -b.t.
995	*/	929	*/
996		930
997	#define MAX_TITLE_CHECK 20	931	#define MAX_TITLE_CHECK 20
998		932
999	void	933	static void
1000	change_book (object *book, int msgtype)	934	change_book (object *book, int msgtype)
1001	{	935	{
1002	int nbr = sizeof (book_descrpt) / sizeof (char *);	936	int nbr = sizeof (book_descrpt) / sizeof (char *);
1003		937
1004	switch (book->type)	938	switch (book->type)
1005	{	939	{
1006	case BOOK:	940	case BOOK:
1007	{	941	{
1008	titlelist *tl = get_titlelist (msgtype);	942	titlelist *tl = get_titlelist (msgtype);
1009	title *t = NULL;	943	title *t = NULL;
1010	int tries = 0;	944	int tries = 0;
1011		945
1012	/* look to see if our msg already been archived. If so, alter	946	/* look to see if our msg already been archived. If so, alter
1013	* the book to match the archival text. If we fail to match,	947	* the book to match the archival text. If we fail to match,
1014	* then we archive the new title/name/msg combo if there is	948	* then we archive the new title/name/msg combo if there is
1015	* room on the titlelist.	949	* room on the titlelist.
1016	*/	950	*/
1017		951
1018	if ((strlen (book->msg) > 5) && (t = find_title (book, msgtype)))	952	if ((strlen (book->msg) > 5) && (t = find_title (book, msgtype)))
1019	{	953	{
1020	object *tmpbook;
1021
1022	/* alter book properties */	954	/* alter book properties */
1023	if ((tmpbook = get_archetype (t->archname)) != NULL)	955	if (object *tmpbook = archetype::get (t->archname))
		956	{
		957	tmpbook->msg = book->msg;
		958	tmpbook->copy_to (book);
		959	tmpbook->destroy ();
		960	}
		961
		962	book->title = t->authour;
		963	book->name = t->name;
		964	book->level = t->level;
		965	}
		966	/* Don't have any default title, so lets make up a new one */
		967	else
		968	{
		969	int numb, maxnames = max_titles[msgtype];
		970	const char *old_title;
		971	const char *old_name;
		972
		973	old_title = book->title;
		974	old_name = book->name;
		975
		976	/* some pre-generated books have title already set (from
		977	* maps), also don't bother looking for unique title if
		978	* we already used up all the available names! */
		979
		980	if (!tl)
		981	{
		982	LOG (llevError, "change_book_name(): can't find title list\n");
		983	numb = 0;
		984	}
		985	else
		986	numb = tl->number;
		987
		988	if (numb == maxnames)
		989	{
		990	#ifdef ARCHIVE_DEBUG
		991	LOG (llevDebug, "titles for list %d full (%d possible).\n", msgtype, maxnames);
		992	#endif
		993	}
		994	/* shouldnt change map-maker books */
		995	else if (!book->title)
		996	do
1024	{	997	{
1025	tmpbook->msg = book->msg;	998	/* random book name */
1026	tmpbook->copy_to (book);	999	new_text_name (book, msgtype);
1027	tmpbook->destroy ();	1000	add_author (book, msgtype); /* random author */
		1001	tries++;
1028	}	1002	}
		1003	while (!unique_book (book, msgtype) && tries < MAX_TITLE_CHECK);
1029		1004
1030	book->title = t->authour;	1005	/* Now deal with 2 cases.
1031	book->name = t->name;	1006	* 1)If no space for a new title exists lets just restore
1032	book->level = t->level;	1007	* the old book properties. Remember, if the book had
		1008	* matchd an older entry on the titlelist, we shouldnt
		1009	* have called this routine in the first place!
		1010	* 2) If we got a unique title, we need to add it to
		1011	* the list.
1033	}	1012	*/
1034	/* Don't have any default title, so lets make up a new one */
1035	else
1036	{
1037	int numb, maxnames = max_titles[msgtype];
1038	const char *old_title;
1039	const char *old_name;
1040		1013
1041	old_title = book->title;	1014	if (tries == MAX_TITLE_CHECK || numb == maxnames)
1042	old_name = book->name;	1015	{ /* got to check maxnames again */
1043
1044	/* some pre-generated books have title already set (from
1045	* maps), also don't bother looking for unique title if
1046	* we already used up all the available names! */
1047
1048	if (!tl)
1049	{
1050	LOG (llevError, "change_book_name(): can't find title list\n");
1051	numb = 0;
1052	}
1053	else
1054	numb = tl->number;
1055
1056	if (numb == maxnames)
1057	{
1058	#ifdef ARCHIVE_DEBUG	1016	#ifdef ARCHIVE_DEBUG
1059	LOG (llevDebug, "titles for list %d full (%d possible).\n", msgtype, maxnames);	1017	LOG (llevDebug, "Failed to obtain unique title for %s %s (names:%d/%d)\n", &book->name, &book->title, numb, maxnames);
1060	#endif	1018	#endif
1061	break;
1062	}
1063	/* shouldnt change map-maker books */
1064	else if (!book->title)
1065	do
1066	{
1067	/* random book name */
1068	new_text_name (book, msgtype);
1069	add_author (book, msgtype); /* random author */
1070	tries++;
1071	}
1072	while (!unique_book (book, msgtype) && tries < MAX_TITLE_CHECK);
1073
1074	/* Now deal with 2 cases.
1075	* 1)If no space for a new title exists lets just restore
1076	* the old book properties. Remember, if the book had
1077	* matchd an older entry on the titlelist, we shouldnt
1078	* have called this routine in the first place!
1079	* 2) If we got a unique title, we need to add it to
1080	* the list.
1081	*/
1082
1083	if (tries == MAX_TITLE_CHECK || numb == maxnames)
1084	{ /* got to check maxnames again */
1085	#ifdef ARCHIVE_DEBUG
1086	LOG (llevDebug, "Failed to obtain unique title for %s %s (names:%d/%d)\n", book->name, book->title, numb, maxnames);
1087	#endif
1088	/* restore old book properties here */	1019	/* restore old book properties here */
1089	book->title = old_title;	1020	book->title = old_title;
1090		1021
1091	if (RANDOM () % 4)	1022	if (rndm (4))
1092	{
1093	/* Lets give the book a description to individualize it some */	1023	/* Lets give the book a description to individualize it some */
1094	char new_name[MAX_BUF];
1095
1096	snprintf (new_name, MAX_BUF, "%s %s", book_descrpt[rndm (nbr)], old_name);	1024	book->name = format ("%s %s", book_descrpt[rndm (nbr)], old_name);
1097
1098	book->name = new_name;
1099	}
1100	else	1025	else
1101	{
1102	book->name = old_name;	1026	book->name = old_name;
1103	}
1104	}	1027	}
1105	else if (book->title && strlen (book->msg) > 5)	1028	else if (book->title && strlen (book->msg) > 5)
1106	{ /* archive if long msg texts */	1029	{ /* archive if long msg texts */
1107	add_book_to_list (book, msgtype);	1030	add_book_to_list (book, msgtype);
1108	}	1031	}
1109	}	1032	}
1110	break;	1033	break;
1111	}	1034	}
1112		1035
1113	default:	1036	default:
1114	LOG (llevError, "change_book_name() called w/ illegal obj type.\n");	1037	LOG (llevError, "change_book_name() called w/ illegal obj type.\n");
1115	return;	1038	return;
1116	}	1039	}
1117	}	1040	}
1118		1041
1119	/*****************************************************************************	1042	/*****************************************************************************
1120	*	1043	*
…		…
1131	* list of all monsters in the current game. If level is non-zero,	1054	* list of all monsters in the current game. If level is non-zero,
1132	* then only monsters greater than that level will be returned.	1055	* then only monsters greater than that level will be returned.
1133	* Changed 971225 to be greater than equal to level passed. Also	1056	* Changed 971225 to be greater than equal to level passed. Also
1134	* made choosing by level more random.	1057	* made choosing by level more random.
1135	*/	1058	*/
1136
1137	object *	1059	object *
1138	get_random_mon (int level)	1060	get_random_mon (int level)
1139	{	1061	{
1140	objectlink *mon = first_mon_info;	1062	objectlink *mon = first_mon_info;
1141	int i = 0, monnr;	1063	int i = 0, monnr;
…		…
1145	return (object *) NULL;	1067	return (object *) NULL;
1146		1068
1147	if (!level)	1069	if (!level)
1148	{	1070	{
1149	/* lets get a random monster from the mon_info linked list */	1071	/* lets get a random monster from the mon_info linked list */
1150	monnr = RANDOM () % nrofmon;	1072	monnr = rndm (nrofmon);
1151		1073
1152	for (mon = first_mon_info, i = 0; mon; mon = mon->next)	1074	for (mon = first_mon_info, i = 0; mon; mon = mon->next)
1153	if (i++ == monnr)	1075	if (i++ == monnr)
1154	break;	1076	break;
1155		1077
…		…
1182	{	1104	{
1183	LOG (llevError, "get_random_mon() couldn't return monster for level %d\n", level);	1105	LOG (llevError, "get_random_mon() couldn't return monster for level %d\n", level);
1184	return NULL;	1106	return NULL;
1185	}	1107	}
1186		1108
1187	monnr = RANDOM () % i;	1109	monnr = rndm (i);
1188	for (mon = first_mon_info; mon; mon = mon->next)	1110	for (mon = first_mon_info; mon; mon = mon->next)
1189	if (mon->ob->level >= level && monnr-- == 0)	1111	if (mon->ob->level >= level && monnr-- == 0)
1190	return mon->ob;	1112	return mon->ob;
1191		1113
1192	if (!mon)	1114	if (!mon)
…		…
1199		1121
1200	/*	1122	/*
1201	* Returns a description of the monster. This really needs to be	1123	* Returns a description of the monster. This really needs to be
1202	* redone, as describe_item really gives a pretty internal description.	1124	* redone, as describe_item really gives a pretty internal description.
1203	*/	1125	*/
1204		1126	static const char *
1205	char *
1206	mon_desc (const object *mon)	1127	mon_desc (const object *mon)
1207	{	1128	{
1208	static char retbuf[HUGE_BUF];	1129	static dynbuf_text buf; buf.clear ();
1209		1130
1210	sprintf (retbuf, " *** %s ***\n", &mon->name);	1131	buf.printf ("B<< %s >>\r", &mon->name);
1211	strcat (retbuf, describe_item (mon, NULL));	1132	buf << describe_item (mon, 0);
1212		1133
1213	return retbuf;	1134	return buf;
1214	}	1135	}
1215		1136
1216		1137
1217	/* This function returns the next monsters after 'tmp'. If no match is	1138	/* This function returns the next monsters after 'tmp'. If no match is
1218	* found, it returns NULL (changed 0.94.3 to do this, since the	1139	* found, it returns NULL (changed 0.94.3 to do this, since the
1219	* calling function (mon_info_msg) seems to expect that.	1140	* calling function (mon_info_msg) seems to expect that.
1220	*/	1141	*/
1221		1142	static object *
1222	object *
1223	get_next_mon (object *tmp)	1143	get_next_mon (object *tmp)
1224	{	1144	{
1225	objectlink *mon;	1145	objectlink *mon;
1226		1146
1227	for (mon = first_mon_info; mon; mon = mon->next)	1147	for (mon = first_mon_info; mon; mon = mon->next)
…		…
1229	break;	1149	break;
1230		1150
1231	/* didn't find a match */	1151	/* didn't find a match */
1232	if (!mon)	1152	if (!mon)
1233	return NULL;	1153	return NULL;
		1154
1234	if (mon->next)	1155	if (mon->next)
1235	return mon->next->ob;	1156	return mon->next->ob;
1236	else	1157	else
1237	return first_mon_info->ob;	1158	return first_mon_info->ob;
1238		1159
1239	}	1160	}
1240		1161
1241
1242
1243	/* mon_info_msg() - generate a message detailing the properties	1162	/* mon_info_msg() - generate a message detailing the properties
1244	* of a randomly selected monster.	1163	* of a randomly selected monster.
1245	*/	1164	*/
1246		1165	static const char *
1247	char *
1248	mon_info_msg (int level, int booksize)	1166	mon_info_msg (int level)
1249	{	1167	{
1250	static char retbuf[BOOK_BUF];	1168	static dynbuf_text buf; buf.clear ();
1251	char tmpbuf[HUGE_BUF];
1252	object *tmp;
1253		1169
1254	/*preamble */	1170	/*preamble */
1255	strcpy (retbuf, "This beastiary contains:");	1171	buf << "This beastiary contains:\n";
1256		1172
1257	/* lets print info on as many monsters as will fit in our	1173	/* lets print info on as many monsters as will fit in our
1258	* document.	1174	* document.
1259	* 8-96 Had to change this a bit, otherwise there would	1175	* 8-96 Had to change this a bit, otherwise there would
1260	* have been an impossibly large number of combinations	1176	* have been an impossibly large number of combinations
1261	* of text! (and flood out the available number of titles	1177	* of text! (and flood out the available number of titles
1262	* in the archive in a snap!) -b.t.	1178	* in the archive in a snap!) -b.t.
1263	*/	1179	*/
1264	tmp = get_random_mon (level * 3);	1180	object *tmp = get_random_mon (level * 3);
1265	while (tmp)	1181	while (tmp && buf.size () < BOOK_BUF)
1266	{	1182	{
1267	/* monster description */	1183	/* monster description */
1268	sprintf (tmpbuf, "\n---\n%s", mon_desc (tmp));	1184	buf.printf ("\n%s\n", mon_desc (tmp));
1269
1270	if (!book_overflow (retbuf, tmpbuf, booksize))
1271	strcat (retbuf, tmpbuf);
1272	else
1273	break;
1274		1185
1275	/* Note that the value this returns is not based on level */	1186	/* Note that the value this returns is not based on level */
1276	tmp = get_next_mon (tmp);	1187	tmp = get_next_mon (tmp);
1277	}	1188	}
1278		1189
1279	#ifdef BOOK_MSG_DEBUG
1280	LOG (llevDebug, "\n mon_info_msg() created strng: %d\n", strlen (retbuf));
1281	fprintf (logfile, " MADE THIS:\n%s\n", retbuf);
1282	#endif
1283
1284	return retbuf;	1190	return buf;
1285	}	1191	}
1286		1192
1287		1193
1288	/*****************************************************************************	1194	/*****************************************************************************
1289	* Artifact msg generation code.	1195	* Artifact msg generation code.
1290	****************************************************************************/	1196	****************************************************************************/
1291		1197
1292	/* artifact_msg() - generate a message detailing the properties	1198	/* artifact_msg() - generate a message detailing the properties
1293	* of 1-6 artifacts drawn sequentially from the artifact list.	1199	* of 1-6 artifacts drawn sequentially from the artifact list.
1294	*/	1200	*/
1295	const char *	1201	static const char *
1296	artifact_msg (int level, int booksize)	1202	artifact_msg (int level)
1297	{	1203	{
1298	artifactlist *al = NULL;	1204	artifactlist *al = NULL;
1299	artifact *art;	1205	artifact *art;
1300	int chance, i, type, index;	1206	int chance, i, type, index;
1301	int book_entries = level > 5 ? RANDOM () % 3 + RANDOM () % 3 + 2 : RANDOM () % level + 1;	1207	int book_entries = level > 5 ? rndm (3) + rndm (3) + 2 : rndm (level) + 1;
1302	const char *ch;	1208	const char *ch;
1303	char name[MAX_BUF], buf[BOOK_BUF], sbuf[MAX_BUF];	1209	char name[MAX_BUF];
1304	static char retbuf[BOOK_BUF];
1305	object *tmp = NULL;	1210	object *tmp = NULL;
		1211
		1212	static dynbuf_text buf; buf.clear ();
1306		1213
1307	/* values greater than 5 create msg buffers that are too big! */	1214	/* values greater than 5 create msg buffers that are too big! */
1308	if (book_entries > 5)	1215	if (book_entries > 5)
1309	book_entries = 5;	1216	book_entries = 5;
1310		1217
…		…
1314	* for that type exists!	1221	* for that type exists!
1315	*/	1222	*/
1316	i = 0;	1223	i = 0;
1317	do	1224	do
1318	{	1225	{
1319	index = RANDOM () % (sizeof (art_name_array) / sizeof (arttypename));	1226	index = rndm (array_length (art_name_array));
1320	type = art_name_array[index].type;	1227	type = art_name_array[index].type;
1321	al = find_artifactlist (type);	1228	al = find_artifactlist (type);
1322	i++;	1229	i++;
1323	}	1230	}
1324	while ((al == NULL) && (i < 10));	1231	while ((al == NULL) && (i < 10));
…		…
1327	return "None";	1234	return "None";
1328		1235
1329	/* There is no reason to start on the artifact list at the begining. Lets	1236	/* There is no reason to start on the artifact list at the begining. Lets
1330	* take our starting position randomly... */	1237	* take our starting position randomly... */
1331	art = al->items;	1238	art = al->items;
1332	for (i = RANDOM () % level + RANDOM () % 2 + 1; i > 0; i--)	1239	for (i = rndm (level) + rndm (2) + 1; i > 0; i--)
1333	{	1240	{
1334	if (art == NULL)	1241	if (!art)
1335	art = al->items; /* hmm, out of stuff, loop back around */	1242	art = al->items; /* hmm, out of stuff, loop back around */
		1243
1336	art = art->next;	1244	art = art->next;
1337	}	1245	}
1338		1246
1339	/* the base 'generic' name for our artifact */	1247	/* the base 'generic' name for our artifact */
1340	assign (name, art_name_array[index].name);	1248	assign (name, art_name_array[index].name);
1341		1249
1342	/* Ok, lets print out the contents */	1250	/* Ok, lets print out the contents */
1343	sprintf (retbuf, "Herein %s detailed %s...\n", book_entries > 1 ? "are" : "is", book_entries > 1 ? "some artifacts" : "an artifact");	1251	buf.printf ("Herein %s detailed %s...\n",
		1252	book_entries > 1 ? "are" : "is",
		1253	book_entries > 1 ? "some artifacts" : "an artifact");
1344		1254
1345	/* artifact msg attributes loop. Lets keep adding entries to the 'book'	1255	/* artifact msg attributes loop. Lets keep adding entries to the 'book'
1346	* as long as we have space up to the allowed max # (book_entires)	1256	* as long as we have space up to the allowed max # (book_entires)
1347	*/	1257	*/
1348	while (book_entries > 0)	1258	while (book_entries > 0 && buf.size () < BOOK_BUF)
1349	{	1259	{
1350		1260
1351	if (art == NULL)	1261	if (!art)
1352	art = al->items;	1262	art = al->items;
1353		1263
1354	/* separator of items */	1264	buf << '\n';
1355	strcpy (buf, "--- \n");
1356		1265
1357	/* Name */	1266	/* Name */
1358	if (art->allowed != NULL && strcmp (art->allowed->name, "All"))	1267	if (art->allowed && art->allowed->name != shstr_All)
1359	{	1268	{
1360	linked_char *temp, *next = art->allowed;	1269	linked_char *temp, *next = art->allowed;
1361		1270
1362	do	1271	do
1363	{	1272	{
1364	temp = next;	1273	temp = next;
1365	next = next->next;	1274	next = next->next;
1366	}	1275	}
1367	while (next && !RANDOM () % 2);	1276	while (next && rndm (2));
		1277
1368	sprintf (buf, "%s A %s of %s", buf, &temp->name, &art->item->name);	1278	buf.printf ("A B<< %s of %s >>", &temp->name, &art->item->name);
1369	}	1279	}
1370	else /* default name is used */	1280	else /* default name is used */
1371	sprintf (buf, "%s The %s of %s", buf, name, &art->item->name);	1281	buf.printf ("The B<< %s of %s >>", name, &art->item->name);
		1282
		1283	buf << " is ";
1372		1284
1373	/* chance of finding */	1285	/* chance of finding */
1374	chance = (int) (100 * ((float) art->chance / al->total_chance));	1286	chance = (int) (100 * ((float) art->chance / al->total_chance));
1375	if (chance >= 20)	1287	if (chance >= 20)
1376	sprintf (sbuf, "an uncommon");	1288	buf << "an uncommon";
1377	else if (chance >= 10)	1289	else if (chance >= 10)
1378	sprintf (sbuf, "an unusual");	1290	buf << "an unusual";
1379	else if (chance >= 5)	1291	else if (chance >= 5)
1380	sprintf (sbuf, "a rare");	1292	buf << "a rare";
1381	else	1293	else
1382	sprintf (sbuf, "a very rare");	1294	buf << "a very rare";
1383	sprintf (buf, "%s is %s\n", buf, sbuf);
1384		1295
1385	/* value of artifact */	1296	/* value of artifact */
1386	sprintf (buf, "%s item with a value that is %d times normal.\n", buf, art->item->value);	1297	buf << " item with a value that is " << art->item->value << " times normal.\n";
1387		1298
1388	/* include the message about the artifact, if exists, and book	1299	/* include the message about the artifact, if exists, and book
1389	* level is kinda high */	1300	* level is kinda high */
1390	if (art->item->msg && (RANDOM () % 4 + 1) < level && !((strlen (art->item->msg) + strlen (buf)) > BOOK_BUF))	1301	if (art->item->msg
		1302	&& rndm (4) + 1 < level)
1391	strcat (buf, art->item->msg);	1303	buf << art->item->msg;
1392		1304
1393	/* properties of the artifact */	1305	/* properties of the artifact */
1394	tmp = object::create ();	1306	tmp = object::create ();
1395	add_abilities (tmp, art->item);	1307	add_abilities (tmp, art->item);
1396	tmp->type = type;	1308	tmp->type = type;
1397	SET_FLAG (tmp, FLAG_IDENTIFIED);	1309	tmp->set_flag (FLAG_IDENTIFIED);
1398	if ((ch = describe_item (tmp, NULL)) != NULL && strlen (ch) > 1)	1310	if ((ch = describe_item (tmp, 0)) && strlen (ch) > 1)
1399	sprintf (buf, "%s Properties of this artifact include: \n %s \n", buf, ch);	1311	buf << "\rProperties of this artifact include:\r" << ch << "\n";
		1312
1400	tmp->destroy ();	1313	tmp->destroy ();
1401	/* add the buf if it will fit */
1402	if (!book_overflow (retbuf, buf, booksize))
1403	strcat (retbuf, buf);
1404	else
1405	break;
1406		1314
1407	art = art->next;	1315	art = art->next;
1408	book_entries--;	1316	book_entries--;
1409	}	1317	}
1410		1318
1411	#ifdef BOOK_MSG_DEBUG
1412	LOG (llevDebug, "artifact_msg() created strng: %d\n", strlen (retbuf));
1413	fprintf (logfile, " MADE THIS:\n%s", retbuf);
1414	#endif
1415	return retbuf;	1319	return buf;
1416	}	1320	}
1417		1321
1418	/*****************************************************************************	1322	/*****************************************************************************
1419	* Spellpath message generation	1323	* Spellpath message generation
1420	*****************************************************************************/	1324	*****************************************************************************/
1421		1325
1422	/* spellpath_msg() - generate a message detailing the member	1326	/* spellpath_msg() - generate a message detailing the member
1423	* incantations/prayers (and some of their properties) belonging to	1327	* incantations/prayers (and some of their properties) belonging to
1424	* a given spellpath.	1328	* a given spellpath.
1425	*/	1329	*/
1426		1330	static char *
1427	char *
1428	spellpath_msg (int level, int booksize)	1331	spellpath_msg (int level)
1429	{	1332	{
1430	static char retbuf[BOOK_BUF];	1333	static dynbuf_text buf; buf.clear ();
1431	char tmpbuf[BOOK_BUF];	1334
1432	int path = RANDOM () % NRSPELLPATHS, prayers = RANDOM () % 2;	1335	int path = rndm (NRSPELLPATHS), prayers = rndm (2);
1433	int did_first_sp = 0;
1434	uint32 pnum = (path == -1) ? PATH_NULL : spellpathdef[path];	1336	uint32 pnum = (path == -1) ? PATH_NULL : spellpathdef[path];
1435	archetype *at;	1337	archetype *at;
1436		1338
1437	/* Preamble */	1339	/* Preamble */
1438	sprintf (retbuf, "Herein are detailed the names of %s\n", prayers ? "prayers" : "incantations");	1340	buf << "Herein are detailed the names of "
		1341	<< (prayers ? "prayers" : "incantations");
1439		1342
1440	if (path == -1)	1343	if (path == -1)
1441	strcat (retbuf, "having no known spell path.\n");	1344	buf << " having no known spell path.\n";
1442	else	1345	else
1443	sprintf (retbuf, "%sbelonging to the path of %s:\n", retbuf, spellpathnames[path]);	1346	buf << " belonging to the path of B<< " << spellpathnames[path] << " >>:\n\n";
		1347
		1348	int seen = 0;
1444		1349
1445	for_all_archetypes (at)	1350	for_all_archetypes (at)
1446	{
1447	/* Determine if this is an appropriate spell. Must	1351	/* Determine if this is an appropriate spell. Must
1448	* be of matching path, must be of appropriate type (prayer	1352	* be of matching path, must be of appropriate type (prayer
1449	* or not), and must be within the valid level range.	1353	* or not), and must be within the valid level range.
1450	*/	1354	*/
1451	if (at->type == SPELL && at->path_attuned & pnum &&	1355	if (at->type == SPELL && at->path_attuned & pnum &&
1452	((at->stats.grace && prayers) || (at->stats.sp && !prayers)) && (at->level < (level * 8)))	1356	((at->stats.grace && prayers) || (at->stats.sp && !prayers)) && (at->level < (level * 8)))
1453	{	1357	{
1454	assign (tmpbuf, at->object::name);	1358	seen = 1;
1455		1359	buf << at->object::name << '\r';
1456	if (book_overflow (retbuf, tmpbuf, booksize))
1457	break;
1458	else
1459	{
1460	if (did_first_sp)
1461	strcat (retbuf, ",\n");
1462	did_first_sp = 1;
1463	strcat (retbuf, tmpbuf);
1464	}
1465	}	1360	}
1466	}	1361
1467	/* Geez, no spells were generated. */	1362	/* Geez, no spells were generated. */
1468	if (!did_first_sp)	1363	if (!seen)
1469	{
1470	if (RANDOM () % 4) /* usually, lets make a recursive call... */	1364	if (rndm (4)) /* usually, lets make a recursive call... */
1471	spellpath_msg (level, booksize);	1365	return spellpath_msg (level);
1472	else /* give up, cause knowing no spells exist for path is info too. */	1366	else /* give up, cause knowing no spells exist for path is info too. */
1473	strcat (retbuf, "\n - no known spells exist -\n");	1367	buf << "- no known spells exist.\n";
1474	}	1368
1475	else
1476	{
1477	strcat (retbuf, "\n");
1478	}
1479	return retbuf;	1369	return buf;
1480	}	1370	}
1481		1371
1482	/* formula_msg() - generate a message detailing the properties	1372	/* formula_msg() - generate a message detailing the properties
1483	* of a randomly selected alchemical formula.	1373	* of a randomly selected alchemical formula.
1484	*/	1374	*/
1485	void	1375	static void
1486	make_formula_book (object *book, int level)	1376	make_formula_book (object *book, int level)
1487	{	1377	{
1488	char retbuf[BOOK_BUF], title[MAX_BUF];	1378	char title[MAX_BUF];
1489	recipelist *fl;	1379	recipelist *fl;
1490	recipe *formula = NULL;	1380	recipe *formula = NULL;
1491	int chance;	1381	int chance;
1492		1382
		1383	static dynbuf_text buf; buf.clear ();
		1384
1493	/* the higher the book level, the more complex (ie number of	1385	/* the higher the book level, the more complex (ie number of
1494	* ingredients) the formula can be.	1386	* ingredients) the formula can be.
1495	*/	1387	*/
1496	fl = get_formulalist (((RANDOM () % level) / 3) + 1);	1388	fl = get_formulalist (rndm (level) / 3 + 1);
1497		1389
1498	if (!fl)	1390	if (!fl)
1499	fl = get_formulalist (1); /* safety */	1391	fl = get_formulalist (1); /* safety */
1500		1392
1501	if (fl->total_chance == 0)	1393	if (fl->total_chance == 0)
…		…
1505	add_author (book, 4);	1397	add_author (book, 4);
1506	return;	1398	return;
1507	}	1399	}
1508		1400
1509	/* get a random formula, weighted by its bookchance */	1401	/* get a random formula, weighted by its bookchance */
1510	chance = RANDOM () % fl->total_chance;	1402	chance = rndm (fl->total_chance);
1511	for (formula = fl->items; formula != NULL; formula = formula->next)	1403	for (formula = fl->items; formula; formula = formula->next)
1512	{	1404	{
1513	chance -= formula->chance;	1405	chance -= formula->chance;
		1406
1514	if (chance <= 0)	1407	if (chance <= 0)
1515	break;	1408	break;
1516	}	1409	}
1517		1410
1518	if (!formula || formula->arch_names <= 0)	1411	if (!formula || formula->arch_names <= 0)
1519	{	1412	{
1520	book->msg = "<indecipherable text>\n";	1413	book->msg = "<indecipherable text>\n";
1521	new_text_name (book, 4);	1414	new_text_name (book, 4);
1522	add_author (book, 4);	1415	add_author (book, 4);
1523		1416	return;
1524	}	1417	}
		1418
		1419	/* looks like a formula was found. Base the amount
		1420	* of information on the booklevel and the spellevel
		1421	* of the formula. */
		1422
		1423	const char *op_name = formula->arch_name [rndm (formula->arch_names)];
		1424	archetype *at;
		1425
		1426	/* preamble */
		1427	buf << "Herein is described a project using B<< "
		1428	<< (formula->skill ? &formula->skill : "an unknown skill")
		1429	<< " >>:\n\n";
		1430
		1431	if ((at = archetype::find (op_name)))
		1432	op_name = at->object::name;
1525	else	1433	else
		1434	LOG (llevError, "formula_msg() can't find arch %s for formula.\n", op_name);
		1435
		1436	/* item name */
		1437	if (formula->title != shstr_NONE)
		1438	{
		1439	buf.printf ("The B<< %s of %s >>", op_name, &formula->title);
		1440	/* This results in things like pile of philo. sulfur.
		1441	* while philo. sulfur may look better, without this,
		1442	* you get things like 'the wise' because its missing the
		1443	* water of section.
		1444	*/
		1445	sprintf (title, "%s: %s of %s",
		1446	formula_book_name [rndm (sizeof (formula_book_name) / sizeof (char *))], op_name, &formula->title);
1526	{	1447	}
1527	/* looks like a formula was found. Base the amount	1448	else
1528	* of information on the booklevel and the spellevel	1449	{
1529	* of the formula. */	1450	buf << "The B<< " << op_name;
1530		1451
1531	const char *op_name = formula->arch_name[RANDOM () % formula->arch_names];	1452	sprintf (title, "%s: %s", formula_book_name [rndm (sizeof (formula_book_name) / sizeof (char *))], op_name);
		1453	if (at->title)
		1454	{
		1455	buf << " " << at->title;
		1456	strcat (title, " ");
		1457	strcat (title, at->title);
		1458	}
		1459
		1460	buf << " >>";
		1461	}
		1462
		1463	/* Lets name the book something meaningful ! */
		1464	book->name = title;
		1465	book->title = NULL;
		1466
		1467	/* ingredients to make it */
		1468	if (formula->ingred)
		1469	{
		1470	linked_char *next;
1532	archetype *at;	1471	archetype *at;
1533		1472
1534	/* preamble */
1535	sprintf (retbuf, "Herein is described a project using %s: \n", formula->skill ? &formula->skill : "an unknown skill");
1536
1537	if ((at = archetype::find (op_name)) != (archetype *) NULL)
1538	op_name = at->object::name;
1539	else
1540	LOG (llevError, "formula_msg() can't find arch %s for formula.\n", op_name);
1541
1542	/* item name */
1543	if (strcmp (formula->title, "NONE"))
1544	{
1545	sprintf (retbuf, "%sThe %s of %s", retbuf, op_name, &formula->title);
1546	/* This results in things like pile of philo. sulfur.
1547	* while philo. sulfur may look better, without this,
1548	* you get things like 'the wise' because its missing the
1549	* water of section.
1550	*/
1551	sprintf (title, "%s: %s of %s",
1552	formula_book_name[RANDOM () % (sizeof (formula_book_name) / sizeof (char *))], op_name, &formula->title);
1553	}
1554	else
1555	{
1556	sprintf (retbuf, "%sThe %s", retbuf, op_name);
1557	sprintf (title, "%s: %s", formula_book_name[RANDOM () % (sizeof (formula_book_name) / sizeof (char *))], op_name);
1558	if (at->title)
1559	{
1560	strcat (retbuf, " ");
1561	strcat (retbuf, at->title);
1562	strcat (title, " ");
1563	strcat (title, at->title);
1564	}
1565	}
1566	/* Lets name the book something meaningful ! */
1567	book->name = title;
1568	book->title = NULL;
1569
1570	/* ingredients to make it */
1571	if (formula->ingred != NULL)
1572	{
1573	linked_char *next;
1574	archetype *at;
1575
1576	at = archetype::find (formula->cauldron);	1473	at = archetype::find (formula->cauldron);
1577		1474
1578	sprintf (retbuf + strlen (retbuf),	1475	buf.printf (" may be made at %s using the following ingredients:\n\n",
1579	" may be made at %s using the following ingredients:\n", at ? query_name (at) : "an unknown place");	1476	at ? query_name (at) : "an appropriate place");
1580		1477
1581	for (next = formula->ingred; next != NULL; next = next->next)	1478	for (next = formula->ingred; next; next = next->next)
1582	{	1479	buf << next->name << '\r';
1583	strcat (retbuf, next->name);	1480	}
1584	strcat (retbuf, "\n");
1585	}
1586	}
1587	else	1481	else
1588	LOG (llevError, "formula_msg() no ingredient list for object %s of %s\n", op_name, &formula->title);	1482	LOG (llevError, "formula_msg() no ingredient list for object %s of %s\n", op_name, &formula->title);
1589	if (retbuf[strlen (retbuf) - 1] != '\n')	1483
		1484	book->msg = buf;
		1485	}
		1486
		1487	#define DESCRIBE_PATH(retbuf, variable, name) \
		1488	if(variable) { \
		1489	int i,j=0; \
		1490	strcat(retbuf,"(" name ": "); \
		1491	for(i=0; i<NRSPELLPATHS; i++) \
		1492	if(variable & (1<<i)) { \
		1493	if (j) \
		1494	strcat(retbuf,", "); \
		1495	else \
		1496	j = 1; \
		1497	strcat(retbuf, spellpathnames[i]); \
		1498	} \
1590	strcat (retbuf, "\n");	1499	strcat(retbuf,")"); \
1591
1592	book->msg = retbuf;
1593	}	1500	}
1594	}
1595		1501
1596	/* god_info_msg() - generate a message detailing the properties	1502	/* god_info_msg() - generate a message detailing the properties
1597	* of a random god. Used by the book hack. b.t.	1503	* of a random god. Used by the book hack. b.t.
1598	*/	1504	*/
1599	const char *	1505	static const char *
1600	god_info_msg (int level, int booksize)	1506	god_info_msg (int level)
1601	{	1507	{
1602	static char retbuf[BOOK_BUF];
1603	const char *name = NULL;	1508	const char *name = NULL;
1604	char buf[BOOK_BUF];
1605	int i;
1606	size_t introlen;
1607	object *god = pntr_to_god_obj (get_rand_god ());	1509	object *god = pntr_to_god_obj (get_rand_god ());
1608		1510
		1511	static dynbuf_text buf; buf.clear ();
		1512
1609	if (!god)	1513	if (!god)
1610	return (char *) NULL; /* oops, problems... */	1514	return 0; /* oops, problems... */
		1515
1611	name = god->name;	1516	name = god->name;
1612		1517
1613	/* preamble.. */	1518	/* preamble.. */
1614	sprintf (retbuf, "This document contains knowledge concerning\n");	1519	buf << "This document contains knowledge concerning the diety B<< "
1615	sprintf (retbuf, "%sthe diety %s", retbuf, name);	1520	<< name << " >>";
1616		1521
1617	/* Always have as default information the god's descriptive terms. */	1522	/* Always have as default information the god's descriptive terms. */
1618	if (nstrtok (god->msg, ",") > 0)	1523	if (nstrtok (god->msg, ",") > 0)
1619	{	1524	buf << ", known as" << strtoktolin (god->msg, ",");
1620	strcat (retbuf, ", known as");
1621	strcat (retbuf, strtoktolin (god->msg, ","));
1622	}
1623	else	1525	else
1624	strcat (retbuf, "...");	1526	buf << "...";
1625		1527
1626	strcat (retbuf, "\n ---\n");	1528	buf << "\n\n";
		1529
1627	introlen = strlen (retbuf); /* so we will know if no new info is added later */	1530	int introlen = buf.size (); /* so we will know if no new info is added later */
1628		1531
1629	/* Information about the god is random, and based on the level of the	1532	/* Information about the god is random, and based on the level of the
1630	* 'book'. Probably there is a more intellegent way to implement	1533	* 'book'. Probably there is a more intellegent way to implement
1631	* this ...	1534	* this ...
1632	*/	1535	*/
1633		1536	while (level > 0 && buf.size () < BOOK_BUF)
1634	while (level > 0)
1635	{	1537	{
1636	sprintf (buf, " ");
1637	if (level == 2 && RANDOM () % 2)	1538	if (level == 2 && rndm (2))
1638	{ /* enemy god */	1539	{ /* enemy god */
1639	const char *enemy = god->title;	1540	const char *enemy = god->title;
1640		1541
1641	if (enemy)	1542	if (enemy)
1642	sprintf (buf, "The gods %s and %s are enemies.\n ---\n", name, enemy);	1543	buf.printf ("The gods %s and %s are enemies.\r", name, enemy);
1643	}	1544	}
1644		1545
1645	if (level == 3 && RANDOM () % 2)	1546	if (level == 3 && rndm (2))
1646	{ /* enemy race, what the god's holy word effects */	1547	{ /* enemy race, what the god's holy word effects */
1647	const char *enemy = god->slaying;	1548	const char *enemy = god->slaying;
		1549	int i;
1648		1550
1649	if (enemy && !(god->path_denied & PATH_TURNING))	1551	if (enemy && !(god->path_denied & PATH_TURNING))
1650	if ((i = nstrtok (enemy, ",")) > 0)	1552	if ((i = nstrtok (enemy, ",")) > 0)
1651	{	1553	{
1652	char tmpbuf[MAX_BUF];	1554	buf << "The holy words of " << name
		1555	<< " have the power to slay creatures belonging to the ";
1653		1556
1654	sprintf (buf, "The holy words of %s have the power to\n", name);
1655	strcat (buf, "slay creatures belonging to the ");
1656	if (i > 1)	1557	if (i > 1)
1657	sprintf (tmpbuf, "following \n races:%s", strtoktolin (enemy, ","));	1558	buf << "following races:" << strtoktolin (enemy, ",");
1658	else	1559	else
1659	sprintf (tmpbuf, "race of%s", strtoktolin (enemy, ","));	1560	buf << "race of" << strtoktolin (enemy, ",");
1660	sprintf (buf, "%s%s\n ---\n", buf, tmpbuf);	1561
		1562	buf << '\r';
1661	}	1563	}
1662	}	1564	}
1663		1565
1664	if (level == 4 && RANDOM () % 2)	1566	if (level == 4 && rndm (2))
1665	{ /* Priest of god gets these protect,vulnerable... */	1567	{ /* Priest of god gets these protect,vulnerable... */
1666	char tmpbuf[MAX_BUF];
1667
1668	if (const char *cp = describe_resistance (god, 1))	1568	if (const char *cp = describe_resistance (god, 1))
1669	{ /* This god does have protections */	1569	{ /* This god does have protections */
1670	sprintf (tmpbuf, "%s has a potent aura which is extended\n", name);	1570	buf << name
		1571	<< " has a potent aura which is extended to"
1671	strcat (tmpbuf, "faithful priests. The effects of this aura include:\n");	1572	" faithful priests. The effects of this aura include: "
1672	strcat (tmpbuf, cp);	1573	<< cp
1673	strcat (buf, tmpbuf);	1574	<< ".\r";
1674	strcat (buf, "\n ---\n");
1675	}	1575	}
1676	else
1677	sprintf (buf, " ");
1678	}	1576	}
1679		1577
1680	if (level == 5 && RANDOM () % 2)	1578	if (level == 5 && rndm (2))
1681	{ /* aligned race, summoning */	1579	{ /* aligned race, summoning */
1682	const char *race = god->race; /* aligned race */	1580	const char *race = god->race; /* aligned race */
		1581	int i;
1683		1582
1684	if (race && !(god->path_denied & PATH_SUMMON))	1583	if (race && !(god->path_denied & PATH_SUMMON))
1685	if ((i = nstrtok (race, ",")) > 0)	1584	if ((i = nstrtok (race, ",")) > 0)
1686	{	1585	{
1687	char tmpbuf[MAX_BUF];	1586	buf << "Creatures sacred to " << name << " include the ";
1688
1689	sprintf (buf, "Creatures sacred to %s include the \n", name);
1690	if (i > 1)	1587	if (i > 1)
1691	sprintf (tmpbuf, "following \n races:%s", strtoktolin (race, ","));	1588	buf << "following races:" << strtoktolin (race, ",");
1692	else	1589	else
1693	sprintf (tmpbuf, "race of%s", strtoktolin (race, ","));	1590	buf << "race of" << strtoktolin (race, ",");
1694	sprintf (buf, "%s%s\n ---\n", buf, tmpbuf);	1591
		1592	buf << '\r';
1695	}	1593	}
1696	}	1594	}
1697		1595
1698	if (level == 6 && RANDOM () % 2)	1596	if (level == 6 && rndm (2))
1699	{ /* blessing,curse properties of the god */	1597	{ /* blessing,curse properties of the god */
1700	char tmpbuf[MAX_BUF];
1701
1702	if (const char *cp = describe_resistance (god, 1))	1598	if (const char *cp = describe_resistance (god, 1))
1703	{ /* This god does have protections */	1599	{ /* This god does have protections */
1704	sprintf (tmpbuf, "\nThe priests of %s are known to be able to \n", name);	1600	buf << "The priests of " << name
		1601	<< " are known to be able to "
1705	strcat (tmpbuf, "bestow a blessing which makes the recipient\n");	1602	"bestow a blessing which makes the recipient "
1706	strcat (tmpbuf, cp);	1603	<< cp
1707	strcat (buf, tmpbuf);	1604	<< '\r';
1708	strcat (buf, "\n ---\n");
1709	}	1605	}
1710	else
1711	sprintf (buf, " ");
1712
1713	}	1606	}
1714		1607
1715	if (level == 8 && RANDOM () % 2)	1608	if (level == 8 && rndm (2))
1716	{ /* immunity, holy possession */	1609	{ /* immunity, holy possession */
		1610	buf << "The priests of " << name
		1611	<< " are known to make cast a mighty"
		1612	" prayer of possession";
		1613
		1614	int first = 1;
		1615
		1616	for (int i = 0; i < NROFATTACKS; i++)
		1617	if (god->resist[i] == 100)
		1618	{
		1619	if (first)
		1620	{
		1621	buf << " which gives the recipient";
		1622	first = 0;
		1623	}
		1624	else
		1625	buf << ", ";
		1626
		1627	buf << " immunity to " << attacktype_desc[i];
		1628	}
		1629
		1630	buf << ".\r";
		1631	}
		1632
		1633	if (level == 12 && rndm (2))
		1634	{ /* spell paths */
		1635	//TODO:
1717	int has_effect = 0, tmpvar;	1636	int has_effect = 0, tmpvar;
1718	char tmpbuf[MAX_BUF];	1637	char tmpbuf[MAX_BUF];
1719		1638
1720	sprintf (tmpbuf, "\n");
1721	sprintf (tmpbuf, "The priests of %s are known to make cast a mighty \n", name);
1722
1723	strcat (tmpbuf, "prayer of possession which gives the recipient\n");
1724
1725	for (tmpvar = 0; tmpvar < NROFATTACKS; tmpvar++)
1726	{
1727	if (god->resist[tmpvar] == 100)
1728	{
1729	has_effect = 1;
1730	sprintf (tmpbuf + strlen (tmpbuf), "Immunity to %s", attacktype_desc[tmpvar]);
1731	}
1732	}
1733
1734	if (has_effect)
1735	{
1736	strcat (buf, tmpbuf);
1737	strcat (buf, "\n ---\n");
1738	}
1739	else
1740	sprintf (buf, " ");
1741	}
1742
1743	if (level == 12 && RANDOM () % 2)
1744	{ /* spell paths */
1745	int has_effect = 0, tmpvar;
1746	char tmpbuf[MAX_BUF];
1747
1748	sprintf (tmpbuf, "\n");
1749	sprintf (tmpbuf, "It is rarely known fact that the priests of %s\n", name);	1639	sprintf (tmpbuf, "It is rarely known fact that the priests of %s\n", name);
1750	strcat (tmpbuf, "are mystically transformed. Effects of this include:\n");	1640	strcat (tmpbuf, "are mystically transformed. Effects of this include:\n");
1751		1641
1752	if ((tmpvar = god->path_attuned))	1642	if ((tmpvar = god->path_attuned))
1753	{	1643	{
…		…
1766	has_effect = 1;	1656	has_effect = 1;
1767	DESCRIBE_PATH (tmpbuf, tmpvar, "Denied");	1657	DESCRIBE_PATH (tmpbuf, tmpvar, "Denied");
1768	}	1658	}
1769		1659
1770	if (has_effect)	1660	if (has_effect)
1771	{	1661	buf << tmpbuf << '\r';
1772	strcat (buf, tmpbuf);
1773	strcat (buf, "\n ---\n");
1774	}
1775	else	1662	else
1776	sprintf (buf, " ");	1663	buf << '\r';
1777	}	1664	}
1778		1665
1779	/* check to be sure new buffer size dont exceed either
1780	* the maximum buffer size, or the 'natural' size of the
1781	* book...
1782	*/
1783	if (book_overflow (retbuf, buf, booksize))
1784	break;
1785	else if (strlen (buf) > 1)
1786	strcat (retbuf, buf);
1787
1788	level--;	1666	level--;
1789	}	1667	}
1790		1668
1791	if (strlen (retbuf) == introlen)	1669	if (buf.size () == introlen)
1792	{ /* we got no information beyond the preamble! */	1670	/* we got no information beyond the preamble! */
1793	strcat (retbuf, " [Unfortunately the rest of the information is\n");	1671	buf << "[Unfortunately the rest of the information is hopelessly garbled!]";
1794	strcat (retbuf, " hopelessly garbled!]\n ---\n");	1672
1795	}
1796	#ifdef BOOK_MSG_DEBUG
1797	LOG (llevDebug, "\n god_info_msg() created strng: %d\n", strlen (retbuf));
1798	fprintf (logfile, " MADE THIS:\n%s", retbuf);
1799	#endif
1800	return retbuf;	1673	return buf;
1801	}	1674	}
1802		1675
1803	/* tailor_readable_ob()- The main routine. This chooses a random	1676	/* tailor_readable_ob()- The main routine. This chooses a random
1804	* message to put in given readable object (type==BOOK) which will	1677	* message to put in given readable object (type==BOOK) which will
1805	* be referred hereafter as a 'book'. We use the book level to de-	1678	* be referred hereafter as a 'book'. We use the book level to de-
1806	* termine the value of the information we will insert. Higher	1679	* termine the value of the information we will insert. Higher
1807	* values mean the book will (generally) have better/more info.	1680	* values mean the book will (generally) have better/more info.
1808	* See individual cases as to how this will be utilized.	1681	* See individual cases as to how this will be utilized.
1809	* "Book" name/content length are based on the weight of the	1682	* "Book" name/content length are based on the weight of the
1810	* document. If the value of msg_type is negative, we will randomly	1683	* document. If the value of msg_type is negative, we will randomly
1811	* choose the kind of message to generate.	1684	* choose the kind of message to generate.
1812	* -b.t. thomas@astro.psu.edu	1685	* -b.t. thomas@astro.psu.edu
1813	*	1686	*
1814	* book is the object we are creating into.	1687	* book is the object we are creating into.
1815	* If msg_type is a positive value, we use that to determine the	1688	* If msg_type is a positive value, we use that to determine the
1816	* message type - otherwise a random value is used.	1689	* message type - otherwise a random value is used.
1817	*	1690	*
1818	*/	1691	*/
1819	void	1692	void
1820	tailor_readable_ob (object *book, int msg_type)	1693	tailor_readable_ob (object *book, int msg_type)
1821	{	1694	{
1822	char msgbuf[BOOK_BUF];
1823	int level = book->level ? (RANDOM () % book->level) + 1 : 1;	1695	int level = book->level ? rndm (book->level) + 1 : 1;
1824	int book_buf_size;
1825		1696
1826	/* safety */	1697	/* safety */
1827	if (book->type != BOOK)	1698	if (book->type != BOOK)
1828	return;	1699	return;
1829		1700
1830	if (level <= 0)	1701	if (level <= 0)
1831	return; /* if no level no point in doing any more... */	1702	return; /* if no level no point in doing any more... */
1832
1833	/* Max text length this book can have. */
1834	book_buf_size = BOOKSIZE (book);
1835		1703
1836	/* &&& The message switch &&& */	1704	/* &&& The message switch &&& */
1837	/* Below all of the possible types of messages in the "book"s.	1705	/* Below all of the possible types of messages in the "book"s.
1838	*/	1706	*/
1839	/*	1707	/*
…		…
1842	* 2) make sure there is an entry in max_titles[] array.	1710	* 2) make sure there is an entry in max_titles[] array.
1843	* 3) make sure there are entries for your case in new_text_title()	1711	* 3) make sure there are entries for your case in new_text_title()
1844	* and add_authour().	1712	* and add_authour().
1845	* 4) you may want separate authour/book name arrays in read.h	1713	* 4) you may want separate authour/book name arrays in read.h
1846	*/	1714	*/
1847		1715	const char *new_msg = "";
1848	msg_type = msg_type > 0 ? msg_type : (RANDOM () % 6);	1716	msg_type = msg_type > 0 ? msg_type : rndm (8);
1849	switch (msg_type)	1717	switch (msg_type)
1850	{	1718	{
1851	case 1: /* monster attrib */	1719	case 1: /* monster attrib */
1852	strcpy (msgbuf, mon_info_msg (level, book_buf_size));	1720	new_msg = mon_info_msg (level);
1853	break;	1721	break;
1854	case 2: /* artifact attrib */	1722	case 2: /* artifact attrib */
1855	strcpy (msgbuf, artifact_msg (level, book_buf_size));	1723	new_msg = artifact_msg (level);
1856	break;	1724	break;
1857	case 3: /* grouping incantations/prayers by path */	1725	case 3: /* grouping incantations/prayers by path */
1858	strcpy (msgbuf, spellpath_msg (level, book_buf_size));	1726	new_msg = spellpath_msg (level);
1859	break;	1727	break;
1860	case 4: /* describe an alchemy formula */	1728	case 4: /* describe an alchemy formula */
1861	make_formula_book (book, level);	1729	make_formula_book (book, level);
1862	/* make_formula_book already gives title */	1730	/* make_formula_book already gives title */
1863	return;	1731	return;
1864	break;
1865	case 5: /* bits of information about a god */	1732	case 5: /* bits of information about a god */
1866	strcpy (msgbuf, god_info_msg (level, book_buf_size));	1733	new_msg = god_info_msg (level);
1867	break;	1734	break;
1868	case 0: /* use info list in lib/ */	1735	case 0: /* use info list in lib/ */
1869	default:	1736	default:
1870	cfperl_make_book (book, level);	1737	cfperl_make_book (book, level);
		1738	/* already gives title */
1871	return;	1739	return;
1872	}	1740	}
1873		1741
1874	strcat (msgbuf, "\n"); /* safety -- we get ugly map saves/crashes w/o this */
1875
1876	if (strlen (msgbuf) > 1)	1742	if (strlen (new_msg) > 1)
1877	{	1743	{
1878	book->msg = msgbuf;	1744	book->msg = new_msg;
1879	/* lets give the "book" a new name, which may be a compound word */	1745	/* lets give the "book" a new name, which may be a compound word */
1880	change_book (book, msg_type);	1746	change_book (book, msg_type);
1881	}	1747	}
1882
1883	}	1748	}
1884
1885
1886	/*****************************************************************************
1887	*
1888	* Cleanup routine for readble stuff.
1889	*
1890	*****************************************************************************/
1891
1892	void
1893	free_all_readable (void)
1894	{
1895	titlelist *tlist, *tnext;
1896	title *title1, *titlenext;
1897	linked_char *lmsg, *nextmsg;
1898	objectlink *monlink, *nextmon;
1899
1900	LOG (llevDebug, "freeing all book information\n");
1901
1902	for (tlist = booklist; tlist != NULL; tlist = tnext)
1903	{
1904	tnext = tlist->next;
1905
1906	for (title1 = tlist->first_book; title1; title1 = titlenext)
1907	{
1908	titlenext = title1->next;
1909	delete title1;
1910	}
1911
1912	delete tlist;
1913	}
1914
1915	for (lmsg = first_msg; lmsg; lmsg = nextmsg)
1916	{
1917	nextmsg = lmsg->next;
1918	delete lmsg;
1919	}
1920
1921	for (monlink = first_mon_info; monlink; monlink = nextmon)
1922	{
1923	nextmon = monlink->next;
1924	delete monlink;
1925	}
1926	}
1927
1928		1749
1929	/*****************************************************************************	1750	/*****************************************************************************
1930	*	1751	*
1931	* Writeback routine for updating the bookarchive.	1752	* Writeback routine for updating the bookarchive.
1932	*	1753	*
1933	****************************************************************************/	1754	****************************************************************************/
1934
1935	/* write_book_archive() - write out the updated book archive */	1755	/* write_book_archive() - write out the updated book archive */
1936
1937	void	1756	void
1938	write_book_archive (void)	1757	write_book_archive ()
1939	{	1758	{
1940	FILE *fp;	1759	FILE *fp;
1941	int index = 0;	1760	int index = 0;
1942	char fname[MAX_BUF];	1761	char fname[MAX_BUF];
1943	title *book = NULL;	1762	title *book = NULL;
1944	titlelist *bl = get_titlelist (0);	1763	titlelist *bl = get_titlelist (0);
1945		1764
1946	/* If nothing changed, don't write anything */	1765	/* If nothing changed, don't write anything */
1947	if (!need_to_write_bookarchive)	1766	if (!need_to_write_bookarchive)
1948	return;	1767	return;
		1768
1949	need_to_write_bookarchive = 0;	1769	need_to_write_bookarchive = 0;
1950		1770
1951	sprintf (fname, "%s/bookarch", settings.localdir);	1771	sprintf (fname, "%s/bookarch", settings.localdir);
1952	LOG (llevDebug, "Updating book archive: %s...\n", fname);	1772	LOG (llevDebug, "Updating book archive: %s...\n", fname);
1953		1773
1954	if ((fp = fopen (fname, "w")) == NULL)	1774	if ((fp = fopen (fname, "w")) == NULL)
1955	{
1956	LOG (llevDebug, "Can't open book archive file %s\n", fname);	1775	LOG (llevDebug, "Can't open book archive file %s\n", fname);
1957	}
1958	else	1776	else
1959	{	1777	{
1960	while (bl)	1778	while (bl)
1961	{	1779	{
1962	for (book = bl->first_book; book; book = book->next)	1780	for (book = bl->first_book; book; book = book->next)
…		…
1969	fprintf (fp, "type %d\n", index);	1787	fprintf (fp, "type %d\n", index);
1970	fprintf (fp, "size %d\n", book->size);	1788	fprintf (fp, "size %d\n", book->size);
1971	fprintf (fp, "index %d\n", book->msg_index);	1789	fprintf (fp, "index %d\n", book->msg_index);
1972	fprintf (fp, "end\n");	1790	fprintf (fp, "end\n");
1973	}	1791	}
		1792
1974	bl = bl->next;	1793	bl = bl->next;
1975	index++;	1794	index++;
1976	}	1795	}
		1796
1977	fclose (fp);	1797	fclose (fp);
1978	chmod (fname, SAVE_MODE);	1798	chmod (fname, SAVE_MODE);
1979	}	1799	}
1980	}	1800	}
		1801
1981	readable_message_type *	1802	readable_message_type *
1982	get_readable_message_type (object *readable)	1803	get_readable_message_type (object *readable)
1983	{	1804	{
1984	uint8 subtype = readable->subtype;	1805	uint8 subtype = readable->subtype;
1985		1806

Diff Legend

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