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.9 by root, Thu Sep 14 22:34:00 2006 UTC vs.
Revision 1.47 by root, Thu Oct 15 23:24:38 2009 UTC

1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3		3	*
		4	* Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
8	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
9	the Free Software Foundation; either version 2 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
10	(at your option) any later version.	11	* option) any later version.
11		12	*
12	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,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	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
18	along with this program; if not, write to the Free Software	19	* and the GNU General Public License along with this program. If not, see
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* <http://www.gnu.org/licenses/>.
20		21	*
21	The authors can be reached via e-mail at <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23
24		24
25	/* This file contains code relevant to the BOOKS hack -- designed	25	/* This file contains code relevant to the BOOKS hack -- designed
26	* to allow randomly occuring messages in non-magical texts.	26	* to allow randomly occuring messages in non-magical texts.
27	*/	27	*/
28		28
…		…
30		30
31	#include <global.h>	31	#include <global.h>
32	#include <book.h>	32	#include <book.h>
33	#include <living.h>	33	#include <living.h>
34	#include <spells.h>	34	#include <spells.h>
35
36		35
37	/* Define this if you want to archive book titles by contents.	36	/* Define this if you want to archive book titles by contents.
38	* This option should enforce UNIQUE combinations of titles,authors and	37	* This option should enforce UNIQUE combinations of titles,authors and
39	* msg contents during and *between* game sessions.	38	* msg contents during and *between* game sessions.
40	* 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
…		…
110	* pointers to all (hostile) monster objects */	109	* pointers to all (hostile) monster objects */
111		110
112	static int nrofmon = 0, need_to_write_bookarchive = 0;	111	static int nrofmon = 0, need_to_write_bookarchive = 0;
113		112
114		113
115	/* this is needed to keep track of status of initialization	114	/* this is needed to keep track of status of initialisation
116	* of the message file */	115	* of the message file */
117	static int nrofmsg = 0;	116	static int nrofmsg = 0;
118		117
119	/* first_msg is the started of the linked list of messages as read from	118	/* first_msg is the started of the linked list of messages as read from
120	* the messages file	119	* the messages file
…		…
187	{"Shield", SHIELD},	186	{"Shield", SHIELD},
188	{"Bracers", BRACERS},	187	{"Bracers", BRACERS},
189	{"Boots", BOOTS},	188	{"Boots", BOOTS},
190	{"Cloak", CLOAK},	189	{"Cloak", CLOAK},
191	{"Gloves", GLOVES},	190	{"Gloves", GLOVES},
192	{"Gridle", GIRDLE},	191	{"Girdle", GIRDLE},
193	{"Ring", RING},	192	{"Ring", RING},
194	{"Horn", HORN},	193	{"Horn", HORN},
195	{"Missile Weapon", BOW},	194	{"Missile Weapon", BOW},
196	{"Missile", ARROW},	195	{"Missile", ARROW},
197	{"Hand Weapon", WEAPON},	196	{"Hand Weapon", WEAPON},
…		…
435	* Be careful to keep the order. If you add readable subtype, add them	434	* Be careful to keep the order. If you add readable subtype, add them
436	* at the bottom of the list. Never delete a subtype because index is used as	435	* at the bottom of the list. Never delete a subtype because index is used as
437	* subtype paramater in arch files!	436	* subtype paramater in arch files!
438	*/	437	*/
439	static readable_message_type readable_message_types[] = {	438	static readable_message_type readable_message_types[] = {
440	/*subtype 0 */ {0, 0},	439	/*subtype 0 */ {0, 0, "info"},
441	/* book messages subtypes */	440	/* book messages subtypes */
442	/*subtype 1 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_1},	441	/*subtype 1 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_1, "readable-book-clasp-1"},
443	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_2},	442	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_2, "readable-book-clasp-2"},
444	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_1},	443	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_1, "readable-book-elegant-1"},
445	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_2},	444	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_2, "readable-book-elegant-2"},
446	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_1},	445	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_1, "readable-book-quarto-1"},
447	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_2},	446	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_2, "readable-book-quarto-2"},
448	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_EVOKER},	447	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_EVOKER, "readable-book-spell-evocation"},
449	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PRAYER},	448	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PRAYER, "readable-book-spell-praying"},
450	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PYRO},	449	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PYRO, "readable-book-spell-pyromancy"},
451	/*subtype 10 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SORCERER},	450	/*subtype 10 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SORCERER, "readable-book-spell-sorcery"},
452	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SUMMONER},	451	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SUMMONER, "readable-book-spell-summoning"},
453	/* card messages subtypes */	452	/* card messages subtypes */
454	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_1},	453	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_1, "readable-card-simple-1"},
455	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_2},	454	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_2, "readable-card-simple-2"},
456	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_3},	455	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_3, "readable-card-simple-3"},
457	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_1},	456	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_1, "readable-card-elegant-1"},
458	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_2},	457	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_2, "readable-card-elegant-2"},
459	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_3},	458	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_3, "readable-card-elegant-3"},
460	{MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_1},	459	{MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_1, "readable-card-strange-1"},
461	{MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_2},	460	{MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_2, "readable-card-strange-2"},
462	/*subtype 20 */ {MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_3},	461	/*subtype 20 */ {MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_3, "readable-card-strange-3"},
463	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_1},	462	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_1, "readable-card-money-1"},
464	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_2},	463	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_2, "readable-card-money-2"},
465	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_3},	464	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_3, "readable-card-money-3"},
466		465
467	/* Paper messages subtypes */	466	/* Paper messages subtypes */
468	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_1},	467	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_1, "readable-paper-note-1"},
469	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_2},	468	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_2, "readable-paper-note-2"},
470	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_3},	469	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_3, "readable-paper-note-3"},
471	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_1},	470	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_1, "readable-paper-letter-old-1"},
472	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_2},	471	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_2, "readable-paper-letter-old-2"},
473	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_1},	472	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_1, "readable-paper-letter-new-1"},
474	/*subtype 30 */ {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_2},	473	/*subtype 30 */ {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_2, "readable-paper-letter-new-2"},
475	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_1},	474	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_1, "readable-paper-envelope-1"},
476	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_2},	475	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_2, "readable-paper-envelope-2"},
477	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_1},	476	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_1, "readable-paper-scroll-old-1"},
478	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_2},	477	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_2, "readable-paper-scroll-old-2"},
479	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_1},	478	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_1, "readable-paper-scroll-new-1"},
480	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_2},	479	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_2, "readable-paper-scroll-new-2"},
481	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_MAGIC},	480	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_MAGIC, "readable-paper-scroll-magic"},
482		481
483	/* road signs messages subtypes */	482	/* road signs messages subtypes */
484	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_BASIC},	483	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_BASIC, "readable-sign-basic"},
485	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_LEFT},	484	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_LEFT, "readable-sign-dir-left"},
486	/*subtype 40 */ {MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_RIGHT},	485	/*subtype 40 */ {MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_RIGHT, "readable-sign-dir-right"},
487	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_BOTH},	486	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_BOTH, "readable-sign-dir-both"},
488		487
489	/* stones and monument messages */	488	/* stones and monument messages */
490	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_1},	489	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_1, "readable-monument-stone-1"},
491	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_2},	490	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_2, "readable-monument-stone-2"},
492	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_3},	491	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_3, "readable-monument-stone-3"},
493	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_1},	492	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_1, "readable-monument-statue-1"},
494	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_2},	493	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_2, "readable-monument-statue-2"},
495	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_3},	494	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_3, "readable-monument-statue-3"},
496	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_1},	495	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_1, "readable-monument-gravestone-1"},
497	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_2},	496	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_2, "readable-monument-gravestone-2"},
498	/*subtype 50 */ {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_3},	497	/*subtype 50 */ {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_3, "readable-monument-gravestone-3"},
499	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_1},	498	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_1, "readable-monument-wall-1"},
500	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_2},	499	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_2, "readable-monument-wall-2"},
501	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_3}	500	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_3, "readable-monument-wall-3"}
502	};	501	};
503	int last_readable_subtype = sizeof (readable_message_types) / sizeof (readable_message_type);	502	int last_readable_subtype = sizeof (readable_message_types) / sizeof (readable_message_type);
504		503
505	static int max_titles[6] = {	504	static int max_titles[6] = {
506	((sizeof (light_book_name) / sizeof (char *)) + (sizeof (heavy_book_name) / sizeof (char *))) * (sizeof (book_author) / sizeof (char *)),	505	((sizeof (light_book_name) / sizeof (char *)) + (sizeof (heavy_book_name) / sizeof (char *))) * (sizeof (book_author) / sizeof (char *)),
…		…
570	* (shstr.c ?), but the quantity BOOK_BUF will need to be defined. */	569	* (shstr.c ?), but the quantity BOOK_BUF will need to be defined. */
571		570
572	/* nstrtok() - simple routine to return the number of list	571	/* nstrtok() - simple routine to return the number of list
573	* items in buf1 as separated by the value of buf2	572	* items in buf1 as separated by the value of buf2
574	*/	573	*/
575		574	static int
576	int
577	nstrtok (const char *buf1, const char *buf2)	575	nstrtok (const char *buf1, const char *buf2)
578	{	576	{
579	char *tbuf, sbuf[12], buf[MAX_BUF];	577	char *tbuf, sbuf[12], buf[MAX_BUF];
580	int number = 0;	578	int number = 0;
581		579
…		…
594		592
595	/* strtoktolin() - takes a string in buf1 and separates it into	593	/* strtoktolin() - takes a string in buf1 and separates it into
596	* a list of strings delimited by buf2. Then returns a comma	594	* a list of strings delimited by buf2. Then returns a comma
597	* separated string w/ decent punctuation.	595	* separated string w/ decent punctuation.
598	*/	596	*/
599		597	static char *
600	char *
601	strtoktolin (const char *buf1, const char *buf2)	598	strtoktolin (const char *buf1, const char *buf2)
602	{	599	{
603	int maxi, i = nstrtok (buf1, buf2);	600	int maxi, i = nstrtok (buf1, buf2);
604	char *tbuf, buf[MAX_BUF], sbuf[12];	601	char *tbuf, buf[MAX_BUF], sbuf[12];
605	static char rbuf[BOOK_BUF];	602	static char rbuf[BOOK_BUF];
…		…
622	tbuf = strtok (NULL, sbuf);	619	tbuf = strtok (NULL, sbuf);
623	}	620	}
624	return (char *) rbuf;	621	return (char *) rbuf;
625	}	622	}
626		623
627	int	624	static int
628	book_overflow (const char *buf1, const char *buf2, int booksize)	625	book_overflow (const char *buf1, const char *buf2, int booksize)
629	{	626	{
630
631	if (buf_overflow (buf1, buf2, BOOK_BUF - 2) /* 2 less so always room for trailing \n */	627	if (buf_overflow (buf1, buf2, BOOK_BUF - 2) /* 2 less so always room for trailing \n */
632	|| buf_overflow (buf1, buf2, booksize))	628	|| buf_overflow (buf1, buf2, booksize))
633	return 1;	629	return 1;
		630
634	return 0;	631	return 0;
635
636
637	}	632	}
638		633
639	/*****************************************************************************	634	/*****************************************************************************
640	*	635	*
641	* Start of initialization related functions.	636	* Start of initialisation related functions.
642	*	637	*
643	****************************************************************************/	638	****************************************************************************/
644		639
645	/* init_msgfile() - if not called before, initialize the info list
646	* reads the messages file into the list pointed to by first_msg
647	*/
648
649	static void
650	init_msgfile (void)
651	{
652	FILE *fp;
653	char buf[MAX_BUF], msgbuf[HUGE_BUF], fname[MAX_BUF], *cp;
654	int comp;
655	static int did_init_msgfile;
656
657	if (did_init_msgfile)
658	return;
659	did_init_msgfile = 1;
660
661	sprintf (fname, "%s/messages", settings.datadir);
662	LOG (llevDebug, "Reading messages from %s...", fname);
663
664	if ((fp = open_and_uncompress (fname, 0, &comp)) != NULL)
665	{
666	linked_char *tmp = NULL;
667
668	while (fgets (buf, MAX_BUF, fp) != NULL)
669	{
670	if (*buf == '#')
671	continue;
672	if ((cp = strchr (buf, '\n')) != NULL)
673	*cp = '\0';
674	cp = buf;
675	while (*cp == ' ') /* Skip blanks */
676	cp++;
677	if (!strncmp (cp, "ENDMSG", 6))
678	{
679	if (strlen (msgbuf) > BOOK_BUF)
680	{
681	LOG (llevDebug, "Warning: this string exceeded max book buf size:");
682	LOG (llevDebug, " %s", msgbuf);
683	}
684	tmp->name = msgbuf;
685	tmp->next = first_msg;
686	first_msg = tmp;
687	nrofmsg++;
688	continue;
689	}
690	else if (!strncmp (cp, "MSG", 3))
691	{
692	tmp = new linked_char;
693
694	strcpy (msgbuf, " "); /* reset msgbuf for new message */
695	continue;
696	}
697	else if (!buf_overflow (msgbuf, cp, HUGE_BUF - 1))
698	{
699	strcat (msgbuf, cp);
700	strcat (msgbuf, "\n");
701	}
702	}
703	close_and_delete (fp, comp);
704	}
705
706	#ifdef BOOK_MSG_DEBUG
707	LOG (llevDebug, "\ninit_info_listfile() got %d messages.\n", nrofmsg);
708	#endif
709	LOG (llevDebug, "done.\n");
710	}
711
712
713	/* init_book_archive() - if not called before, initialize the info list	640	/* init_book_archive() - if not called before, initialise the info list
714	* This reads in the bookarch file into memory. bookarch is the file	641	* This reads in the bookarch file into memory. bookarch is the file
715	* created and updated across multiple runs of the program.	642	* created and updated across multiple runs of the program.
716	*/	643	*/
717
718	static void	644	static void
719	init_book_archive (void)	645	init_book_archive (void)
720	{	646	{
721	FILE *fp;	647	FILE *fp;
722	int comp, nroftitle = 0;	648	int comp, nroftitle = 0;
…		…
788	book->next = bl->first_book;	714	book->next = bl->first_book;
789	bl->first_book = book;	715	bl->first_book = book;
790	bl->number++;	716	bl->number++;
791	}	717	}
792	}	718	}
793	LOG (llevDebug, " book archives(used/avail): ");	719	LOG (llevDebug, "book archives(used/avail): \n");
794	for (bl = booklist, i = 0; bl != NULL && i < sizeof (max_titles) / sizeof (*max_titles); bl = bl->next, i++)	720	for (bl = booklist, i = 0; bl != NULL && i < sizeof (max_titles) / sizeof (*max_titles); bl = bl->next, i++)
795	{	721	{
796	LOG (llevDebug, "(%d/%d)", bl->number, max_titles[i]);	722	LOG (llevDebug, " (%d/%d)\n", bl->number, max_titles[i]);
797	}	723	}
798	LOG (llevDebug, "\n");
799	close_and_delete (fp, comp);	724	close_and_delete (fp, comp);
800	}	725	}
801		726
802	#ifdef BOOK_MSG_DEBUG	727	#ifdef BOOK_MSG_DEBUG
803	LOG (llevDebug, "\n init_book_archive() got %d titles.\n", nroftitle);	728	LOG (llevDebug, "init_book_archive() got %d titles.\n", nroftitle);
804	#endif	729	#endif
805	LOG (llevDebug, " done.\n");	730	LOG (llevDebug, " done.\n");
806	}	731	}
807		732
808	/* init_mon_info() - creates the linked list of pointers to	733	/* init_mon_info() - creates the linked list of pointers to
…		…
815	archetype *at;	740	archetype *at;
816	static int did_init_mon_info = 0;	741	static int did_init_mon_info = 0;
817		742
818	if (did_init_mon_info)	743	if (did_init_mon_info)
819	return;	744	return;
		745
820	did_init_mon_info = 1;	746	did_init_mon_info = 1;
821		747
822		748	for_all_archetypes (at)
823	for (at = first_archetype; at != NULL; at = at->next)
824	{	749	{
825	if (QUERY_FLAG (&at->clone, FLAG_MONSTER) && (!QUERY_FLAG (&at->clone, FLAG_CHANGING) || QUERY_FLAG (&at->clone, FLAG_UNAGGRESSIVE)))	750	if (QUERY_FLAG (at, FLAG_MONSTER) && (!QUERY_FLAG (at, FLAG_CHANGING) || QUERY_FLAG (at, FLAG_UNAGGRESSIVE)))
826	{	751	{
827	objectlink *mon = (objectlink *) malloc (sizeof (objectlink));	752	objectlink *mon = new objectlink;
828		753
829	mon->ob = &at->clone;	754	mon->ob = at;
830	mon->id = nrofmon;
831	mon->next = first_mon_info;	755	mon->next = first_mon_info;
832	first_mon_info = mon;	756	first_mon_info = mon;
833	nrofmon++;	757	nrofmon++;
834	}	758	}
835	}	759	}
		760
836	LOG (llevDebug, "init_mon_info() got %d monsters\n", nrofmon);	761	LOG (llevDebug, "init_mon_info() got %d monsters\n", nrofmon);
837	}	762	}
838		763
839
840	/* init_readable() - initialize linked lists utilized by	764	/* init_readable() - initialise linked lists utilized by
841	* message functions in tailor_readable_ob()	765	* message functions in tailor_readable_ob()
842	*	766	*
843	* This is the function called by the main routine to initialize	767	* This is the function called by the main routine to initialise
844	* all the readable information.	768	* all the readable information.
845	*/	769	*/
846
847	void	770	void
848	init_readable (void)	771	init_readable (void)
849	{	772	{
850	static int did_this;	773	static int did_this;
851		774
852	if (did_this)	775	if (did_this)
853	return;	776	return;
		777
854	did_this = 1;	778	did_this = 1;
855		779
856	LOG (llevDebug, "Initializing reading data...");	780	LOG (llevDebug, "Initialising reading data...\n");
857	init_msgfile ();
858	init_book_archive ();	781	init_book_archive ();
859	init_mon_info ();	782	init_mon_info ();
860	LOG (llevDebug, " Done\n");	783	LOG (llevDebug, " Done\n");
861
862	}	784	}
863		785
864	/*****************************************************************************	786	/*****************************************************************************
865	*	787	*
866	* This is the start of the administrative functions when creating	788	* This is the start of the administrative functions when creating
867	* new books (ie, updating title and the like)	789	* new books (ie, updating title and the like)
868	*	790	*
869	*****************************************************************************/	791	*****************************************************************************/
870		792
871
872	/* find_title() - Search the titlelist (based on msgtype) to see if	793	/* find_title() - Search the titlelist (based on msgtype) to see if
873	* book matches something already there. IF so, return that title.	794	* book matches something already there. IF so, return that title.
874	*/	795	*/
875
876	static title *	796	static title *
877	find_title (const object *book, int msgtype)	797	find_title (const object *book, int msgtype)
878	{	798	{
879	title *t = NULL;	799	title *t = NULL;
880	titlelist *tl = get_titlelist (msgtype);	800	titlelist *tl = get_titlelist (msgtype);
…		…
893	else	813	else
894	t = t->next;	814	t = t->next;
895		815
896	#ifdef ARCHIVE_DEBUG	816	#ifdef ARCHIVE_DEBUG
897	if (t)	817	if (t)
898	LOG (llevDebug, "Found title match (list %d): %s %s (%d)\n", msgtype, t->name, t->authour, t->msg_index);	818	LOG (llevDebug, "Found title match (list %d): %s %s (%d)\n", msgtype, &t->name, &t->authour, t->msg_index);
899	#endif	819	#endif
900		820
901	return t;	821	return t;
902	}	822	}
903		823
…		…
905	* handled directly in change_book_name(). Names are based on text	825	* handled directly in change_book_name(). Names are based on text
906	* msgtype	826	* msgtype
907	* this sets book book->name based on msgtype given. What name	827	* this sets book book->name based on msgtype given. What name
908	* is given is based on various criteria	828	* is given is based on various criteria
909	*/	829	*/
910
911	static void	830	static void
912	new_text_name (object *book, int msgtype)	831	new_text_name (object *book, int msgtype)
913	{	832	{
914	int nbr;	833	int nbr;
915	char name[MAX_BUF];	834	char name[MAX_BUF];
…		…
917	if (book->type != BOOK)	836	if (book->type != BOOK)
918	return;	837	return;
919		838
920	switch (msgtype)	839	switch (msgtype)
921	{	840	{
922	case 1: /*monster */	841	case 1: /*monster */
923	nbr = sizeof (mon_book_name) / sizeof (char *);	842	nbr = sizeof (mon_book_name) / sizeof (char *);
924	strcpy (name, mon_book_name[RANDOM () % nbr]);	843	assign (name, mon_book_name[rndm (nbr)]);
925	break;	844	break;
926	case 2: /*artifact */	845	case 2: /*artifact */
927	nbr = sizeof (art_book_name) / sizeof (char *);	846	nbr = sizeof (art_book_name) / sizeof (char *);
928	strcpy (name, art_book_name[RANDOM () % nbr]);	847	assign (name, art_book_name[rndm (nbr)]);
929	break;	848	break;
930	case 3: /*spellpath */	849	case 3: /*spellpath */
931	nbr = sizeof (path_book_name) / sizeof (char *);	850	nbr = sizeof (path_book_name) / sizeof (char *);
932	strcpy (name, path_book_name[RANDOM () % nbr]);	851	assign (name, path_book_name[rndm (nbr)]);
933	break;	852	break;
934	case 4: /*alchemy */	853	case 4: /*alchemy */
935	nbr = sizeof (formula_book_name) / sizeof (char *);	854	nbr = sizeof (formula_book_name) / sizeof (char *);
936	strcpy (name, formula_book_name[RANDOM () % nbr]);	855	assign (name, formula_book_name[rndm (nbr)]);
937	break;	856	break;
938	case 5: /*gods */	857	case 5: /*gods */
939	nbr = sizeof (gods_book_name) / sizeof (char *);	858	nbr = sizeof (gods_book_name) / sizeof (char *);
940	strcpy (name, gods_book_name[RANDOM () % nbr]);	859	assign (name, gods_book_name[rndm (nbr)]);
941	break;	860	break;
942	case 6: /*msg file */	861	case 6: /*msg file */
943	default:	862	default:
944	if (book->weight > 2000)	863	if (book->weight > 2000)
945	{ /* based on weight */	864	{ /* based on weight */
946	nbr = sizeof (heavy_book_name) / sizeof (char *);	865	nbr = sizeof (heavy_book_name) / sizeof (char *);
947	strcpy (name, heavy_book_name[RANDOM () % nbr]);	866	assign (name, heavy_book_name[rndm (nbr)]);
948	}	867	}
949	else if (book->weight < 2001)	868	else if (book->weight < 2001)
950	{	869	{
951	nbr = sizeof (light_book_name) / sizeof (char *);	870	nbr = sizeof (light_book_name) / sizeof (char *);
952	strcpy (name, light_book_name[RANDOM () % nbr]);	871	assign (name, light_book_name[rndm (nbr)]);
953	}	872	}
954	break;	873	break;
955	}	874	}
956		875
957	book->name = name;	876	book->name = name;
958	}	877	}
959		878
…		…
971	if (msgtype < 0 || strlen (op->msg) < 5)	890	if (msgtype < 0 || strlen (op->msg) < 5)
972	return;	891	return;
973		892
974	switch (msgtype)	893	switch (msgtype)
975	{	894	{
976	case 1: /* monster */	895	case 1: /* monster */
977	nbr = sizeof (mon_author) / sizeof (char *);	896	nbr = sizeof (mon_author) / sizeof (char *);
978	strcpy (name, mon_author[RANDOM () % nbr]);	897	assign (name, mon_author[rndm (nbr)]);
979	break;	898	break;
980	case 2: /* artifacts */	899	case 2: /* artifacts */
981	nbr = sizeof (art_author) / sizeof (char *);	900	nbr = sizeof (art_author) / sizeof (char *);
982	strcpy (name, art_author[RANDOM () % nbr]);	901	assign (name, art_author[rndm (nbr)]);
983	break;	902	break;
984	case 3: /* spellpath */	903	case 3: /* spellpath */
985	nbr = sizeof (path_author) / sizeof (char *);	904	nbr = sizeof (path_author) / sizeof (char *);
986	strcpy (name, path_author[RANDOM () % nbr]);	905	assign (name, path_author[rndm (nbr)]);
987	break;	906	break;
988	case 4: /* alchemy */	907	case 4: /* alchemy */
989	nbr = sizeof (formula_author) / sizeof (char *);	908	nbr = sizeof (formula_author) / sizeof (char *);
990	strcpy (name, formula_author[RANDOM () % nbr]);	909	assign (name, formula_author[rndm (nbr)]);
991	break;	910	break;
992	case 5: /* gods */	911	case 5: /* gods */
993	nbr = sizeof (gods_author) / sizeof (char *);	912	nbr = sizeof (gods_author) / sizeof (char *);
994	strcpy (name, gods_author[RANDOM () % nbr]);	913	assign (name, gods_author[rndm (nbr)]);
995	break;	914	break;
996	case 6: /* msg file */	915	case 6: /* msg file */
997	default:	916	default:
998	strcpy (name, book_author[RANDOM () % nbr]);	917	assign (name, book_author[rndm (nbr)]);
999	}	918	}
1000		919
1001	sprintf (title, "of %s", name);	920	sprintf (title, "of %s", name);
1002	op->title = title;	921	op->title = title;
1003	}	922	}
…		…
1008	*/	927	*/
1009		928
1010	static int	929	static int
1011	unique_book (const object *book, int msgtype)	930	unique_book (const object *book, int msgtype)
1012	{	931	{
1013	title *test;
1014
1015	if (!booklist)	932	if (!booklist)
1016	return 1; /* No archival entries! Must be unique! */	933	return 1; /* No archival entries! Must be unique! */
1017		934
1018	/* Go through the booklist. If the author and name match, not unique so	935	/* Go through the booklist. If the author and name match, not unique so
1019	* return 0.	936	* return 0.
1020	*/	937	*/
1021	for (test = get_titlelist (msgtype)->first_book; test; test = test->next)	938	for (title *test = get_titlelist (msgtype)->first_book; test; test = test->next)
1022	{
1023	if (!strcmp (test->name, book->name) && !strcmp (book->title, test->authour))	939	if (test->name == book->name && book->title == test->authour)
1024	return 0;	940	return 0;
1025	}	941
1026	return 1;	942	return 1;
1027	}	943	}
1028		944
1029	/* add_book_to_list() */	945	/* add_book_to_list() */
1030		946
…		…
1043	t = get_empty_book ();	959	t = get_empty_book ();
1044	t->name = book->name;	960	t->name = book->name;
1045	t->authour = book->title;	961	t->authour = book->title;
1046	t->size = strlen (book->msg);	962	t->size = strlen (book->msg);
1047	t->msg_index = strtoint (book->msg);	963	t->msg_index = strtoint (book->msg);
1048	t->archname = book->arch->name;	964	t->archname = book->arch->archname;
1049	t->level = book->level;	965	t->level = book->level;
1050		966
1051	t->next = tl->first_book;	967	t->next = tl->first_book;
1052	tl->first_book = t;	968	tl->first_book = t;
1053	tl->number++;	969	tl->number++;
1054		970
1055	/* We have stuff we need to write now */	971	/* We have stuff we need to write now */
1056	need_to_write_bookarchive = 1;	972	need_to_write_bookarchive = 1;
1057		973
1058	#ifdef ARCHIVE_DEBUG	974	#ifdef ARCHIVE_DEBUG
1059	LOG (llevDebug, "Archiving new title: %s %s (%d)\n", book->name, book->title, msgtype);	975	LOG (llevDebug, "Archiving new title: %s %s (%d)\n", &book->name, &book->title, msgtype);
1060	#endif	976	#endif
1061		977
1062	}	978	}
1063		979
1064		980
…		…
1070	* levels and architypes. -b.t.	986	* levels and architypes. -b.t.
1071	*/	987	*/
1072		988
1073	#define MAX_TITLE_CHECK 20	989	#define MAX_TITLE_CHECK 20
1074		990
1075	void	991	static void
1076	change_book (object *book, int msgtype)	992	change_book (object *book, int msgtype)
1077	{	993	{
1078	int nbr = sizeof (book_descrpt) / sizeof (char *);	994	int nbr = sizeof (book_descrpt) / sizeof (char *);
1079		995
1080	switch (book->type)	996	switch (book->type)
1081	{	997	{
1082	case BOOK:	998	case BOOK:
1083	{	999	{
1084	titlelist *tl = get_titlelist (msgtype);	1000	titlelist *tl = get_titlelist (msgtype);
1085	title *t = NULL;	1001	title *t = NULL;
1086	int tries = 0;	1002	int tries = 0;
1087		1003
1088	/* look to see if our msg already been archived. If so, alter	1004	/* look to see if our msg already been archived. If so, alter
1089	* the book to match the archival text. If we fail to match,	1005	* the book to match the archival text. If we fail to match,
1090	* then we archive the new title/name/msg combo if there is	1006	* then we archive the new title/name/msg combo if there is
1091	* room on the titlelist.	1007	* room on the titlelist.
1092	*/	1008	*/
1093		1009
1094	if ((strlen (book->msg) > 5) && (t = find_title (book, msgtype)))	1010	if ((strlen (book->msg) > 5) && (t = find_title (book, msgtype)))
1095	{	1011	{
1096	object *tmpbook;
1097
1098	/* alter book properties */	1012	/* alter book properties */
1099	if ((tmpbook = get_archetype (t->archname)) != NULL)	1013	if (object *tmpbook = get_archetype (t->archname))
		1014	{
		1015	tmpbook->msg = book->msg;
		1016	tmpbook->copy_to (book);
		1017	tmpbook->destroy ();
		1018	}
		1019
		1020	book->title = t->authour;
		1021	book->name = t->name;
		1022	book->level = t->level;
		1023	}
		1024	/* Don't have any default title, so lets make up a new one */
		1025	else
		1026	{
		1027	int numb, maxnames = max_titles[msgtype];
		1028	const char *old_title;
		1029	const char *old_name;
		1030
		1031	old_title = book->title;
		1032	old_name = book->name;
		1033
		1034	/* some pre-generated books have title already set (from
		1035	* maps), also don't bother looking for unique title if
		1036	* we already used up all the available names! */
		1037
		1038	if (!tl)
		1039	{
		1040	LOG (llevError, "change_book_name(): can't find title list\n");
		1041	numb = 0;
		1042	}
		1043	else
		1044	numb = tl->number;
		1045
		1046	if (numb == maxnames)
		1047	{
		1048	#ifdef ARCHIVE_DEBUG
		1049	LOG (llevDebug, "titles for list %d full (%d possible).\n", msgtype, maxnames);
		1050	#endif
		1051	}
		1052	/* shouldnt change map-maker books */
		1053	else if (!book->title)
		1054	do
1100	{	1055	{
1101	tmpbook->msg = book->msg;	1056	/* random book name */
1102	copy_object (tmpbook, book);	1057	new_text_name (book, msgtype);
1103	free_object (tmpbook);	1058	add_author (book, msgtype); /* random author */
		1059	tries++;
1104	}	1060	}
		1061	while (!unique_book (book, msgtype) && tries < MAX_TITLE_CHECK);
1105		1062
1106	book->title = t->authour;	1063	/* Now deal with 2 cases.
1107	book->name = t->name;	1064	* 1)If no space for a new title exists lets just restore
1108	book->level = t->level;	1065	* the old book properties. Remember, if the book had
		1066	* matchd an older entry on the titlelist, we shouldnt
		1067	* have called this routine in the first place!
		1068	* 2) If we got a unique title, we need to add it to
		1069	* the list.
1109	}	1070	*/
1110	/* Don't have any default title, so lets make up a new one */
1111	else
1112	{
1113	int numb, maxnames = max_titles[msgtype];
1114	const char *old_title;
1115	const char *old_name;
1116		1071
1117	old_title = book->title;	1072	if (tries == MAX_TITLE_CHECK || numb == maxnames)
1118	old_name = book->name;	1073	{ /* got to check maxnames again */
1119
1120	/* some pre-generated books have title already set (from
1121	* maps), also don't bother looking for unique title if
1122	* we already used up all the available names! */
1123
1124	if (!tl)
1125	{
1126	LOG (llevError, "change_book_name(): can't find title list\n");
1127	numb = 0;
1128	}
1129	else
1130	numb = tl->number;
1131
1132	if (numb == maxnames)
1133	{
1134	#ifdef ARCHIVE_DEBUG	1074	#ifdef ARCHIVE_DEBUG
1135	LOG (llevDebug, "titles for list %d full (%d possible).\n", msgtype, maxnames);	1075	LOG (llevDebug, "Failed to obtain unique title for %s %s (names:%d/%d)\n", &book->name, &book->title, numb, maxnames);
1136	#endif	1076	#endif
1137	break;	1077	/* restore old book properties here */
1138	}	1078	book->title = old_title;
1139	/* shouldnt change map-maker books */	1079
1140	else if (!book->title)	1080	if (rndm (4))
1141	do
1142	{	1081	{
1143	/* random book name */	1082	/* Lets give the book a description to individualize it some */
1144	new_text_name (book, msgtype);	1083	char new_name[MAX_BUF];
1145	add_author (book, msgtype); /* random author */	1084
1146	tries++;	1085	snprintf (new_name, MAX_BUF, "%s %s", book_descrpt[rndm (nbr)], old_name);
		1086
		1087	book->name = new_name;
1147	}	1088	}
1148	while (!unique_book (book, msgtype) && tries < MAX_TITLE_CHECK);
1149
1150	/* Now deal with 2 cases.
1151	* 1)If no space for a new title exists lets just restore
1152	* the old book properties. Remember, if the book had
1153	* matchd an older entry on the titlelist, we shouldnt
1154	* have called this routine in the first place!
1155	* 2) If we got a unique title, we need to add it to
1156	* the list.
1157	*/
1158
1159	if (tries == MAX_TITLE_CHECK || numb == maxnames)
1160	{ /* got to check maxnames again */
1161	#ifdef ARCHIVE_DEBUG
1162	LOG (llevDebug, "Failed to obtain unique title for %s %s (names:%d/%d)\n", book->name, book->title, numb, maxnames);
1163	#endif
1164	/* restore old book properties here */
1165	book->title = old_title;
1166
1167	if (RANDOM () % 4)
1168	{
1169	/* Lets give the book a description to individualize it some */
1170	char new_name[MAX_BUF];
1171
1172	snprintf (new_name, MAX_BUF, "%s %s", book_descrpt[RANDOM () % nbr], old_name);
1173
1174	book->name = new_name;
1175	}
1176	else	1089	else
1177	{	1090	{
1178	book->name = old_name;	1091	book->name = old_name;
1179	}	1092	}
1180	}	1093	}
1181	else if (book->title && strlen (book->msg) > 5)	1094	else if (book->title && strlen (book->msg) > 5)
1182	{ /* archive if long msg texts */	1095	{ /* archive if long msg texts */
1183	add_book_to_list (book, msgtype);	1096	add_book_to_list (book, msgtype);
1184	}	1097	}
1185	}	1098	}
1186	break;	1099	break;
1187	}	1100	}
1188		1101
1189	default:	1102	default:
1190	LOG (llevError, "change_book_name() called w/ illegal obj type.\n");	1103	LOG (llevError, "change_book_name() called w/ illegal obj type.\n");
1191	return;	1104	return;
1192	}	1105	}
1193	}	1106	}
1194		1107
1195	/*****************************************************************************	1108	/*****************************************************************************
1196	*	1109	*
…		…
1207	* list of all monsters in the current game. If level is non-zero,	1120	* list of all monsters in the current game. If level is non-zero,
1208	* then only monsters greater than that level will be returned.	1121	* then only monsters greater than that level will be returned.
1209	* Changed 971225 to be greater than equal to level passed. Also	1122	* Changed 971225 to be greater than equal to level passed. Also
1210	* made choosing by level more random.	1123	* made choosing by level more random.
1211	*/	1124	*/
1212
1213	object *	1125	object *
1214	get_random_mon (int level)	1126	get_random_mon (int level)
1215	{	1127	{
1216	objectlink *mon = first_mon_info;	1128	objectlink *mon = first_mon_info;
1217	int i = 0, monnr;	1129	int i = 0, monnr;
…		…
1221	return (object *) NULL;	1133	return (object *) NULL;
1222		1134
1223	if (!level)	1135	if (!level)
1224	{	1136	{
1225	/* lets get a random monster from the mon_info linked list */	1137	/* lets get a random monster from the mon_info linked list */
1226	monnr = RANDOM () % nrofmon;	1138	monnr = rndm (nrofmon);
1227		1139
1228	for (mon = first_mon_info, i = 0; mon; mon = mon->next)	1140	for (mon = first_mon_info, i = 0; mon; mon = mon->next)
1229	if (i++ == monnr)	1141	if (i++ == monnr)
1230	break;	1142	break;
1231		1143
…		…
1258	{	1170	{
1259	LOG (llevError, "get_random_mon() couldn't return monster for level %d\n", level);	1171	LOG (llevError, "get_random_mon() couldn't return monster for level %d\n", level);
1260	return NULL;	1172	return NULL;
1261	}	1173	}
1262		1174
1263	monnr = RANDOM () % i;	1175	monnr = rndm (i);
1264	for (mon = first_mon_info; mon; mon = mon->next)	1176	for (mon = first_mon_info; mon; mon = mon->next)
1265	if (mon->ob->level >= level && monnr-- == 0)	1177	if (mon->ob->level >= level && monnr-- == 0)
1266	return mon->ob;	1178	return mon->ob;
1267		1179
1268	if (!mon)	1180	if (!mon)
…		…
1275		1187
1276	/*	1188	/*
1277	* Returns a description of the monster. This really needs to be	1189	* Returns a description of the monster. This really needs to be
1278	* redone, as describe_item really gives a pretty internal description.	1190	* redone, as describe_item really gives a pretty internal description.
1279	*/	1191	*/
1280		1192	static const char *
1281	char *
1282	mon_desc (const object *mon)	1193	mon_desc (const object *mon)
1283	{	1194	{
1284	static char retbuf[HUGE_BUF];	1195	static dynbuf_text buf; buf.clear ();
1285		1196
1286	sprintf (retbuf, " *** %s ***\n", &mon->name);	1197	buf.printf ("B<< %s >>\r", &mon->name);
1287	strcat (retbuf, describe_item (mon, NULL));	1198	buf << describe_item (mon, 0);
1288		1199
1289	return retbuf;	1200	return buf;
1290	}	1201	}
1291		1202
1292		1203
1293	/* This function returns the next monsters after 'tmp'. If no match is	1204	/* This function returns the next monsters after 'tmp'. If no match is
1294	* found, it returns NULL (changed 0.94.3 to do this, since the	1205	* found, it returns NULL (changed 0.94.3 to do this, since the
1295	* calling function (mon_info_msg) seems to expect that.	1206	* calling function (mon_info_msg) seems to expect that.
1296	*/	1207	*/
1297		1208	static object *
1298	object *
1299	get_next_mon (object *tmp)	1209	get_next_mon (object *tmp)
1300	{	1210	{
1301	objectlink *mon;	1211	objectlink *mon;
1302		1212
1303	for (mon = first_mon_info; mon; mon = mon->next)	1213	for (mon = first_mon_info; mon; mon = mon->next)
…		…
1312	else	1222	else
1313	return first_mon_info->ob;	1223	return first_mon_info->ob;
1314		1224
1315	}	1225	}
1316		1226
1317
1318
1319	/* mon_info_msg() - generate a message detailing the properties	1227	/* mon_info_msg() - generate a message detailing the properties
1320	* of a randomly selected monster.	1228	* of a randomly selected monster.
1321	*/	1229	*/
1322		1230	static const char *
1323	char *
1324	mon_info_msg (int level, int booksize)	1231	mon_info_msg (int level, int booksize)
1325	{	1232	{
1326	static char retbuf[BOOK_BUF];	1233	static dynbuf_text buf; buf.clear ();
1327	char tmpbuf[HUGE_BUF];
1328	object *tmp;
1329		1234
1330	/*preamble */	1235	/*preamble */
1331	strcpy (retbuf, "This beastiary contains:");	1236	buf << "This beastiary contains:\n";
1332		1237
1333	/* lets print info on as many monsters as will fit in our	1238	/* lets print info on as many monsters as will fit in our
1334	* document.	1239	* document.
1335	* 8-96 Had to change this a bit, otherwise there would	1240	* 8-96 Had to change this a bit, otherwise there would
1336	* have been an impossibly large number of combinations	1241	* have been an impossibly large number of combinations
1337	* of text! (and flood out the available number of titles	1242	* of text! (and flood out the available number of titles
1338	* in the archive in a snap!) -b.t.	1243	* in the archive in a snap!) -b.t.
1339	*/	1244	*/
1340	tmp = get_random_mon (level * 3);	1245	object *tmp = get_random_mon (level * 3);
1341	while (tmp)	1246	while (tmp && buf.size () < BOOK_BUF)
1342	{	1247	{
1343	/* monster description */	1248	/* monster description */
1344	sprintf (tmpbuf, "\n---\n%s", mon_desc (tmp));	1249	buf.printf ("\n%s\n", mon_desc (tmp));
1345
1346	if (!book_overflow (retbuf, tmpbuf, booksize))
1347	strcat (retbuf, tmpbuf);
1348	else
1349	break;
1350		1250
1351	/* Note that the value this returns is not based on level */	1251	/* Note that the value this returns is not based on level */
1352	tmp = get_next_mon (tmp);	1252	tmp = get_next_mon (tmp);
1353	}	1253	}
1354		1254
1355	#ifdef BOOK_MSG_DEBUG
1356	LOG (llevDebug, "\n mon_info_msg() created strng: %d\n", strlen (retbuf));
1357	fprintf (logfile, " MADE THIS:\n%s\n", retbuf);
1358	#endif
1359
1360	return retbuf;	1255	return buf;
1361	}	1256	}
1362		1257
1363		1258
1364	/*****************************************************************************	1259	/*****************************************************************************
1365	* Artifact msg generation code.	1260	* Artifact msg generation code.
1366	****************************************************************************/	1261	****************************************************************************/
1367		1262
1368	/* artifact_msg() - generate a message detailing the properties	1263	/* artifact_msg() - generate a message detailing the properties
1369	* of 1-6 artifacts drawn sequentially from the artifact list.	1264	* of 1-6 artifacts drawn sequentially from the artifact list.
1370	*/	1265	*/
1371		1266	static const char *
1372	char *
1373	artifact_msg (int level, int booksize)	1267	artifact_msg (int level, int booksize)
1374	{	1268	{
1375	artifactlist *al = NULL;	1269	artifactlist *al = NULL;
1376	artifact *art;	1270	artifact *art;
1377	int chance, i, type, index;	1271	int chance, i, type, index;
1378	int book_entries = level > 5 ? RANDOM () % 3 + RANDOM () % 3 + 2 : RANDOM () % level + 1;	1272	int book_entries = level > 5 ? rndm (3) + rndm (3) + 2 : rndm (level) + 1;
1379	char *ch, name[MAX_BUF], buf[BOOK_BUF], sbuf[MAX_BUF];	1273	const char *ch;
1380	static char retbuf[BOOK_BUF];	1274	char name[MAX_BUF];
1381	object *tmp = NULL;	1275	object *tmp = NULL;
		1276
		1277	static dynbuf_text buf; buf.clear ();
1382		1278
1383	/* values greater than 5 create msg buffers that are too big! */	1279	/* values greater than 5 create msg buffers that are too big! */
1384	if (book_entries > 5)	1280	if (book_entries > 5)
1385	book_entries = 5;	1281	book_entries = 5;
1386		1282
…		…
1390	* for that type exists!	1286	* for that type exists!
1391	*/	1287	*/
1392	i = 0;	1288	i = 0;
1393	do	1289	do
1394	{	1290	{
1395	index = RANDOM () % (sizeof (art_name_array) / sizeof (arttypename));	1291	index = rndm (sizeof (art_name_array) / sizeof (arttypename));
1396	type = art_name_array[index].type;	1292	type = art_name_array[index].type;
1397	al = find_artifactlist (type);	1293	al = find_artifactlist (type);
1398	i++;	1294	i++;
1399	}	1295	}
1400	while ((al == NULL) && (i < 10));	1296	while ((al == NULL) && (i < 10));
1401		1297
1402	if (i == 10) /* Unable to find a message */	1298	if (i == 10) /* Unable to find a message */
1403	return ("None");	1299	return "None";
1404		1300
1405	/* There is no reason to start on the artifact list at the begining. Lets	1301	/* There is no reason to start on the artifact list at the begining. Lets
1406	* take our starting position randomly... */	1302	* take our starting position randomly... */
1407	art = al->items;	1303	art = al->items;
1408	for (i = RANDOM () % level + RANDOM () % 2 + 1; i > 0; i--)	1304	for (i = rndm (level) + rndm (2) + 1; i > 0; i--)
1409	{	1305	{
1410	if (art == NULL)	1306	if (!art)
1411	art = al->items; /* hmm, out of stuff, loop back around */	1307	art = al->items; /* hmm, out of stuff, loop back around */
		1308
1412	art = art->next;	1309	art = art->next;
1413	}	1310	}
1414		1311
1415	/* the base 'generic' name for our artifact */	1312	/* the base 'generic' name for our artifact */
1416	strcpy (name, art_name_array[index].name);	1313	assign (name, art_name_array[index].name);
1417		1314
1418	/* Ok, lets print out the contents */	1315	/* Ok, lets print out the contents */
1419	sprintf (retbuf, "Herein %s detailed %s...\n", book_entries > 1 ? "are" : "is", book_entries > 1 ? "some artifacts" : "an artifact");	1316	buf.printf ("Herein %s detailed %s...\n",
		1317	book_entries > 1 ? "are" : "is",
		1318	book_entries > 1 ? "some artifacts" : "an artifact");
1420		1319
1421	/* artifact msg attributes loop. Lets keep adding entries to the 'book'	1320	/* artifact msg attributes loop. Lets keep adding entries to the 'book'
1422	* as long as we have space up to the allowed max # (book_entires)	1321	* as long as we have space up to the allowed max # (book_entires)
1423	*/	1322	*/
1424	while (book_entries > 0)	1323	while (book_entries > 0 && buf.size () < BOOK_BUF)
1425	{	1324	{
1426		1325
1427	if (art == NULL)	1326	if (!art)
1428	art = al->items;	1327	art = al->items;
1429		1328
1430	/* separator of items */	1329	buf << '\n';
1431	strcpy (buf, "--- \n");
1432		1330
1433	/* Name */	1331	/* Name */
1434	if (art->allowed != NULL && strcmp (art->allowed->name, "All"))	1332	if (art->allowed && art->allowed->name != shstr_All)
1435	{	1333	{
1436	linked_char *temp, *next = art->allowed;	1334	linked_char *temp, *next = art->allowed;
1437		1335
1438	do	1336	do
1439	{	1337	{
1440	temp = next;	1338	temp = next;
1441	next = next->next;	1339	next = next->next;
1442	}	1340	}
1443	while (next && !RANDOM () % 2);	1341	while (next && rndm (2));
		1342
1444	sprintf (buf, "%s A %s of %s", buf, &temp->name, &art->item->name);	1343	buf.printf ("A B<< %s of %s >>", &temp->name, &art->item->name);
1445	}	1344	}
1446	else /* default name is used */	1345	else /* default name is used */
1447	sprintf (buf, "%s The %s of %s", buf, name, &art->item->name);	1346	buf.printf ("The B<< %s of %s >>", name, &art->item->name);
		1347
		1348	buf << " is ";
1448		1349
1449	/* chance of finding */	1350	/* chance of finding */
1450	chance = (int) (100 * ((float) art->chance / al->total_chance));	1351	chance = (int) (100 * ((float) art->chance / al->total_chance));
1451	if (chance >= 20)	1352	if (chance >= 20)
1452	sprintf (sbuf, "an uncommon");	1353	buf << "an uncommon";
1453	else if (chance >= 10)	1354	else if (chance >= 10)
1454	sprintf (sbuf, "an unusual");	1355	buf << "an unusual";
1455	else if (chance >= 5)	1356	else if (chance >= 5)
1456	sprintf (sbuf, "a rare");	1357	buf << "a rare";
1457	else	1358	else
1458	sprintf (sbuf, "a very rare");	1359	buf << "a very rare";
1459	sprintf (buf, "%s is %s\n", buf, sbuf);
1460		1360
1461	/* value of artifact */	1361	/* value of artifact */
1462	sprintf (buf, "%s item with a value that is %d times normal.\n", buf, art->item->value);	1362	buf << " item with a value that is " << art->item->value << " times normal.\n";
1463		1363
1464	/* include the message about the artifact, if exists, and book	1364	/* include the message about the artifact, if exists, and book
1465	* level is kinda high */	1365	* level is kinda high */
1466	if (art->item->msg && (RANDOM () % 4 + 1) < level && !((strlen (art->item->msg) + strlen (buf)) > BOOK_BUF))	1366	if (art->item->msg
		1367	&& rndm (4) + 1 < level)
1467	strcat (buf, art->item->msg);	1368	buf << art->item->msg;
1468		1369
1469	/* properties of the artifact */	1370	/* properties of the artifact */
1470	tmp = get_object ();	1371	tmp = object::create ();
1471	add_abilities (tmp, art->item);	1372	add_abilities (tmp, art->item);
1472	tmp->type = type;	1373	tmp->type = type;
1473	SET_FLAG (tmp, FLAG_IDENTIFIED);	1374	SET_FLAG (tmp, FLAG_IDENTIFIED);
1474	if ((ch = describe_item (tmp, NULL)) != NULL && strlen (ch) > 1)	1375	if ((ch = describe_item (tmp, 0)) && strlen (ch) > 1)
1475	sprintf (buf, "%s Properties of this artifact include: \n %s \n", buf, ch);	1376	buf << "\rProperties of this artifact include:\r" << ch << "\n";
1476	free_object (tmp);	1377
1477	/* add the buf if it will fit */	1378	tmp->destroy ();
1478	if (!book_overflow (retbuf, buf, booksize))
1479	strcat (retbuf, buf);
1480	else
1481	break;
1482		1379
1483	art = art->next;	1380	art = art->next;
1484	book_entries--;	1381	book_entries--;
1485	}	1382	}
1486		1383
1487	#ifdef BOOK_MSG_DEBUG
1488	LOG (llevDebug, "artifact_msg() created strng: %d\n", strlen (retbuf));
1489	fprintf (logfile, " MADE THIS:\n%s", retbuf);
1490	#endif
1491	return retbuf;	1384	return buf;
1492	}	1385	}
1493		1386
1494	/*****************************************************************************	1387	/*****************************************************************************
1495	* Spellpath message generation	1388	* Spellpath message generation
1496	*****************************************************************************/	1389	*****************************************************************************/
1497		1390
1498	/* spellpath_msg() - generate a message detailing the member	1391	/* spellpath_msg() - generate a message detailing the member
1499	* incantations/prayers (and some of their properties) belonging to	1392	* incantations/prayers (and some of their properties) belonging to
1500	* a given spellpath.	1393	* a given spellpath.
1501	*/	1394	*/
1502		1395	static char *
1503	char *
1504	spellpath_msg (int level, int booksize)	1396	spellpath_msg (int level, int booksize)
1505	{	1397	{
		1398	static dynbuf_text buf; buf.clear ();
		1399
1506	static char retbuf[BOOK_BUF];	1400	static char retbuf[BOOK_BUF];
1507	char tmpbuf[BOOK_BUF];	1401	char tmpbuf[BOOK_BUF];
1508	int path = RANDOM () % NRSPELLPATHS, prayers = RANDOM () % 2;	1402	int path = rndm (NRSPELLPATHS), prayers = rndm (2);
1509	int did_first_sp = 0;
1510	uint32 pnum = (path == -1) ? PATH_NULL : spellpathdef[path];	1403	uint32 pnum = (path == -1) ? PATH_NULL : spellpathdef[path];
1511	archetype *at;	1404	archetype *at;
1512		1405
1513	/* Preamble */	1406	/* Preamble */
1514	sprintf (retbuf, "Herein are detailed the names of %s\n", prayers ? "prayers" : "incantations");	1407	buf << "Herein are detailed the names of "
		1408	<< (prayers ? "prayers" : "incantations");
1515		1409
1516	if (path == -1)	1410	if (path == -1)
1517	strcat (retbuf, "having no known spell path.\n");	1411	buf << " having no known spell path.\n";
1518	else	1412	else
1519	sprintf (retbuf, "%sbelonging to the path of %s:\n", retbuf, spellpathnames[path]);	1413	buf << " belonging to the path of B<< " << spellpathnames[path] << " >>:\n\n";
1520		1414
1521	for (at = first_archetype; at != NULL; at = at->next)	1415	int seen = 0;
1522	{	1416
		1417	for_all_archetypes (at)
1523	/* Determine if this is an appropriate spell. Must	1418	/* Determine if this is an appropriate spell. Must
1524	* be of matching path, must be of appropriate type (prayer	1419	* be of matching path, must be of appropriate type (prayer
1525	* or not), and must be within the valid level range.	1420	* or not), and must be within the valid level range.
1526	*/	1421	*/
1527	if (at->clone.type == SPELL && at->clone.path_attuned & pnum &&	1422	if (at->type == SPELL && at->path_attuned & pnum &&
1528	((at->clone.stats.grace && prayers) || (at->clone.stats.sp && !prayers)) && (at->clone.level < (level * 8)))	1423	((at->stats.grace && prayers) || (at->stats.sp && !prayers)) && (at->level < (level * 8)))
1529	{	1424	{
1530	strcpy (tmpbuf, at->clone.name);	1425	seen = 1;
1531		1426	buf << at->object::name << '\r';
1532	if (book_overflow (retbuf, tmpbuf, booksize))
1533	break;
1534	else
1535	{
1536	if (did_first_sp)
1537	strcat (retbuf, ",\n");
1538	did_first_sp = 1;
1539	strcat (retbuf, tmpbuf);
1540	}
1541	}	1427	}
1542	}	1428
1543	/* Geez, no spells were generated. */	1429	/* Geez, no spells were generated. */
1544	if (!did_first_sp)	1430	if (!seen)
1545	{
1546	if (RANDOM () % 4) /* usually, lets make a recursive call... */	1431	if (rndm (4)) /* usually, lets make a recursive call... */
1547	spellpath_msg (level, booksize);	1432	return spellpath_msg (level, booksize);
1548	else /* give up, cause knowing no spells exist for path is info too. */	1433	else /* give up, cause knowing no spells exist for path is info too. */
1549	strcat (retbuf, "\n - no known spells exist -\n");	1434	buf << "- no known spells exist.\n";
1550	}	1435
1551	else
1552	{
1553	strcat (retbuf, "\n");
1554	}
1555	return retbuf;	1436	return buf;
1556	}	1437	}
1557
1558
1559		1438
1560	/* formula_msg() - generate a message detailing the properties	1439	/* formula_msg() - generate a message detailing the properties
1561	* of a randomly selected alchemical formula.	1440	* of a randomly selected alchemical formula.
1562	*/	1441	*/
1563		1442	static void
1564	void
1565	make_formula_book (object *book, int level)	1443	make_formula_book (object *book, int level)
1566	{	1444	{
1567	char retbuf[BOOK_BUF], title[MAX_BUF];	1445	char title[MAX_BUF];
1568	recipelist *fl;	1446	recipelist *fl;
1569	recipe *formula = NULL;	1447	recipe *formula = NULL;
1570	int chance;	1448	int chance;
1571		1449
		1450	static dynbuf_text buf; buf.clear ();
		1451
1572	/* the higher the book level, the more complex (ie number of	1452	/* the higher the book level, the more complex (ie number of
1573	* ingredients) the formula can be.	1453	* ingredients) the formula can be.
1574	*/	1454	*/
1575	fl = get_formulalist (((RANDOM () % level) / 3) + 1);	1455	fl = get_formulalist (rndm (level) / 3 + 1);
1576		1456
1577	if (!fl)	1457	if (!fl)
1578	fl = get_formulalist (1); /* safety */	1458	fl = get_formulalist (1); /* safety */
1579		1459
1580	if (fl->total_chance == 0)	1460	if (fl->total_chance == 0)
…		…
1584	add_author (book, 4);	1464	add_author (book, 4);
1585	return;	1465	return;
1586	}	1466	}
1587		1467
1588	/* get a random formula, weighted by its bookchance */	1468	/* get a random formula, weighted by its bookchance */
1589	chance = RANDOM () % fl->total_chance;	1469	chance = rndm (fl->total_chance);
1590	for (formula = fl->items; formula != NULL; formula = formula->next)	1470	for (formula = fl->items; formula; formula = formula->next)
1591	{	1471	{
1592	chance -= formula->chance;	1472	chance -= formula->chance;
		1473
1593	if (chance <= 0)	1474	if (chance <= 0)
1594	break;	1475	break;
1595	}	1476	}
1596		1477
1597	if (!formula || formula->arch_names <= 0)	1478	if (!formula || formula->arch_names <= 0)
1598	{	1479	{
1599	book->msg = "<indecipherable text>\n";	1480	book->msg = "<indecipherable text>\n";
1600	new_text_name (book, 4);	1481	new_text_name (book, 4);
1601	add_author (book, 4);	1482	add_author (book, 4);
1602		1483	return;
1603	}	1484	}
		1485
		1486	/* looks like a formula was found. Base the amount
		1487	* of information on the booklevel and the spellevel
		1488	* of the formula. */
		1489
		1490	const char *op_name = formula->arch_name [rndm (formula->arch_names)];
		1491	archetype *at;
		1492
		1493	/* preamble */
		1494	buf << "Herein is described a project using B<< "
		1495	<< (formula->skill ? &formula->skill : "an unknown skill")
		1496	<< " >>:\n\n";
		1497
		1498	if ((at = archetype::find (op_name)))
		1499	op_name = at->object::name;
1604	else	1500	else
		1501	LOG (llevError, "formula_msg() can't find arch %s for formula.\n", op_name);
		1502
		1503	/* item name */
		1504	if (formula->title != shstr_NONE)
		1505	{
		1506	buf.printf ("The B<< %s of %s >>", op_name, &formula->title);
		1507	/* This results in things like pile of philo. sulfur.
		1508	* while philo. sulfur may look better, without this,
		1509	* you get things like 'the wise' because its missing the
		1510	* water of section.
		1511	*/
		1512	sprintf (title, "%s: %s of %s",
		1513	formula_book_name [rndm (sizeof (formula_book_name) / sizeof (char *))], op_name, &formula->title);
1605	{	1514	}
1606	/* looks like a formula was found. Base the amount	1515	else
1607	* of information on the booklevel and the spellevel	1516	{
1608	* of the formula. */	1517	buf << "The B<< " << op_name;
1609		1518
1610	const char *op_name = formula->arch_name[RANDOM () % formula->arch_names];	1519	sprintf (title, "%s: %s", formula_book_name [rndm (sizeof (formula_book_name) / sizeof (char *))], op_name);
		1520	if (at->title)
		1521	{
		1522	buf << " " << at->title;
		1523	strcat (title, " ");
		1524	strcat (title, at->title);
		1525	}
		1526
		1527	buf << " >>";
		1528	}
		1529
		1530	/* Lets name the book something meaningful ! */
		1531	book->name = title;
		1532	book->title = NULL;
		1533
		1534	/* ingredients to make it */
		1535	if (formula->ingred)
		1536	{
		1537	linked_char *next;
1611	archetype *at;	1538	archetype *at;
1612		1539
1613	/* preamble */
1614	sprintf (retbuf, "Herein is described a project using %s: \n", formula->skill ? &formula->skill : "an unknown skill");
1615
1616	if ((at = archetype::find (op_name)) != (archetype *) NULL)
1617	op_name = at->clone.name;
1618	else
1619	LOG (llevError, "formula_msg() can't find arch %s for formula.\n", op_name);
1620
1621	/* item name */
1622	if (strcmp (formula->title, "NONE"))
1623	{
1624	sprintf (retbuf, "%sThe %s of %s", retbuf, op_name, &formula->title);
1625	/* This results in things like pile of philo. sulfur.
1626	* while philo. sulfur may look better, without this,
1627	* you get things like 'the wise' because its missing the
1628	* water of section.
1629	*/
1630	sprintf (title, "%s: %s of %s",
1631	formula_book_name[RANDOM () % (sizeof (formula_book_name) / sizeof (char *))], op_name, &formula->title);
1632	}
1633	else
1634	{
1635	sprintf (retbuf, "%sThe %s", retbuf, op_name);
1636	sprintf (title, "%s: %s", formula_book_name[RANDOM () % (sizeof (formula_book_name) / sizeof (char *))], op_name);
1637	if (at->clone.title)
1638	{
1639	strcat (retbuf, " ");
1640	strcat (retbuf, at->clone.title);
1641	strcat (title, " ");
1642	strcat (title, at->clone.title);
1643	}
1644	}
1645	/* Lets name the book something meaningful ! */
1646	book->name = title;
1647	book->title = NULL;
1648
1649	/* ingredients to make it */
1650	if (formula->ingred != NULL)
1651	{
1652	linked_char *next;
1653	archetype *at;
1654
1655	at = archetype::find (formula->cauldron);	1540	at = archetype::find (formula->cauldron);
1656		1541
1657	sprintf (retbuf + strlen (retbuf),	1542	buf.printf (" may be made at %s using the following ingredients:\n\n",
1658	" may be made at %s using the following ingredients:\n", at ? query_name (&at->clone) : "an unknown place");	1543	at ? query_name (at) : "an appropriate place");
1659		1544
1660	for (next = formula->ingred; next != NULL; next = next->next)	1545	for (next = formula->ingred; next; next = next->next)
1661	{	1546	buf << next->name << '\r';
1662	strcat (retbuf, next->name);
1663	strcat (retbuf, "\n");
1664	}
1665	}
1666	else
1667	LOG (llevError, "formula_msg() no ingredient list for object %s of %s\n", op_name, &formula->title);
1668	if (retbuf[strlen (retbuf) - 1] != '\n')
1669	strcat (retbuf, "\n");
1670
1671	book->msg = retbuf;
1672	}
1673	}
1674
1675
1676	/* msgfile_msg() - generate a message drawn randomly from a
1677	* file in lib/. Level currently has no effect on the message
1678	* which is returned.
1679	*/
1680
1681	char *
1682	msgfile_msg (int level, int booksize)
1683	{
1684	static char retbuf[BOOK_BUF];
1685	int i, msgnum;
1686	linked_char *msg = NULL;
1687
1688	/* get a random message for the 'book' from linked list */
1689	if (nrofmsg > 1)
1690	{	1547	}
1691	msg = first_msg;
1692	msgnum = RANDOM () % nrofmsg;
1693	for (i = 0; msg && i < nrofmsg && i != msgnum; i++)
1694	msg = msg->next;
1695	}
1696
1697	if (msg && !book_overflow (retbuf, msg->name, booksize))
1698	strcpy (retbuf, msg->name);
1699	else	1548	else
1700	sprintf (retbuf, "\n <undecipherable text>");	1549	LOG (llevError, "formula_msg() no ingredient list for object %s of %s\n", op_name, &formula->title);
1701		1550
1702	#ifdef BOOK_MSG_DEBUG	1551	book->msg = buf;
1703	LOG (llevDebug, "\n info_list_msg() created strng: %d\n", strlen (retbuf));
1704	LOG (llevDebug, " MADE THIS:\n%s\n", retbuf);
1705	#endif
1706
1707	return retbuf;
1708	}	1552	}
1709		1553
		1554	#define DESCRIBE_PATH(retbuf, variable, name) \
		1555	if(variable) { \
		1556	int i,j=0; \
		1557	strcat(retbuf,"(" name ": "); \
		1558	for(i=0; i<NRSPELLPATHS; i++) \
		1559	if(variable & (1<<i)) { \
		1560	if (j) \
		1561	strcat(retbuf,", "); \
		1562	else \
		1563	j = 1; \
		1564	strcat(retbuf, spellpathnames[i]); \
		1565	} \
		1566	strcat(retbuf,")"); \
		1567	}
1710		1568
1711	/* god_info_msg() - generate a message detailing the properties	1569	/* god_info_msg() - generate a message detailing the properties
1712	* of a random god. Used by the book hack. b.t.	1570	* of a random god. Used by the book hack. b.t.
1713	*/	1571	*/
1714
1715	const char *	1572	static const char *
1716	god_info_msg (int level, int booksize)	1573	god_info_msg (int level, int booksize)
1717	{	1574	{
1718	static char retbuf[BOOK_BUF];
1719	const char *name = NULL;	1575	const char *name = NULL;
1720	char buf[BOOK_BUF];
1721	int i;
1722	size_t introlen;
1723	object *god = pntr_to_god_obj (get_rand_god ());	1576	object *god = pntr_to_god_obj (get_rand_god ());
1724		1577
		1578	static dynbuf_text buf; buf.clear ();
		1579
1725	if (!god)	1580	if (!god)
1726	return (char *) NULL; /* oops, problems... */	1581	return 0; /* oops, problems... */
		1582
1727	name = god->name;	1583	name = god->name;
1728		1584
1729	/* preamble.. */	1585	/* preamble.. */
1730	sprintf (retbuf, "This document contains knowledge concerning\n");	1586	buf << "This document contains knowledge concerning the diety B<< "
1731	sprintf (retbuf, "%sthe diety %s", retbuf, name);	1587	<< name << " >>";
1732		1588
1733	/* Always have as default information the god's descriptive terms. */	1589	/* Always have as default information the god's descriptive terms. */
1734	if (nstrtok (god->msg, ",") > 0)	1590	if (nstrtok (god->msg, ",") > 0)
1735	{	1591	buf << ", known as" << strtoktolin (god->msg, ",");
1736	strcat (retbuf, ", known as");
1737	strcat (retbuf, strtoktolin (god->msg, ","));
1738	}
1739	else	1592	else
1740	strcat (retbuf, "...");	1593	buf << "...";
1741		1594
1742	strcat (retbuf, "\n ---\n");	1595	buf << "\n\n";
		1596
1743	introlen = strlen (retbuf); /* so we will know if no new info is added later */	1597	int introlen = buf.size (); /* so we will know if no new info is added later */
1744		1598
1745	/* Information about the god is random, and based on the level of the	1599	/* Information about the god is random, and based on the level of the
1746	* 'book'. Probably there is a more intellegent way to implement	1600	* 'book'. Probably there is a more intellegent way to implement
1747	* this ...	1601	* this ...
1748	*/	1602	*/
1749		1603	while (level > 0 && buf.size () < BOOK_BUF)
1750	while (level > 0)
1751	{	1604	{
1752	sprintf (buf, " ");
1753	if (level == 2 && RANDOM () % 2)	1605	if (level == 2 && rndm (2))
1754	{ /* enemy god */	1606	{ /* enemy god */
1755	const char *enemy = god->title;	1607	const char *enemy = god->title;
1756		1608
1757	if (enemy)	1609	if (enemy)
1758	sprintf (buf, "The gods %s and %s are enemies.\n ---\n", name, enemy);	1610	buf.printf ("The gods %s and %s are enemies.\r", name, enemy);
1759	}	1611	}
		1612
1760	if (level == 3 && RANDOM () % 2)	1613	if (level == 3 && rndm (2))
1761	{ /* enemy race, what the god's holy word effects */	1614	{ /* enemy race, what the god's holy word effects */
1762	const char *enemy = god->slaying;	1615	const char *enemy = god->slaying;
		1616	int i;
1763		1617
1764	if (enemy && !(god->path_denied & PATH_TURNING))	1618	if (enemy && !(god->path_denied & PATH_TURNING))
1765	if ((i = nstrtok (enemy, ",")) > 0)	1619	if ((i = nstrtok (enemy, ",")) > 0)
1766	{	1620	{
1767	char tmpbuf[MAX_BUF];	1621	char tmpbuf[MAX_BUF];
1768		1622
1769	sprintf (buf, "The holy words of %s have the power to\n", name);	1623	buf << "The holy words of " << name
1770	strcat (buf, "slay creatures belonging to the ");	1624	<< " have the power to slay creatures belonging to the ";
		1625
1771	if (i > 1)	1626	if (i > 1)
1772	sprintf (tmpbuf, "following \n races:%s", strtoktolin (enemy, ","));	1627	buf << "following races:" << strtoktolin (enemy, ",");
1773	else	1628	else
1774	sprintf (tmpbuf, "race of%s", strtoktolin (enemy, ","));	1629	buf << "race of" << strtoktolin (enemy, ",");
1775	sprintf (buf, "%s%s\n ---\n", buf, tmpbuf);	1630
		1631	buf << '\r';
1776	}	1632	}
1777	}	1633	}
		1634
1778	if (level == 4 && RANDOM () % 2)	1635	if (level == 4 && rndm (2))
1779	{ /* Priest of god gets these protect,vulnerable... */	1636	{ /* Priest of god gets these protect,vulnerable... */
1780	char tmpbuf[MAX_BUF], *cp;
1781
1782	cp = describe_resistance (god, 1);	1637	if (const char *cp = describe_resistance (god, 1))
1783
1784	if (*cp)
1785	{ /* This god does have protections */	1638	{ /* This god does have protections */
1786	sprintf (tmpbuf, "%s has a potent aura which is extended\n", name);	1639	buf << name
		1640	<< " has a potent aura which is extended to"
1787	strcat (tmpbuf, "faithful priests. The effects of this aura include:\n");	1641	" faithful priests. The effects of this aura include: "
1788	strcat (tmpbuf, cp);	1642	<< cp
1789	strcat (buf, tmpbuf);	1643	<< ".\r";
1790	strcat (buf, "\n ---\n");
1791	}	1644	}
1792	else
1793	sprintf (buf, " ");
1794	}	1645	}
		1646
1795	if (level == 5 && RANDOM () % 2)	1647	if (level == 5 && rndm (2))
1796	{ /* aligned race, summoning */	1648	{ /* aligned race, summoning */
1797	const char *race = god->race; /* aligned race */	1649	const char *race = god->race; /* aligned race */
		1650	int i;
1798		1651
1799	if (race && !(god->path_denied & PATH_SUMMON))	1652	if (race && !(god->path_denied & PATH_SUMMON))
1800	if ((i = nstrtok (race, ",")) > 0)	1653	if ((i = nstrtok (race, ",")) > 0)
1801	{	1654	{
1802	char tmpbuf[MAX_BUF];	1655	buf << "Creatures sacred to " << name << " include the ";
1803
1804	sprintf (buf, "Creatures sacred to %s include the \n", name);
1805	if (i > 1)	1656	if (i > 1)
1806	sprintf (tmpbuf, "following \n races:%s", strtoktolin (race, ","));	1657	buf << "following races:" << strtoktolin (race, ",");
1807	else	1658	else
1808	sprintf (tmpbuf, "race of%s", strtoktolin (race, ","));	1659	buf << "race of" << strtoktolin (race, ",");
1809	sprintf (buf, "%s%s\n ---\n", buf, tmpbuf);	1660
		1661	buf << '\r';
1810	}	1662	}
1811	}	1663	}
		1664
1812	if (level == 6 && RANDOM () % 2)	1665	if (level == 6 && rndm (2))
1813	{ /* blessing,curse properties of the god */	1666	{ /* blessing,curse properties of the god */
1814	char tmpbuf[MAX_BUF], *cp;
1815
1816	cp = describe_resistance (god, 1);	1667	if (const char *cp = describe_resistance (god, 1))
1817
1818	if (*cp)
1819	{ /* This god does have protections */	1668	{ /* This god does have protections */
1820	sprintf (tmpbuf, "\nThe priests of %s are known to be able to \n", name);	1669	buf << "The priests of " << name
		1670	<< " are known to be able to "
1821	strcat (tmpbuf, "bestow a blessing which makes the recipient\n");	1671	"bestow a blessing which makes the recipient "
1822	strcat (tmpbuf, cp);	1672	<< cp
1823	strcat (buf, tmpbuf);	1673	<< '\r';
1824	strcat (buf, "\n ---\n");
1825	}	1674	}
1826	else
1827	sprintf (buf, " ");
1828
1829	}	1675	}
		1676
1830	if (level == 8 && RANDOM () % 2)	1677	if (level == 8 && rndm (2))
1831	{ /* immunity, holy possession */	1678	{ /* immunity, holy possession */
1832	int has_effect = 0, tmpvar;	1679	buf << "The priests of " << name
1833	char tmpbuf[MAX_BUF];	1680	<< " are known to make cast a mighty"
		1681	" prayer of possession";
		1682
		1683	int first = 1;
1834		1684
1835	sprintf (tmpbuf, "\n");
1836	sprintf (tmpbuf, "The priests of %s are known to make cast a mighty \n", name);
1837
1838	strcat (tmpbuf, "prayer of possession which gives the recipient\n");
1839
1840	for (tmpvar = 0; tmpvar < NROFATTACKS; tmpvar++)	1685	for (int i = 0; i < NROFATTACKS; i++)
		1686	if (god->resist[i] == 100)
1841	{	1687	{
1842	if (god->resist[tmpvar] == 100)	1688	if (first)
1843	{	1689	{
		1690	buf << " which gives the recipient";
1844	has_effect = 1;	1691	first = 0;
1845	sprintf (tmpbuf + strlen (tmpbuf), "Immunity to %s", attacktype_desc[tmpvar]);
1846	}	1692	}
		1693	else
		1694	buf << ", ";
		1695
		1696	buf << " immunity to " << attacktype_desc[i];
1847	}	1697	}
1848	if (has_effect)	1698
1849	{	1699	buf << ".\r";
1850	strcat (buf, tmpbuf);
1851	strcat (buf, "\n ---\n");
1852	}
1853	else
1854	sprintf (buf, " ");
1855	}	1700	}
		1701
1856	if (level == 12 && RANDOM () % 2)	1702	if (level == 12 && rndm (2))
1857	{ /* spell paths */	1703	{ /* spell paths */
		1704	//TODO:
1858	int has_effect = 0, tmpvar;	1705	int has_effect = 0, tmpvar;
1859	char tmpbuf[MAX_BUF];	1706	char tmpbuf[MAX_BUF];
1860		1707
1861	sprintf (tmpbuf, "\n");	1708	sprintf (tmpbuf, "\n");
1862	sprintf (tmpbuf, "It is rarely known fact that the priests of %s\n", name);	1709	sprintf (tmpbuf, "It is rarely known fact that the priests of %s\n", name);
1863	strcat (tmpbuf, "are mystically transformed. Effects of this include:\n");	1710	strcat (tmpbuf, "are mystically transformed. Effects of this include:\n");
		1711
1864	if ((tmpvar = god->path_attuned))	1712	if ((tmpvar = god->path_attuned))
1865	{	1713	{
1866	has_effect = 1;	1714	has_effect = 1;
1867	DESCRIBE_PATH (tmpbuf, tmpvar, "Attuned");	1715	DESCRIBE_PATH (tmpbuf, tmpvar, "Attuned");
1868	}	1716	}
		1717
1869	if ((tmpvar = god->path_repelled))	1718	if ((tmpvar = god->path_repelled))
1870	{	1719	{
1871	has_effect = 1;	1720	has_effect = 1;
1872	DESCRIBE_PATH (tmpbuf, tmpvar, "Repelled");	1721	DESCRIBE_PATH (tmpbuf, tmpvar, "Repelled");
1873	}	1722	}
		1723
1874	if ((tmpvar = god->path_denied))	1724	if ((tmpvar = god->path_denied))
1875	{	1725	{
1876	has_effect = 1;	1726	has_effect = 1;
1877	DESCRIBE_PATH (tmpbuf, tmpvar, "Denied");	1727	DESCRIBE_PATH (tmpbuf, tmpvar, "Denied");
1878	}	1728	}
		1729
1879	if (has_effect)	1730	if (has_effect)
1880	{	1731	buf << tmpbuf << '\r';
1881	strcat (buf, tmpbuf);
1882	strcat (buf, "\n ---\n");
1883	}
1884	else	1732	else
1885	sprintf (buf, " ");	1733	buf << '\r';
1886	}	1734	}
1887		1735
1888	/* check to be sure new buffer size dont exceed either
1889	* the maximum buffer size, or the 'natural' size of the
1890	* book...
1891	*/
1892	if (book_overflow (retbuf, buf, booksize))
1893	break;
1894	else if (strlen (buf) > 1)
1895	strcat (retbuf, buf);
1896	level--;	1736	level--;
1897	}	1737	}
1898	if (strlen (retbuf) == introlen)	1738
		1739	if (buf.size () == introlen)
1899	{ /* we got no information beyond the preamble! */	1740	/* we got no information beyond the preamble! */
1900	strcat (retbuf, " [Unfortunately the rest of the information is\n");	1741	buf << "[Unfortunately the rest of the information is hopelessly garbled!]";
1901	strcat (retbuf, " hopelessly garbled!]\n ---\n");	1742
1902	}
1903	#ifdef BOOK_MSG_DEBUG
1904	LOG (llevDebug, "\n god_info_msg() created strng: %d\n", strlen (retbuf));
1905	fprintf (logfile, " MADE THIS:\n%s", retbuf);
1906	#endif
1907	return retbuf;	1743	return buf;
1908	}	1744	}
1909		1745
1910	/* tailor_readable_ob()- The main routine. This chooses a random	1746	/* tailor_readable_ob()- The main routine. This chooses a random
1911	* message to put in given readable object (type==BOOK) which will	1747	* message to put in given readable object (type==BOOK) which will
1912	* be referred hereafter as a 'book'. We use the book level to de-	1748	* be referred hereafter as a 'book'. We use the book level to de-
…		…
1921	* book is the object we are creating into.	1757	* book is the object we are creating into.
1922	* If msg_type is a positive value, we use that to determine the	1758	* If msg_type is a positive value, we use that to determine the
1923	* message type - otherwise a random value is used.	1759	* message type - otherwise a random value is used.
1924	*	1760	*
1925	*/	1761	*/
1926
1927	void	1762	void
1928	tailor_readable_ob (object *book, int msg_type)	1763	tailor_readable_ob (object *book, int msg_type)
1929	{	1764	{
1930	char msgbuf[BOOK_BUF];	1765	char msgbuf[BOOK_BUF];
1931	int level = book->level ? (RANDOM () % book->level) + 1 : 1;	1766	int level = book->level ? rndm (book->level) + 1 : 1;
1932	int book_buf_size;	1767	int book_buf_size;
1933		1768
1934	/* safety */	1769	/* safety */
1935	if (book->type != BOOK)	1770	if (book->type != BOOK)
1936	return;	1771	return;
…		…
1950	* 2) make sure there is an entry in max_titles[] array.	1785	* 2) make sure there is an entry in max_titles[] array.
1951	* 3) make sure there are entries for your case in new_text_title()	1786	* 3) make sure there are entries for your case in new_text_title()
1952	* and add_authour().	1787	* and add_authour().
1953	* 4) you may want separate authour/book name arrays in read.h	1788	* 4) you may want separate authour/book name arrays in read.h
1954	*/	1789	*/
1955
1956	msg_type = msg_type > 0 ? msg_type : (RANDOM () % 6);	1790	msg_type = msg_type > 0 ? msg_type : rndm (8);
1957	switch (msg_type)	1791	switch (msg_type)
1958	{	1792	{
1959	case 1: /* monster attrib */	1793	case 1: /* monster attrib */
1960	strcpy (msgbuf, mon_info_msg (level, book_buf_size));	1794	strcpy (msgbuf, mon_info_msg (level, book_buf_size));
1961	break;	1795	break;
1962	case 2: /* artifact attrib */	1796	case 2: /* artifact attrib */
1963	strcpy (msgbuf, artifact_msg (level, book_buf_size));	1797	strcpy (msgbuf, artifact_msg (level, book_buf_size));
1964	break;	1798	break;
1965	case 3: /* grouping incantations/prayers by path */	1799	case 3: /* grouping incantations/prayers by path */
1966	strcpy (msgbuf, spellpath_msg (level, book_buf_size));	1800	strcpy (msgbuf, spellpath_msg (level, book_buf_size));
1967	break;	1801	break;
1968	case 4: /* describe an alchemy formula */	1802	case 4: /* describe an alchemy formula */
1969	make_formula_book (book, level);	1803	make_formula_book (book, level);
1970	/* make_formula_book already gives title */	1804	/* make_formula_book already gives title */
1971	return;	1805	return;
1972	break;
1973	case 5: /* bits of information about a god */	1806	case 5: /* bits of information about a god */
1974	strcpy (msgbuf, god_info_msg (level, book_buf_size));	1807	strcpy (msgbuf, god_info_msg (level, book_buf_size));
1975	break;	1808	break;
1976	case 0: /* use info list in lib/ */	1809	case 0: /* use info list in lib/ */
1977	default:	1810	default:
1978	strcpy (msgbuf, msgfile_msg (level, book_buf_size));	1811	cfperl_make_book (book, level);
1979	break;	1812	/* already gives title */
		1813	return;
1980	}	1814	}
1981		1815
1982	strcat (msgbuf, "\n"); /* safety -- we get ugly map saves/crashes w/o this */	1816	strcat (msgbuf, "\n"); /* safety -- we get ugly map saves/crashes w/o this */
		1817
