[ViewVC] Diff of: cvs/deliantra/server/common/readable.C

Comparing deliantra/server/common/readable.C (file contents):
Revision 1.44 by root, Thu Oct 15 21:40:42 2009 UTC vs.
Revision 1.70 by root, Sat Dec 1 20:22:12 2018 UTC

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

Diff Legend

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

Comparing deliantra/server/common/readable.C (file contents): Revision 1.44 by root, Thu Oct 15 21:40:42 2009 UTC vs. Revision 1.70 by root, Sat Dec 1 20:22:12 2018 UTC

Diff Legend

Comparing deliantra/server/common/readable.C (file contents):
Revision 1.44 by root, Thu Oct 15 21:40:42 2009 UTC vs.
Revision 1.70 by root, Sat Dec 1 20:22:12 2018 UTC