/* TMORPH2.T
* This library imitates Kevin Forchione's tmorph.t library. However, it fixes
* a major problem with the original library, which could not handle strings
* with embedded code (i.e. code in <<>>). This version also handles recursive
* expressions.
*
* For the copyright notice to the original tmorph.t, see the end of this
* file. While this file is not simply a modified version of the original (I
* wrote most of it from scratch), there are a few portions which are almost
* direct copies.
*
* This library Copyright 2003 by Shadow Wolf. All Rights Reserved. Distribution
* terms are the same as Kevin Forchione's original library:
*
* You may modify and use this file in any way you want, provided that
* if you redistribute modified copies of this file in source form, the
* copies must include the original copyright notice (including this
* paragraph), and must be clearly marked as modified from the original
* version.
*/
/*******************************************************
* Using TMORPH2.T
*
* Morph expressions are embedded within the text string you want to display,
* using square brackets '[]' to delimit them. Each morph expression consists of
* the following elements:
* An optional initializer followed by a pipe '|': The initializer can either
* be a number (typically generated by an embedded expression) or a name and
* type pair. If the pipe is used without an initializer, a random value will
* be used. If no initializer or pipe is used, then the most recently
* generated value will be used.
*
* After the initializer is a list of alternative strings, separated by
* slashes '/'. You can leave an element blank in order to not display any
* text.
*
* This improved version of the text morphing library allows for recursive
* expressions. The innermost morph expression is generated first, with its
* result placed in the outer expression. Evaluated expressions (code in << >>
* delimiters) are also evaluated before the morph expression containing them.
*
* This version also handles HTML tags (by ignoring them), if USE_HTML_PROMPT is
* defined. (I figure anyone writing an HTML game is going to use HTML prompts as a
* minimum.)
*
* Example:
*
* (From Kevin Forchione's original library)
* "[|A ball/Balls] of searing flame burst[s/]
* out of your magic ring, rebound[s/] off of the ground, and
* vaporize[s/] the kni[fe/ves] before [it/they]
* can reach you.";
*
* The first expression "[|A ball/Balls] has the pipe to initialize the
* sequence, and the remaining expressions use the same value.
*
* Dynamic Control: Since embedded expressions can be evaluated, simply
* include the expression before the pipe:
*
* "[<<object.knifecount>>|A ball/Balls/A mighty fireball]"
*
* No need to modify global variables (I'm not using a global anyway :-)
*
* Recursive Example:
*
* magicRing: clothingItem
* sdesc = "[|gold /magic /plain gold /]ring"
* noun = 'ring'
* adjective = 'plain' 'gold' 'magic'
* putOnDesc = "[ringPutOnDesc rrm|%You% put%s% on
* <<self.thedesc>>./<<caps()>><<self.thedesc>> fits neatly on %your%
* finger./Worn.] "
* location = startroom
* ;
*
* Special Sequences:
*
* There are five types of sequences, encoded with seq, rnd, mod, rrs, rrm.
*
* MorphSequencer (seq)
* --------------------
*
* [myseq seq|A ball/Balls/A mighty fireball]
*
* Creates a sequence named 'myseq', which produces 'A ball', 'Balls', and
* 'A mighty fireball' in that order, continuing with 'A mighty fireball' for
* all subsequent calls.
*
* MorphRandomizer (rnd)
* ---------------------
*
* [myrnd rnd|A ball/Balls/A mighty fireball]
*
* Produces output in a completely random fashion. Equivalent to not
* specifying a sequence (i.e. pipe only).
*
* MorphModulus (mod)
* ------------------
*
* [mymod mod|A ball/Balls/A mighty fireball]
*
* Similar to MorphSeqencer, except it wraps around to the beginning when the
* list is exhausted.
*
* MorphRedRndSeq (rrs)
* --------------------
*
* [myrrs rrs|A ball/Balls/A mighty fireball]
*
* Short for Reducing Random Sequence, I believe. When a particular selection
* is used, it is removed from the list in subsequent calls. (Like dealing
* from a deck). When the list is exhausted, the last displayed choice is used.
*
* MorphRedRndMod (rrm)
* --------------------
*
* [myrrm rrm|A ball/Balls/A mighty fireball]
*
* Like rrs above, except that when the list is exhausted it is re-shuffled.
*
*/
#ifndef __TMORPH_MODULE_
#define __TMORPH_MODULE_
// The following module by Kevin Forchione is required for parsing the
// initializer strings. Get it at www.ifarchive.org or mirrors, as
// if-archive/programming/tads2/examples/parseword.t
#include <parseword.t>
#pragma C+
class morphExpr: object
expr = '' // The current expression string
evaluate = {
local initial, str;
local lst, ret, i, w, s, intag;
// Split expression into initializer and list portion
str = self.expr;
ret = reSearch('%|', str);
if (ret == nil) {
initial = nil;
} else {
initial = substr(str, 1, ret[1] -1);
str = substr(str, ret[1] + 1, length(str));
}
// Create list of alternatives (basically copied from tmorph.t):
lst = []; w = ''; intag = nil;
for (i = 1; i <= length(str); i++) {
s = substr(str, i, 1);
#ifdef USE_HTML_PROMPT
if (s == '<') {intag = true; w += s;}
else if (s == '>' and intag) {intag = nil; w += s;}
else
#endif
if (not intag and s == '/') {
lst += w; w = '';
} else w += s;
}
lst += w;
if (initial != nil)
self.parseInitializer (initial, length(lst));
return lst[tmorph.choice];
}
parseInitializer(str, len) = {
// Much of this method is a near-copy of the morphTracker function
// in Kevin's original tmorph.t
local tk, o, mt = 'rnd';
local tokenList = parseWord(str);
if (length(tokenList) < 1) {
tmorph.choice = _rand(len);
return;
}
tk = tokenList[1];
if (length(tokenList) == 2) mt = tokenList[2];
// You can use a number or evaluated expression as an initializer!
if (cvtnum(tk) > 0) {
o = cvtnum(tk) % len;
if (o == 0) o = len;
tmorph.choice = o;
return;
}
o = tmorph.getSequence(tk);
if (o == nil) {
switch (mt) {
case 'seq':
o = MorphSequencer.instantiate(tk, len);
break;
case 'mod':
o = MorphModulus.instantiate(tk, len);
break;
case 'rrm':
o = MorphRedRandMod.instantiate(tk, len);
break;
case 'rrs':
o = MorphRedRandSeq.instantiate(tk, len);
break;
default:
tmorph.choice = _rand(len);
return;
}
}
tmorph.choice = o.getval;
}
;
// tmorph:
// This object carries the necessary global state for the library. I could
// have modified global, but I prefer not to clutter the namespace.
tmorph: object
choice = 1 // choice variable, set by user or | operator
curr = nil // Current morph expression
stack = [] // stack of previous morph expressions
push = {
// push current expression onto the stack, begin new expr
if (self.curr != nil)
self.stack = [self.curr] + self.stack;
self.curr = new morphExpr;
self.curr.expr = '';
}
pop = {
if (self.curr != nil)
delete self.curr;
self.curr = nil;
if (car(self.stack)) {
self.curr = car(self.stack);
self.stack = cdr(self.stack);
}
}
sequences = []
getSequence (tk) = {
// This function is also mostly from tmorph.t
local l = self.sequences;
local c = car(l);
while(c) {
l = cdr(l);
if (c.name == tk) return c;
c = car(l);
}
return nil;
}
inTag = nil // in HTML tag
;
morphFilter: function (s)
{
local print = '';
local ret, tmp;
while (s != '') {
#ifdef USE_HTML_PROMPT
ret = reSearch('%[|%]|<|>', s);
#else
ret = reSearch('%[|%]',s);
#endif
if (ret == nil) { // finished
if (tmorph.curr == nil) {
print += s;
return print;
} else {
tmorph.curr.expr += s;
return print; // print the available part
}
}
#ifdef USE_HTML_PROMPT
if (tmorph.inTag) {
tmp = substr(s, 1, ret[1]);
s = substr(s, ret[1]+1, length(s));
if (tmorph.curr == nil)
print += tmp;
else
tmorph.curr.expr += tmp;
if (ret[3] == '>') tmorph.inTag = nil;
} else if (ret[3] == '<') {
tmorph.inTag = true;
tmp = substr(s, 1, ret[1]);
s = substr(s, ret[1]+1, length(s));
if (tmorph.curr == nil)
print += tmp;
else tmorph.curr.expr += tmp;
} else if (ret[3] == '>') {
tmp = substr(s, 1, ret[1]);
s = substr(s, ret[1]+1, length(s));
if (tmorph.curr == nil)
print += tmp;
else tmorph.curr.expr += tmp;
} else
#endif
if (tmorph.curr==nil and ret[3] == '[') // not in an expression
{
print += substr(s, 1, ret[1]-1);
s = substr(s, ret[1]+1, length(s));
tmorph.push;
} else if (tmorph.curr == nil and ret[3] == ']' ){
return '\b[ERROR: unbalanced square brackets]\b';
} else if (ret[3] == '[') {
tmorph.curr.expr += substr(s, 1, ret[1] - 1);
s = substr(s, ret[1]+1, length(s));
tmorph.push; // push current expr, begin a new one
} else if (ret[3] == ']') {
tmorph.curr.expr += substr(s, 1, ret[1] -1);
s = substr(s, ret[1] +1, length(s));
tmp = tmorph.curr.evaluate;
tmorph.pop; // pop the stack
if (tmorph.curr == nil) {
print += tmp;
} else {
tmorph.curr.expr += tmp;
}
} else {
return '\b[ERROR: matched a non-bracket!]\b';
}
}
return print;
}
// MorphSequencer and its derivatives are taken with only slight modification
// from the original tmorph.t by Kevin Forchione
class MorphSequencer: object
len = 0
val = 0
name = ''
getval = {
self.val++;
if (self.val > self.len) self.val = self.len;
return self.val;
}
instantiate(tk, l) = {
local x = new MorphSequencer;
x.len = l;
x.name = tk;
tmorph.sequences += x;
return x;
}
;
class MorphRandomizer: MorphSequencer
getval = {
self.val = _rand(self.len);
return self.val;
}
instantiate(tk, l) = {
local x = new MorphRandomizer;
x.len = l;
x.name = tk;
tmorph.sequences += x;
return x;
}
;
class MorphModulus: MorphSequencer
getval = {
self.val++;
if (self.val > self.len) self.val = 1;
return self.val;
}
instantiate(tk, l) = {
local x = new MorphModulus;
x.len = l;
x.name = tk;
tmorph.sequences += x;
return x;
}
;
class MorphRedRandMod: MorphSequencer
rndList = []
getval = {
local i, ln;
ln = length(self.rndList);
if (ln == 0) {
// (re)build rndList
ln = self.len;
self.rndList = [];
for (i = 1; i <= ln; ++i)
self.rndList += i;
}
self.val = self.rndList[_rand(ln)];
self.rndList -= self.val;
return self.val;
}
instantiate(tk, l) = {
local x = new MorphRedRandMod;
x.len = l;
x.name = tk;
tmorph.sequences += x;
x.rndList = [];
return x;
}
;
class MorphRedRandSeq: MorphSequencer
rndList = []
getval = {
local i, ln;
ln = length (self.rndList);
if (ln == 0) {
return self.val;
}
self.val = self.rndList[_rand(ln)];
self.rndList -= self.val;
return self.val;
}
instantiate(tk, l) = {
local x = new MorphRedRandSeq;
local i;
x.len = l;
x.name = tk;
tmorph.sequences += x;
x.rndList = [];
for (i = 1; i <= l; ++i)
x.rndList += i;
return x;
}
;
#endif // TMORPH_MODULE
// Below is the copyright information from the original tmorph.t module.
/* Copyright (c) 2000 by Kevin Forchione. All Rights Reserved. */
/*----------------------------------------------------------------------
* COPYRIGHT NOTICE
*
* You may modify and use this file in any way you want, provided that
* if you redistribute modified copies of this file in source form, the
* copies must include the original copyright notice (including this
* paragraph), and must be clearly marked as modified from the original
* version.
*
*------------------------------------------------------------------------------
* REVISION HISTORY
*
* 20-Feb-00: Creation.
* 21-Feb-00: Modified to include init in the function call.
*/
