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.45 by root, Thu Oct 15 22:50:41 2009 UTC

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

Diff Legend

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