ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/readable.C
(Generate patch)

Comparing deliantra/server/common/readable.C (file contents):
Revision 1.2 by root, Tue Aug 29 08:01:35 2006 UTC vs.
Revision 1.54 by root, Sun Nov 29 10:55:18 2009 UTC

1/* 1/*
2 * static char *rcsid_readable_c = 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * "$Id: readable.C,v 1.2 2006/08/29 08:01:35 root Exp $"; 3 *
4 */ 4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5
6/*
7 CrossFire, A Multiplayer game for X-windows
8
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
11 7 *
12 This program is free software; you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
13 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
14 the Free Software Foundation; either version 2 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
15 (at your option) any later version. 11 * option) any later version.
16 12 *
17 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,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details. 16 * GNU General Public License for more details.
21 17 *
22 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
23 along with this program; if not, write to the Free Software 19 * and the GNU General Public License along with this program. If not, see
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * <http://www.gnu.org/licenses/>.
25 21 *
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 * The authors can be reached via e-mail to <support@deliantra.net>
27*/ 23 */
28
29 24
30/* This file contains code relevant to the BOOKS hack -- designed 25/* This file contains code relevant to the BOOKS hack -- designed
31 * to allow randomly occuring messages in non-magical texts. 26 * to allow randomly occuring messages in non-magical texts.
32 */ 27 */
33 28
… …
35 30
36#include <global.h> 31#include <global.h>
37#include <book.h> 32#include <book.h>
38#include <living.h> 33#include <living.h>
39#include <spells.h> 34#include <spells.h>
40
41 35
42/* Define this if you want to archive book titles by contents. 36/* Define this if you want to archive book titles by contents.
43 * This option should enforce UNIQUE combinations of titles,authors and 37 * This option should enforce UNIQUE combinations of titles,authors and
44 * msg contents during and *between* game sessions. 38 * msg contents during and *between* game sessions.
45 * 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
… …
67 * be sure to copy it over to the new lib directory when you change versions. 61 * be sure to copy it over to the new lib directory when you change versions.
68 * -b.t. 62 * -b.t.
69 */ 63 */
70 64
71/* This flag is useful to see what kind of output messages are created */ 65/* This flag is useful to see what kind of output messages are created */
66
72/* #define BOOK_MSG_DEBUG */ 67/* #define BOOK_MSG_DEBUG */
73 68
74/* This flag is useful for debuging archiving action */ 69/* This flag is useful for debuging archiving action */
70
75/* #define ARCHIVE_DEBUG */ 71/* #define ARCHIVE_DEBUG */
76 72
77/* Moved these structures from struct.h to this file in 0.94.3 - they 73/* Moved these structures from struct.h to this file in 0.94.3 - they
78 * are not needed anyplace else, so why have them globally declared? 74 * are not needed anyplace else, so why have them globally declared?
79 */ 75 */
80 76
81/* 'title' and 'titlelist' are used by the readable code */ 77/* 'title' and 'titlelist' are used by the readable code */
82typedef struct titlestruct { 78struct title : zero_initialised
83 const char *name; /* the name of the book */ 79{
80 shstr name; /* the name of the book */
84 const char *authour; /* the name of the book authour */ 81 shstr authour; /* the name of the book authour */
85 const char *archname; /* the archetype name of the book */ 82 shstr archname; /* the archetype name of the book */
86 int level; /* level of difficulty of this message */ 83 int level; /* level of difficulty of this message */
87 int size; /* size of the book message */ 84 int size; /* size of the book message */
88 int msg_index; /* an index value derived from book message */ 85 int msg_index; /* an index value derived from book message */
89 struct titlestruct *next; 86 title *next;
90} title; 87};
91 88
92typedef struct titleliststruct { 89struct titlelist : zero_initialised
90{
93 int number; /* number of items in the list */ 91 int number; /* number of items in the list */
94 struct titlestruct *first_book; /* pointer to first book in this list */ 92 title *first_book; /* pointer to first book in this list */
95 struct titleliststruct *next; /* pointer to next book list */ 93 titlelist *next; /* pointer to next book list */
96} titlelist; 94};
97
98 95
99/* special structure, used only by art_name_array[] */ 96/* special structure, used only by art_name_array[] */
100 97struct arttypename
101typedef struct namebytype 98{
102 {
103 const char *name; /* generic name to call artifacts of this type */ 99 const char *name; /* generic name to call artifacts of this type */
104 int type; /* matching type */ 100 int type; /* matching type */
105 } 101};
106arttypename;
107
108 102
109/* booklist is the buffer of books read in from the bookarch file */ 103/* booklist is the buffer of books read in from the bookarch file */
110static titlelist *booklist = NULL; 104static titlelist *booklist = NULL;
111 105
112static objectlink *first_mon_info = NULL; 106static objectlink *first_mon_info = NULL;
113 107
114/* these are needed for creation of a linked list of 108/* these are needed for creation of a linked list of
115 * pointers to all (hostile) monster objects */ 109 * pointers to all (hostile) monster objects */
116 110
117static int nrofmon = 0, need_to_write_bookarchive=0; 111static int nrofmon = 0, need_to_write_bookarchive = 0;
118
119
120/* this is needed to keep track of status of initialization
121 * of the message file */
122static int nrofmsg = 0;
123
124/* first_msg is the started of the linked list of messages as read from
125 * the messages file
126 */
127static linked_char *first_msg = NULL;
128 112
129/* 113/*
130 * Spellpath information 114 * Spellpath information
131 */ 115 */
132
133static uint32 spellpathdef[NRSPELLPATHS] = 116static uint32 spellpathdef[NRSPELLPATHS] = {
134{
135 PATH_PROT, 117 PATH_PROT,
136 PATH_FIRE, 118 PATH_FIRE,
137 PATH_FROST, 119 PATH_FROST,
138 PATH_ELEC, 120 PATH_ELEC,
139 PATH_MISSILE, 121 PATH_MISSILE,
140 PATH_SELF, 122 PATH_SELF,
141 PATH_SUMMON, 123 PATH_SUMMON,
142 PATH_ABJURE, 124 PATH_ABJURE,
143 PATH_RESTORE, 125 PATH_RESTORE,
144 PATH_DETONATE, 126 PATH_DETONATE,
145 PATH_MIND, 127 PATH_MIND,
146 PATH_CREATE, 128 PATH_CREATE,
147 PATH_TELE, 129 PATH_TELE,
148 PATH_INFO, 130 PATH_INFO,
149 PATH_TRANSMUTE, 131 PATH_TRANSMUTE,
150 PATH_TRANSFER, 132 PATH_TRANSFER,
151 PATH_TURNING, 133 PATH_TURNING,
152 PATH_WOUNDING, 134 PATH_WOUNDING,
153 PATH_DEATH, 135 PATH_DEATH,
154 PATH_LIGHT 136 PATH_LIGHT
155}; 137};
156 138
157static const char* const path_book_name[] = 139static const char *const path_book_name[] = {
158{
159 "codex", 140 "codex",
160 "compendium", 141 "compendium",
161 "exposition", 142 "exposition",
162 "tables", 143 "tables",
163 "treatise" 144 "treatise"
164}; 145};
165 146
166/* used by spellpath texts */ 147/* used by spellpath texts */
167static const char* const path_author[] = 148static const char *const path_author[] = {
168{
169 "aether", 149 "aether",
170 "astral byways", 150 "astral byways",
171 "connections", 151 "connections",
172 "the Grey Council", 152 "the Grey Council",
173 "deep pathways", 153 "deep pathways",
174 "knowledge", 154 "knowledge",
175 "magic", 155 "magic",
176 "mystic ways", 156 "mystic ways",
177 "pathways", 157 "pathways",
178 "power", 158 "power",
179 "spells", 159 "spells",
180 "transforms", 160 "transforms",
181 "the mystic veil", 161 "the mystic veil",
182 "unknown spells" 162 "unknown spells"
183}; 163};
184 164
185/* 165/*
186 * Artiface/item information 166 * Artiface/item information
187 */ 167 */
188 168
189/* if it isnt listed here, then art_attr_msg will never generate 169/* if it isnt listed here, then art_attr_msg will never generate
190 * a message for this type of artifact. -b.t. */ 170 * a message for this type of artifact. -b.t. */
191 171
192static arttypename art_name_array[] = 172static arttypename art_name_array[] = {
193{
194 {"Helmet", HELMET}, 173 {"Helmet", HELMET},
195 {"Amulet", AMULET}, 174 {"Amulet", AMULET},
196 {"Shield", SHIELD}, 175 {"Shield", SHIELD},
197 {"Bracers", BRACERS}, 176 {"Bracers", BRACERS},
198 {"Boots", BOOTS}, 177 {"Boots", BOOTS},
199 {"Cloak", CLOAK}, 178 {"Cloak", CLOAK},
200 {"Gloves", GLOVES}, 179 {"Gloves", GLOVES},
201 {"Gridle", GIRDLE}, 180 {"Girdle", GIRDLE},
202 {"Ring", RING}, 181 {"Ring", RING},
203 {"Horn", HORN}, 182 {"Horn", HORN},
204 {"Missile Weapon", BOW}, 183 {"Missile Weapon", BOW},
205 {"Missile", ARROW}, 184 {"Missile", ARROW},
206 {"Hand Weapon", WEAPON}, 185 {"Hand Weapon", WEAPON},
207 {"Artifact", SKILL}, 186 {"Artifact", SKILL},
208 {"Food", FOOD}, 187 {"Food", FOOD},
209 {"Body Armour", ARMOUR} 188 {"Body Armour", ARMOUR}
210}; 189};
211 190
212static const char* const art_book_name[] = 191static const char *const art_book_name[] = {
213{
214 "collection", 192 "collection",
215 "file", 193 "file",
216 "files", 194 "files",
217 "guide", 195 "guide",
218 "handbook", 196 "handbook",
219 "index", 197 "index",
220 "inventory", 198 "inventory",
221 "list", 199 "list",
222 "listing", 200 "listing",
223 "record", 201 "record",
224 "record book" 202 "record book"
225}; 203};
226 204
227/* used by artifact texts */ 205/* used by artifact texts */
228static const char* const art_author[] = 206static const char *const art_author[] = {
229{
230 "ancient things", 207 "ancient things",
231 "artifacts", 208 "artifacts",
232 "Havlor", /* ancient warrior scribe :) */ 209 "Havlor", /* ancient warrior scribe :) */
233 "items", 210 "items",
234 "lost artifacts", 211 "lost artifacts",
235 "the ancients", 212 "the ancients",
236 "useful things" 213 "useful things"
237}; 214};
238 215
239/* 216/*
240 * Monster book information 217 * Monster book information
241 */ 218 */
242 219
243static const char* const mon_book_name[] = 220static const char *const mon_book_name[] = {
244{
245 "beastuary", 221 "beastuary",
246 "catalog", 222 "catalog",
247 "compilation", 223 "compilation",
248 "collection", 224 "collection",
249 "encyclopedia", 225 "encyclopedia",
250 "guide", 226 "guide",
251 "handbook", 227 "handbook",
252 "list", 228 "list",
253 "manual", 229 "manual",
254 "notes", 230 "notes",
255 "record", 231 "record",
256 "register", 232 "register",
257 "volume" 233 "volume"
258}; 234};
259 235
260 236
261/* used by monster beastuary texts */ 237/* used by monster beastuary texts */
262static const char* const mon_author[] = 238static const char *const mon_author[] = {
263{
264 "beasts", 239 "beasts",
265 "creatures", 240 "creatures",
266 "dezidens", 241 "dezidens",
267 "dwellers", 242 "dwellers",
268 "evil nature", 243 "evil nature",
269 "life", 244 "life",
270 "monsters", 245 "monsters",
271 "nature", 246 "nature",
272 "new life", 247 "new life",
273 "residents", 248 "residents",
274 "the spawn", 249 "the spawn",
275 "the living", 250 "the living",
276 "things" 251 "things"
277}; 252};
278 253
279/* 254/*
280 * God book information 255 * God book information
281 */ 256 */
282 257
283static const char* const gods_book_name[] = 258static const char *const gods_book_name[] = {
284{
285 "devotional", 259 "devotional",
286 "devout notes", 260 "devout notes",
287 "divine text", 261 "divine text",
288 "divine work", 262 "divine work",
289 "holy book", 263 "holy book",
290 "holy record", 264 "holy record",
291 "moral text", 265 "moral text",
292 "sacred guide", 266 "sacred guide",
293 "testament", 267 "testament",
294 "transcript" 268 "transcript"
295}; 269};
296 270
297/* used by gods texts */ 271/* used by gods texts */
298static const char* const gods_author[] = 272static const char *const gods_author[] = {
299{
300 "cults", 273 "cults",
301 "joy", 274 "joy",
302 "lasting curse", 275 "lasting curse",
303 "madness", 276 "madness",
304 "religions", 277 "religions",
305 "the dead", 278 "the dead",
306 "the gods", 279 "the gods",
307 "the heirophant", 280 "the heirophant",
308 "the poor priest", 281 "the poor priest",
309 "the priestess", 282 "the priestess",
310 "pain", 283 "pain",
311 "white" 284 "white"
312}; 285};
313 286
314 287
315/* 288/*
316 * Alchemy (formula) information 289 * Alchemy (formula) information
317 */ 290 */
318 291
319static const char* const formula_book_name[] = 292static const char *const formula_book_name[] = {
320{
321 "cookbook", 293 "cookbook",
322 "formulary", 294 "formulary",
323 "lab book", 295 "lab book",
324 "lab notes", 296 "lab notes",
325 "recipe book", 297 "recipe book",
326 "experiment record", 298 "experiment record",
327 "work plan", 299 "work plan",
328 "design notes" 300 "design notes"
329}; 301};
330 302
331/* this isn't used except for empty books */ 303/* this isn't used except for empty books */
332static const char* const formula_author[] = 304static const char *const formula_author[] = {
333{
334 "Albertus Magnus", 305 "Albertus Magnus",
335 "alchemy", 306 "alchemy",
336 "balms", 307 "balms",
337 "creation", 308 "creation",
338 "dusts", 309 "dusts",
339 "magical manufacture", 310 "magical manufacture",
340 "making", 311 "making",
341 "philosophical items", 312 "philosophical items",
342 "potions", 313 "potions",
343 "powders", 314 "powders",
344 "the cauldron", 315 "the cauldron",
345 "the lamp black", 316 "the lamp black",
346 "transmutation", 317 "transmutation",
347 "waters" 318 "waters"
348}; 319};
349 320
350/* 321/*
351 * Generic book information 322 * Generic book information
352 */ 323 */
353 324
354/* used by msg file and 'generic' books */ 325/* used by msg file and 'generic' books */
355static const char* const light_book_name[] = 326static const char *const light_book_name[] = {
356{
357 "calendar", 327 "calendar",
358 "datebook", 328 "datebook",
359 "diary", 329 "diary",
360 "guidebook", 330 "guidebook",
361 "handbook", 331 "handbook",
362 "ledger", 332 "ledger",
363 "notes", 333 "notes",
364 "notebook", 334 "notebook",
365 "octavo", 335 "octavo",
366 "pamphlet", 336 "pamphlet",
367 "practicum", 337 "practicum",
368 "script", 338 "script",
369 "transcript" 339 "transcript"
370}; 340};
371 341
372static const char* const heavy_book_name[] = 342static const char *const heavy_book_name[] = {
373{
374 "catalog", 343 "catalog",
375 "compendium", 344 "compendium",
376 "guide", 345 "guide",
377 "manual", 346 "manual",
378 "opus", 347 "opus",
379 "tome", 348 "tome",
380 "treatise", 349 "treatise",
381 "volume", 350 "volume",
382 "work" 351 "work"
383}; 352};
384 353
385 354
386/* used by 'generic' books */ 355/* used by 'generic' books */
387static const char* const book_author[] = 356static const char *const book_author[] = {
388{
389 "Abdulah", 357 "Abdulah",
390 "Al'hezred", 358 "Al'hezred",
391 "Alywn", 359 "Alywn",
392 "Arundel", 360 "Arundel",
393 "Arvind", 361 "Arvind",
394 "Aerlingas", 362 "Aerlingas",
395 "Bacon", 363 "Bacon",
396 "Baliqendii", 364 "Baliqendii",
397 "Bosworth", 365 "Bosworth",
398 "Beathis", 366 "Beathis",
399 "Bertil", 367 "Bertil",
400 "Cauchy", 368 "Cauchy",
401 "Chakrabarti", 369 "Chakrabarti",
402 "der Waalis", 370 "der Waalis",
403 "Dirk", 371 "Dirk",
404 "Djwimii", 372 "Djwimii",
405 "Eisenstaadt", 373 "Eisenstaadt",
406 "Fendris", 374 "Fendris",
407 "Frank", 375 "Frank",
408 "Habbi", 376 "Habbi",
409 "Harlod", 377 "Harlod",
410 "Ichibod", 378 "Ichibod",
411 "Janus", 379 "Janus",
412 "June", 380 "June",
413 "Magnuson", 381 "Magnuson",
414 "Nandii", 382 "Nandii",
415 "Nitfeder", 383 "Nitfeder",
416 "Norris", 384 "Norris",
417 "Parael", 385 "Parael",
418 "Penhew", 386 "Penhew",
419 "Sophia", 387 "Sophia",
420 "Skilly", 388 "Skilly",
421 "Tahir", 389 "Tahir",
422 "Thockmorton", 390 "Thockmorton",
423 "Thomas", 391 "Thomas",
424 "van Helsing", 392 "van Helsing",
425 "van Pelt", 393 "van Pelt",
426 "Voormis", 394 "Voormis",
427 "Xavier", 395 "Xavier",
428 "Xeno", 396 "Xeno",
429 "Zardoz", 397 "Zardoz",
430 "Zagy" 398 "Zagy"
431}; 399};
432 400
433static const char* const book_descrpt[] = 401static const char *const book_descrpt[] = {
434{
435 "ancient", 402 "ancient",
436 "cryptic", 403 "cryptic",
437 "cryptical", 404 "cryptical",
438 "dusty", 405 "dusty",
439 "hiearchical", 406 "hiearchical",
440 "grizzled", 407 "grizzled",
441 "gold-guilt", 408 "gold-guilt",
442 "great", 409 "great",
443 "lost", 410 "lost",
444 "magnificent", 411 "magnificent",
445 "musty", 412 "musty",
446 "mythical", 413 "mythical",
447 "mystical", 414 "mystical",
448 "rustic", 415 "rustic",
449 "stained", 416 "stained",
450 "silvered", 417 "silvered",
451 "transcendental", 418 "transcendental",
452 "weathered" 419 "weathered"
453}; 420};
421
454/* Each line of this array is a readable subtype 422/* Each line of this array is a readable subtype
455 * Be careful to keep the order. If you add readable subtype, add them 423 * Be careful to keep the order. If you add readable subtype, add them
456 * at the bottom of the list. Never delete a subtype because index is used as 424 * at the bottom of the list. Never delete a subtype because index is used as
457 * subtype paramater in arch files! 425 * subtype paramater in arch files!
458 */ 426 */
459static readable_message_type readable_message_types[] = 427static readable_message_type readable_message_types[] = {
460{
461 /*subtype 0 */ {0,0}, 428 /*subtype 0 */ {0, 0, "info"},
462 /* book messages subtypes */ 429 /* book messages subtypes */
463 /*subtype 1 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_1}, 430 /*subtype 1 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_1, "readable-book-clasp-1"},
464 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_2}, 431 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_CLASP_2, "readable-book-clasp-2"},
465 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_1}, 432 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_1, "readable-book-elegant-1"},
466 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_2}, 433 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_ELEGANT_2, "readable-book-elegant-2"},
467 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_1}, 434 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_1, "readable-book-quarto-1"},
468 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_2}, 435 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_QUARTO_2, "readable-book-quarto-2"},
469 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_EVOKER}, 436 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_EVOKER, "readable-book-spell-evocation"},
470 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PRAYER}, 437 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PRAYER, "readable-book-spell-praying"},
471 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PYRO}, 438 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_PYRO, "readable-book-spell-pyromancy"},
472 /*subtype 10 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SORCERER}, 439 /*subtype 10 */ {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SORCERER, "readable-book-spell-sorcery"},
473 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SUMMONER}, 440 {MSG_TYPE_BOOK, MSG_TYPE_BOOK_SPELL_SUMMONER, "readable-book-spell-summoning"},
474 /* card messages subtypes*/ 441 /* card messages subtypes */
475 {MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_1}, 442 {MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_1, "readable-card-simple-1"},
476 {MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_2}, 443 {MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_2, "readable-card-simple-2"},
477 {MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_3}, 444 {MSG_TYPE_CARD, MSG_TYPE_CARD_SIMPLE_3, "readable-card-simple-3"},
478 {MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_1}, 445 {MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_1, "readable-card-elegant-1"},
479 {MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_2}, 446 {MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_2, "readable-card-elegant-2"},
480 {MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_3}, 447 {MSG_TYPE_CARD, MSG_TYPE_CARD_ELEGANT_3, "readable-card-elegant-3"},
481 {MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_1}, 448 {MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_1, "readable-card-strange-1"},
482 {MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_2}, 449 {MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_2, "readable-card-strange-2"},
483 /*subtype 20 */ {MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_3}, 450 /*subtype 20 */ {MSG_TYPE_CARD, MSG_TYPE_CARD_STRANGE_3, "readable-card-strange-3"},
484 {MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_1}, 451 {MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_1, "readable-card-money-1"},
485 {MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_2}, 452 {MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_2, "readable-card-money-2"},
486 {MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_3}, 453 {MSG_TYPE_CARD, MSG_TYPE_CARD_MONEY_3, "readable-card-money-3"},
487 454
488 /* Paper messages subtypes */ 455 /* Paper messages subtypes */
489 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_1}, 456 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_1, "readable-paper-note-1"},
490 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_2}, 457 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_2, "readable-paper-note-2"},
491 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_3}, 458 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_NOTE_3, "readable-paper-note-3"},
492 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_1}, 459 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_1, "readable-paper-letter-old-1"},
493 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_2}, 460 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_OLD_2, "readable-paper-letter-old-2"},
494 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_1}, 461 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_1, "readable-paper-letter-new-1"},
495 /*subtype 30 */ {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_2}, 462 /*subtype 30 */ {MSG_TYPE_PAPER, MSG_TYPE_PAPER_LETTER_NEW_2, "readable-paper-letter-new-2"},
496 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_1}, 463 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_1, "readable-paper-envelope-1"},
497 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_2}, 464 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_ENVELOPE_2, "readable-paper-envelope-2"},
498 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_1}, 465 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_1, "readable-paper-scroll-old-1"},
499 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_2}, 466 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_OLD_2, "readable-paper-scroll-old-2"},
500 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_1}, 467 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_1, "readable-paper-scroll-new-1"},
501 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_2}, 468 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_NEW_2, "readable-paper-scroll-new-2"},
502 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_MAGIC}, 469 {MSG_TYPE_PAPER, MSG_TYPE_PAPER_SCROLL_MAGIC, "readable-paper-scroll-magic"},
503 470
504 /* road signs messages subtypes */ 471 /* road signs messages subtypes */
505 {MSG_TYPE_SIGN, MSG_TYPE_SIGN_BASIC}, 472 {MSG_TYPE_SIGN, MSG_TYPE_SIGN_BASIC, "readable-sign-basic"},
506 {MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_LEFT}, 473 {MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_LEFT, "readable-sign-dir-left"},
507 /*subtype 40 */ {MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_RIGHT}, 474 /*subtype 40 */ {MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_RIGHT, "readable-sign-dir-right"},
508 {MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_BOTH}, 475 {MSG_TYPE_SIGN, MSG_TYPE_SIGN_DIR_BOTH, "readable-sign-dir-both"},
509 476
510 /* stones and monument messages */ 477 /* stones and monument messages */
511 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_1}, 478 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_1, "readable-monument-stone-1"},
512 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_2}, 479 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_2, "readable-monument-stone-2"},
513 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_3}, 480 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STONE_3, "readable-monument-stone-3"},
514 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_1}, 481 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_1, "readable-monument-statue-1"},
515 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_2}, 482 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_2, "readable-monument-statue-2"},
516 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_3}, 483 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_STATUE_3, "readable-monument-statue-3"},
517 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_1}, 484 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_1, "readable-monument-gravestone-1"},
518 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_2}, 485 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_2, "readable-monument-gravestone-2"},
519 /*subtype 50 */ {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_3}, 486 /*subtype 50 */ {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_GRAVESTONE_3, "readable-monument-gravestone-3"},
520 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_1}, 487 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_1, "readable-monument-wall-1"},
521 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_2}, 488 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_2, "readable-monument-wall-2"},
522 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_3} 489 {MSG_TYPE_MONUMENT, MSG_TYPE_MONUMENT_WALL_3, "readable-monument-wall-3"}
523}; 490};
524int last_readable_subtype = sizeof(readable_message_types)/sizeof(readable_message_type); 491static int last_readable_subtype = sizeof (readable_message_types) / sizeof (readable_message_type);
525 492
526static int max_titles[6] = 493static int max_titles[6] = {
527{
528 ((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 *)),
529 (sizeof (mon_book_name) / sizeof (char *)) * (sizeof (mon_author) / sizeof (char *)), 495 (sizeof (mon_book_name) / sizeof (char *)) * (sizeof (mon_author) / sizeof (char *)),
530 (sizeof (art_book_name) / sizeof (char *)) * (sizeof (art_author) / sizeof (char *)), 496 (sizeof (art_book_name) / sizeof (char *)) * (sizeof (art_author) / sizeof (char *)),
531 (sizeof (path_book_name) / sizeof (char *)) * (sizeof (path_author) / sizeof (char *)), 497 (sizeof (path_book_name) / sizeof (char *)) * (sizeof (path_author) / sizeof (char *)),
532 (sizeof (formula_book_name) / sizeof (char *)) * (sizeof (formula_author) / sizeof (char *)), 498 (sizeof (formula_book_name) / sizeof (char *)) * (sizeof (formula_author) / sizeof (char *)),
533 (sizeof (gods_book_name) / sizeof (char *)) * (sizeof (gods_author) / sizeof (char *)) 499 (sizeof (gods_book_name) / sizeof (char *)) * (sizeof (gods_author) / sizeof (char *))
534}; 500};
535 501
536/****************************************************************************** 502/******************************************************************************
537 * 503 *
538 * 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
539 * 505 *
540 *****************************************************************************/ 506 *****************************************************************************/
541 507
542static titlelist * 508static titlelist *
543get_empty_booklist (void) 509get_empty_booklist ()
544{ 510{
545 titlelist *bl = (titlelist *) malloc (sizeof (titlelist)); 511 titlelist *bl = new titlelist;
546 if (bl == NULL) 512
547 fatal (OUT_OF_MEMORY);
548 bl->number = 0; 513 bl->number = 0;
549 bl->first_book = NULL; 514 bl->first_book = NULL;
550 bl->next = NULL; 515 bl->next = NULL;
551 return bl; 516 return bl;
552} 517}
553 518
554static title * 519static title *
555get_empty_book (void) 520get_empty_book ()
556{ 521{
557 title *t = (title *) malloc (sizeof (title)); 522 title *t = new title;
558 if (t == NULL) 523
559 fatal (OUT_OF_MEMORY);
560 t->name = NULL; 524 t->name = NULL;
561 t->archname = NULL; 525 t->archname = NULL;
562 t->authour = NULL; 526 t->authour = NULL;
563 t->level = 0; 527 t->level = 0;
564 t->size = 0; 528 t->size = 0;
565 t->msg_index = 0; 529 t->msg_index = 0;
566 t->next = NULL; 530 t->next = NULL;
567 return t; 531 return t;
568} 532}
569 533
570/* get_titlelist() - returns pointer to the title list referanced by i */ 534/* get_titlelist() - returns pointer to the title list referanced by i */
571 535
572static titlelist * 536static titlelist *
573get_titlelist (int i) 537get_titlelist (int i)
574{ 538{
575 titlelist *tl = booklist; 539 titlelist *tl = booklist;
576 int number = i; 540 int number = i;
577 541
578 if (number < 0) 542 if (number < 0)
579 return tl;
580
581 while (tl && number)
582 {
583 if (!tl->next)
584 tl->next = get_empty_booklist ();
585 tl = tl->next;
586 number--;
587 }
588
589 return tl; 543 return tl;
544
545 while (tl && number)
546 {
547 if (!tl->next)
548 tl->next = get_empty_booklist ();
549
550 tl = tl->next;
551 number--;
552 }
553
554 return tl;
590} 555}
591 556
592/* HANDMADE STRING FUNCTIONS.., perhaps these belong in another file 557/* HANDMADE STRING FUNCTIONS.., perhaps these belong in another file
593 * (shstr.c ?), but the quantity BOOK_BUF will need to be defined. */ 558 * (shstr.c ?), but the quantity BOOK_BUF will need to be defined. */
594 559
595/* nstrtok() - simple routine to return the number of list 560/* nstrtok() - simple routine to return the number of list
596 * items in buf1 as separated by the value of buf2 561 * items in buf1 as separated by the value of buf2
597 */ 562 */
598 563static int
599int
600nstrtok (const char *buf1, const char *buf2) 564nstrtok (const char *buf1, const char *buf2)
601{ 565{
602 char *tbuf, sbuf[12], buf[MAX_BUF]; 566 char *tbuf, sbuf[12], buf[MAX_BUF];
603 int number = 0; 567 int number = 0;
604 568
605 if (!buf1 || !buf2) 569 if (!buf1 || !buf2)
606 return 0; 570 return 0;
607 sprintf (buf, "%s", buf1); 571 sprintf (buf, "%s", buf1);
608 sprintf (sbuf, "%s", buf2); 572 sprintf (sbuf, "%s", buf2);
609 tbuf = strtok (buf, sbuf); 573 tbuf = strtok (buf, sbuf);
610 while (tbuf) 574 while (tbuf)
611 { 575 {
612 number++; 576 number++;
613 tbuf = strtok (NULL, sbuf); 577 tbuf = strtok (NULL, sbuf);
614 } 578 }
615 return number; 579 return number;
616} 580}
617 581
618/* strtoktolin() - takes a string in buf1 and separates it into 582/* strtoktolin() - takes a string in buf1 and separates it into
619 * a list of strings delimited by buf2. Then returns a comma 583 * a list of strings delimited by buf2. Then returns a comma
620 * separated string w/ decent punctuation. 584 * separated string w/ decent punctuation.
621 */ 585 */
622 586static char *
623char *
624strtoktolin (const char *buf1, const char *buf2) 587strtoktolin (const char *buf1, const char *buf2)
625{ 588{
626 int maxi, i = nstrtok (buf1, buf2); 589 int maxi, i = nstrtok (buf1, buf2);
627 char *tbuf, buf[MAX_BUF], sbuf[12]; 590 char *tbuf, buf[MAX_BUF], sbuf[12];
628 static char rbuf[BOOK_BUF]; 591 static char rbuf[BOOK_BUF];
629 592
630 maxi = i; 593 maxi = i;
631 strcpy(buf, buf1); 594 strcpy (buf, buf1);
632 strcpy(sbuf, buf2); 595 strcpy (sbuf, buf2);
633 strcpy(rbuf, " "); 596 strcpy (rbuf, " ");
634 tbuf = strtok (buf, sbuf); 597 tbuf = strtok (buf, sbuf);
635 while (tbuf && i > 0) 598 while (tbuf && i > 0)
636 { 599 {
637 strcat (rbuf, tbuf); 600 strcat (rbuf, tbuf);
638 i--; 601 i--;
639 if (i == 1 && maxi > 1) 602 if (i == 1 && maxi > 1)
640 strcat (rbuf, " and "); 603 strcat (rbuf, " and ");
641 else if (i > 0 && maxi > 1) 604 else if (i > 0 && maxi > 1)
642 strcat (rbuf, ", "); 605 strcat (rbuf, ", ");
643 else 606 else
644 strcat (rbuf, "."); 607 strcat (rbuf, ".");
645 tbuf = strtok (NULL, sbuf); 608 tbuf = strtok (NULL, sbuf);
646 } 609 }
647 return (char *) rbuf; 610 return (char *) rbuf;
648}
649
650int
651book_overflow (const char *buf1, const char *buf2, int booksize)
652{
653
654 if (buf_overflow (buf1, buf2, BOOK_BUF - 2) /* 2 less so always room for trailing \n */
655 || buf_overflow (buf1, buf2, booksize))
656 return 1;
657 return 0;
658
659
660} 611}
661 612
662/***************************************************************************** 613/*****************************************************************************
663 * 614 *
664 * Start of initialization related functions. 615 * Start of initialisation related functions.
665 * 616 *
666 ****************************************************************************/ 617 ****************************************************************************/
667 618
668/* init_msgfile() - if not called before, initialize the info list
669 * reads the messages file into the list pointed to by first_msg
670*/
671
672static void
673init_msgfile (void)
674{
675 FILE *fp;
676 char buf[MAX_BUF], msgbuf[HUGE_BUF], fname[MAX_BUF], *cp;
677 int comp;
678 static int did_init_msgfile;
679
680 if (did_init_msgfile)
681 return;
682 did_init_msgfile = 1;
683
684 sprintf (fname, "%s/messages", settings.datadir);
685 LOG (llevDebug, "Reading messages from %s...", fname);
686
687 if ((fp = open_and_uncompress (fname, 0, &comp)) != NULL)
688 {
689 linked_char *tmp = NULL;
690 while (fgets (buf, MAX_BUF, fp) != NULL)
691 {
692 if (*buf == '#')
693 continue;
694 if ((cp = strchr (buf, '\n')) != NULL)
695 *cp = '\0';
696 cp = buf;
697 while (*cp == ' ') /* Skip blanks */
698 cp++;
699 if (!strncmp (cp, "ENDMSG", 6))
700 {
701 if (strlen (msgbuf) > BOOK_BUF)
702 {
703 LOG (llevDebug, "Warning: this string exceeded max book buf size:");
704 LOG (llevDebug, " %s", msgbuf);
705 }
706 tmp->name = add_string (msgbuf);
707 tmp->next = first_msg;
708 first_msg = tmp;
709 nrofmsg++;
710 continue;
711 }
712 else if (!strncmp (cp, "MSG", 3))
713 {
714 tmp = (linked_char *) malloc (sizeof (linked_char));
715 strcpy (msgbuf, " "); /* reset msgbuf for new message */
716 continue;
717 }
718 else if (!buf_overflow (msgbuf, cp, HUGE_BUF - 1))
719 {
720 strcat (msgbuf, cp);
721 strcat (msgbuf, "\n");
722 }
723 }
724 close_and_delete (fp, comp);
725 }
726
727#ifdef BOOK_MSG_DEBUG
728 LOG (llevDebug, "\ninit_info_listfile() got %d messages.\n", nrofmsg);
729#endif
730 LOG (llevDebug, "done.\n");
731}
732
733
734/* init_book_archive() - if not called before, initialize the info list 619/* init_book_archive() - if not called before, initialise the info list
735 * This reads in the bookarch file into memory. bookarch is the file 620 * This reads in the bookarch file into memory. bookarch is the file
736 * created and updated across multiple runs of the program. 621 * created and updated across multiple runs of the program.
737 */ 622 */
738
739static void 623static void
740init_book_archive (void) 624init_book_archive ()
741{ 625{
742 FILE *fp; 626 FILE *fp;
743 int comp, nroftitle = 0; 627 int comp, nroftitle = 0;
744 char buf[MAX_BUF], fname[MAX_BUF], *cp; 628 char buf[MAX_BUF], fname[MAX_BUF], *cp;
745 title *book = NULL; 629 title *book = NULL;
746 titlelist *bl = get_empty_booklist (); 630 titlelist *bl = get_empty_booklist ();
747 static int did_init_barch; 631 static int did_init_barch;
748 632
749 if (did_init_barch) 633 if (did_init_barch)
750 return; 634 return;
635
751 did_init_barch = 1; 636 did_init_barch = 1;
752 637
753 if (!booklist) 638 if (!booklist)
754 booklist = bl; 639 booklist = bl;
755 640
756 sprintf (fname, "%s/bookarch", settings.localdir); 641 sprintf (fname, "%s/bookarch", settings.localdir);
757 LOG (llevDebug, " Reading bookarch from %s...\n", fname); 642 LOG (llevDebug, " Reading bookarch from %s...\n", fname);
758 643
759 if ((fp = open_and_uncompress (fname, 0, &comp)) != NULL) 644 if ((fp = open_and_uncompress (fname, 0, &comp)) != NULL)
760 { 645 {
761 int value, type = 0; 646 int value, type = 0;
762 size_t i; 647 size_t i;
763 648
764 while (fgets (buf, MAX_BUF, fp) != NULL) 649 while (fgets (buf, MAX_BUF, fp) != NULL)
650 {
651 if (*buf == '#')
652 continue;
653 if ((cp = strchr (buf, '\n')) != NULL)
654 *cp = '\0';
655 cp = buf;
656 while (*cp == ' ') /* Skip blanks */
657 cp++;
658 if (!strncmp (cp, "title", 4))
765 { 659 {
766 if (*buf == '#')
767 continue;
768 if ((cp = strchr (buf, '\n')) != NULL)
769 *cp = '\0';
770 cp = buf;
771 while (*cp == ' ') /* Skip blanks */
772 cp++;
773 if (!strncmp (cp, "title", 4))
774 {
775 book = get_empty_book (); /* init new book entry */ 660 book = get_empty_book (); /* init new book entry */
776 book->name = add_string (strchr (cp, ' ') + 1); 661 book->name = strchr (cp, ' ') + 1;
777 type = -1; 662 type = -1;
778 nroftitle++; 663 nroftitle++;
779 continue; 664 continue;
780 }
781 if (!strncmp (cp, "authour", 4))
782 {
783 book->authour = add_string (strchr (cp, ' ') + 1);
784 }
785 if (!strncmp (cp, "arch", 4))
786 {
787 book->archname = add_string (strchr (cp, ' ') + 1);
788 }
789 else if (sscanf (cp, "level %d", &value))
790 {
791 book->level = (uint16) value;
792 }
793 else if (sscanf (cp, "type %d", &value))
794 {
795 type = (uint16) value;
796 }
797 else if (sscanf (cp, "size %d", &value))
798 {
799 book->size = (uint16) value;
800 }
801 else if (sscanf (cp, "index %d", &value))
802 {
803 book->msg_index = (uint16) value;
804 }
805 else if (!strncmp (cp, "end", 3))
806 { /* link it */
807 bl = get_titlelist (type);
808 book->next = bl->first_book;
809 bl->first_book = book;
810 bl->number++;
811 }
812 } 665 }
813 LOG (llevDebug, " book archives(used/avail): "); 666 if (!strncmp (cp, "authour", 4))
814 for (bl = booklist, i = 0; bl != NULL && i < sizeof(max_titles)/sizeof(*max_titles); bl = bl->next, i++)
815 { 667 {
816 LOG (llevDebug, "(%d/%d)", bl->number, max_titles[i]); 668 book->authour = strchr (cp, ' ') + 1;
817 } 669 }
818 LOG (llevDebug, "\n"); 670 if (!strncmp (cp, "arch", 4))
671 {
672 book->archname = strchr (cp, ' ') + 1;
673 }
674 else if (sscanf (cp, "level %d", &value))
675 {
676 book->level = (uint16) value;
677 }
678 else if (sscanf (cp, "type %d", &value))
679 {
680 type = (uint16) value;
681 }
682 else if (sscanf (cp, "size %d", &value))
683 {
684 book->size = (uint16) value;
685 }
686 else if (sscanf (cp, "index %d", &value))
687 {
688 book->msg_index = (uint16) value;
689 }
690 else if (!strncmp (cp, "end", 3))
691 { /* link it */
692 bl = get_titlelist (type);
693 book->next = bl->first_book;
694 bl->first_book = book;
695 bl->number++;
696 }
697 }
698 LOG (llevDebug, "book archives(used/avail): \n");
699 for (bl = booklist, i = 0; bl != NULL && i < sizeof (max_titles) / sizeof (*max_titles); bl = bl->next, i++)
700 {
701 LOG (llevDebug, " (%d/%d)\n", bl->number, max_titles[i]);
702 }
819 close_and_delete (fp, comp); 703 close_and_delete (fp, comp);
820 } 704 }
821 705
822#ifdef BOOK_MSG_DEBUG 706#ifdef BOOK_MSG_DEBUG
823 LOG (llevDebug, "\n init_book_archive() got %d titles.\n", nroftitle); 707 LOG (llevDebug, "init_book_archive() got %d titles.\n", nroftitle);
824#endif 708#endif
825 LOG (llevDebug, " done.\n"); 709 LOG (llevDebug, " done.\n");
826} 710}
827 711
828/* init_mon_info() - creates the linked list of pointers to 712/* init_mon_info() - creates the linked list of pointers to
829 * monster archetype objects if not called previously 713 * monster archetype objects if not called previously
830 */ 714 */
831
832static void 715static void
833init_mon_info (void) 716init_mon_info ()
834{ 717{
835 archetype *at; 718 archetype *at;
836 static int did_init_mon_info = 0; 719 static int did_init_mon_info = 0;
837 720
838 if (did_init_mon_info) 721 if (did_init_mon_info)
839 return; 722 return;
723
840 did_init_mon_info = 1; 724 did_init_mon_info = 1;
841 725
842 726 for_all_archetypes (at)
843 for (at = first_archetype; at != NULL; at = at->next) 727 if (at->flag [FLAG_MONSTER]
728 && at->is_head ()
729 && (!at->flag [FLAG_CHANGING] || at->flag [FLAG_UNAGGRESSIVE]))
844 { 730 {
845 if (QUERY_FLAG (&at->clone, FLAG_MONSTER) && 731 objectlink *mon = new objectlink;
846 (!QUERY_FLAG (&at->clone, FLAG_CHANGING) 732
847 || QUERY_FLAG (&at->clone, FLAG_UNAGGRESSIVE)) 733 mon->ob = at;
848 )
849 {
850 objectlink *mon = (objectlink *) malloc (sizeof (objectlink));
851 mon->ob = &at->clone;
852 mon->id = nrofmon;
853 mon->next = first_mon_info; 734 mon->next = first_mon_info;
854 first_mon_info = mon; 735 first_mon_info = mon;
855 nrofmon++; 736 nrofmon++;
856 }
857 } 737 }
738
858 LOG (llevDebug, "init_mon_info() got %d monsters\n", nrofmon); 739 LOG (llevDebug, "init_mon_info() got %d monsters\n", nrofmon);
859} 740}
860 741
861
862/* init_readable() - initialize linked lists utilized by 742/* init_readable() - initialise linked lists utilized by
863 * message functions in tailor_readable_ob() 743 * message functions in tailor_readable_ob()
864 * 744 *
865 * This is the function called by the main routine to initialize 745 * This is the function called by the main routine to initialise
866 * all the readable information. 746 * all the readable information.
867 */ 747 */
868
869void 748void
870init_readable (void) 749init_readable ()
871{ 750{
872 static int did_this; 751 static int did_this;
873 752
874 if (did_this) return; 753 if (did_this)
754 return;
755
875 did_this = 1; 756 did_this = 1;
876 757
877 LOG (llevDebug, "Initializing reading data..."); 758 LOG (llevDebug, "Initialising reading data...\n");
878 init_msgfile ();
879 init_book_archive (); 759 init_book_archive ();
880 init_mon_info (); 760 init_mon_info ();
881 LOG (llevDebug, " Done\n"); 761 LOG (llevDebug, " Done\n");
882
883} 762}
884 763
885/***************************************************************************** 764/*****************************************************************************
886 * 765 *
887 * This is the start of the administrative functions when creating 766 * This is the start of the administrative functions when creating
888 * new books (ie, updating title and the like) 767 * new books (ie, updating title and the like)
889 * 768 *
890 *****************************************************************************/ 769 *****************************************************************************/
891 770
892
893/* find_title() - Search the titlelist (based on msgtype) to see if 771/* find_title() - Search the titlelist (based on msgtype) to see if
894 * book matches something already there. IF so, return that title. 772 * book matches something already there. IF so, return that title.
895 */ 773 */
896
897static title * 774static title *
898find_title (const object *book, int msgtype) 775find_title (const object *book, int msgtype)
899{ 776{
900 title *t = NULL; 777 title *t = NULL;
901 titlelist *tl = get_titlelist (msgtype); 778 titlelist *tl = get_titlelist (msgtype);
902 int length = strlen (book->msg); 779 int length = strlen (book->msg);
903 int index = strtoint (book->msg); 780 int index = strtoint (book->msg);
904 781
905 if (msgtype < 0) 782 if (msgtype < 0)
906 return (title *) NULL; 783 return (title *) NULL;
907 784
908 if (tl) 785 if (tl)
909 t = tl->first_book; 786 t = tl->first_book;
787
910 while (t) 788 while (t)
911 if (t->size == length && t->msg_index == index) 789 if (t->size == length && t->msg_index == index)
912 break; 790 break;
913 else 791 else
914 t = t->next; 792 t = t->next;
915 793
916#ifdef ARCHIVE_DEBUG 794#ifdef ARCHIVE_DEBUG
917 if (t) 795 if (t)
918 LOG (llevDebug, "Found title match (list %d): %s %s (%d)\n", 796 LOG (llevDebug, "Found title match (list %d): %s %s (%d)\n", msgtype, &t->name, &t->authour, t->msg_index);
919 msgtype, t->name, t->authour, t->msg_index);
920#endif 797#endif
921 798
922 return t; 799 return t;
923} 800}
924 801
925/* new_text_name() - Only for objects of type BOOK. SPELLBOOK stuff is 802/* new_text_name() - Only for objects of type BOOK. SPELLBOOK stuff is
926 * handled directly in change_book_name(). Names are based on text 803 * handled directly in change_book_name(). Names are based on text
927 * msgtype 804 * msgtype
928 * this sets book book->name based on msgtype given. What name 805 * this sets book book->name based on msgtype given. What name
929 * is given is based on various criteria 806 * is given is based on various criteria
930 */ 807 */
931
932static void 808static void
933new_text_name (object *book, int msgtype) 809new_text_name (object *book, int msgtype)
934{ 810{
935 int nbr; 811 int nbr;
936 char name[MAX_BUF]; 812 char name[MAX_BUF];
937 813
938 if (book->type != BOOK) 814 if (book->type != BOOK)
939 return; 815 return;
940 816
941 switch (msgtype) 817 switch (msgtype)
942 { 818 {
943 case 1: /*monster */ 819 case 1: /*monster */
944 nbr = sizeof (mon_book_name) / sizeof (char *); 820 nbr = sizeof (mon_book_name) / sizeof (char *);
945 strcpy (name, mon_book_name[RANDOM () % nbr]); 821 assign (name, mon_book_name[rndm (nbr)]);
946 break; 822 break;
947 case 2: /*artifact */ 823 case 2: /*artifact */
948 nbr = sizeof (art_book_name) / sizeof (char *); 824 nbr = sizeof (art_book_name) / sizeof (char *);
949 strcpy (name, art_book_name[RANDOM () % nbr]); 825 assign (name, art_book_name[rndm (nbr)]);
950 break; 826 break;
951 case 3: /*spellpath */ 827 case 3: /*spellpath */
952 nbr = sizeof (path_book_name) / sizeof (char *); 828 nbr = sizeof (path_book_name) / sizeof (char *);
953 strcpy (name, path_book_name[RANDOM () % nbr]); 829 assign (name, path_book_name[rndm (nbr)]);
954 break; 830 break;
955 case 4: /*alchemy */ 831 case 4: /*alchemy */
956 nbr = sizeof (formula_book_name) / sizeof (char *); 832 nbr = sizeof (formula_book_name) / sizeof (char *);
957 strcpy (name, formula_book_name[RANDOM () % nbr]); 833 assign (name, formula_book_name[rndm (nbr)]);
958 break; 834 break;
959 case 5: /*gods */ 835 case 5: /*gods */
960 nbr = sizeof (gods_book_name) / sizeof (char *); 836 nbr = sizeof (gods_book_name) / sizeof (char *);
961 strcpy (name, gods_book_name[RANDOM () % nbr]); 837 assign (name, gods_book_name[rndm (nbr)]);
962 break; 838 break;
963 case 6: /*msg file */ 839 case 6: /*msg file */
964 default: 840 default:
965 if (book->weight > 2000) 841 if (book->weight > 2000)
966 { /* based on weight */ 842 { /* based on weight */
967 nbr = sizeof (heavy_book_name) / sizeof (char *); 843 nbr = sizeof (heavy_book_name) / sizeof (char *);
968 strcpy (name, heavy_book_name[RANDOM () % nbr]); 844 assign (name, heavy_book_name[rndm (nbr)]);
969 } 845 }
970 else if (book->weight < 2001) 846 else if (book->weight < 2001)
971 { 847 {
972 nbr = sizeof (light_book_name) / sizeof (char *); 848 nbr = sizeof (light_book_name) / sizeof (char *);
973 strcpy (name, light_book_name[RANDOM () % nbr]); 849 assign (name, light_book_name[rndm (nbr)]);
974 } 850 }
975 break; 851 break;
976 } 852 }
977 free_string (book->name); 853
978 book->name = add_string (name); 854 book->name = name;
979} 855}
980 856
981/* add_book_author() 857/* add_book_author()
982 * A lot like new_text_name above, but instead chooses an author 858 * A lot like new_text_name above, but instead chooses an author
983 * and sets op->title to that value 859 * and sets op->title to that value
984 */ 860 */
985 861
986static void 862static void
987add_author (object *op, int msgtype) 863add_author (object *op, int msgtype)
988{ 864{
989 char title[MAX_BUF], name[MAX_BUF]; 865 char title[MAX_BUF], name[MAX_BUF];
990 int nbr = sizeof (book_author) / sizeof (char *); 866 int nbr = sizeof (book_author) / sizeof (char *);
991 867
992 if (msgtype < 0 || strlen (op->msg) < 5) 868 if (msgtype < 0 || strlen (op->msg) < 5)
993 return; 869 return;
994 870
995 switch (msgtype) 871 switch (msgtype)
996 { 872 {
997 case 1: /* monster */ 873 case 1: /* monster */
998 nbr = sizeof (mon_author) / sizeof (char *); 874 nbr = sizeof (mon_author) / sizeof (char *);
999 strcpy (name, mon_author[RANDOM () % nbr]); 875 assign (name, mon_author[rndm (nbr)]);
1000 break; 876 break;
1001 case 2: /* artifacts */ 877 case 2: /* artifacts */
1002 nbr = sizeof (art_author) / sizeof (char *); 878 nbr = sizeof (art_author) / sizeof (char *);
1003 strcpy (name, art_author[RANDOM () % nbr]); 879 assign (name, art_author[rndm (nbr)]);
1004 break; 880 break;
1005 case 3: /* spellpath */ 881 case 3: /* spellpath */
1006 nbr = sizeof (path_author) / sizeof (char *); 882 nbr = sizeof (path_author) / sizeof (char *);
1007 strcpy (name, path_author[RANDOM () % nbr]); 883 assign (name, path_author[rndm (nbr)]);
1008 break; 884 break;
1009 case 4: /* alchemy */ 885 case 4: /* alchemy */
1010 nbr = sizeof (formula_author) / sizeof (char *); 886 nbr = sizeof (formula_author) / sizeof (char *);
1011 strcpy (name, formula_author[RANDOM () % nbr]); 887 assign (name, formula_author[rndm (nbr)]);
1012 break; 888 break;
1013 case 5: /* gods */ 889 case 5: /* gods */
1014 nbr = sizeof (gods_author) / sizeof (char *); 890 nbr = sizeof (gods_author) / sizeof (char *);
1015 strcpy (name, gods_author[RANDOM () % nbr]); 891 assign (name, gods_author[rndm (nbr)]);
1016 break; 892 break;
1017 case 6: /* msg file */ 893 case 6: /* msg file */
1018 default: 894 default:
1019 strcpy (name, book_author[RANDOM () % nbr]); 895 assign (name, book_author[rndm (nbr)]);
1020 } 896 }
1021 897
1022 sprintf (title, "of %s", name); 898 sprintf (title, "of %s", name);
1023 op->title = add_string (title); 899 op->title = title;
1024} 900}
1025 901
1026/* unique_book() - check to see if the book title/msg is unique. We 902/* unique_book() - check to see if the book title/msg is unique. We
1027 * go through the entire list of possibilities each time. If we find 903 * go through the entire list of possibilities each time. If we find
1028 * a match, then unique_book returns true (because inst unique). 904 * a match, then unique_book returns true (because inst unique).
1029 */ 905 */
1030 906
1031static int 907static int
1032unique_book (const object *book, int msgtype) 908unique_book (const object *book, int msgtype)
1033{ 909{
1034 title *test;
1035
1036 if (!booklist) 910 if (!booklist)
1037 return 1; /* No archival entries! Must be unique! */ 911 return 1; /* No archival entries! Must be unique! */
1038 912
1039 /* Go through the booklist. If the author and name match, not unique so 913 /* Go through the booklist. If the author and name match, not unique so
1040 * return 0. 914 * return 0.
1041 */ 915 */
1042 for (test = get_titlelist (msgtype)->first_book; test; test=test->next) { 916 for (title *test = get_titlelist (msgtype)->first_book; test; test = test->next)
1043 if (!strcmp(test->name, book->name) && !strcmp(book->title, test->authour)) 917 if (test->name == book->name && book->title == test->authour)
1044 return 0; 918 return 0;
1045 } 919
1046 return 1; 920 return 1;
1047} 921}
1048 922
1049/* add_book_to_list() */ 923/* add_book_to_list() */
1050 924
1051static void 925static void
1052add_book_to_list (const object *book, int msgtype) 926add_book_to_list (const object *book, int msgtype)
1053{ 927{
1054 titlelist *tl = get_titlelist (msgtype); 928 titlelist *tl = get_titlelist (msgtype);
1055 title *t; 929 title *t;
1056 930
1057 if (!tl) 931 if (!tl)
1058 { 932 {
1059 LOG (llevError, "add_book_to_list can't get booklist!\n"); 933 LOG (llevError, "add_book_to_list can't get booklist!\n");
1060 return; 934 return;
1061 } 935 }
1062 936
1063 t = get_empty_book (); 937 t = get_empty_book ();
1064 t->name = add_string (book->name); 938 t->name = book->name;
1065 t->authour = add_string (book->title); 939 t->authour = book->title;
1066 t->size = strlen (book->msg); 940 t->size = strlen (book->msg);
1067 t->msg_index = strtoint (book->msg); 941 t->msg_index = strtoint (book->msg);
1068 t->archname = add_string (book->arch->name); 942 t->archname = book->arch->archname;
1069 t->level = book->level; 943 t->level = book->level;
1070 944
1071 t->next = tl->first_book; 945 t->next = tl->first_book;
1072 tl->first_book = t; 946 tl->first_book = t;
1073 tl->number++; 947 tl->number++;
1074 948
1075 /* We have stuff we need to write now */ 949 /* We have stuff we need to write now */
1076 need_to_write_bookarchive=1; 950 need_to_write_bookarchive = 1;
1077 951
1078#ifdef ARCHIVE_DEBUG 952#ifdef ARCHIVE_DEBUG
1079 LOG (llevDebug, "Archiving new title: %s %s (%d)\n", book->name, 953 LOG (llevDebug, "Archiving new title: %s %s (%d)\n", &book->name, &book->title, msgtype);
1080 book->title, msgtype);
1081#endif 954#endif
1082 955
1083} 956}
1084 957
1085 958
… …
1091 * levels and architypes. -b.t. 964 * levels and architypes. -b.t.
1092 */ 965 */
1093 966
1094#define MAX_TITLE_CHECK 20 967#define MAX_TITLE_CHECK 20
1095 968
1096void 969static void
1097change_book (object *book, int msgtype) 970change_book (object *book, int msgtype)
1098{ 971{
1099 int nbr = sizeof (book_descrpt) / sizeof (char *); 972 int nbr = sizeof (book_descrpt) / sizeof (char *);
1100 973
1101 switch (book->type) 974 switch (book->type)
1102 { 975 {
1103 case BOOK: 976 case BOOK:
1104 { 977 {
1105 titlelist *tl = get_titlelist (msgtype); 978 titlelist *tl = get_titlelist (msgtype);
1106 title *t = NULL; 979 title *t = NULL;
1107 int tries = 0; 980 int tries = 0;
981
1108 /* look to see if our msg already been archived. If so, alter 982 /* 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, 983 * 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 984 * then we archive the new title/name/msg combo if there is
1111 * room on the titlelist. 985 * room on the titlelist.
986 */
987
988 if ((strlen (book->msg) > 5) && (t = find_title (book, msgtype)))
989 {
990 /* alter book properties */
991 if (object *tmpbook = get_archetype (t->archname))
992 {
993 tmpbook->msg = book->msg;
994 tmpbook->copy_to (book);
995 tmpbook->destroy ();
996 }
997
998 book->title = t->authour;
999 book->name = t->name;
1000 book->level = t->level;
1001 }
1002 /* Don't have any default title, so lets make up a new one */
1003 else
1004 {
1005 int numb, maxnames = max_titles[msgtype];
1006 const char *old_title;
1007 const char *old_name;
1008
1009 old_title = book->title;
1010 old_name = book->name;
1011
1012 /* some pre-generated books have title already set (from
1013 * maps), also don't bother looking for unique title if
1014 * we already used up all the available names! */
1015
1016 if (!tl)
1017 {
1018 LOG (llevError, "change_book_name(): can't find title list\n");
1019 numb = 0;
1020 }
1021 else
1022 numb = tl->number;
1023
1024 if (numb == maxnames)
1025 {
1026#ifdef ARCHIVE_DEBUG
1027 LOG (llevDebug, "titles for list %d full (%d possible).\n", msgtype, maxnames);
1028#endif
1029 }
1030 /* shouldnt change map-maker books */
1031 else if (!book->title)
1032 do
1033 {
1034 /* random book name */
1035 new_text_name (book, msgtype);
1036 add_author (book, msgtype); /* random author */
1037 tries++;
1038 }
1039 while (!unique_book (book, msgtype) && tries < MAX_TITLE_CHECK);
1040
1041 /* Now deal with 2 cases.
1042 * 1)If no space for a new title exists lets just restore
1043 * the old book properties. Remember, if the book had
1044 * matchd an older entry on the titlelist, we shouldnt
1045 * have called this routine in the first place!
1046 * 2) If we got a unique title, we need to add it to
1047 * the list.
1112 */ 1048 */
1113 1049
1114 if ((strlen (book->msg) > 5) && (t = find_title (book, msgtype))) 1050 if (tries == MAX_TITLE_CHECK || numb == maxnames)
1115 { 1051 { /* got to check maxnames again */
1116 object *tmpbook; 1052#ifdef ARCHIVE_DEBUG
1117 1053 LOG (llevDebug, "Failed to obtain unique title for %s %s (names:%d/%d)\n", &book->name, &book->title, numb, maxnames);
1054#endif
1118 /* alter book properties */ 1055 /* restore old book properties here */
1119 if ((tmpbook = get_archetype (t->archname)) != NULL) 1056 book->title = old_title;
1057
1058 if (rndm (4))
1120 { 1059 {
1121 if (tmpbook->msg) 1060 /* Lets give the book a description to individualize it some */
1122 free_string (book->msg); 1061 char new_name[MAX_BUF];
1123 tmpbook->msg = add_string (book->msg); 1062
1124 copy_object (tmpbook, book); 1063 snprintf (new_name, MAX_BUF, "%s %s", book_descrpt[rndm (nbr)], old_name);
1125 free_object (tmpbook); 1064
1065 book->name = new_name;
1126 } 1066 }
1127 1067 else
1128 book->title = add_string (t->authour); 1068 {
1129 free_string (book->name);
1130 book->name = add_string (t->name); 1069 book->name = old_name;
1131 book->level = t->level; 1070 }
1132 } 1071 }
1133 /* Don't have any default title, so lets make up a new one */
1134 else
1135 {
1136 int numb, maxnames = max_titles[msgtype];
1137 const char *old_title;
1138 const char *old_name;
1139
1140 old_title = book->title ? add_string(book->title) : NULL;
1141 old_name = add_string(book->name);
1142
1143 /* some pre-generated books have title already set (from
1144 * maps), also don't bother looking for unique title if
1145 * we already used up all the available names! */
1146
1147 if (!tl)
1148 {
1149 LOG (llevError, "change_book_name(): can't find title list\n");
1150 numb = 0;
1151 }
1152 else
1153 numb = tl->number;
1154
1155 if (numb == maxnames)
1156 {
1157#ifdef ARCHIVE_DEBUG
1158 LOG (llevDebug, "titles for list %d full (%d possible).\n",
1159 msgtype, maxnames);
1160#endif
1161 if (old_title != NULL)
1162 free_string(old_title);
1163 free_string(old_name);
1164 break;
1165 }
1166 /* shouldnt change map-maker books */
1167 else if (!book->title)
1168 do
1169 {
1170 /* random book name */
1171 new_text_name (book, msgtype);
1172 add_author (book, msgtype); /* random author */
1173 tries++;
1174 }
1175 while (!unique_book (book, msgtype) && tries < MAX_TITLE_CHECK);
1176
1177 /* Now deal with 2 cases.
1178 * 1)If no space for a new title exists lets just restore
1179 * the old book properties. Remember, if the book had
1180 * matchd an older entry on the titlelist, we shouldnt
1181 * have called this routine in the first place!
1182 * 2) If we got a unique title, we need to add it to
1183 * the list.
1184 */
1185
1186 if (tries == MAX_TITLE_CHECK || numb == maxnames)
1187 { /* got to check maxnames again */
1188#ifdef ARCHIVE_DEBUG
1189 LOG (llevDebug, "Failed to obtain unique title for %s %s (names:%d/%d)\n",
1190 book->name, book->title, numb, maxnames);
1191#endif
1192 /* restore old book properties here */
1193 free_string (book->name);
1194 free_string (book->title);
1195 if (old_title!=NULL)
1196 book->title = add_string (old_title);
1197
1198 if (RANDOM () % 4) {
1199 /* Lets give the book a description to individualize it some */
1200 char new_name[MAX_BUF];
1201 snprintf (new_name, MAX_BUF, "%s %s", book_descrpt[RANDOM () % nbr], old_name);
1202
1203 book->name = add_string (new_name);
1204 } else {
1205 book->name = add_string (old_name);
1206 }
1207 }
1208 else if (book->title && strlen (book->msg) > 5) { /* archive if long msg texts */ 1072 else if (book->title && strlen (book->msg) > 5)
1073 { /* archive if long msg texts */
1209 add_book_to_list (book, msgtype); 1074 add_book_to_list (book, msgtype);
1210 }
1211
1212 if (old_title != NULL)
1213 free_string(old_title);
1214 free_string(old_name);
1215
1216 } 1075 }
1217 break;
1218 } 1076 }
1077 break;
1078 }
1219 1079
1220 default: 1080 default:
1221 LOG (llevError, "change_book_name() called w/ illegal obj type.\n"); 1081 LOG (llevError, "change_book_name() called w/ illegal obj type.\n");
1222 return; 1082 return;
1223 } 1083 }
1224} 1084}
1225 1085
1226/***************************************************************************** 1086/*****************************************************************************
1227 * 1087 *
1228 * This is the start of the area that generates the actual contents 1088 * This is the start of the area that generates the actual contents
… …
1238 * list of all monsters in the current game. If level is non-zero, 1098 * list of all monsters in the current game. If level is non-zero,
1239 * then only monsters greater than that level will be returned. 1099 * then only monsters greater than that level will be returned.
1240 * Changed 971225 to be greater than equal to level passed. Also 1100 * Changed 971225 to be greater than equal to level passed. Also
1241 * made choosing by level more random. 1101 * made choosing by level more random.
1242 */ 1102 */
1243
1244object * 1103object *
1245get_random_mon (int level) 1104get_random_mon (int level)
1246{ 1105{
1247 objectlink *mon = first_mon_info; 1106 objectlink *mon = first_mon_info;
1248 int i = 0, monnr; 1107 int i = 0, monnr;
1249 1108
1250 /* safety check. Problem w/ init_mon_info list? */ 1109 /* safety check. Problem w/ init_mon_info list? */
1251 if (!nrofmon || !mon) 1110 if (!nrofmon || !mon)
1252 return (object *) NULL; 1111 return (object *) NULL;
1253 1112
1254 if (!level) 1113 if (!level)
1255 { 1114 {
1256 /* lets get a random monster from the mon_info linked list */ 1115 /* lets get a random monster from the mon_info linked list */
1257 monnr = RANDOM () % nrofmon; 1116 monnr = rndm (nrofmon);
1258 1117
1259 for (mon = first_mon_info, i = 0; mon; mon = mon->next)
1260 if (i++ == monnr)
1261 break;
1262
1263 if (!mon)
1264 {
1265 LOG (llevError, "get_random_mon: Didn't find a monster when we should have\n");
1266 return NULL;
1267 }
1268 return mon->ob;
1269 }
1270
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
1273 * the list, and then returned the first monster after that which was
1274 * appropriate level. This wasn't very random because if you had a
1275 * bunch of low level monsters and then a high level one, if the random
1276 * determine took one of the low level ones, it would just forward to the
1277 * high level one and return that. Thus, monsters that immediatly followed
1278 * a bunch of low level monsters would be more heavily returned. It also
1279 * means some of the dragons would be poorly represented, since they
1280 * are a group of high level monsters all around each other.
1281 */
1282
1283 /* First count number of monsters meeting level criteria */
1284 for (mon = first_mon_info, i = 0; mon; mon = mon->next) 1118 for (mon = first_mon_info, i = 0; mon; mon = mon->next)
1285 if (mon->ob->level >= level) 1119 if (i++ == monnr)
1286 i++; 1120 break;
1287 1121
1288 if (i == 0) 1122 if (!mon)
1289 { 1123 {
1290 LOG (llevError, "get_random_mon() couldn't return monster for level %d\n", 1124 LOG (llevError, "get_random_mon: Didn't find a monster when we should have\n");
1291 level);
1292 return NULL; 1125 return NULL;
1293 } 1126 }
1127 return mon->ob;
1128 }
1294 1129
1295 monnr = RANDOM () % i; 1130 /* Case where we are searching by level. Redone 971225 to be clearer
1131 * and more random. Before, it looks like it took a random monster from
1132 * the list, and then returned the first monster after that which was
1133 * appropriate level. This wasn't very random because if you had a
1134 * bunch of low level monsters and then a high level one, if the random
1135 * determine took one of the low level ones, it would just forward to the
1136 * high level one and return that. Thus, monsters that immediatly followed
1137 * a bunch of low level monsters would be more heavily returned. It also
1138 * means some of the dragons would be poorly represented, since they
1139 * are a group of high level monsters all around each other.
1140 */
1141
1142 /* First count number of monsters meeting level criteria */
1143 for (mon = first_mon_info, i = 0; mon; mon = mon->next)
1144 if (mon->ob->level >= level)
1145 i++;
1146
1147 if (i == 0)
1148 {
1149 LOG (llevError, "get_random_mon() couldn't return monster for level %d\n", level);
1150 return NULL;
1151 }
1152
1153 monnr = rndm (i);
1296 for (mon = first_mon_info; mon; mon = mon->next) 1154 for (mon = first_mon_info; mon; mon = mon->next)
1297 if (mon->ob->level >= level && monnr-- == 0) 1155 if (mon->ob->level >= level && monnr-- == 0)
1298 return mon->ob; 1156 return mon->ob;
1299 1157
1300 if (!mon) 1158 if (!mon)
1301 { 1159 {
1302 LOG (llevError, "get_random_mon(): didn't find a monster when we should have\n"); 1160 LOG (llevError, "get_random_mon(): didn't find a monster when we should have\n");
1303 return NULL; 1161 return NULL;
1304 } 1162 }
1305 return NULL; /* Should be unreached, by keeps warnings down */ 1163 return NULL; /* Should be unreached, by keeps warnings down */
1306} 1164}
1307 1165
1308/* 1166/*
1309 * Returns a description of the monster. This really needs to be 1167 * Returns a description of the monster. This really needs to be
1310 * redone, as describe_item really gives a pretty internal description. 1168 * redone, as describe_item really gives a pretty internal description.
1311 */ 1169 */
1312 1170static const char *
1313char *
1314mon_desc (const object *mon) 1171mon_desc (const object *mon)
1315{ 1172{
1316 static char retbuf[HUGE_BUF]; 1173 static dynbuf_text buf; buf.clear ();
1317 1174
1318 sprintf (retbuf, " *** %s ***\n", mon->name); 1175 buf.printf ("B<< %s >>\r", &mon->name);
1319 strcat (retbuf, describe_item(mon, NULL)); 1176 buf << describe_item (mon, 0);
1320 1177
1321 return retbuf; 1178 return buf;
1322} 1179}
1323 1180
1324 1181
1325/* This function returns the next monsters after 'tmp'. If no match is 1182/* This function returns the next monsters after 'tmp'. If no match is
1326 * found, it returns NULL (changed 0.94.3 to do this, since the 1183 * found, it returns NULL (changed 0.94.3 to do this, since the
1327 * calling function (mon_info_msg) seems to expect that. 1184 * calling function (mon_info_msg) seems to expect that.
1328 */ 1185 */
1329 1186static object *
1330object *
1331get_next_mon (object *tmp) 1187get_next_mon (object *tmp)
1332{ 1188{
1333 objectlink *mon; 1189 objectlink *mon;
1334 1190
1335 for (mon = first_mon_info; mon; mon = mon->next) 1191 for (mon = first_mon_info; mon; mon = mon->next)
1336 if (mon->ob == tmp) 1192 if (mon->ob == tmp)
1337 break; 1193 break;
1338 1194
1339 /* didn't find a match */ 1195 /* didn't find a match */
1340 if (!mon) 1196 if (!mon)
1341 return NULL; 1197 return NULL;
1198
1342 if (mon->next) 1199 if (mon->next)
1343 return mon->next->ob; 1200 return mon->next->ob;
1344 else 1201 else
1345 return first_mon_info->ob; 1202 return first_mon_info->ob;
1346 1203
1347} 1204}
1348
1349
1350 1205
1351/* mon_info_msg() - generate a message detailing the properties 1206/* mon_info_msg() - generate a message detailing the properties
1352 * of a randomly selected monster. 1207 * of a randomly selected monster.
1353 */ 1208 */
1354 1209static const char *
1355char *
1356mon_info_msg (int level, int booksize) 1210mon_info_msg (int level)
1357{ 1211{
1358 static char retbuf[BOOK_BUF]; 1212 static dynbuf_text buf; buf.clear ();
1359 char tmpbuf[HUGE_BUF];
1360 object *tmp;
1361 1213
1362 /*preamble */ 1214 /*preamble */
1363 strcpy (retbuf, "This beastiary contains:"); 1215 buf << "This beastiary contains:\n";
1364 1216
1365 /* lets print info on as many monsters as will fit in our 1217 /* lets print info on as many monsters as will fit in our
1366 * document. 1218 * document.
1367 * 8-96 Had to change this a bit, otherwise there would 1219 * 8-96 Had to change this a bit, otherwise there would
1368 * have been an impossibly large number of combinations 1220 * have been an impossibly large number of combinations
1369 * of text! (and flood out the available number of titles 1221 * of text! (and flood out the available number of titles
1370 * in the archive in a snap!) -b.t. 1222 * in the archive in a snap!) -b.t.
1371 */ 1223 */
1372 tmp = get_random_mon (level * 3); 1224 object *tmp = get_random_mon (level * 3);
1373 while (tmp) { 1225 while (tmp && buf.size () < BOOK_BUF)
1226 {
1374 /* monster description */ 1227 /* monster description */
1375 sprintf (tmpbuf, "\n---\n%s", mon_desc (tmp)); 1228 buf.printf ("\n%s\n", mon_desc (tmp));
1376 1229
1377 if (!book_overflow (retbuf, tmpbuf, booksize))
1378 strcat (retbuf, tmpbuf);
1379 else
1380 break;
1381
1382 /* Note that the value this returns is not based on level */ 1230 /* Note that the value this returns is not based on level */
1383 tmp = get_next_mon (tmp); 1231 tmp = get_next_mon (tmp);
1384 } 1232 }
1385 1233
1386#ifdef BOOK_MSG_DEBUG
1387 LOG (llevDebug, "\n mon_info_msg() created strng: %d\n", strlen (retbuf));
1388 fprintf (logfile, " MADE THIS:\n%s\n", retbuf);
1389#endif
1390
1391 return retbuf; 1234 return buf;
1392} 1235}
1393 1236
1394 1237
1395/***************************************************************************** 1238/*****************************************************************************
1396 * Artifact msg generation code. 1239 * Artifact msg generation code.
1397 ****************************************************************************/ 1240 ****************************************************************************/
1398 1241
1399/* artifact_msg() - generate a message detailing the properties 1242/* artifact_msg() - generate a message detailing the properties
1400 * of 1-6 artifacts drawn sequentially from the artifact list. 1243 * of 1-6 artifacts drawn sequentially from the artifact list.
1401 */ 1244 */
1402 1245static const char *
1403char *
1404artifact_msg (int level, int booksize) 1246artifact_msg (int level)
1405{ 1247{
1406 artifactlist *al = NULL; 1248 artifactlist *al = NULL;
1407 artifact *art; 1249 artifact *art;
1408 int chance, i, type, index; 1250 int chance, i, type, index;
1409 int book_entries = level > 5 ? RANDOM () % 3 + RANDOM () % 3 + 2 : RANDOM () % level + 1; 1251 int book_entries = level > 5 ? rndm (3) + rndm (3) + 2 : rndm (level) + 1;
1410 char *ch, name[MAX_BUF], buf[BOOK_BUF], sbuf[MAX_BUF]; 1252 const char *ch;
1411 static char retbuf[BOOK_BUF]; 1253 char name[MAX_BUF];
1412 object *tmp = NULL; 1254 object *tmp = NULL;
1413 1255
1256 static dynbuf_text buf; buf.clear ();
1257
1414 /* values greater than 5 create msg buffers that are too big! */ 1258 /* values greater than 5 create msg buffers that are too big! */
1415 if (book_entries > 5) 1259 if (book_entries > 5)
1416 book_entries = 5; 1260 book_entries = 5;
1417 1261
1418 /* lets determine what kind of artifact type randomly. 1262 /* lets determine what kind of artifact type randomly.
1419 * Right now legal artifacts only come from those listed 1263 * Right now legal artifacts only come from those listed
1420 * in art_name_array. Also, we check to be sure an artifactlist 1264 * in art_name_array. Also, we check to be sure an artifactlist
1421 * for that type exists! 1265 * for that type exists!
1422 */ 1266 */
1423 i=0; 1267 i = 0;
1268 do
1424 do { 1269 {
1425 index = RANDOM () % (sizeof (art_name_array) / sizeof (arttypename)); 1270 index = rndm (sizeof (art_name_array) / sizeof (arttypename));
1426 type = art_name_array[index].type; 1271 type = art_name_array[index].type;
1427 al = find_artifactlist (type); 1272 al = find_artifactlist (type);
1428 i++; 1273 i++;
1274 }
1429 } while ((al == NULL) && (i<10)); 1275 while ((al == NULL) && (i < 10));
1430 1276
1431 if (i==10) /* Unable to find a message */ 1277 if (i == 10) /* Unable to find a message */
1432 return("None"); 1278 return "None";
1433 1279
1434 /* There is no reason to start on the artifact list at the begining. Lets 1280 /* There is no reason to start on the artifact list at the begining. Lets
1435 * take our starting position randomly... */ 1281 * take our starting position randomly... */
1436 art = al->items; 1282 art = al->items;
1437 for (i = RANDOM () % level + RANDOM () % 2 + 1; i > 0; i--) 1283 for (i = rndm (level) + rndm (2) + 1; i > 0; i--)
1438 { 1284 {
1439 if (art == NULL) 1285 if (!art)
1440 art = al->items; /* hmm, out of stuff, loop back around */ 1286 art = al->items; /* hmm, out of stuff, loop back around */
1287
1441 art = art->next; 1288 art = art->next;
1442 } 1289 }
1443 1290
1444 /* the base 'generic' name for our artifact */ 1291 /* the base 'generic' name for our artifact */
1445 strcpy(name, art_name_array[index].name); 1292 assign (name, art_name_array[index].name);
1446 1293
1447 /* Ok, lets print out the contents */ 1294 /* Ok, lets print out the contents */
1448 sprintf (retbuf, "Herein %s detailed %s...\n", book_entries > 1 ? "are" : "is", 1295 buf.printf ("Herein %s detailed %s...\n",
1296 book_entries > 1 ? "are" : "is",
1449 book_entries > 1 ? "some artifacts" : "an artifact"); 1297 book_entries > 1 ? "some artifacts" : "an artifact");
1450 1298
1451 /* artifact msg attributes loop. Lets keep adding entries to the 'book' 1299 /* 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) 1300 * as long as we have space up to the allowed max # (book_entires)
1453 */ 1301 */
1454 while (book_entries > 0) 1302 while (book_entries > 0 && buf.size () < BOOK_BUF)
1455 { 1303 {
1456 1304
1457 if (art == NULL) 1305 if (!art)
1458 art = al->items; 1306 art = al->items;
1459 1307
1460 /* separator of items */ 1308 buf << '\n';
1461 strcpy (buf, "--- \n");
1462 1309
1463 /* Name */ 1310 /* Name */
1464 if (art->allowed != NULL && strcmp (art->allowed->name, "All")) 1311 if (art->allowed && art->allowed->name != shstr_All)
1312 {
1313 linked_char *temp, *next = art->allowed;
1314
1315 do
1465 { 1316 {
1466 linked_char *temp, *next = art->allowed;
1467 do
1468 {
1469 temp = next; 1317 temp = next;
1470 next = next->next; 1318 next = next->next;
1471 }
1472 while ((next != (linked_char *) NULL) && !RANDOM () % 2);
1473 sprintf (buf, "%s A %s of %s", buf, temp->name, art->item->name);
1474 } 1319 }
1475 else /* default name is used */ 1320 while (next && rndm (2));
1321
1322 buf.printf ("A B<< %s of %s >>", &temp->name, &art->item->name);
1323 }
1324 else /* default name is used */
1476 sprintf (buf, "%s The %s of %s", buf, name, art->item->name); 1325 buf.printf ("The B<< %s of %s >>", name, &art->item->name);
1477 1326
1327 buf << " is ";
1328
1478 /* chance of finding */ 1329 /* chance of finding */
1479 chance = (int) (100 * ((float) art->chance / al->total_chance)); 1330 chance = (int) (100 * ((float) art->chance / al->total_chance));
1480 if (chance >= 20) 1331 if (chance >= 20)
1481 sprintf (sbuf, "an uncommon"); 1332 buf << "an uncommon";
1482 else if (chance >= 10) 1333 else if (chance >= 10)
1483 sprintf (sbuf, "an unusual"); 1334 buf << "an unusual";
1484 else if (chance >= 5) 1335 else if (chance >= 5)
1485 sprintf (sbuf, "a rare"); 1336 buf << "a rare";
1486 else 1337 else
1487 sprintf (sbuf, "a very rare"); 1338 buf << "a very rare";
1488 sprintf (buf, "%s is %s\n", buf, sbuf);
1489 1339
1490 /* value of artifact */ 1340 /* value of artifact */
1491 sprintf (buf, "%s item with a value that is %d times normal.\n", 1341 buf << " item with a value that is " << art->item->value << " times normal.\n";
1492 buf, art->item->value);
1493 1342
1494 /* include the message about the artifact, if exists, and book 1343 /* include the message about the artifact, if exists, and book
1495 * level is kinda high */ 1344 * level is kinda high */
1496 if (art->item->msg && (RANDOM () % 4 + 1) < level && 1345 if (art->item->msg
1497 !((strlen (art->item->msg) + strlen (buf)) > BOOK_BUF)) 1346 && rndm (4) + 1 < level)
1498 strcat(buf, art->item->msg); 1347 buf << art->item->msg;
1499 1348
1500 /* properties of the artifact */ 1349 /* properties of the artifact */
1501 tmp = get_object (); 1350 tmp = object::create ();
1502 add_abilities (tmp, art->item); 1351 add_abilities (tmp, art->item);
1503 tmp->type = type; 1352 tmp->type = type;
1504 SET_FLAG (tmp, FLAG_IDENTIFIED); 1353 SET_FLAG (tmp, FLAG_IDENTIFIED);
1505 if ((ch = describe_item (tmp, NULL)) != NULL && strlen (ch) > 1) 1354 if ((ch = describe_item (tmp, 0)) && strlen (ch) > 1)
1506 sprintf (buf, "%s Properties of this artifact include: \n %s \n", 1355 buf << "\rProperties of this artifact include:\r" << ch << "\n";
1507 buf, ch);
1508 free_object(tmp);
1509 /* add the buf if it will fit */
1510 if (!book_overflow (retbuf, buf, booksize))
1511 strcat (retbuf, buf);
1512 else
1513 break;
1514 1356
1357 tmp->destroy ();
1358
1515 art = art->next; 1359 art = art->next;
1516 book_entries--; 1360 book_entries--;
1517 } 1361 }
1518 1362
1519#ifdef BOOK_MSG_DEBUG
1520 LOG (llevDebug, "artifact_msg() created strng: %d\n", strlen (retbuf));
1521 fprintf (logfile, " MADE THIS:\n%s", retbuf);
1522#endif
1523 return retbuf; 1363 return buf;
1524} 1364}
1525 1365
1526/***************************************************************************** 1366/*****************************************************************************
1527 * Spellpath message generation 1367 * Spellpath message generation
1528 *****************************************************************************/ 1368 *****************************************************************************/
1529 1369
1530/* spellpath_msg() - generate a message detailing the member 1370/* spellpath_msg() - generate a message detailing the member
1531 * incantations/prayers (and some of their properties) belonging to 1371 * incantations/prayers (and some of their properties) belonging to
1532 * a given spellpath. 1372 * a given spellpath.
1533 */ 1373 */
1534 1374static char *
1535char *
1536spellpath_msg (int level, int booksize) 1375spellpath_msg (int level)
1537{ 1376{
1377 static dynbuf_text buf; buf.clear ();
1378
1538 static char retbuf[BOOK_BUF]; 1379 static char retbuf[BOOK_BUF];
1539 char tmpbuf[BOOK_BUF]; 1380 char tmpbuf[BOOK_BUF];
1540 int path = RANDOM () % NRSPELLPATHS, prayers = RANDOM () % 2; 1381 int path = rndm (NRSPELLPATHS), prayers = rndm (2);
1541 int did_first_sp = 0;
1542 uint32 pnum = (path == -1) ? PATH_NULL : spellpathdef[path]; 1382 uint32 pnum = (path == -1) ? PATH_NULL : spellpathdef[path];
1543 archetype *at; 1383 archetype *at;
1544 1384
1545 /* Preamble */ 1385 /* Preamble */
1546 sprintf (retbuf, "Herein are detailed the names of %s\n", 1386 buf << "Herein are detailed the names of "
1547 prayers ? "prayers": "incantations"); 1387 << (prayers ? "prayers" : "incantations");
1548 1388
1549 if (path == -1) 1389 if (path == -1)
1550 strcat (retbuf, "having no known spell path.\n"); 1390 buf << " having no known spell path.\n";
1551 else 1391 else
1552 sprintf (retbuf, "%sbelonging to the path of %s:\n", retbuf, 1392 buf << " belonging to the path of B<< " << spellpathnames[path] << " >>:\n\n";
1553 spellpathnames[path]);
1554 1393
1555 for (at=first_archetype; at != NULL; at=at->next) { 1394 int seen = 0;
1395
1396 for_all_archetypes (at)
1556 /* Determine if this is an appropriate spell. Must 1397 /* Determine if this is an appropriate spell. Must
1557 * be of matching path, must be of appropriate type (prayer 1398 * be of matching path, must be of appropriate type (prayer
1558 * or not), and must be within the valid level range. 1399 * or not), and must be within the valid level range.
1559 */ 1400 */
1560 if (at->clone.type == SPELL && at->clone.path_attuned & pnum && 1401 if (at->type == SPELL && at->path_attuned & pnum &&
1561 ((at->clone.stats.grace && prayers) || (at->clone.stats.sp && !prayers)) && 1402 ((at->stats.grace && prayers) || (at->stats.sp && !prayers)) && (at->level < (level * 8)))
1562 (at->clone.level < (level * 8))) { 1403 {
1563 strcpy (tmpbuf, at->clone.name); 1404 seen = 1;
1564 1405 buf << at->object::name << '\r';
1565 if (book_overflow (retbuf, tmpbuf, booksize))
1566 break;
1567 else {
1568 if (did_first_sp)
1569 strcat (retbuf, ",\n");
1570 did_first_sp = 1;
1571 strcat (retbuf, tmpbuf);
1572 }
1573 }
1574 } 1406 }
1407
1575 /* Geez, no spells were generated. */ 1408 /* Geez, no spells were generated. */
1576 if (!did_first_sp) { 1409 if (!seen)
1577 if (RANDOM () % 4) /* usually, lets make a recursive call... */ 1410 if (rndm (4)) /* usually, lets make a recursive call... */
1578 spellpath_msg (level, booksize); 1411 return spellpath_msg (level);
1579 else /* give up, cause knowing no spells exist for path is info too. */ 1412 else /* give up, cause knowing no spells exist for path is info too. */
1580 strcat (retbuf, "\n - no known spells exist -\n"); 1413 buf << "- no known spells exist.\n";
1581 } 1414
1582 else {
1583 strcat (retbuf, "\n");
1584 }
1585 return retbuf; 1415 return buf;
1586} 1416}
1587
1588
1589 1417
1590/* formula_msg() - generate a message detailing the properties 1418/* formula_msg() - generate a message detailing the properties
1591 * of a randomly selected alchemical formula. 1419 * of a randomly selected alchemical formula.
1592 */ 1420 */
1593 1421static void
1594void make_formula_book(object *book, int level) { 1422make_formula_book (object *book, int level)
1595 char retbuf[BOOK_BUF], title[MAX_BUF]; 1423{
1424 char title[MAX_BUF];
1596 recipelist *fl; 1425 recipelist *fl;
1597 recipe *formula = NULL; 1426 recipe *formula = NULL;
1598 int chance; 1427 int chance;
1599 1428
1429 static dynbuf_text buf; buf.clear ();
1430
1600 /* the higher the book level, the more complex (ie number of 1431 /* the higher the book level, the more complex (ie number of
1601 * ingredients) the formula can be. 1432 * ingredients) the formula can be.
1602 */ 1433 */
1603 fl = get_formulalist (((RANDOM () % level) / 3) + 1); 1434 fl = get_formulalist (rndm (level) / 3 + 1);
1604 1435
1605 if (!fl) 1436 if (!fl)
1606 fl = get_formulalist (1); /* safety */ 1437 fl = get_formulalist (1); /* safety */
1607 1438
1608 if (fl->total_chance == 0) 1439 if (fl->total_chance == 0)
1609 { 1440 {
1610 book->msg = add_string(" <indecipherable text>\n"); 1441 book->msg = "<indecipherable text>\n";
1611 new_text_name(book, 4); 1442 new_text_name (book, 4);
1612 add_author(book,4); 1443 add_author (book, 4);
1613 return; 1444 return;
1614 } 1445 }
1615 1446
1616 /* get a random formula, weighted by its bookchance */ 1447 /* get a random formula, weighted by its bookchance */
1617 chance = RANDOM () % fl->total_chance; 1448 chance = rndm (fl->total_chance);
1618 for (formula = fl->items; formula != NULL; formula = formula->next) { 1449 for (formula = fl->items; formula; formula = formula->next)
1450 {
1619 chance -= formula->chance; 1451 chance -= formula->chance;
1452
1620 if (chance <= 0) 1453 if (chance <= 0)
1621 break; 1454 break;
1622 } 1455 }
1623 1456
1624 if (!formula || formula->arch_names <= 0) { 1457 if (!formula || formula->arch_names <= 0)
1458 {
1625 book->msg = add_string(" <indecipherable text>\n"); 1459 book->msg = "<indecipherable text>\n";
1626 new_text_name(book, 4); 1460 new_text_name (book, 4);
1627 add_author(book,4); 1461 add_author (book, 4);
1628 1462 return;
1629 } else { 1463 }
1464
1630 /* looks like a formula was found. Base the amount 1465 /* looks like a formula was found. Base the amount
1631 * of information on the booklevel and the spellevel 1466 * of information on the booklevel and the spellevel
1632 * of the formula. */ 1467 * of the formula. */
1633 1468
1634 const char *op_name = formula->arch_name[RANDOM()%formula->arch_names]; 1469 const char *op_name = formula->arch_name [rndm (formula->arch_names)];
1635 archetype *at; 1470 archetype *at;
1636 1471
1637 /* preamble */ 1472 /* preamble */
1638 sprintf(retbuf, "Herein is described a project using %s: \n", 1473 buf << "Herein is described a project using B<< "
1639 formula->skill?formula->skill:"an unknown skill"); 1474 << (formula->skill ? &formula->skill : "an unknown skill")
1475 << " >>:\n\n";
1640 1476
1641 if ((at = find_archetype (op_name)) != (archetype *) NULL) 1477 if ((at = archetype::find (op_name)))
1642 op_name = at->clone.name; 1478 op_name = at->object::name;
1643 else 1479 else
1644 LOG (llevError, "formula_msg() can't find arch %s for formula.\n", 1480 LOG (llevError, "formula_msg() can't find arch %s for formula.\n", op_name);
1645 op_name);
1646 1481
1647 /* item name */ 1482 /* item name */
1648 if (strcmp (formula->title, "NONE")) { 1483 if (formula->title != shstr_NONE)
1649 sprintf (retbuf, "%sThe %s of %s", retbuf, op_name, formula->title); 1484 {
1485 buf.printf ("The B<< %s of %s >>", op_name, &formula->title);
1650 /* This results in things like pile of philo. sulfur. 1486 /* This results in things like pile of philo. sulfur.
1651 * while philo. sulfur may look better, without this, 1487 * while philo. sulfur may look better, without this,
1652 * you get things like 'the wise' because its missing the 1488 * you get things like 'the wise' because its missing the
1653 * water of section. 1489 * water of section.
1654 */ 1490 */
1655 sprintf(title,"%s: %s of %s", 1491 sprintf (title, "%s: %s of %s",
1656 formula_book_name[RANDOM() % (sizeof(formula_book_name) / sizeof(char*))], 1492 formula_book_name [rndm (sizeof (formula_book_name) / sizeof (char *))], op_name, &formula->title);
1657 op_name, formula->title); 1493 }
1494 else
1495 {
1496 buf << "The B<< " << op_name;
1497
1498 sprintf (title, "%s: %s", formula_book_name [rndm (sizeof (formula_book_name) / sizeof (char *))], op_name);
1499 if (at->title)
1500 {
1501 buf << " " << at->title;
1502 strcat (title, " ");
1503 strcat (title, at->title);
1658 } 1504 }
1505
1506 buf << " >>";
1507 }
1508
1509 /* Lets name the book something meaningful ! */
1510 book->name = title;
1511 book->title = NULL;
1512
1513 /* ingredients to make it */
1514 if (formula->ingred)
1515 {
1516 linked_char *next;
1517 archetype *at;
1518
1519 at = archetype::find (formula->cauldron);
1520
1521 buf.printf (" may be made at %s using the following ingredients:\n\n",
1522 at ? query_name (at) : "an appropriate place");
1523
1524 for (next = formula->ingred; next; next = next->next)
1525 buf << next->name << '\r';
1526 }
1527 else
1528 LOG (llevError, "formula_msg() no ingredient list for object %s of %s\n", op_name, &formula->title);
1529
1530 book->msg = buf;
1531}
1532
1533#define DESCRIBE_PATH(retbuf, variable, name) \
1534 if(variable) { \
1535 int i,j=0; \
1536 strcat(retbuf,"(" name ": "); \
1537 for(i=0; i<NRSPELLPATHS; i++) \
1538 if(variable & (1<<i)) { \
1539 if (j) \
1540 strcat(retbuf,", "); \
1659 else 1541 else \
1542 j = 1; \
1543 strcat(retbuf, spellpathnames[i]); \
1544 } \
1545 strcat(retbuf,")"); \
1546 }
1547
1548/* god_info_msg() - generate a message detailing the properties
1549 * of a random god. Used by the book hack. b.t.
1550 */
1551static const char *
1552god_info_msg (int level)
1553{
1554 const char *name = NULL;
1555 object *god = pntr_to_god_obj (get_rand_god ());
1556
1557 static dynbuf_text buf; buf.clear ();
1558
1559 if (!god)
1560 return 0; /* oops, problems... */
1561
1562 name = god->name;
1563
1564 /* preamble.. */
1565 buf << "This document contains knowledge concerning the diety B<< "
1566 << name << " >>";
1567
1568 /* Always have as default information the god's descriptive terms. */
1569 if (nstrtok (god->msg, ",") > 0)
1570 buf << ", known as" << strtoktolin (god->msg, ",");
1571 else
1572 buf << "...";
1573
1574 buf << "\n\n";
1575
1576 int introlen = buf.size (); /* so we will know if no new info is added later */
1577
1578 /* Information about the god is random, and based on the level of the
1579 * 'book'. Probably there is a more intellegent way to implement
1580 * this ...
1581 */
1582 while (level > 0 && buf.size () < BOOK_BUF)
1583 {
1584 if (level == 2 && rndm (2))
1585 { /* enemy god */
1586 const char *enemy = god->title;
1587
1588 if (enemy)
1589 buf.printf ("The gods %s and %s are enemies.\r", name, enemy);
1660 { 1590 }
1661 sprintf (retbuf, "%sThe %s", retbuf, op_name); 1591
1662 sprintf(title,"%s: %s", 1592 if (level == 3 && rndm (2))
1663 formula_book_name[RANDOM() % (sizeof(formula_book_name) / sizeof(char*))], 1593 { /* enemy race, what the god's holy word effects */
1664 op_name); 1594 const char *enemy = god->slaying;
1665 if (at->clone.title) 1595 int i;
1596
1597 if (enemy && !(god->path_denied & PATH_TURNING))
1598 if ((i = nstrtok (enemy, ",")) > 0)
1666 { 1599 {
1667 strcat (retbuf, " "); 1600 char tmpbuf[MAX_BUF];
1668 strcat (retbuf, at->clone.title); 1601
1669 strcat(title, " "); 1602 buf << "The holy words of " << name
1670 strcat(title, at->clone.title); 1603 << " have the power to slay creatures belonging to the ";
1604
1605 if (i > 1)
1606 buf << "following races:" << strtoktolin (enemy, ",");
1607 else
1608 buf << "race of" << strtoktolin (enemy, ",");
1609
1610 buf << '\r';
1611 }
1612 }
1613
1614 if (level == 4 && rndm (2))
1615 { /* Priest of god gets these protect,vulnerable... */
1616 if (const char *cp = describe_resistance (god, 1))
1617 { /* This god does have protections */
1618 buf << name
1619 << " has a potent aura which is extended to"
1620 " faithful priests. The effects of this aura include: "
1621 << cp
1622 << ".\r";
1671 } 1623 }
1672 } 1624 }
1673 /* Lets name the book something meaningful ! */ 1625
1674 if (book->name) free_string(book->name); 1626 if (level == 5 && rndm (2))
1675 book->name = add_string(title); 1627 { /* aligned race, summoning */
1676 if (book->title) { 1628 const char *race = god->race; /* aligned race */
1677 free_string(book->title); 1629 int i;
1678 book->title = NULL; 1630
1631 if (race && !(god->path_denied & PATH_SUMMON))
1632 if ((i = nstrtok (race, ",")) > 0)
1633 {
1634 buf << "Creatures sacred to " << name << " include the ";
1635 if (i > 1)
1636 buf << "following races:" << strtoktolin (race, ",");
1637 else
1638 buf << "race of" << strtoktolin (race, ",");
1639
1640 buf << '\r';
1641 }
1679 } 1642 }
1680 1643
1681 /* ingredients to make it */ 1644 if (level == 6 && rndm (2))
1682 if (formula->ingred != NULL) 1645 { /* blessing,curse properties of the god */
1683 { 1646 if (const char *cp = describe_resistance (god, 1))
1684 linked_char *next; 1647 { /* This god does have protections */
1685 archetype *at; 1648 buf << "The priests of " << name
1686 1649 << " are known to be able to "
1687 at = find_archetype(formula->cauldron); 1650 "bestow a blessing which makes the recipient "
1688 1651 << cp
1689 sprintf(retbuf + strlen(retbuf), 1652 << '\r';
1690 " may be made at %s using the following ingredients:\n",
1691 at?query_name(&at->clone):"an unknown place");
1692
1693 for (next = formula->ingred; next != NULL; next = next->next)
1694 {
1695 strcat (retbuf, next->name);
1696 strcat (retbuf, "\n");
1697 } 1653 }
1698 } 1654 }
1699 else
1700 LOG (llevError, "formula_msg() no ingredient list for object %s of %s\n",
1701 op_name, formula->title);
1702 if (retbuf[strlen(retbuf)-1]!= '\n') strcat(retbuf, "\n");
1703 if (book->msg) free_string(book->msg);
1704 book->msg = add_string(retbuf);
1705 }
1706}
1707 1655
1708 1656 if (level == 8 && rndm (2))
1709/* msgfile_msg() - generate a message drawn randomly from a 1657 { /* immunity, holy possession */
1710 * file in lib/. Level currently has no effect on the message 1658 buf << "The priests of " << name
1711 * which is returned. 1659 << " are known to make cast a mighty"
1712 */ 1660 " prayer of possession";
1713
1714char *
1715msgfile_msg (int level, int booksize)
1716{
1717 static char retbuf[BOOK_BUF];
1718 int i, msgnum;
1719 linked_char *msg = NULL;
1720
1721 /* get a random message for the 'book' from linked list */
1722 if (nrofmsg > 1)
1723 {
1724 msg = first_msg;
1725 msgnum = RANDOM () % nrofmsg;
1726 for (i = 0; msg && i < nrofmsg && i != msgnum; i++)
1727 msg = msg->next;
1728 }
1729
1730 if (msg && !book_overflow (retbuf, msg->name, booksize))
1731 strcpy (retbuf, msg->name);
1732 else
1733 sprintf (retbuf, "\n <undecipherable text>");
1734
1735#ifdef BOOK_MSG_DEBUG
1736 LOG (llevDebug, "\n info_list_msg() created strng: %d\n", strlen (retbuf));
1737 LOG (llevDebug, " MADE THIS:\n%s\n", retbuf);
1738#endif
1739
1740 return retbuf;
1741}
1742
1743
1744/* god_info_msg() - generate a message detailing the properties
1745 * of a random god. Used by the book hack. b.t.
1746 */
1747
1748const char *
1749god_info_msg (int level, int booksize)
1750{
1751 static char retbuf[BOOK_BUF];
1752 const char *name = NULL;
1753 char buf[BOOK_BUF];
1754 int i;
1755 size_t introlen;
1756 object *god = pntr_to_god_obj (get_rand_god ());
1757
1758 if (!god)
1759 return (char *) NULL; /* oops, problems... */
1760 name = god->name;
1761
1762 /* preamble.. */
1763 sprintf (retbuf, "This document contains knowledge concerning\n");
1764 sprintf (retbuf, "%sthe diety %s", retbuf, name);
1765
1766 /* Always have as default information the god's descriptive terms. */
1767 if (nstrtok (god->msg, ",") > 0)
1768 {
1769 strcat (retbuf, ", known as");
1770 strcat (retbuf, strtoktolin (god->msg, ","));
1771 }
1772 else
1773 strcat (retbuf, "...");
1774
1775 strcat (retbuf, "\n ---\n");
1776 introlen = strlen (retbuf); /* so we will know if no new info is added later */
1777
1778 /* Information about the god is random, and based on the level of the
1779 * 'book'. Probably there is a more intellegent way to implement
1780 * this ...
1781 */
1782
1783 while (level > 0)
1784 {
1785 sprintf (buf, " ");
1786 if (level == 2 && RANDOM () % 2)
1787 { /* enemy god */
1788 const char *enemy = god->title;
1789 if (enemy)
1790 sprintf (buf, "The gods %s and %s are enemies.\n ---\n",
1791 name, enemy);
1792 } 1661
1793 if (level == 3 && RANDOM () % 2) 1662 int first = 1;
1794 { /* enemy race, what the god's holy word effects */
1795 const char *enemy = god->slaying;
1796 if (enemy && !(god->path_denied & PATH_TURNING))
1797 if ((i = nstrtok (enemy, ",")) > 0)
1798 {
1799 char tmpbuf[MAX_BUF];
1800 sprintf (buf, "The holy words of %s have the power to\n", name);
1801 strcat (buf, "slay creatures belonging to the ");
1802 if (i > 1)
1803 sprintf (tmpbuf, "following \n races:%s",
1804 strtoktolin (enemy, ","));
1805 else
1806 sprintf (tmpbuf, "race of%s", strtoktolin (enemy, ","));
1807 sprintf (buf, "%s%s\n ---\n", buf, tmpbuf);
1808 }
1809 }
1810 if (level == 4 && RANDOM () % 2)
1811 { /* Priest of god gets these protect,vulnerable... */
1812 char tmpbuf[MAX_BUF],*cp;
1813 1663
1814 cp = describe_resistance(god, 1); 1664 for (int i = 0; i < NROFATTACKS; i++)
1815 1665 if (god->resist[i] == 100)
1816 if (*cp) { /* This god does have protections */
1817 sprintf (tmpbuf, "%s has a potent aura which is extended\n"
1818 ,name);
1819 strcat (tmpbuf, "faithful priests. The effects of this aura include:\n");
1820 strcat(tmpbuf, cp);
1821 strcat (buf, tmpbuf);
1822 strcat (buf, "\n ---\n");
1823 } 1666 {
1824 else
1825 sprintf (buf, " ");
1826 }
1827 if (level == 5 && RANDOM () % 2)
1828 { /* aligned race, summoning */
1829 const char *race = god->race; /* aligned race */
1830 if (race && !(god->path_denied & PATH_SUMMON))
1831 if ((i = nstrtok (race, ",")) > 0)
1832 {
1833 char tmpbuf[MAX_BUF];
1834 sprintf (buf, "Creatures sacred to %s include the \n", name);
1835 if (i > 1)
1836 sprintf (tmpbuf, "following \n races:%s",
1837 strtoktolin (race, ","));
1838 else
1839 sprintf (tmpbuf, "race of%s", strtoktolin (race, ","));
1840 sprintf (buf, "%s%s\n ---\n", buf, tmpbuf);
1841 }
1842 }
1843 if (level == 6 && RANDOM () % 2)
1844 { /* blessing,curse properties of the god */
1845 char tmpbuf[MAX_BUF],*cp;
1846
1847 cp = describe_resistance(god, 1);
1848
1849 if (*cp) { /* This god does have protections */
1850 sprintf (tmpbuf, "\nThe priests of %s are known to be able to \n"
1851 ,name);
1852 strcat (tmpbuf, "bestow a blessing which makes the recipient\n");
1853 strcat(tmpbuf, cp);
1854 strcat (buf, tmpbuf);
1855 strcat (buf, "\n ---\n");
1856 }
1857 else
1858 sprintf (buf, " ");
1859
1860 }
1861 if (level == 8 && RANDOM () % 2)
1862 { /* immunity, holy possession */
1863 int has_effect = 0, tmpvar;
1864 char tmpbuf[MAX_BUF];
1865 sprintf (tmpbuf, "\n");
1866 sprintf (tmpbuf, "The priests of %s are known to make cast a mighty \n"
1867 ,name);
1868
1869 strcat (tmpbuf, "prayer of possession which gives the recipient\n");
1870
1871 for (tmpvar=0; tmpvar<NROFATTACKS; tmpvar++) {
1872 if (god->resist[tmpvar]==100) {
1873 has_effect = 1;
1874 sprintf(tmpbuf + strlen(tmpbuf),"Immunity to %s", attacktype_desc[tmpvar]);
1875 }
1876 }
1877 if (has_effect) { 1667 if (first)
1878 strcat (buf, tmpbuf);
1879 strcat (buf, "\n ---\n");
1880 }
1881 else
1882 sprintf (buf, " ");
1883 }
1884 if (level == 12 && RANDOM () % 2)
1885 { /* spell paths */
1886 int has_effect = 0, tmpvar;
1887 char tmpbuf[MAX_BUF];
1888 sprintf (tmpbuf, "\n");
1889 sprintf (tmpbuf, "It is rarely known fact that the priests of %s\n"
1890 ,name);
1891 strcat (tmpbuf, "are mystically transformed. Effects of this include:\n");
1892 if ((tmpvar = god->path_attuned))
1893 { 1668 {
1669 buf << " which gives the recipient";
1894 has_effect = 1; 1670 first = 0;
1895 DESCRIBE_PATH (tmpbuf, tmpvar, "Attuned");
1896 }
1897 if ((tmpvar = god->path_repelled))
1898 {
1899 has_effect = 1;
1900 DESCRIBE_PATH (tmpbuf, tmpvar, "Repelled");
1901 }
1902 if ((tmpvar = god->path_denied))
1903 {
1904 has_effect = 1;
1905 DESCRIBE_PATH (tmpbuf, tmpvar, "Denied");
1906 }
1907 if (has_effect)
1908 {
1909 strcat (buf, tmpbuf);
1910 strcat (buf, "\n ---\n");
1911 } 1671 }
1912 else 1672 else
1913 sprintf (buf, " "); 1673 buf << ", ";
1674
1675 buf << " immunity to " << attacktype_desc[i];
1914 } 1676 }
1915 1677
1916 /* check to be sure new buffer size dont exceed either 1678 buf << ".\r";
1917 * the maximum buffer size, or the 'natural' size of the
1918 * book...
1919 */
1920 if (book_overflow (retbuf, buf, booksize))
1921 break;
1922 else if (strlen (buf) > 1)
1923 strcat (retbuf, buf);
1924 level--;
1925 } 1679 }
1926 if (strlen (retbuf) == introlen) 1680
1681 if (level == 12 && rndm (2))
1682 { /* spell paths */
1683 //TODO:
1684 int has_effect = 0, tmpvar;
1685 char tmpbuf[MAX_BUF];
1686
1687 sprintf (tmpbuf, "\n");
1688 sprintf (tmpbuf, "It is rarely known fact that the priests of %s\n", name);
1689 strcat (tmpbuf, "are mystically transformed. Effects of this include:\n");
1690
1691 if ((tmpvar = god->path_attuned))
1692 {
1693 has_effect = 1;
1694 DESCRIBE_PATH (tmpbuf, tmpvar, "Attuned");
1695 }
1696
1697 if ((tmpvar = god->path_repelled))
1698 {
1699 has_effect = 1;
1700 DESCRIBE_PATH (tmpbuf, tmpvar, "Repelled");
1701 }
1702
1703 if ((tmpvar = god->path_denied))
1704 {
1705 has_effect = 1;
1706 DESCRIBE_PATH (tmpbuf, tmpvar, "Denied");
1707 }
1708
1709 if (has_effect)
1710 buf << tmpbuf << '\r';
1711 else
1712 buf << '\r';
1713 }
1714
1715 level--;
1716 }
1717
1718 if (buf.size () == introlen)
1927 { /* we got no information beyond the preamble! */ 1719 /* we got no information beyond the preamble! */
1928 strcat (retbuf, " [Unfortunately the rest of the information is\n"); 1720 buf << "[Unfortunately the rest of the information is hopelessly garbled!]";
1929 strcat (retbuf, " hopelessly garbled!]\n ---\n"); 1721
1930 }
1931#ifdef BOOK_MSG_DEBUG
1932 LOG (llevDebug, "\n god_info_msg() created strng: %d\n", strlen (retbuf));
1933 fprintf (logfile, " MADE THIS:\n%s", retbuf);
1934#endif
1935 return retbuf; 1722 return buf;
1936} 1723}
1937 1724
1938/* tailor_readable_ob()- The main routine. This chooses a random 1725/* tailor_readable_ob()- The main routine. This chooses a random
1939 * message to put in given readable object (type==BOOK) which will 1726 * message to put in given readable object (type==BOOK) which will
1940 * be referred hereafter as a 'book'. We use the book level to de- 1727 * be referred hereafter as a 'book'. We use the book level to de-
… …
1949 * book is the object we are creating into. 1736 * book is the object we are creating into.
1950 * If msg_type is a positive value, we use that to determine the 1737 * If msg_type is a positive value, we use that to determine the
1951 * message type - otherwise a random value is used. 1738 * message type - otherwise a random value is used.
1952 * 1739 *
1953 */ 1740 */
1954
1955void 1741void
1956tailor_readable_ob (object *book, int msg_type) 1742tailor_readable_ob (object *book, int msg_type)
1957{ 1743{
1958 char msgbuf[BOOK_BUF];
1959 int level = book->level ? (RANDOM () % book->level) + 1 : 1; 1744 int level = book->level ? rndm (book->level) + 1 : 1;
1960 int book_buf_size;
1961 1745
1962 /* safety */ 1746 /* safety */
1963 if (book->type != BOOK) 1747 if (book->type != BOOK)
1748 return;
1749
1750 if (level <= 0)
1751 return; /* if no level no point in doing any more... */
1752
1753 /* &&& The message switch &&& */
1754 /* Below all of the possible types of messages in the "book"s.
1755 */
1756 /*
1757 * IF you add a new type of book msg, you will have to do several things.
1758 * 1) make sure there is an entry in the msg switch below!
1759 * 2) make sure there is an entry in max_titles[] array.
1760 * 3) make sure there are entries for your case in new_text_title()
1761 * and add_authour().
1762 * 4) you may want separate authour/book name arrays in read.h
1763 */
1764 const char *new_msg = "";
1765 msg_type = msg_type > 0 ? msg_type : rndm (8);
1766 switch (msg_type)
1767 {
1768 case 1: /* monster attrib */
1769 new_msg = mon_info_msg (level);
1770 break;
1771 case 2: /* artifact attrib */
1772 new_msg = artifact_msg (level);
1773 break;
1774 case 3: /* grouping incantations/prayers by path */
1775 new_msg = spellpath_msg (level);
1776 break;
1777 case 4: /* describe an alchemy formula */
1778 make_formula_book (book, level);
1779 /* make_formula_book already gives title */
1964 return; 1780 return;
1965 1781 case 5: /* bits of information about a god */
1966 if (level <= 0) 1782 new_msg = god_info_msg (level);
1967 return; /* if no level no point in doing any more... */
1968
1969 /* Max text length this book can have. */
1970 book_buf_size = BOOKSIZE (book);
1971
1972 /* &&& The message switch &&& */
1973 /* Below all of the possible types of messages in the "book"s.
1974 */
1975 /*
1976 * IF you add a new type of book msg, you will have to do several things.
1977 * 1) make sure there is an entry in the msg switch below!
1978 * 2) make sure there is an entry in max_titles[] array.
1979 * 3) make sure there are entries for your case in new_text_title()
1980 * and add_authour().
1981 * 4) you may want separate authour/book name arrays in read.h
1982 */
1983
1984 msg_type = msg_type > 0 ? msg_type : (RANDOM () % 6);
1985 switch (msg_type)
1986 {
1987 case 1: /* monster attrib */
1988 strcpy (msgbuf, mon_info_msg (level, book_buf_size));
1989 break; 1783 break;
1990 case 2: /* artifact attrib */
1991 strcpy (msgbuf, artifact_msg (level, book_buf_size));
1992 break;
1993 case 3: /* grouping incantations/prayers by path */
1994 strcpy (msgbuf, spellpath_msg (level, book_buf_size));
1995 break;
1996 case 4: /* describe an alchemy formula */
1997 make_formula_book(book, level);
1998 /* make_formula_book already gives title */
1999 return;
2000 break;
2001 case 5: /* bits of information about a god */
2002 strcpy (msgbuf, god_info_msg (level, book_buf_size));
2003 break;
2004 case 0: /* use info list in lib/ */ 1784 case 0: /* use info list in lib/ */
2005 default: 1785 default:
2006 strcpy (msgbuf, msgfile_msg (level, book_buf_size)); 1786 cfperl_make_book (book, level);
2007 break; 1787 /* already gives title */
1788 return;
2008 } 1789 }
2009 1790
2010 strcat (msgbuf, "\n"); /* safety -- we get ugly map saves/crashes w/o this */
2011 if (strlen (msgbuf) > 1) 1791 if (strlen (new_msg) > 1)
2012 { 1792 {
2013 if (book->msg) 1793 book->msg = new_msg;
2014 free_string (book->msg);
2015 book->msg = add_string (msgbuf);
2016 /* lets give the "book" a new name, which may be a compound word */ 1794 /* lets give the "book" a new name, which may be a compound word */
2017 change_book (book, msg_type); 1795 change_book (book, msg_type);
2018 } 1796 }
2019
2020} 1797}
2021
2022
2023/*****************************************************************************
2024 *
2025 * Cleanup routine for readble stuff.
2026 *
2027 *****************************************************************************/
2028
2029void
2030free_all_readable (void)
2031{
2032 titlelist *tlist, *tnext;
2033 title *title1, *titlenext;
2034 linked_char *lmsg, *nextmsg;
2035 objectlink *monlink, *nextmon;
2036
2037 LOG (llevDebug, "freeing all book information\n");
2038
2039 for (tlist = booklist; tlist != NULL; tlist = tnext)
2040 {
2041 tnext = tlist->next;
2042 for (title1 = tlist->first_book; title1; title1 = titlenext)
2043 {
2044 titlenext = title1->next;
2045 if (title1->name)
2046 free_string (title1->name);
2047 if (title1->authour)
2048 free_string (title1->authour);
2049 if (title1->archname)
2050 free_string (title1->archname);
2051 free (title1);
2052 }
2053 free (tlist);
2054 }
2055 for (lmsg = first_msg; lmsg; lmsg = nextmsg)
2056 {
2057 nextmsg = lmsg->next;
2058 if (lmsg->name)
2059 free_string (lmsg->name);
2060 free (lmsg);
2061 }
2062 for (monlink = first_mon_info; monlink; monlink = nextmon)
2063 {
2064 nextmon = monlink->next;
2065 free (monlink);
2066 }
2067}
2068
2069 1798
2070/***************************************************************************** 1799/*****************************************************************************
2071 * 1800 *
2072 * Writeback routine for updating the bookarchive. 1801 * Writeback routine for updating the bookarchive.
2073 * 1802 *
2074 ****************************************************************************/ 1803 ****************************************************************************/
2075
2076/* write_book_archive() - write out the updated book archive */ 1804/* write_book_archive() - write out the updated book archive */
2077
2078void 1805void
2079write_book_archive (void) 1806write_book_archive ()
2080{ 1807{
2081 FILE *fp; 1808 FILE *fp;
2082 int index = 0; 1809 int index = 0;
2083 char fname[MAX_BUF]; 1810 char fname[MAX_BUF];
2084 title *book = NULL; 1811 title *book = NULL;
2085 titlelist *bl = get_titlelist (0); 1812 titlelist *bl = get_titlelist (0);
2086 1813
2087 /* If nothing changed, don't write anything */ 1814 /* If nothing changed, don't write anything */
2088 if (!need_to_write_bookarchive) return; 1815 if (!need_to_write_bookarchive)
1816 return;
1817
2089 need_to_write_bookarchive=0; 1818 need_to_write_bookarchive = 0;
2090 1819
2091 sprintf (fname, "%s/bookarch", settings.localdir); 1820 sprintf (fname, "%s/bookarch", settings.localdir);
2092 LOG (llevDebug, "Updating book archive: %s...\n", fname); 1821 LOG (llevDebug, "Updating book archive: %s...\n", fname);
2093 1822
2094 if ((fp = fopen (fname, "w")) == NULL) 1823 if ((fp = fopen (fname, "w")) == NULL)
2095 {
2096 LOG (llevDebug, "Can't open book archive file %s\n", fname); 1824 LOG (llevDebug, "Can't open book archive file %s\n", fname);
2097 }
2098 else 1825 else
2099 { 1826 {
2100 while (bl) 1827 while (bl)
2101 { 1828 {
2102 for (book = bl->first_book; book; book = book->next) 1829 for (book = bl->first_book; book; book = book->next)
2103 if (book && book->authour) 1830 if (book && book->authour)
2104 { 1831 {
2105 fprintf (fp, "title %s\n", book->name); 1832 fprintf (fp, "title %s\n", &book->name);
2106 fprintf (fp, "authour %s\n", book->authour); 1833 fprintf (fp, "authour %s\n", &book->authour);
2107 fprintf (fp, "arch %s\n", book->archname); 1834 fprintf (fp, "arch %s\n", &book->archname);
2108 fprintf (fp, "level %d\n", book->level); 1835 fprintf (fp, "level %d\n", book->level);
2109 fprintf (fp, "type %d\n", index); 1836 fprintf (fp, "type %d\n", index);
2110 fprintf (fp, "size %d\n", book->size); 1837 fprintf (fp, "size %d\n", book->size);
2111 fprintf (fp, "index %d\n", book->msg_index); 1838 fprintf (fp, "index %d\n", book->msg_index);
2112 fprintf (fp, "end\n"); 1839 fprintf (fp, "end\n");
2113 }
2114 bl = bl->next;
2115 index++;
2116 } 1840 }
1841
1842 bl = bl->next;
1843 index++;
1844 }
1845
2117 fclose (fp); 1846 fclose (fp);
2118 chmod (fname, SAVE_MODE); 1847 chmod (fname, SAVE_MODE);
2119 } 1848 }
2120} 1849}
1850
1851readable_message_type *
2121readable_message_type* get_readable_message_type(object* readable){ 1852get_readable_message_type (object *readable)
1853{
2122 uint8 subtype = readable->subtype; 1854 uint8 subtype = readable->subtype;
1855
2123 if (subtype>last_readable_subtype) 1856 if (subtype > last_readable_subtype)
2124 return &(readable_message_types[0]); 1857 return &readable_message_types[0];
1858
2125 return &(readable_message_types[subtype]); 1859 return &readable_message_types[subtype];
2126} 1860}

Diff Legend

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