1983	if (strlen (msgbuf) > 1)	1818	if (strlen (msgbuf) > 1)
1984	{	1819	{
1985	book->msg = msgbuf;	1820	book->msg = msgbuf;
1986	/* lets give the "book" a new name, which may be a compound word */	1821	/* lets give the "book" a new name, which may be a compound word */
1987	change_book (book, msg_type);	1822	change_book (book, msg_type);
1988	}	1823	}
1989
1990	}	1824	}
1991		1825
1992		1826
1993	/*****************************************************************************	1827	/*****************************************************************************
1994	*	1828	*
…		…
2004	linked_char *lmsg, *nextmsg;	1838	linked_char *lmsg, *nextmsg;
2005	objectlink *monlink, *nextmon;	1839	objectlink *monlink, *nextmon;
2006		1840
2007	LOG (llevDebug, "freeing all book information\n");	1841	LOG (llevDebug, "freeing all book information\n");
2008		1842
2009	for (tlist = booklist; tlist != NULL; tlist = tnext)	1843	for (tlist = booklist; tlist; tlist = tnext)
2010	{	1844	{
2011	tnext = tlist->next;	1845	tnext = tlist->next;
2012		1846
2013	for (title1 = tlist->first_book; title1; title1 = titlenext)	1847	for (title1 = tlist->first_book; title1; title1 = titlenext)
2014	{	1848	{
…		…
2016	delete title1;	1850	delete title1;
2017	}	1851	}
2018		1852
2019	delete tlist;	1853	delete tlist;
2020	}	1854	}
		1855
2021	for (lmsg = first_msg; lmsg; lmsg = nextmsg)	1856	for (lmsg = first_msg; lmsg; lmsg = nextmsg)
2022	{	1857	{
2023	nextmsg = lmsg->next;	1858	nextmsg = lmsg->next;
2024	delete lmsg;	1859	delete lmsg;
2025	}	1860	}
		1861
2026	for (monlink = first_mon_info; monlink; monlink = nextmon)	1862	for (monlink = first_mon_info; monlink; monlink = nextmon)
2027	{	1863	{
2028	nextmon = monlink->next;	1864	nextmon = monlink->next;
2029	free (monlink);	1865	delete monlink;
2030	}	1866	}
2031	}	1867	}
2032		1868
2033		1869
2034	/*****************************************************************************	1870	/*****************************************************************************
…		…
2087	get_readable_message_type (object *readable)	1923	get_readable_message_type (object *readable)
2088	{	1924	{
2089	uint8 subtype = readable->subtype;	1925	uint8 subtype = readable->subtype;
2090		1926
2091	if (subtype > last_readable_subtype)	1927	if (subtype > last_readable_subtype)
2092	return &(readable_message_types[0]);	1928	return &readable_message_types[0];
		1929
2093	return &(readable_message_types[subtype]);	1930	return &readable_message_types[subtype];
2094	}	1931	}

Diff Legend

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