ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/common/readable.C

Comparing deliantra/server/common/readable.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:00 2006 UTC vs.
Revision 1.2 by root, Tue Aug 29 08:01:35 2006 UTC

1	/*	1	/*
2	* static char *rcsid_readable_c =	2	* static char *rcsid_readable_c =
3	* "$Id: readable.C,v 1.1 2006/08/13 17:16:00 elmex Exp $";	3	* "$Id: readable.C,v 1.2 2006/08/29 08:01:35 root Exp $";
4	*/	4	*/
5		5
6	/*	6	/*
7	CrossFire, A Multiplayer game for X-windows	7	CrossFire, A Multiplayer game for X-windows
8		8
…		…
456	* at the bottom of the list. Never delete a subtype because index is used as	456	* at the bottom of the list. Never delete a subtype because index is used as
457	* subtype paramater in arch files!	457	* subtype paramater in arch files!
458	*/	458	*/
459	static readable_message_type readable_message_types[] =	459	static readable_message_type readable_message_types[] =
460	{	460	{
461	/*subtype 0 */ {0,0},	461	/*subtype 0 */ {0,0},
462	/* book messages subtypes */	462	/* book messages subtypes */
463	/*subtype 1 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_1},	463	/*subtype 1 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_1},
464	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_2},	464	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_2},
465	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_1},	465	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_1},
466	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_2},	466	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_2},
467	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_1},	467	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_1},
468	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_2},	468	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_2},
469	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_EVOKER},	469	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_EVOKER},
470	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PRAYER},	470	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PRAYER},
471	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PYRO},	471	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PYRO},
472	/*subtype 10 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SORCERER},	472	/*subtype 10 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SORCERER},
473	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SUMMONER},	473	{MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SUMMONER},
474	/* card messages subtypes*/	474	/* card messages subtypes*/
475	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_1},	475	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_1},
476	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_2},	476	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_2},
477	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_3},	477	{MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_3},
478	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_1},	478	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_1},
479	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_2},	479	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_2},
480	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_3},	480	{MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_3},
481	{MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_1},	481	{MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_1},
482	{MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_2},	482	{MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_2},
483	/*subtype 20 */ {MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_3},	483	/*subtype 20 */ {MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_3},
484	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_1},	484	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_1},
485	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_2},	485	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_2},
486	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_3},	486	{MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_3},
487		487
488	/* Paper messages subtypes */	488	/* Paper messages subtypes */
…		…
490	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_2},	490	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_2},
491	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_3},	491	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_3},
492	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_1},	492	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_1},
493	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_2},	493	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_2},
494	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_1},	494	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_1},
495	/*subtype 30 */ {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_2},	495	/*subtype 30 */ {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_2},
496	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_1},	496	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_1},
497	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_2},	497	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_2},
498	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_1},	498	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_1},
499	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_2},	499	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_2},
500	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_1},	500	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_1},
…		…
502	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_MAGIC},	502	{MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_MAGIC},
503		503
504	/* road signs messages subtypes */	504	/* road signs messages subtypes */
505	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_BASIC},	505	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_BASIC},
506	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_LEFT},	506	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_LEFT},
507	/*subtype 40 */ {MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_RIGHT},	507	/*subtype 40 */ {MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_RIGHT},
508	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_BOTH},	508	{MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_BOTH},
509		509
510	/* stones and monument messages */	510	/* stones and monument messages */
511	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_1},	511	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_1},
512	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_2},	512	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_2},
…		…
514	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_1},	514	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_1},
515	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_2},	515	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_2},
516	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_3},	516	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_3},
517	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_1},	517	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_1},
518	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_2},	518	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_2},
519	/*subtype 50 */ {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_3},	519	/*subtype 50 */ {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_3},
520	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_1},	520	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_1},
521	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_2},	521	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_2},
522	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_3}	522	{MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_3}
523	};	523	};
524	int last_readable_subtype = sizeof(readable_message_types)/sizeof(readable_message_type);	524	int last_readable_subtype = sizeof(readable_message_types)/sizeof(readable_message_type);
…		…
542	static titlelist *	542	static titlelist *
543	get_empty_booklist (void)	543	get_empty_booklist (void)
544	{	544	{
545	titlelist *bl = (titlelist *) malloc (sizeof (titlelist));	545	titlelist *bl = (titlelist *) malloc (sizeof (titlelist));
546	if (bl == NULL)	546	if (bl == NULL)
547	fatal (OUT_OF_MEMORY);	547	fatal (OUT_OF_MEMORY);
548	bl->number = 0;	548	bl->number = 0;
549	bl->first_book = NULL;	549	bl->first_book = NULL;
550	bl->next = NULL;	550	bl->next = NULL;
551	return bl;	551	return bl;
552	}	552	}
…		…
554	static title *	554	static title *
555	get_empty_book (void)	555	get_empty_book (void)
556	{	556	{
557	title *t = (title *) malloc (sizeof (title));	557	title *t = (title *) malloc (sizeof (title));
558	if (t == NULL)	558	if (t == NULL)
559	fatal (OUT_OF_MEMORY);	559	fatal (OUT_OF_MEMORY);
560	t->name = NULL;	560	t->name = NULL;
561	t->archname = NULL;	561	t->archname = NULL;
562	t->authour = NULL;	562	t->authour = NULL;
563	t->level = 0;	563	t->level = 0;
564	t->size = 0;	564	t->size = 0;
…		…
574	{	574	{
575	titlelist *tl = booklist;	575	titlelist *tl = booklist;
576	int number = i;	576	int number = i;
577		577
578	if (number < 0)	578	if (number < 0)
579	return tl;	579	return tl;
580		580
581	while (tl && number)	581	while (tl && number)
582	{	582	{
583	if (!tl->next)	583	if (!tl->next)
584	tl->next = get_empty_booklist ();	584	tl->next = get_empty_booklist ();
585	tl = tl->next;	585	tl = tl->next;
586	number--;	586	number--;
587	}	587	}
588		588
589	return tl;	589	return tl;
590	}	590	}
591		591
…		…
601	{	601	{
602	char *tbuf, sbuf[12], buf[MAX_BUF];	602	char *tbuf, sbuf[12], buf[MAX_BUF];
603	int number = 0;	603	int number = 0;
604		604
605	if (!buf1 || !buf2)	605	if (!buf1 || !buf2)
606	return 0;	606	return 0;
607	sprintf (buf, "%s", buf1);	607	sprintf (buf, "%s", buf1);
608	sprintf (sbuf, "%s", buf2);	608	sprintf (sbuf, "%s", buf2);
609	tbuf = strtok (buf, sbuf);	609	tbuf = strtok (buf, sbuf);
610	while (tbuf)	610	while (tbuf)
611	{	611	{
612	number++;	612	number++;
613	tbuf = strtok (NULL, sbuf);	613	tbuf = strtok (NULL, sbuf);
614	}	614	}
615	return number;	615	return number;
616	}	616	}
617		617
618	/* strtoktolin() - takes a string in buf1 and separates it into	618	/* strtoktolin() - takes a string in buf1 and separates it into
…		…
632	strcpy(sbuf, buf2);	632	strcpy(sbuf, buf2);
633	strcpy(rbuf, " ");	633	strcpy(rbuf, " ");
634	tbuf = strtok (buf, sbuf);	634	tbuf = strtok (buf, sbuf);
635	while (tbuf && i > 0)	635	while (tbuf && i > 0)
636	{	636	{
637	strcat (rbuf, tbuf);	637	strcat (rbuf, tbuf);
638	i--;	638	i--;
639	if (i == 1 && maxi > 1)	639	if (i == 1 && maxi > 1)
640	strcat (rbuf, " and ");	640	strcat (rbuf, " and ");
641	else if (i > 0 && maxi > 1)	641	else if (i > 0 && maxi > 1)
642	strcat (rbuf, ", ");	642	strcat (rbuf, ", ");
643	else	643	else
644	strcat (rbuf, ".");	644	strcat (rbuf, ".");
645	tbuf = strtok (NULL, sbuf);	645	tbuf = strtok (NULL, sbuf);
646	}	646	}
647	return (char *) rbuf;	647	return (char *) rbuf;
648	}	648	}
649		649
650	int	650	int
651	book_overflow (const char *buf1, const char *buf2, int booksize)	651	book_overflow (const char *buf1, const char *buf2, int booksize)
652	{	652	{
653		653
654	if (buf_overflow (buf1, buf2, BOOK_BUF - 2) /* 2 less so always room for trailing \n */	654	if (buf_overflow (buf1, buf2, BOOK_BUF - 2) /* 2 less so always room for trailing \n */
655	|| buf_overflow (buf1, buf2, booksize))	655	|| buf_overflow (buf1, buf2, booksize))
656	return 1;	656	return 1;
657	return 0;	657	return 0;
658		658
659		659
660	}	660	}
661		661
…		…
676	char buf[MAX_BUF], msgbuf[HUGE_BUF], fname[MAX_BUF], *cp;	676	char buf[MAX_BUF], msgbuf[HUGE_BUF], fname[MAX_BUF], *cp;
677	int comp;	677	int comp;
678	static int did_init_msgfile;	678	static int did_init_msgfile;
679		679
680	if (did_init_msgfile)	680	if (did_init_msgfile)
681	return;	681	return;
682	did_init_msgfile = 1;	682	did_init_msgfile = 1;
683		683
684	sprintf (fname, "%s/messages", settings.datadir);	684	sprintf (fname, "%s/messages", settings.datadir);
685	LOG (llevDebug, "Reading messages from %s...", fname);	685	LOG (llevDebug, "Reading messages from %s...", fname);
686		686
687	if ((fp = open_and_uncompress (fname, 0, &comp)) != NULL)	687	if ((fp = open_and_uncompress (fname, 0, &comp)) != NULL)
688	{	688	{
689	linked_char *tmp = NULL;	689	linked_char *tmp = NULL;
690	while (fgets (buf, MAX_BUF, fp) != NULL)	690	while (fgets (buf, MAX_BUF, fp) != NULL)
691	{	691	{
692	if (*buf == '#')	692	if (*buf == '#')
693	continue;	693	continue;
694	if ((cp = strchr (buf, '\n')) != NULL)	694	if ((cp = strchr (buf, '\n')) != NULL)
695	*cp = '\0';	695	*cp = '\0';
696	cp = buf;	696	cp = buf;
697	while (*cp == ' ') /* Skip blanks */	697	while (*cp == ' ') /* Skip blanks */
698	cp++;	698	cp++;
699	if (!strncmp (cp, "ENDMSG", 6))	699	if (!strncmp (cp, "ENDMSG", 6))
700	{	700	{
701	if (strlen (msgbuf) > BOOK_BUF)	701	if (strlen (msgbuf) > BOOK_BUF)
702	{	702	{
703	LOG (llevDebug, "Warning: this string exceeded max book buf size:");	703	LOG (llevDebug, "Warning: this string exceeded max book buf size:");
704	LOG (llevDebug, " %s", msgbuf);	704	LOG (llevDebug, " %s", msgbuf);
705	}	705	}
706	tmp->name = add_string (msgbuf);	706	tmp->name = add_string (msgbuf);
707	tmp->next = first_msg;	707	tmp->next = first_msg;
708	first_msg = tmp;	708	first_msg = tmp;
709	nrofmsg++;	709	nrofmsg++;
710	continue;	710	continue;
711	}	711	}
712	else if (!strncmp (cp, "MSG", 3))	712	else if (!strncmp (cp, "MSG", 3))
713	{	713	{
714	tmp = (linked_char *) malloc (sizeof (linked_char));	714	tmp = (linked_char *) malloc (sizeof (linked_char));
715	strcpy (msgbuf, " "); /* reset msgbuf for new message */	715	strcpy (msgbuf, " "); /* reset msgbuf for new message */
716	continue;	716	continue;
717	}	717	}
718	else if (!buf_overflow (msgbuf, cp, HUGE_BUF - 1))	718	else if (!buf_overflow (msgbuf, cp, HUGE_BUF - 1))
719	{	719	{
720	strcat (msgbuf, cp);	720	strcat (msgbuf, cp);
721	strcat (msgbuf, "\n");	721	strcat (msgbuf, "\n");
722	}	722	}
723	}	723	}
724	close_and_delete (fp, comp);	724	close_and_delete (fp, comp);
725	}	725	}
726		726
727	#ifdef BOOK_MSG_DEBUG	727	#ifdef BOOK_MSG_DEBUG
728	LOG (llevDebug, "\ninit_info_listfile() got %d messages.\n", nrofmsg);	728	LOG (llevDebug, "\ninit_info_listfile() got %d messages.\n", nrofmsg);
729	#endif	729	#endif
…		…
745	title *book = NULL;	745	title *book = NULL;
746	titlelist *bl = get_empty_booklist ();	746	titlelist *bl = get_empty_booklist ();
747	static int did_init_barch;	747	static int did_init_barch;
748		748
749	if (did_init_barch)	749	if (did_init_barch)
750	return;	750	return;
751	did_init_barch = 1;	751	did_init_barch = 1;
752		752
753	if (!booklist)	753	if (!booklist)
754	booklist = bl;	754	booklist = bl;
755		755
756	sprintf (fname, "%s/bookarch", settings.localdir);	756	sprintf (fname, "%s/bookarch", settings.localdir);
757	LOG (llevDebug, " Reading bookarch from %s...\n", fname);	757	LOG (llevDebug, " Reading bookarch from %s...\n", fname);
758		758
759	if ((fp = open_and_uncompress (fname, 0, &comp)) != NULL)	759	if ((fp = open_and_uncompress (fname, 0, &comp)) != NULL)
760	{	760	{
761	int value, type = 0;	761	int value, type = 0;
762	size_t i;	762	size_t i;
763		763
764	while (fgets (buf, MAX_BUF, fp) != NULL)	764	while (fgets (buf, MAX_BUF, fp) != NULL)
765	{	765	{
766	if (*buf == '#')	766	if (*buf == '#')
767	continue;	767	continue;
768	if ((cp = strchr (buf, '\n')) != NULL)	768	if ((cp = strchr (buf, '\n')) != NULL)
769	*cp = '\0';	769	*cp = '\0';
770	cp = buf;	770	cp = buf;
771	while (*cp == ' ') /* Skip blanks */	771	while (*cp == ' ') /* Skip blanks */
772	cp++;	772	cp++;
773	if (!strncmp (cp, "title", 4))	773	if (!strncmp (cp, "title", 4))
774	{	774	{
775	book = get_empty_book (); /* init new book entry */	775	book = get_empty_book (); /* init new book entry */
776	book->name = add_string (strchr (cp, ' ') + 1);	776	book->name = add_string (strchr (cp, ' ') + 1);
777	type = -1;	777	type = -1;
778	nroftitle++;	778	nroftitle++;
779	continue;	779	continue;
780	}	780	}
781	if (!strncmp (cp, "authour", 4))	781	if (!strncmp (cp, "authour", 4))
782	{	782	{
783	book->authour = add_string (strchr (cp, ' ') + 1);	783	book->authour = add_string (strchr (cp, ' ') + 1);
784	}	784	}
785	if (!strncmp (cp, "arch", 4))	785	if (!strncmp (cp, "arch", 4))
786	{	786	{
787	book->archname = add_string (strchr (cp, ' ') + 1);	787	book->archname = add_string (strchr (cp, ' ') + 1);
788	}	788	}
789	else if (sscanf (cp, "level %d", &value))	789	else if (sscanf (cp, "level %d", &value))
790	{	790	{
791	book->level = (uint16) value;	791	book->level = (uint16) value;
792	}	792	}
793	else if (sscanf (cp, "type %d", &value))	793	else if (sscanf (cp, "type %d", &value))
794	{	794	{
795	type = (uint16) value;	795	type = (uint16) value;
796	}	796	}
797	else if (sscanf (cp, "size %d", &value))	797	else if (sscanf (cp, "size %d", &value))
798	{	798	{
799	book->size = (uint16) value;	799	book->size = (uint16) value;
800	}	800	}
801	else if (sscanf (cp, "index %d", &value))	801	else if (sscanf (cp, "index %d", &value))
802	{	802	{
803	book->msg_index = (uint16) value;	803	book->msg_index = (uint16) value;
804	}	804	}
805	else if (!strncmp (cp, "end", 3))	805	else if (!strncmp (cp, "end", 3))
806	{ /* link it */	806	{ /* link it */
807	bl = get_titlelist (type);	807	bl = get_titlelist (type);
808	book->next = bl->first_book;	808	book->next = bl->first_book;
809	bl->first_book = book;	809	bl->first_book = book;
810	bl->number++;	810	bl->number++;
811	}	811	}
812	}	812	}
813	LOG (llevDebug, " book archives(used/avail): ");	813	LOG (llevDebug, " book archives(used/avail): ");
814	for (bl = booklist, i = 0; bl != NULL && i < sizeof(max_titles)/sizeof(*max_titles); bl = bl->next, i++)	814	for (bl = booklist, i = 0; bl != NULL && i < sizeof(max_titles)/sizeof(*max_titles); bl = bl->next, i++)
815	{	815	{
816	LOG (llevDebug, "(%d/%d)", bl->number, max_titles[i]);	816	LOG (llevDebug, "(%d/%d)", bl->number, max_titles[i]);
817	}	817	}
818	LOG (llevDebug, "\n");	818	LOG (llevDebug, "\n");
819	close_and_delete (fp, comp);	819	close_and_delete (fp, comp);
820	}	820	}
821		821
822	#ifdef BOOK_MSG_DEBUG	822	#ifdef BOOK_MSG_DEBUG
823	LOG (llevDebug, "\n init_book_archive() got %d titles.\n", nroftitle);	823	LOG (llevDebug, "\n init_book_archive() got %d titles.\n", nroftitle);
824	#endif	824	#endif
…		…
834	{	834	{
835	archetype *at;	835	archetype *at;
836	static int did_init_mon_info = 0;	836	static int did_init_mon_info = 0;
837		837
838	if (did_init_mon_info)	838	if (did_init_mon_info)
839	return;	839	return;
840	did_init_mon_info = 1;	840	did_init_mon_info = 1;
841		841
842		842
843	for (at = first_archetype; at != NULL; at = at->next)	843	for (at = first_archetype; at != NULL; at = at->next)
844	{	844	{
845	if (QUERY_FLAG (&at->clone, FLAG_MONSTER) &&	845	if (QUERY_FLAG (&at->clone, FLAG_MONSTER) &&
846	(!QUERY_FLAG (&at->clone, FLAG_CHANGING)	846	(!QUERY_FLAG (&at->clone, FLAG_CHANGING)
847	|| QUERY_FLAG (&at->clone, FLAG_UNAGGRESSIVE))	847	|| QUERY_FLAG (&at->clone, FLAG_UNAGGRESSIVE))
848	)	848	)
849	{	849	{
850	objectlink *mon = (objectlink *) malloc (sizeof (objectlink));	850	objectlink *mon = (objectlink *) malloc (sizeof (objectlink));
851	mon->ob = &at->clone;	851	mon->ob = &at->clone;
852	mon->id = nrofmon;	852	mon->id = nrofmon;
853	mon->next = first_mon_info;	853	mon->next = first_mon_info;
854	first_mon_info = mon;	854	first_mon_info = mon;
855	nrofmon++;	855	nrofmon++;
856	}	856	}
857	}	857	}
858	LOG (llevDebug, "init_mon_info() got %d monsters\n", nrofmon);	858	LOG (llevDebug, "init_mon_info() got %d monsters\n", nrofmon);
859	}	859	}
860		860
861		861
…		…
901	titlelist *tl = get_titlelist (msgtype);	901	titlelist *tl = get_titlelist (msgtype);
902	int length = strlen (book->msg);	902	int length = strlen (book->msg);
903	int index = strtoint (book->msg);	903	int index = strtoint (book->msg);
904		904
905	if (msgtype < 0)	905	if (msgtype < 0)
906	return (title *) NULL;	906	return (title *) NULL;
907		907
908	if (tl)	908	if (tl)
909	t = tl->first_book;	909	t = tl->first_book;
910	while (t)	910	while (t)
911	if (t->size == length && t->msg_index == index)	911	if (t->size == length && t->msg_index == index)
912	break;	912	break;
913	else	913	else
914	t = t->next;	914	t = t->next;
915		915
916	#ifdef ARCHIVE_DEBUG	916	#ifdef ARCHIVE_DEBUG
917	if (t)	917	if (t)
918	LOG (llevDebug, "Found title match (list %d): %s %s (%d)\n",	918	LOG (llevDebug, "Found title match (list %d): %s %s (%d)\n",
919	msgtype, t->name, t->authour, t->msg_index);	919	msgtype, t->name, t->authour, t->msg_index);
920	#endif	920	#endif
921		921
922	return t;	922	return t;
923	}	923	}
924		924
…		…
934	{	934	{
935	int nbr;	935	int nbr;
936	char name[MAX_BUF];	936	char name[MAX_BUF];
937		937
938	if (book->type != BOOK)	938	if (book->type != BOOK)
939	return;	939	return;
940		940
941	switch (msgtype)	941	switch (msgtype)
942	{	942	{
943	case 1: /*monster */	943	case 1: /*monster */
944	nbr = sizeof (mon_book_name) / sizeof (char *);	944	nbr = sizeof (mon_book_name) / sizeof (char *);
945	strcpy (name, mon_book_name[RANDOM () % nbr]);	945	strcpy (name, mon_book_name[RANDOM () % nbr]);
946	break;	946	break;
947	case 2: /*artifact */	947	case 2: /*artifact */
948	nbr = sizeof (art_book_name) / sizeof (char *);	948	nbr = sizeof (art_book_name) / sizeof (char *);
949	strcpy (name, art_book_name[RANDOM () % nbr]);	949	strcpy (name, art_book_name[RANDOM () % nbr]);
950	break;	950	break;
951	case 3: /*spellpath */	951	case 3: /*spellpath */
952	nbr = sizeof (path_book_name) / sizeof (char *);	952	nbr = sizeof (path_book_name) / sizeof (char *);
953	strcpy (name, path_book_name[RANDOM () % nbr]);	953	strcpy (name, path_book_name[RANDOM () % nbr]);
954	break;	954	break;
955	case 4: /*alchemy */	955	case 4: /*alchemy */
956	nbr = sizeof (formula_book_name) / sizeof (char *);	956	nbr = sizeof (formula_book_name) / sizeof (char *);
957	strcpy (name, formula_book_name[RANDOM () % nbr]);	957	strcpy (name, formula_book_name[RANDOM () % nbr]);
958	break;	958	break;
959	case 5: /*gods */	959	case 5: /*gods */
960	nbr = sizeof (gods_book_name) / sizeof (char *);	960	nbr = sizeof (gods_book_name) / sizeof (char *);
961	strcpy (name, gods_book_name[RANDOM () % nbr]);	961	strcpy (name, gods_book_name[RANDOM () % nbr]);
962	break;	962	break;
963	case 6: /*msg file */	963	case 6: /*msg file */
964	default:	964	default:
965	if (book->weight > 2000)	965	if (book->weight > 2000)
966	{ /* based on weight */	966	{ /* based on weight */
967	nbr = sizeof (heavy_book_name) / sizeof (char *);	967	nbr = sizeof (heavy_book_name) / sizeof (char *);
968	strcpy (name, heavy_book_name[RANDOM () % nbr]);	968	strcpy (name, heavy_book_name[RANDOM () % nbr]);
969	}	969	}
970	else if (book->weight < 2001)	970	else if (book->weight < 2001)
971	{	971	{
972	nbr = sizeof (light_book_name) / sizeof (char *);	972	nbr = sizeof (light_book_name) / sizeof (char *);
973	strcpy (name, light_book_name[RANDOM () % nbr]);	973	strcpy (name, light_book_name[RANDOM () % nbr]);
974	}	974	}
975	break;	975	break;
976	}	976	}
977	free_string (book->name);	977	free_string (book->name);
978	book->name = add_string (name);	978	book->name = add_string (name);
979	}	979	}
980		980
…		…
988	{	988	{
989	char title[MAX_BUF], name[MAX_BUF];	989	char title[MAX_BUF], name[MAX_BUF];
990	int nbr = sizeof (book_author) / sizeof (char *);	990	int nbr = sizeof (book_author) / sizeof (char *);
991		991
992	if (msgtype < 0 || strlen (op->msg) < 5)	992	if (msgtype < 0 || strlen (op->msg) < 5)
993	return;	993	return;
994		994
995	switch (msgtype)	995	switch (msgtype)
996	{	996	{
997	case 1: /* monster */	997	case 1: /* monster */
998	nbr = sizeof (mon_author) / sizeof (char *);	998	nbr = sizeof (mon_author) / sizeof (char *);
999	strcpy (name, mon_author[RANDOM () % nbr]);	999	strcpy (name, mon_author[RANDOM () % nbr]);
1000	break;	1000	break;
1001	case 2: /* artifacts */	1001	case 2: /* artifacts */
1002	nbr = sizeof (art_author) / sizeof (char *);	1002	nbr = sizeof (art_author) / sizeof (char *);
1003	strcpy (name, art_author[RANDOM () % nbr]);	1003	strcpy (name, art_author[RANDOM () % nbr]);
1004	break;	1004	break;
1005	case 3: /* spellpath */	1005	case 3: /* spellpath */
1006	nbr = sizeof (path_author) / sizeof (char *);	1006	nbr = sizeof (path_author) / sizeof (char *);
1007	strcpy (name, path_author[RANDOM () % nbr]);	1007	strcpy (name, path_author[RANDOM () % nbr]);
1008	break;	1008	break;
1009	case 4: /* alchemy */	1009	case 4: /* alchemy */
1010	nbr = sizeof (formula_author) / sizeof (char *);	1010	nbr = sizeof (formula_author) / sizeof (char *);
1011	strcpy (name, formula_author[RANDOM () % nbr]);	1011	strcpy (name, formula_author[RANDOM () % nbr]);
1012	break;	1012	break;
1013	case 5: /* gods */	1013	case 5: /* gods */
1014	nbr = sizeof (gods_author) / sizeof (char *);	1014	nbr = sizeof (gods_author) / sizeof (char *);
1015	strcpy (name, gods_author[RANDOM () % nbr]);	1015	strcpy (name, gods_author[RANDOM () % nbr]);
1016	break;	1016	break;
1017	case 6: /* msg file */	1017	case 6: /* msg file */
1018	default:	1018	default:
1019	strcpy (name, book_author[RANDOM () % nbr]);	1019	strcpy (name, book_author[RANDOM () % nbr]);
1020	}	1020	}
1021		1021
1022	sprintf (title, "of %s", name);	1022	sprintf (title, "of %s", name);
1023	op->title = add_string (title);	1023	op->title = add_string (title);
1024	}	1024	}
…		…
1032	unique_book (const object *book, int msgtype)	1032	unique_book (const object *book, int msgtype)
1033	{	1033	{
1034	title *test;	1034	title *test;
1035		1035
1036	if (!booklist)	1036	if (!booklist)
1037	return 1; /* No archival entries! Must be unique! */	1037	return 1; /* No archival entries! Must be unique! */
1038		1038
1039	/* Go through the booklist. If the author and name match, not unique so	1039	/* Go through the booklist. If the author and name match, not unique so
1040	* return 0.	1040	* return 0.
1041	*/	1041	*/
1042	for (test = get_titlelist (msgtype)->first_book; test; test=test->next) {	1042	for (test = get_titlelist (msgtype)->first_book; test; test=test->next) {
1043	if (!strcmp(test->name, book->name) && !strcmp(book->title, test->authour))	1043	if (!strcmp(test->name, book->name) && !strcmp(book->title, test->authour))
1044	return 0;	1044	return 0;
1045	}	1045	}
1046	return 1;	1046	return 1;
1047	}	1047	}
1048		1048
1049	/* add_book_to_list() */	1049	/* add_book_to_list() */
…		…
1054	titlelist *tl = get_titlelist (msgtype);	1054	titlelist *tl = get_titlelist (msgtype);
1055	title *t;	1055	title *t;
1056		1056
1057	if (!tl)	1057	if (!tl)
1058	{	1058	{
1059	LOG (llevError, "add_book_to_list can't get booklist!\n");	1059	LOG (llevError, "add_book_to_list can't get booklist!\n");
1060	return;	1060	return;
1061	}	1061	}
1062		1062
1063	t = get_empty_book ();	1063	t = get_empty_book ();
1064	t->name = add_string (book->name);	1064	t->name = add_string (book->name);
1065	t->authour = add_string (book->title);	1065	t->authour = add_string (book->title);
…		…
1075	/* We have stuff we need to write now */	1075	/* We have stuff we need to write now */
1076	need_to_write_bookarchive=1;	1076	need_to_write_bookarchive=1;
1077		1077
1078	#ifdef ARCHIVE_DEBUG	1078	#ifdef ARCHIVE_DEBUG
1079	LOG (llevDebug, "Archiving new title: %s %s (%d)\n", book->name,	1079	LOG (llevDebug, "Archiving new title: %s %s (%d)\n", book->name,
1080	book->title, msgtype);	1080	book->title, msgtype);
1081	#endif	1081	#endif
1082		1082
1083	}	1083	}
1084		1084
1085		1085
…		…
1099	int nbr = sizeof (book_descrpt) / sizeof (char *);	1099	int nbr = sizeof (book_descrpt) / sizeof (char *);
1100		1100
1101	switch (book->type)	1101	switch (book->type)
1102	{	1102	{
1103	case BOOK:	1103	case BOOK:
1104	{	1104	{
1105	titlelist *tl = get_titlelist (msgtype);	1105	titlelist *tl = get_titlelist (msgtype);
1106	title *t = NULL;	1106	title *t = NULL;
1107	int tries = 0;	1107	int tries = 0;
1108	/* look to see if our msg already been archived. If so, alter	1108	/* look to see if our msg already been archived. If so, alter
1109	* the book to match the archival text. If we fail to match,	1109	* the book to match the archival text. If we fail to match,
1110	* then we archive the new title/name/msg combo if there is	1110	* then we archive the new title/name/msg combo if there is
1111	* room on the titlelist.	1111	* room on the titlelist.
1112	*/	1112	*/
1113		1113
1114	if ((strlen (book->msg) > 5) && (t = find_title (book, msgtype)))	1114	if ((strlen (book->msg) > 5) && (t = find_title (book, msgtype)))
1115	{	1115	{
1116	object *tmpbook;	1116	object *tmpbook;
1117		1117
1118	/* alter book properties */	1118	/* alter book properties */
1119	if ((tmpbook = get_archetype (t->archname)) != NULL)	1119	if ((tmpbook = get_archetype (t->archname)) != NULL)
1120	{	1120	{
1121	if (tmpbook->msg)	1121	if (tmpbook->msg)
1122	free_string (book->msg);	1122	free_string (book->msg);
1123	tmpbook->msg = add_string (book->msg);	1123	tmpbook->msg = add_string (book->msg);
1124	copy_object (tmpbook, book);	1124	copy_object (tmpbook, book);
1125	free_object (tmpbook);	1125	free_object (tmpbook);
1126	}	1126	}
1127		1127
1128	book->title = add_string (t->authour);	1128	book->title = add_string (t->authour);
1129	free_string (book->name);	1129	free_string (book->name);
1130	book->name = add_string (t->name);	1130	book->name = add_string (t->name);
1131	book->level = t->level;	1131	book->level = t->level;
1132	}	1132	}
1133	/* Don't have any default title, so lets make up a new one */	1133	/* Don't have any default title, so lets make up a new one */
1134	else	1134	else
1135	{	1135	{
1136	int numb, maxnames = max_titles[msgtype];	1136	int numb, maxnames = max_titles[msgtype];
1137	const char *old_title;	1137	const char *old_title;
1138	const char *old_name;	1138	const char *old_name;
1139		1139
1140	old_title = book->title ? add_string(book->title) : NULL;	1140	old_title = book->title ? add_string(book->title) : NULL;
1141	old_name = add_string(book->name);	1141	old_name = add_string(book->name);
1142		1142
1143	/* some pre-generated books have title already set (from	1143	/* some pre-generated books have title already set (from
1144	* maps), also don't bother looking for unique title if	1144	* maps), also don't bother looking for unique title if
1145	* we already used up all the available names! */	1145	* we already used up all the available names! */
1146		1146
1147	if (!tl)	1147	if (!tl)
1148	{	1148	{
1149	LOG (llevError, "change_book_name(): can't find title list\n");	1149	LOG (llevError, "change_book_name(): can't find title list\n");
1150	numb = 0;	1150	numb = 0;
1151	}	1151	}
1152	else	1152	else
1153	numb = tl->number;	1153	numb = tl->number;
1154		1154
1155	if (numb == maxnames)	1155	if (numb == maxnames)
1156	{	1156	{
1157	#ifdef ARCHIVE_DEBUG	1157	#ifdef ARCHIVE_DEBUG
1158	LOG (llevDebug, "titles for list %d full (%d possible).\n",	1158	LOG (llevDebug, "titles for list %d full (%d possible).\n",
1159	msgtype, maxnames);	1159	msgtype, maxnames);
1160	#endif	1160	#endif
1161	if (old_title != NULL)	1161	if (old_title != NULL)
1162	free_string(old_title);	1162	free_string(old_title);
1163	free_string(old_name);	1163	free_string(old_name);
1164	break;	1164	break;
1165	}	1165	}
1166	/* shouldnt change map-maker books */	1166	/* shouldnt change map-maker books */
1167	else if (!book->title)	1167	else if (!book->title)
1168	do	1168	do
1169	{	1169	{
1170	/* random book name */	1170	/* random book name */
1171	new_text_name (book, msgtype);	1171	new_text_name (book, msgtype);
1172	add_author (book, msgtype); /* random author */	1172	add_author (book, msgtype); /* random author */
1173	tries++;	1173	tries++;
1174	}	1174	}
1175	while (!unique_book (book, msgtype) && tries < MAX_TITLE_CHECK);	1175	while (!unique_book (book, msgtype) && tries < MAX_TITLE_CHECK);
1176		1176
1177	/* Now deal with 2 cases.	1177	/* Now deal with 2 cases.
1178	* 1)If no space for a new title exists lets just restore	1178	* 1)If no space for a new title exists lets just restore
1179	* the old book properties. Remember, if the book had	1179	* the old book properties. Remember, if the book had
1180	* matchd an older entry on the titlelist, we shouldnt	1180	* matchd an older entry on the titlelist, we shouldnt
1181	* have called this routine in the first place!	1181	* have called this routine in the first place!
1182	* 2) If we got a unique title, we need to add it to	1182	* 2) If we got a unique title, we need to add it to
1183	* the list.	1183	* the list.
1184	*/	1184	*/
1185		1185
1186	if (tries == MAX_TITLE_CHECK || numb == maxnames)	1186	if (tries == MAX_TITLE_CHECK || numb == maxnames)
1187	{ /* got to check maxnames again */	1187	{ /* got to check maxnames again */
1188	#ifdef ARCHIVE_DEBUG	1188	#ifdef ARCHIVE_DEBUG
1189	LOG (llevDebug, "Failed to obtain unique title for %s %s (names:%d/%d)\n",	1189	LOG (llevDebug, "Failed to obtain unique title for %s %s (names:%d/%d)\n",
1190	book->name, book->title, numb, maxnames);	1190	book->name, book->title, numb, maxnames);
1191	#endif	1191	#endif
1192	/* restore old book properties here */	1192	/* restore old book properties here */
1193	free_string (book->name);	1193	free_string (book->name);
1194	free_string (book->title);	1194	free_string (book->title);
1195	if (old_title!=NULL)	1195	if (old_title!=NULL)
1196	book->title = add_string (old_title);	1196	book->title = add_string (old_title);
1197		1197
1198	if (RANDOM () % 4) {	1198	if (RANDOM () % 4) {
1199	/* Lets give the book a description to individualize it some */	1199	/* Lets give the book a description to individualize it some */
1200	char new_name[MAX_BUF];	1200	char new_name[MAX_BUF];
1201	snprintf (new_name, MAX_BUF, "%s %s", book_descrpt[RANDOM () % nbr], old_name);	1201	snprintf (new_name, MAX_BUF, "%s %s", book_descrpt[RANDOM () % nbr], old_name);
1202		1202
1203	book->name = add_string (new_name);	1203	book->name = add_string (new_name);
1204	} else {	1204	} else {
1205	book->name = add_string (old_name);	1205	book->name = add_string (old_name);
1206	}	1206	}
1207	}	1207	}
1208	else if (book->title && strlen (book->msg) > 5) { /* archive if long msg texts */	1208	else if (book->title && strlen (book->msg) > 5) { /* archive if long msg texts */
1209	add_book_to_list (book, msgtype);	1209	add_book_to_list (book, msgtype);
1210	}	1210	}
1211		1211
1212	if (old_title != NULL)	1212	if (old_title != NULL)
1213	free_string(old_title);	1213	free_string(old_title);
1214	free_string(old_name);	1214	free_string(old_name);
1215		1215
1216	}	1216	}
1217	break;	1217	break;
1218	}	1218	}
1219		1219
1220	default:	1220	default:
1221	LOG (llevError, "change_book_name() called w/ illegal obj type.\n");	1221	LOG (llevError, "change_book_name() called w/ illegal obj type.\n");
1222	return;	1222	return;
1223	}	1223	}
1224	}	1224	}
1225		1225
1226	/*****************************************************************************	1226	/*****************************************************************************
1227	*	1227	*
…		…
1247	objectlink *mon = first_mon_info;	1247	objectlink *mon = first_mon_info;
1248	int i = 0, monnr;	1248	int i = 0, monnr;
1249		1249
1250	/* safety check. Problem w/ init_mon_info list? */	1250	/* safety check. Problem w/ init_mon_info list? */
1251	if (!nrofmon || !mon)	1251	if (!nrofmon || !mon)
1252	return (object *) NULL;	1252	return (object *) NULL;
1253		1253
1254	if (!level)	1254	if (!level)
1255	{	1255	{
1256	/* lets get a random monster from the mon_info linked list */	1256	/* lets get a random monster from the mon_info linked list */
1257	monnr = RANDOM () % nrofmon;	1257	monnr = RANDOM () % nrofmon;
1258		1258
1259	for (mon = first_mon_info, i = 0; mon; mon = mon->next)	1259	for (mon = first_mon_info, i = 0; mon; mon = mon->next)
1260	if (i++ == monnr)	1260	if (i++ == monnr)
1261	break;	1261	break;
1262		1262
1263	if (!mon)	1263	if (!mon)
1264	{	1264	{
1265	LOG (llevError, "get_random_mon: Didn't find a monster when we should have\n");	1265	LOG (llevError, "get_random_mon: Didn't find a monster when we should have\n");
1266	return NULL;	1266	return NULL;
1267	}	1267	}
1268	return mon->ob;	1268	return mon->ob;
1269	}	1269	}
1270		1270
1271	/* Case where we are searching by level. Redone 971225 to be clearer	1271	/* Case where we are searching by level. Redone 971225 to be clearer
1272	* and more random. Before, it looks like it took a random monster from	1272	* and more random. Before, it looks like it took a random monster from
1273	* the list, and then returned the first monster after that which was	1273	* the list, and then returned the first monster after that which was
…		…
1280	* are a group of high level monsters all around each other.	1280	* are a group of high level monsters all around each other.
1281	*/	1281	*/
1282		1282
1283	/* First count number of monsters meeting level criteria */	1283	/* First count number of monsters meeting level criteria */
1284	for (mon = first_mon_info, i = 0; mon; mon = mon->next)	1284	for (mon = first_mon_info, i = 0; mon; mon = mon->next)
1285	if (mon->ob->level >= level)	1285	if (mon->ob->level >= level)
1286	i++;	1286	i++;
1287		1287
1288	if (i == 0)	1288	if (i == 0)
1289	{	1289	{
1290	LOG (llevError, "get_random_mon() couldn't return monster for level %d\n",	1290	LOG (llevError, "get_random_mon() couldn't return monster for level %d\n",
1291	level);	1291	level);
1292	return NULL;	1292	return NULL;
1293	}	1293	}
1294		1294
1295	monnr = RANDOM () % i;	1295	monnr = RANDOM () % i;
1296	for (mon = first_mon_info; mon; mon = mon->next)	1296	for (mon = first_mon_info; mon; mon = mon->next)
1297	if (mon->ob->level >= level && monnr-- == 0)	1297	if (mon->ob->level >= level && monnr-- == 0)
1298	return mon->ob;	1298	return mon->ob;
1299		1299
1300	if (!mon)	1300	if (!mon)
1301	{	1301	{
1302	LOG (llevError, "get_random_mon(): didn't find a monster when we should have\n");	1302	LOG (llevError, "get_random_mon(): didn't find a monster when we should have\n");
1303	return NULL;	1303	return NULL;
1304	}	1304	}
1305	return NULL; /* Should be unreached, by keeps warnings down */	1305	return NULL; /* Should be unreached, by keeps warnings down */
1306	}	1306	}
1307		1307
1308	/*	1308	/*
…		…
1331	get_next_mon (object *tmp)	1331	get_next_mon (object *tmp)
1332	{	1332	{
1333	objectlink *mon;	1333	objectlink *mon;
1334		1334
1335	for (mon = first_mon_info; mon; mon = mon->next)	1335	for (mon = first_mon_info; mon; mon = mon->next)
1336	if (mon->ob == tmp)	1336	if (mon->ob == tmp)
1337	break;	1337	break;
1338		1338
1339	/* didn't find a match */	1339	/* didn't find a match */
1340	if (!mon)	1340	if (!mon)
1341	return NULL;	1341	return NULL;
1342	if (mon->next)	1342	if (mon->next)
1343	return mon->next->ob;	1343	return mon->next->ob;
1344	else	1344	else
1345	return first_mon_info->ob;	1345	return first_mon_info->ob;
1346		1346
1347	}	1347	}
1348		1348
1349		1349
1350		1350
…		…
1369	* of text! (and flood out the available number of titles	1369	* of text! (and flood out the available number of titles
1370	* in the archive in a snap!) -b.t.	1370	* in the archive in a snap!) -b.t.
1371	*/	1371	*/
1372	tmp = get_random_mon (level * 3);	1372	tmp = get_random_mon (level * 3);
1373	while (tmp) {	1373	while (tmp) {
1374	/* monster description */	1374	/* monster description */
1375	sprintf (tmpbuf, "\n---\n%s", mon_desc (tmp));	1375	sprintf (tmpbuf, "\n---\n%s", mon_desc (tmp));
1376		1376
1377	if (!book_overflow (retbuf, tmpbuf, booksize))	1377	if (!book_overflow (retbuf, tmpbuf, booksize))
1378	strcat (retbuf, tmpbuf);	1378	strcat (retbuf, tmpbuf);
1379	else	1379	else
1380	break;	1380	break;
1381		1381
1382	/* Note that the value this returns is not based on level */	1382	/* Note that the value this returns is not based on level */
1383	tmp = get_next_mon (tmp);	1383	tmp = get_next_mon (tmp);
1384	}	1384	}
1385		1385
1386	#ifdef BOOK_MSG_DEBUG	1386	#ifdef BOOK_MSG_DEBUG
1387	LOG (llevDebug, "\n mon_info_msg() created strng: %d\n", strlen (retbuf));	1387	LOG (llevDebug, "\n mon_info_msg() created strng: %d\n", strlen (retbuf));
1388	fprintf (logfile, " MADE THIS:\n%s\n", retbuf);	1388	fprintf (logfile, " MADE THIS:\n%s\n", retbuf);
…		…
1411	static char retbuf[BOOK_BUF];	1411	static char retbuf[BOOK_BUF];
1412	object *tmp = NULL;	1412	object *tmp = NULL;
1413		1413
1414	/* values greater than 5 create msg buffers that are too big! */	1414	/* values greater than 5 create msg buffers that are too big! */
1415	if (book_entries > 5)	1415	if (book_entries > 5)
1416	book_entries = 5;	1416	book_entries = 5;
1417		1417
1418	/* lets determine what kind of artifact type randomly.	1418	/* lets determine what kind of artifact type randomly.
1419	* Right now legal artifacts only come from those listed	1419	* Right now legal artifacts only come from those listed
1420	* in art_name_array. Also, we check to be sure an artifactlist	1420	* in art_name_array. Also, we check to be sure an artifactlist
1421	* for that type exists!	1421	* for that type exists!
1422	*/	1422	*/
1423	i=0;	1423	i=0;
1424	do {	1424	do {
1425	index = RANDOM () % (sizeof (art_name_array) / sizeof (arttypename));	1425	index = RANDOM () % (sizeof (art_name_array) / sizeof (arttypename));
1426	type = art_name_array[index].type;	1426	type = art_name_array[index].type;
1427	al = find_artifactlist (type);	1427	al = find_artifactlist (type);
1428	i++;	1428	i++;
1429	} while ((al == NULL) && (i<10));	1429	} while ((al == NULL) && (i<10));
1430		1430
1431	if (i==10) /* Unable to find a message */	1431	if (i==10) /* Unable to find a message */
1432	return("None");	1432	return("None");
1433		1433
1434	/* There is no reason to start on the artifact list at the begining. Lets	1434	/* There is no reason to start on the artifact list at the begining. Lets
1435	* take our starting position randomly... */	1435	* take our starting position randomly... */
1436	art = al->items;	1436	art = al->items;
1437	for (i = RANDOM () % level + RANDOM () % 2 + 1; i > 0; i--)	1437	for (i = RANDOM () % level + RANDOM () % 2 + 1; i > 0; i--)
1438	{	1438	{
1439	if (art == NULL)	1439	if (art == NULL)
1440	art = al->items; /* hmm, out of stuff, loop back around */	1440	art = al->items; /* hmm, out of stuff, loop back around */
1441	art = art->next;	1441	art = art->next;
1442	}	1442	}
1443		1443
1444	/* the base 'generic' name for our artifact */	1444	/* the base 'generic' name for our artifact */
1445	strcpy(name, art_name_array[index].name);	1445	strcpy(name, art_name_array[index].name);
1446		1446
1447	/* Ok, lets print out the contents */	1447	/* Ok, lets print out the contents */
1448	sprintf (retbuf, "Herein %s detailed %s...\n", book_entries > 1 ? "are" : "is",	1448	sprintf (retbuf, "Herein %s detailed %s...\n", book_entries > 1 ? "are" : "is",
1449	book_entries > 1 ? "some artifacts" : "an artifact");	1449	book_entries > 1 ? "some artifacts" : "an artifact");
1450		1450
1451	/* artifact msg attributes loop. Lets keep adding entries to the 'book'	1451	/* artifact msg attributes loop. Lets keep adding entries to the 'book'
1452	* as long as we have space up to the allowed max # (book_entires)	1452	* as long as we have space up to the allowed max # (book_entires)
1453	*/	1453	*/
1454	while (book_entries > 0)	1454	while (book_entries > 0)
1455	{	1455	{
1456		1456
1457	if (art == NULL)	1457	if (art == NULL)
1458	art = al->items;	1458	art = al->items;
1459		1459
1460	/* separator of items */	1460	/* separator of items */
1461	strcpy (buf, "--- \n");	1461	strcpy (buf, "--- \n");
1462		1462
1463	/* Name */	1463	/* Name */
1464	if (art->allowed != NULL && strcmp (art->allowed->name, "All"))	1464	if (art->allowed != NULL && strcmp (art->allowed->name, "All"))
1465	{	1465	{
1466	linked_char *temp, *next = art->allowed;	1466	linked_char *temp, *next = art->allowed;
1467	do	1467	do
1468	{	1468	{
1469	temp = next;	1469	temp = next;
1470	next = next->next;	1470	next = next->next;
1471	}	1471	}
1472	while ((next != (linked_char *) NULL) && !RANDOM () % 2);	1472	while ((next != (linked_char *) NULL) && !RANDOM () % 2);
1473	sprintf (buf, "%s A %s of %s", buf, temp->name, art->item->name);	1473	sprintf (buf, "%s A %s of %s", buf, temp->name, art->item->name);
1474	}	1474	}
1475	else /* default name is used */	1475	else /* default name is used */
1476	sprintf (buf, "%s The %s of %s", buf, name, art->item->name);	1476	sprintf (buf, "%s The %s of %s", buf, name, art->item->name);
1477		1477
1478	/* chance of finding */	1478	/* chance of finding */
1479	chance = (int) (100 * ((float) art->chance / al->total_chance));	1479	chance = (int) (100 * ((float) art->chance / al->total_chance));
1480	if (chance >= 20)	1480	if (chance >= 20)
1481	sprintf (sbuf, "an uncommon");	1481	sprintf (sbuf, "an uncommon");
1482	else if (chance >= 10)	1482	else if (chance >= 10)
1483	sprintf (sbuf, "an unusual");	1483	sprintf (sbuf, "an unusual");
1484	else if (chance >= 5)	1484	else if (chance >= 5)
1485	sprintf (sbuf, "a rare");	1485	sprintf (sbuf, "a rare");
1486	else	1486	else
1487	sprintf (sbuf, "a very rare");	1487	sprintf (sbuf, "a very rare");
1488	sprintf (buf, "%s is %s\n", buf, sbuf);	1488	sprintf (buf, "%s is %s\n", buf, sbuf);
1489		1489
1490	/* value of artifact */	1490	/* value of artifact */
1491	sprintf (buf, "%s item with a value that is %d times normal.\n",	1491	sprintf (buf, "%s item with a value that is %d times normal.\n",
1492	buf, art->item->value);	1492	buf, art->item->value);
1493		1493
1494	/* include the message about the artifact, if exists, and book	1494	/* include the message about the artifact, if exists, and book
1495	* level is kinda high */	1495	* level is kinda high */
1496	if (art->item->msg && (RANDOM () % 4 + 1) < level &&	1496	if (art->item->msg && (RANDOM () % 4 + 1) < level &&
1497	!((strlen (art->item->msg) + strlen (buf)) > BOOK_BUF))	1497	!((strlen (art->item->msg) + strlen (buf)) > BOOK_BUF))
1498	strcat(buf, art->item->msg);	1498	strcat(buf, art->item->msg);
1499		1499
1500	/* properties of the artifact */	1500	/* properties of the artifact */
1501	tmp = get_object ();	1501	tmp = get_object ();
1502	add_abilities (tmp, art->item);	1502	add_abilities (tmp, art->item);
1503	tmp->type = type;	1503	tmp->type = type;
1504	SET_FLAG (tmp, FLAG_IDENTIFIED);	1504	SET_FLAG (tmp, FLAG_IDENTIFIED);
1505	if ((ch = describe_item (tmp, NULL)) != NULL && strlen (ch) > 1)	1505	if ((ch = describe_item (tmp, NULL)) != NULL && strlen (ch) > 1)
1506	sprintf (buf, "%s Properties of this artifact include: \n %s \n",	1506	sprintf (buf, "%s Properties of this artifact include: \n %s \n",
1507	buf, ch);	1507	buf, ch);
1508	free_object(tmp);	1508	free_object(tmp);
1509	/* add the buf if it will fit */	1509	/* add the buf if it will fit */
1510	if (!book_overflow (retbuf, buf, booksize))	1510	if (!book_overflow (retbuf, buf, booksize))
1511	strcat (retbuf, buf);	1511	strcat (retbuf, buf);
1512	else	1512	else
1513	break;	1513	break;
1514		1514
1515	art = art->next;	1515	art = art->next;
1516	book_entries--;	1516	book_entries--;
1517	}	1517	}
1518		1518
1519	#ifdef BOOK_MSG_DEBUG	1519	#ifdef BOOK_MSG_DEBUG
1520	LOG (llevDebug, "artifact_msg() created strng: %d\n", strlen (retbuf));	1520	LOG (llevDebug, "artifact_msg() created strng: %d\n", strlen (retbuf));
1521	fprintf (logfile, " MADE THIS:\n%s", retbuf);	1521	fprintf (logfile, " MADE THIS:\n%s", retbuf);
…		…
1542	uint32 pnum = (path == -1) ? PATH_NULL : spellpathdef[path];	1542	uint32 pnum = (path == -1) ? PATH_NULL : spellpathdef[path];
1543	archetype *at;	1543	archetype *at;
1544		1544
1545	/* Preamble */	1545	/* Preamble */
1546	sprintf (retbuf, "Herein are detailed the names of %s\n",	1546	sprintf (retbuf, "Herein are detailed the names of %s\n",
1547	prayers ? "prayers": "incantations");	1547	prayers ? "prayers": "incantations");
1548		1548
1549	if (path == -1)	1549	if (path == -1)
1550	strcat (retbuf, "having no known spell path.\n");	1550	strcat (retbuf, "having no known spell path.\n");
1551	else	1551	else
1552	sprintf (retbuf, "%sbelonging to the path of %s:\n", retbuf,	1552	sprintf (retbuf, "%sbelonging to the path of %s:\n", retbuf,
1553	spellpathnames[path]);	1553	spellpathnames[path]);
1554		1554
1555	for (at=first_archetype; at != NULL; at=at->next) {	1555	for (at=first_archetype; at != NULL; at=at->next) {
1556	/* Determine if this is an appropriate spell. Must	1556	/* Determine if this is an appropriate spell. Must
1557	* be of matching path, must be of appropriate type (prayer	1557	* be of matching path, must be of appropriate type (prayer
1558	* or not), and must be within the valid level range.	1558	* or not), and must be within the valid level range.
1559	*/	1559	*/
1560	if (at->clone.type == SPELL && at->clone.path_attuned & pnum &&	1560	if (at->clone.type == SPELL && at->clone.path_attuned & pnum &&
1561	((at->clone.stats.grace && prayers) || (at->clone.stats.sp && !prayers)) &&	1561	((at->clone.stats.grace && prayers) || (at->clone.stats.sp && !prayers)) &&
1562	(at->clone.level < (level * 8))) {	1562	(at->clone.level < (level * 8))) {
1563	strcpy (tmpbuf, at->clone.name);	1563	strcpy (tmpbuf, at->clone.name);
1564		1564
1565	if (book_overflow (retbuf, tmpbuf, booksize))	1565	if (book_overflow (retbuf, tmpbuf, booksize))
1566	break;	1566	break;
1567	else {	1567	else {
1568	if (did_first_sp)	1568	if (did_first_sp)
1569	strcat (retbuf, ",\n");	1569	strcat (retbuf, ",\n");
1570	did_first_sp = 1;	1570	did_first_sp = 1;
1571	strcat (retbuf, tmpbuf);	1571	strcat (retbuf, tmpbuf);
1572	}	1572	}
1573	}	1573	}
1574	}	1574	}
1575	/* Geez, no spells were generated. */	1575	/* Geez, no spells were generated. */
1576	if (!did_first_sp) {	1576	if (!did_first_sp) {
1577	if (RANDOM () % 4) /* usually, lets make a recursive call... */	1577	if (RANDOM () % 4) /* usually, lets make a recursive call... */
1578	spellpath_msg (level, booksize);	1578	spellpath_msg (level, booksize);
1579	else /* give up, cause knowing no spells exist for path is info too. */	1579	else /* give up, cause knowing no spells exist for path is info too. */
1580	strcat (retbuf, "\n - no known spells exist -\n");	1580	strcat (retbuf, "\n - no known spells exist -\n");
1581	}	1581	}
1582	else {	1582	else {
1583	strcat (retbuf, "\n");	1583	strcat (retbuf, "\n");
1584	}	1584	}
1585	return retbuf;	1585	return retbuf;
1586	}	1586	}
1587		1587
1588		1588
…		…
1601	* ingredients) the formula can be.	1601	* ingredients) the formula can be.
1602	*/	1602	*/
1603	fl = get_formulalist (((RANDOM () % level) / 3) + 1);	1603	fl = get_formulalist (((RANDOM () % level) / 3) + 1);
1604		1604
1605	if (!fl)	1605	if (!fl)
1606	fl = get_formulalist (1); /* safety */	1606	fl = get_formulalist (1); /* safety */
1607		1607
1608	if (fl->total_chance == 0)	1608	if (fl->total_chance == 0)
1609	{	1609	{
1610	book->msg = add_string(" <indecipherable text>\n");	1610	book->msg = add_string(" <indecipherable text>\n");
1611	new_text_name(book, 4);	1611	new_text_name(book, 4);
1612	add_author(book,4);	1612	add_author(book,4);
1613	return;	1613	return;
1614	}	1614	}
1615		1615
1616	/* get a random formula, weighted by its bookchance */	1616	/* get a random formula, weighted by its bookchance */
1617	chance = RANDOM () % fl->total_chance;	1617	chance = RANDOM () % fl->total_chance;
1618	for (formula = fl->items; formula != NULL; formula = formula->next) {	1618	for (formula = fl->items; formula != NULL; formula = formula->next) {
1619	chance -= formula->chance;	1619	chance -= formula->chance;
1620	if (chance <= 0)	1620	if (chance <= 0)
1621	break;	1621	break;
1622	}	1622	}
1623		1623
1624	if (!formula || formula->arch_names <= 0) {	1624	if (!formula || formula->arch_names <= 0) {
1625	book->msg = add_string(" <indecipherable text>\n");	1625	book->msg = add_string(" <indecipherable text>\n");
1626	new_text_name(book, 4);	1626	new_text_name(book, 4);
1627	add_author(book,4);	1627	add_author(book,4);
1628		1628
1629	} else {	1629	} else {
1630	/* looks like a formula was found. Base the amount	1630	/* looks like a formula was found. Base the amount
1631	* of information on the booklevel and the spellevel	1631	* of information on the booklevel and the spellevel
1632	* of the formula. */	1632	* of the formula. */
1633		1633
1634	const char *op_name = formula->arch_name[RANDOM()%formula->arch_names];	1634	const char *op_name = formula->arch_name[RANDOM()%formula->arch_names];
1635	archetype *at;	1635	archetype *at;
1636		1636
1637	/* preamble */	1637	/* preamble */
1638	sprintf(retbuf, "Herein is described a project using %s: \n",	1638	sprintf(retbuf, "Herein is described a project using %s: \n",
1639	formula->skill?formula->skill:"an unknown skill");	1639	formula->skill?formula->skill:"an unknown skill");
1640		1640
1641	if ((at = find_archetype (op_name)) != (archetype *) NULL)	1641	if ((at = find_archetype (op_name)) != (archetype *) NULL)
1642	op_name = at->clone.name;	1642	op_name = at->clone.name;
1643	else	1643	else
1644	LOG (llevError, "formula_msg() can't find arch %s for formula.\n",	1644	LOG (llevError, "formula_msg() can't find arch %s for formula.\n",
1645	op_name);	1645	op_name);
1646		1646
1647	/* item name */	1647	/* item name */
1648	if (strcmp (formula->title, "NONE")) {	1648	if (strcmp (formula->title, "NONE")) {
1649	sprintf (retbuf, "%sThe %s of %s", retbuf, op_name, formula->title);	1649	sprintf (retbuf, "%sThe %s of %s", retbuf, op_name, formula->title);
1650	/* This results in things like pile of philo. sulfur.	1650	/* This results in things like pile of philo. sulfur.
1651	* while philo. sulfur may look better, without this,	1651	* while philo. sulfur may look better, without this,
1652	* you get things like 'the wise' because its missing the	1652	* you get things like 'the wise' because its missing the
1653	* water of section.	1653	* water of section.
1654	*/	1654	*/
1655	sprintf(title,"%s: %s of %s",	1655	sprintf(title,"%s: %s of %s",
1656	formula_book_name[RANDOM() % (sizeof(formula_book_name) / sizeof(char*))],	1656	formula_book_name[RANDOM() % (sizeof(formula_book_name) / sizeof(char*))],
1657	op_name, formula->title);	1657	op_name, formula->title);
1658	}	1658	}
1659	else	1659	else
1660	{	1660	{
1661	sprintf (retbuf, "%sThe %s", retbuf, op_name);	1661	sprintf (retbuf, "%sThe %s", retbuf, op_name);
1662	sprintf(title,"%s: %s",	1662	sprintf(title,"%s: %s",
1663	formula_book_name[RANDOM() % (sizeof(formula_book_name) / sizeof(char*))],	1663	formula_book_name[RANDOM() % (sizeof(formula_book_name) / sizeof(char*))],
1664	op_name);	1664	op_name);
1665	if (at->clone.title)	1665	if (at->clone.title)
1666	{	1666	{
1667	strcat (retbuf, " ");	1667	strcat (retbuf, " ");
1668	strcat (retbuf, at->clone.title);	1668	strcat (retbuf, at->clone.title);
1669	strcat(title, " ");	1669	strcat(title, " ");
1670	strcat(title, at->clone.title);	1670	strcat(title, at->clone.title);
1671	}	1671	}
1672	}	1672	}
1673	/* Lets name the book something meaningful ! */	1673	/* Lets name the book something meaningful ! */
1674	if (book->name) free_string(book->name);	1674	if (book->name) free_string(book->name);
1675	book->name = add_string(title);	1675	book->name = add_string(title);
1676	if (book->title) {	1676	if (book->title) {
1677	free_string(book->title);	1677	free_string(book->title);
1678	book->title = NULL;	1678	book->title = NULL;
1679	}	1679	}
1680		1680
1681	/* ingredients to make it */	1681	/* ingredients to make it */
1682	if (formula->ingred != NULL)	1682	if (formula->ingred != NULL)
1683	{	1683	{
1684	linked_char *next;	1684	linked_char *next;
1685	archetype *at;	1685	archetype *at;
1686		1686
1687	at = find_archetype(formula->cauldron);	1687	at = find_archetype(formula->cauldron);
1688		1688
1689	sprintf(retbuf + strlen(retbuf),	1689	sprintf(retbuf + strlen(retbuf),
1690	" may be made at %s using the following ingredients:\n",	1690	" may be made at %s using the following ingredients:\n",
1691	at?query_name(&at->clone):"an unknown place");	1691	at?query_name(&at->clone):"an unknown place");
1692		1692
1693	for (next = formula->ingred; next != NULL; next = next->next)	1693	for (next = formula->ingred; next != NULL; next = next->next)
1694	{	1694	{
1695	strcat (retbuf, next->name);	1695	strcat (retbuf, next->name);
1696	strcat (retbuf, "\n");	1696	strcat (retbuf, "\n");
1697	}	1697	}
1698	}	1698	}
1699	else	1699	else
1700	LOG (llevError, "formula_msg() no ingredient list for object %s of %s\n",	1700	LOG (llevError, "formula_msg() no ingredient list for object %s of %s\n",
1701	op_name, formula->title);	1701	op_name, formula->title);
1702	if (retbuf[strlen(retbuf)-1]!= '\n') strcat(retbuf, "\n");	1702	if (retbuf[strlen(retbuf)-1]!= '\n') strcat(retbuf, "\n");
1703	if (book->msg) free_string(book->msg);	1703	if (book->msg) free_string(book->msg);
1704	book->msg = add_string(retbuf);	1704	book->msg = add_string(retbuf);
1705	}	1705	}
1706	}	1706	}
1707		1707
1708		1708
1709	/* msgfile_msg() - generate a message drawn randomly from a	1709	/* msgfile_msg() - generate a message drawn randomly from a
…		…
1719	linked_char *msg = NULL;	1719	linked_char *msg = NULL;
1720		1720
1721	/* get a random message for the 'book' from linked list */	1721	/* get a random message for the 'book' from linked list */
1722	if (nrofmsg > 1)	1722	if (nrofmsg > 1)
1723	{	1723	{
1724	msg = first_msg;	1724	msg = first_msg;
1725	msgnum = RANDOM () % nrofmsg;	1725	msgnum = RANDOM () % nrofmsg;
1726	for (i = 0; msg && i < nrofmsg && i != msgnum; i++)	1726	for (i = 0; msg && i < nrofmsg && i != msgnum; i++)
1727	msg = msg->next;	1727	msg = msg->next;
1728	}	1728	}
1729		1729
1730	if (msg && !book_overflow (retbuf, msg->name, booksize))	1730	if (msg && !book_overflow (retbuf, msg->name, booksize))
1731	strcpy (retbuf, msg->name);	1731	strcpy (retbuf, msg->name);
1732	else	1732	else
1733	sprintf (retbuf, "\n <undecipherable text>");	1733	sprintf (retbuf, "\n <undecipherable text>");
1734		1734
1735	#ifdef BOOK_MSG_DEBUG	1735	#ifdef BOOK_MSG_DEBUG
1736	LOG (llevDebug, "\n info_list_msg() created strng: %d\n", strlen (retbuf));	1736	LOG (llevDebug, "\n info_list_msg() created strng: %d\n", strlen (retbuf));
1737	LOG (llevDebug, " MADE THIS:\n%s\n", retbuf);	1737	LOG (llevDebug, " MADE THIS:\n%s\n", retbuf);
1738	#endif	1738	#endif
…		…
1754	int i;	1754	int i;
1755	size_t introlen;	1755	size_t introlen;
1756	object *god = pntr_to_god_obj (get_rand_god ());	1756	object *god = pntr_to_god_obj (get_rand_god ());
1757		1757
1758	if (!god)	1758	if (!god)
1759	return (char *) NULL; /* oops, problems... */	1759	return (char *) NULL; /* oops, problems... */
1760	name = god->name;	1760	name = god->name;
1761		1761
1762	/* preamble.. */	1762	/* preamble.. */
1763	sprintf (retbuf, "This document contains knowledge concerning\n");	1763	sprintf (retbuf, "This document contains knowledge concerning\n");
1764	sprintf (retbuf, "%sthe diety %s", retbuf, name);	1764	sprintf (retbuf, "%sthe diety %s", retbuf, name);
1765		1765
1766	/* Always have as default information the god's descriptive terms. */	1766	/* Always have as default information the god's descriptive terms. */
1767	if (nstrtok (god->msg, ",") > 0)	1767	if (nstrtok (god->msg, ",") > 0)
1768	{	1768	{
1769	strcat (retbuf, ", known as");	1769	strcat (retbuf, ", known as");
1770	strcat (retbuf, strtoktolin (god->msg, ","));	1770	strcat (retbuf, strtoktolin (god->msg, ","));
1771	}	1771	}
1772	else	1772	else
1773	strcat (retbuf, "...");	1773	strcat (retbuf, "...");
1774		1774
1775	strcat (retbuf, "\n ---\n");	1775	strcat (retbuf, "\n ---\n");
1776	introlen = strlen (retbuf); /* so we will know if no new info is added later */	1776	introlen = strlen (retbuf); /* so we will know if no new info is added later */
1777		1777
1778	/* Information about the god is random, and based on the level of the	1778	/* Information about the god is random, and based on the level of the
…		…
1780	* this ...	1780	* this ...
1781	*/	1781	*/
1782		1782
1783	while (level > 0)	1783	while (level > 0)
1784	{	1784	{
1785	sprintf (buf, " ");	1785	sprintf (buf, " ");
1786	if (level == 2 && RANDOM () % 2)	1786	if (level == 2 && RANDOM () % 2)
1787	{ /* enemy god */	1787	{ /* enemy god */
1788	const char *enemy = god->title;	1788	const char *enemy = god->title;
1789	if (enemy)	1789	if (enemy)
1790	sprintf (buf, "The gods %s and %s are enemies.\n ---\n",	1790	sprintf (buf, "The gods %s and %s are enemies.\n ---\n",
1791	name, enemy);	1791	name, enemy);
1792	}	1792	}
1793	if (level == 3 && RANDOM () % 2)	1793	if (level == 3 && RANDOM () % 2)
1794	{ /* enemy race, what the god's holy word effects */	1794	{ /* enemy race, what the god's holy word effects */
1795	const char *enemy = god->slaying;	1795	const char *enemy = god->slaying;
1796	if (enemy && !(god->path_denied & PATH_TURNING))	1796	if (enemy && !(god->path_denied & PATH_TURNING))
1797	if ((i = nstrtok (enemy, ",")) > 0)	1797	if ((i = nstrtok (enemy, ",")) > 0)
1798	{	1798	{
1799	char tmpbuf[MAX_BUF];	1799	char tmpbuf[MAX_BUF];
1800	sprintf (buf, "The holy words of %s have the power to\n", name);	1800	sprintf (buf, "The holy words of %s have the power to\n", name);
1801	strcat (buf, "slay creatures belonging to the ");	1801	strcat (buf, "slay creatures belonging to the ");
1802	if (i > 1)	1802	if (i > 1)
1803	sprintf (tmpbuf, "following \n races:%s",	1803	sprintf (tmpbuf, "following \n races:%s",
1804	strtoktolin (enemy, ","));	1804	strtoktolin (enemy, ","));
1805	else	1805	else
1806	sprintf (tmpbuf, "race of%s", strtoktolin (enemy, ","));	1806	sprintf (tmpbuf, "race of%s", strtoktolin (enemy, ","));
1807	sprintf (buf, "%s%s\n ---\n", buf, tmpbuf);	1807	sprintf (buf, "%s%s\n ---\n", buf, tmpbuf);
1808	}	1808	}
1809	}	1809	}
1810	if (level == 4 && RANDOM () % 2)	1810	if (level == 4 && RANDOM () % 2)
1811	{ /* Priest of god gets these protect,vulnerable... */	1811	{ /* Priest of god gets these protect,vulnerable... */
1812	char tmpbuf[MAX_BUF],*cp;	1812	char tmpbuf[MAX_BUF],*cp;
1813		1813
1814	cp = describe_resistance(god, 1);	1814	cp = describe_resistance(god, 1);
1815		1815
1816	if (*cp) { /* This god does have protections */	1816	if (*cp) { /* This god does have protections */
1817	sprintf (tmpbuf, "%s has a potent aura which is extended\n"	1817	sprintf (tmpbuf, "%s has a potent aura which is extended\n"
1818	,name);	1818	,name);
1819	strcat (tmpbuf, "faithful priests. The effects of this aura include:\n");	1819	strcat (tmpbuf, "faithful priests. The effects of this aura include:\n");
1820	strcat(tmpbuf, cp);	1820	strcat(tmpbuf, cp);
1821	strcat (buf, tmpbuf);	1821	strcat (buf, tmpbuf);
1822	strcat (buf, "\n ---\n");	1822	strcat (buf, "\n ---\n");
1823	}	1823	}
1824	else	1824	else
1825	sprintf (buf, " ");	1825	sprintf (buf, " ");
1826	}	1826	}
1827	if (level == 5 && RANDOM () % 2)	1827	if (level == 5 && RANDOM () % 2)
1828	{ /* aligned race, summoning */	1828	{ /* aligned race, summoning */
1829	const char *race = god->race; /* aligned race */	1829	const char *race = god->race; /* aligned race */
1830	if (race && !(god->path_denied & PATH_SUMMON))	1830	if (race && !(god->path_denied & PATH_SUMMON))
1831	if ((i = nstrtok (race, ",")) > 0)	1831	if ((i = nstrtok (race, ",")) > 0)
1832	{	1832	{
1833	char tmpbuf[MAX_BUF];	1833	char tmpbuf[MAX_BUF];
1834	sprintf (buf, "Creatures sacred to %s include the \n", name);	1834	sprintf (buf, "Creatures sacred to %s include the \n", name);
1835	if (i > 1)	1835	if (i > 1)
1836	sprintf (tmpbuf, "following \n races:%s",	1836	sprintf (tmpbuf, "following \n races:%s",
1837	strtoktolin (race, ","));	1837	strtoktolin (race, ","));
1838	else	1838	else
1839	sprintf (tmpbuf, "race of%s", strtoktolin (race, ","));	1839	sprintf (tmpbuf, "race of%s", strtoktolin (race, ","));
1840	sprintf (buf, "%s%s\n ---\n", buf, tmpbuf);	1840	sprintf (buf, "%s%s\n ---\n", buf, tmpbuf);
1841	}	1841	}
1842	}	1842	}
1843	if (level == 6 && RANDOM () % 2)	1843	if (level == 6 && RANDOM () % 2)
1844	{ /* blessing,curse properties of the god */	1844	{ /* blessing,curse properties of the god */
1845	char tmpbuf[MAX_BUF],*cp;	1845	char tmpbuf[MAX_BUF],*cp;
1846		1846
1847	cp = describe_resistance(god, 1);	1847	cp = describe_resistance(god, 1);
1848		1848
1849	if (*cp) { /* This god does have protections */	1849	if (*cp) { /* This god does have protections */
1850	sprintf (tmpbuf, "\nThe priests of %s are known to be able to \n"	1850	sprintf (tmpbuf, "\nThe priests of %s are known to be able to \n"
1851	,name);	1851	,name);
1852	strcat (tmpbuf, "bestow a blessing which makes the recipient\n");	1852	strcat (tmpbuf, "bestow a blessing which makes the recipient\n");
1853	strcat(tmpbuf, cp);	1853	strcat(tmpbuf, cp);
1854	strcat (buf, tmpbuf);	1854	strcat (buf, tmpbuf);
1855	strcat (buf, "\n ---\n");	1855	strcat (buf, "\n ---\n");
1856	}	1856	}
1857	else	1857	else
1858	sprintf (buf, " ");	1858	sprintf (buf, " ");
1859		1859
1860	}	1860	}
1861	if (level == 8 && RANDOM () % 2)	1861	if (level == 8 && RANDOM () % 2)
1862	{ /* immunity, holy possession */	1862	{ /* immunity, holy possession */
1863	int has_effect = 0, tmpvar;	1863	int has_effect = 0, tmpvar;
1864	char tmpbuf[MAX_BUF];	1864	char tmpbuf[MAX_BUF];
1865	sprintf (tmpbuf, "\n");	1865	sprintf (tmpbuf, "\n");
1866	sprintf (tmpbuf, "The priests of %s are known to make cast a mighty \n"	1866	sprintf (tmpbuf, "The priests of %s are known to make cast a mighty \n"
1867	,name);	1867	,name);
1868		1868
1869	strcat (tmpbuf, "prayer of possession which gives the recipient\n");	1869	strcat (tmpbuf, "prayer of possession which gives the recipient\n");
1870		1870
1871	for (tmpvar=0; tmpvar<NROFATTACKS; tmpvar++) {	1871	for (tmpvar=0; tmpvar<NROFATTACKS; tmpvar++) {
1872	if (god->resist[tmpvar]==100) {	1872	if (god->resist[tmpvar]==100) {
1873	has_effect = 1;	1873	has_effect = 1;
1874	sprintf(tmpbuf + strlen(tmpbuf),"Immunity to %s", attacktype_desc[tmpvar]);	1874	sprintf(tmpbuf + strlen(tmpbuf),"Immunity to %s", attacktype_desc[tmpvar]);
1875	}	1875	}
1876	}	1876	}
1877	if (has_effect) {	1877	if (has_effect) {
1878	strcat (buf, tmpbuf);	1878	strcat (buf, tmpbuf);
1879	strcat (buf, "\n ---\n");	1879	strcat (buf, "\n ---\n");
1880	}	1880	}
1881	else	1881	else
1882	sprintf (buf, " ");	1882	sprintf (buf, " ");
1883	}	1883	}
1884	if (level == 12 && RANDOM () % 2)	1884	if (level == 12 && RANDOM () % 2)
1885	{ /* spell paths */	1885	{ /* spell paths */
1886	int has_effect = 0, tmpvar;	1886	int has_effect = 0, tmpvar;
1887	char tmpbuf[MAX_BUF];	1887	char tmpbuf[MAX_BUF];
1888	sprintf (tmpbuf, "\n");	1888	sprintf (tmpbuf, "\n");
1889	sprintf (tmpbuf, "It is rarely known fact that the priests of %s\n"	1889	sprintf (tmpbuf, "It is rarely known fact that the priests of %s\n"
1890	,name);	1890	,name);
1891	strcat (tmpbuf, "are mystically transformed. Effects of this include:\n");	1891	strcat (tmpbuf, "are mystically transformed. Effects of this include:\n");
1892	if ((tmpvar = god->path_attuned))	1892	if ((tmpvar = god->path_attuned))
1893	{	1893	{
1894	has_effect = 1;	1894	has_effect = 1;
1895	DESCRIBE_PATH (tmpbuf, tmpvar, "Attuned");	1895	DESCRIBE_PATH (tmpbuf, tmpvar, "Attuned");
1896	}	1896	}
1897	if ((tmpvar = god->path_repelled))	1897	if ((tmpvar = god->path_repelled))
1898	{	1898	{
1899	has_effect = 1;	1899	has_effect = 1;
1900	DESCRIBE_PATH (tmpbuf, tmpvar, "Repelled");	1900	DESCRIBE_PATH (tmpbuf, tmpvar, "Repelled");
1901	}	1901	}
1902	if ((tmpvar = god->path_denied))	1902	if ((tmpvar = god->path_denied))
1903	{	1903	{
1904	has_effect = 1;	1904	has_effect = 1;
1905	DESCRIBE_PATH (tmpbuf, tmpvar, "Denied");	1905	DESCRIBE_PATH (tmpbuf, tmpvar, "Denied");
1906	}	1906	}
1907	if (has_effect)	1907	if (has_effect)
1908	{	1908	{
1909	strcat (buf, tmpbuf);	1909	strcat (buf, tmpbuf);
1910	strcat (buf, "\n ---\n");	1910	strcat (buf, "\n ---\n");
1911	}	1911	}
1912	else	1912	else
1913	sprintf (buf, " ");	1913	sprintf (buf, " ");
1914	}	1914	}
1915		1915
1916	/* check to be sure new buffer size dont exceed either	1916	/* check to be sure new buffer size dont exceed either
1917	* the maximum buffer size, or the 'natural' size of the	1917	* the maximum buffer size, or the 'natural' size of the
1918	* book...	1918	* book...
1919	*/	1919	*/
1920	if (book_overflow (retbuf, buf, booksize))	1920	if (book_overflow (retbuf, buf, booksize))
1921	break;	1921	break;
1922	else if (strlen (buf) > 1)	1922	else if (strlen (buf) > 1)
1923	strcat (retbuf, buf);	1923	strcat (retbuf, buf);
1924	level--;	1924	level--;
1925	}	1925	}
1926	if (strlen (retbuf) == introlen)	1926	if (strlen (retbuf) == introlen)
1927	{ /* we got no information beyond the preamble! */	1927	{ /* we got no information beyond the preamble! */
1928	strcat (retbuf, " [Unfortunately the rest of the information is\n");	1928	strcat (retbuf, " [Unfortunately the rest of the information is\n");
1929	strcat (retbuf, " hopelessly garbled!]\n ---\n");	1929	strcat (retbuf, " hopelessly garbled!]\n ---\n");
1930	}	1930	}
1931	#ifdef BOOK_MSG_DEBUG	1931	#ifdef BOOK_MSG_DEBUG
1932	LOG (llevDebug, "\n god_info_msg() created strng: %d\n", strlen (retbuf));	1932	LOG (llevDebug, "\n god_info_msg() created strng: %d\n", strlen (retbuf));
1933	fprintf (logfile, " MADE THIS:\n%s", retbuf);	1933	fprintf (logfile, " MADE THIS:\n%s", retbuf);
1934	#endif	1934	#endif
…		…
1959	int level = book->level ? (RANDOM () % book->level) + 1 : 1;	1959	int level = book->level ? (RANDOM () % book->level) + 1 : 1;
1960	int book_buf_size;	1960	int book_buf_size;
1961		1961
1962	/* safety */	1962	/* safety */
1963	if (book->type != BOOK)	1963	if (book->type != BOOK)
1964	return;	1964	return;
1965		1965
1966	if (level <= 0)	1966	if (level <= 0)
1967	return; /* if no level no point in doing any more... */	1967	return; /* if no level no point in doing any more... */
1968		1968
1969	/* Max text length this book can have. */	1969	/* Max text length this book can have. */
1970	book_buf_size = BOOKSIZE (book);	1970	book_buf_size = BOOKSIZE (book);
1971		1971
1972	/* &&& The message switch &&& */	1972	/* &&& The message switch &&& */
…		…
1983		1983
1984	msg_type = msg_type > 0 ? msg_type : (RANDOM () % 6);	1984	msg_type = msg_type > 0 ? msg_type : (RANDOM () % 6);
1985	switch (msg_type)	1985	switch (msg_type)
1986	{	1986	{
1987	case 1: /* monster attrib */	1987	case 1: /* monster attrib */
1988	strcpy (msgbuf, mon_info_msg (level, book_buf_size));	1988	strcpy (msgbuf, mon_info_msg (level, book_buf_size));
1989	break;	1989	break;
1990	case 2: /* artifact attrib */	1990	case 2: /* artifact attrib */
1991	strcpy (msgbuf, artifact_msg (level, book_buf_size));	1991	strcpy (msgbuf, artifact_msg (level, book_buf_size));
1992	break;	1992	break;
1993	case 3: /* grouping incantations/prayers by path */	1993	case 3: /* grouping incantations/prayers by path */
1994	strcpy (msgbuf, spellpath_msg (level, book_buf_size));	1994	strcpy (msgbuf, spellpath_msg (level, book_buf_size));
1995	break;	1995	break;
1996	case 4: /* describe an alchemy formula */	1996	case 4: /* describe an alchemy formula */
1997	make_formula_book(book, level);	1997	make_formula_book(book, level);
1998	/* make_formula_book already gives title */	1998	/* make_formula_book already gives title */
1999	return;	1999	return;
2000	break;	2000	break;
2001	case 5: /* bits of information about a god */	2001	case 5: /* bits of information about a god */
2002	strcpy (msgbuf, god_info_msg (level, book_buf_size));	2002	strcpy (msgbuf, god_info_msg (level, book_buf_size));
2003	break;	2003	break;
2004	case 0: /* use info list in lib/ */	2004	case 0: /* use info list in lib/ */
2005	default:	2005	default:
2006	strcpy (msgbuf, msgfile_msg (level, book_buf_size));	2006	strcpy (msgbuf, msgfile_msg (level, book_buf_size));
2007	break;	2007	break;
2008	}	2008	}
2009		2009
2010	strcat (msgbuf, "\n"); /* safety -- we get ugly map saves/crashes w/o this */	2010	strcat (msgbuf, "\n"); /* safety -- we get ugly map saves/crashes w/o this */
2011	if (strlen (msgbuf) > 1)	2011	if (strlen (msgbuf) > 1)
2012	{	2012	{
2013	if (book->msg)	2013	if (book->msg)
2014	free_string (book->msg);	2014	free_string (book->msg);
2015	book->msg = add_string (msgbuf);	2015	book->msg = add_string (msgbuf);
2016	/* lets give the "book" a new name, which may be a compound word */	2016	/* lets give the "book" a new name, which may be a compound word */
2017	change_book (book, msg_type);	2017	change_book (book, msg_type);
2018	}	2018	}
2019		2019
2020	}	2020	}
2021		2021
2022		2022
…		…
2036		2036
2037	LOG (llevDebug, "freeing all book information\n");	2037	LOG (llevDebug, "freeing all book information\n");
2038		2038
2039	for (tlist = booklist; tlist != NULL; tlist = tnext)	2039	for (tlist = booklist; tlist != NULL; tlist = tnext)
2040	{	2040	{
2041	tnext = tlist->next;	2041	tnext = tlist->next;
2042	for (title1 = tlist->first_book; title1; title1 = titlenext)	2042	for (title1 = tlist->first_book; title1; title1 = titlenext)
2043	{	2043	{
2044	titlenext = title1->next;	2044	titlenext = title1->next;
2045	if (title1->name)	2045	if (title1->name)
2046	free_string (title1->name);	2046	free_string (title1->name);
2047	if (title1->authour)	2047	if (title1->authour)
2048	free_string (title1->authour);	2048	free_string (title1->authour);
2049	if (title1->archname)	2049	if (title1->archname)
2050	free_string (title1->archname);	2050	free_string (title1->archname);
2051	free (title1);	2051	free (title1);
2052	}	2052	}
2053	free (tlist);	2053	free (tlist);
2054	}	2054	}
2055	for (lmsg = first_msg; lmsg; lmsg = nextmsg)	2055	for (lmsg = first_msg; lmsg; lmsg = nextmsg)
2056	{	2056	{
2057	nextmsg = lmsg->next;	2057	nextmsg = lmsg->next;
2058	if (lmsg->name)	2058	if (lmsg->name)
2059	free_string (lmsg->name);	2059	free_string (lmsg->name);
2060	free (lmsg);	2060	free (lmsg);
2061	}	2061	}
2062	for (monlink = first_mon_info; monlink; monlink = nextmon)	2062	for (monlink = first_mon_info; monlink; monlink = nextmon)
2063	{	2063	{
2064	nextmon = monlink->next;	2064	nextmon = monlink->next;
2065	free (monlink);	2065	free (monlink);
2066	}	2066	}
2067	}	2067	}
2068		2068
2069		2069
2070	/*****************************************************************************	2070	/*****************************************************************************
…		…
2091	sprintf (fname, "%s/bookarch", settings.localdir);	2091	sprintf (fname, "%s/bookarch", settings.localdir);
2092	LOG (llevDebug, "Updating book archive: %s...\n", fname);	2092	LOG (llevDebug, "Updating book archive: %s...\n", fname);
2093		2093
2094	if ((fp = fopen (fname, "w")) == NULL)	2094	if ((fp = fopen (fname, "w")) == NULL)
2095	{	2095	{
2096	LOG (llevDebug, "Can't open book archive file %s\n", fname);	2096	LOG (llevDebug, "Can't open book archive file %s\n", fname);
2097	}	2097	}
2098	else	2098	else
2099	{	2099	{
2100	while (bl)	2100	while (bl)
2101	{	2101	{
2102	for (book = bl->first_book; book; book = book->next)	2102	for (book = bl->first_book; book; book = book->next)
2103	if (book && book->authour)	2103	if (book && book->authour)
2104	{	2104	{
2105	fprintf (fp, "title %s\n", book->name);	2105	fprintf (fp, "title %s\n", book->name);
2106	fprintf (fp, "authour %s\n", book->authour);	2106	fprintf (fp, "authour %s\n", book->authour);
2107	fprintf (fp, "arch %s\n", book->archname);	2107	fprintf (fp, "arch %s\n", book->archname);
2108	fprintf (fp, "level %d\n", book->level);	2108	fprintf (fp, "level %d\n", book->level);
2109	fprintf (fp, "type %d\n", index);	2109	fprintf (fp, "type %d\n", index);
2110	fprintf (fp, "size %d\n", book->size);	2110	fprintf (fp, "size %d\n", book->size);
2111	fprintf (fp, "index %d\n", book->msg_index);	2111	fprintf (fp, "index %d\n", book->msg_index);
2112	fprintf (fp, "end\n");	2112	fprintf (fp, "end\n");
2113	}	2113	}
2114	bl = bl->next;	2114	bl = bl->next;
2115	index++;	2115	index++;
2116	}	2116	}
2117	fclose (fp);	2117	fclose (fp);
2118	chmod (fname, SAVE_MODE);	2118	chmod (fname, SAVE_MODE);
2119	}	2119	}
2120	}	2120	}
2121	readable_message_type* get_readable_message_type(object* readable){	2121	readable_message_type* get_readable_message_type(object* readable){
2122	uint8 subtype = readable->subtype;	2122	uint8 subtype = readable->subtype;
2123	if (subtype>last_readable_subtype)	2123	if (subtype>last_readable_subtype)
2124	return &(readable_message_types[0]);	2124	return &(readable_message_types[0]);
2125	return &(readable_message_types[subtype]);	2125	return &(readable_message_types[subtype]);
2126	}	2126	}

Diff Legend

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