[MUD-Dev] Re: let's call it a spellcraft

[Travis Casey]

On 26 September 1998, Matthew R. Sheahan wrote:

> pretty much everything i see around that's intended to be an "advanced
> magic system" amounts to a spell programming language with magicians as
> mana hackers.  it occurs to me that this is really laying the bones of
> the system pretty bare to the players, and is dissonant with many fantasy
> themes (ones where magicians are, knowledge-wise, children with candles
> in a very big, very dark room -- as opposed to technically super-competent
> magickal engineers a la Zelazny's Lords of Chaos).

Well, I'd say that the SDL version of magic is just the one that's
getting discussed the most on the list... probably because many of us
are programmers and, therefore, see how such a system might work and
some of the potentials in it quite well.

One of my posts discussed a couple of other methods, but no one has
replied to it... it's the one that talks about the system in TORG's
Aysle.

> where the injury really comes in here, though, is that is turns magickal
> R&D into all D, no R.  there's no room for creating an effect that no one
> even knew was possible before.  and how cool is _that_?

I'm not sure that that's true... have you ever seen a program do
something that you didn't think was possible in the language being
used?  I have, so I can see the possibility with an SDL as well.

There are other ways it could be done with an SDL as well... nothing
says that the SDL has to be fully documented to the players, for
example... there might be "hidden commands" that mages today don't
know about, and rumors of ancient spells that did "impossible" things.
Characters could then try to research ways to do those (via trial and
error) or try to find some of those ancient spells and reverse
engineer them.

Remember, since we're simulating a world, the SDL isn't something that
was invented, it's just something that *is*.  To some extent, it's
like someone finding a compiler for a computer language they don't
know, with a guide to creating a "hello, world"-type program and some
sample programs... you don't really know what it's capable of doing
until you try.

> so what i'm kinda thinking of is something where maybe you have a set of
> tokens that can be permuted in a very large number of ways.  say, a set
> of symbols that can be given different colors, sizes, spatial relationships,
> accompanying incantations/gestures/items, what-have-you.  easy to make the
> final result set here very large.  if want, you can keep everyone from
> using every effect by restricting access to a given symbol, color, etc.
> then you distribute some basic spells in the form of instructions, but
> let people play with the system all they want.  (that's research.)

This is the same sort of system that was recently being discussed in
rec.games.design ... I don't remember the subject of the thread now,
but I do remember that people were talking about using runes as the
symbols, so you could do a search on DejaNews with that.

Also, look for the "waving hands" spellcasting game... it's a game
where you build spells by using a series of hand positions, revealing
them at a rate of one per turn... but the players can see each others
hand positions, and some of the spells are counterspells.  Thus, you
can start building one spell, see that your opponent is doing spell Y,
then decide to switch to spell Z, which happens to start with the last
couple of gestures you were just doing...

> one thing i like here is that it's possible for research to be dangerous
> in a non-contrived way -- just because you might not be sure that that
> symbol set you've put together doesn't mean "extra-heavy fireball, maximum
> range 1 foot".  ;)

You could also combine this approach with a spell programming
approach... the juxtapositions of symbols are the "lines" of spell
code.

When you get down to it, the basics of spell programming are the
basics of any programming:

 - You have a set of commands which can be used.
 - Programming allows you to sequence these commands, saying that
   first one should be done, then the other.
 - Programming languages often (but not always) have constructs that
   allow for looping and branching.

That's it.  Any spell system which has those things can be considered
a spell programming language... it doesn't have to be well-documented,
use commands that are made up of words, or do anything else in the way
that you'd expect a "normal" programming language to.

Remember, as I said before, a spell programming language is something
that's either basic to the design of the universe or was implemented
by some power on the order of a god.  There's no reason why it has to
be orthogonal, context-insensitive, etc... those are just properties of
computer programming languages that people try to put in to make them
easy to use.

A spell programming language might resemble machine code more than a
high-level language... hard to read, very detailed, and with strange
dependencies that you won't notice until you're deep into it.

--
       |\      _,,,---,,_        Travis S. Casey  <efindel at io.com>
 ZZzz  /,`.-'`'    -.  ;-;;,_   No one agrees with me.  Not even me.
      |,4-  ) )-,_..;\ (  `'-'
     '---''(_/--'  `-'\_)