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

Diff Legend

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