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.6 by root, Wed Sep 13 23:32:04 2006 UTC vs.
Revision 1.45 by root, Thu Oct 15 22:50:41 2009 UTC

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

Diff Legend

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