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.24 by root, Thu May 24 03:33:28 2007 UTC

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

Diff Legend

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