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

Comparing deliantra/server/common/readable.C (file contents):
Revision 1.31 by root, Tue Jul 10 06:05:55 2007 UTC vs.
Revision 1.62 by root, Sun May 1 16:58:15 2011 UTC

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

Diff Legend

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

Comparing deliantra/server/common/readable.C (file contents): Revision 1.31 by root, Tue Jul 10 06:05:55 2007 UTC vs. Revision 1.62 by root, Sun May 1 16:58:15 2011 UTC

Diff Legend

Comparing deliantra/server/common/readable.C (file contents):
Revision 1.31 by root, Tue Jul 10 06:05:55 2007 UTC vs.
Revision 1.62 by root, Sun May 1 16:58:15 2011 UTC