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

Diff Legend

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