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

Diff Legend

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