From the NannyMUD documentation
2000-12-12
stdline - An addition to the std library for lines.
This document just serves as a general description of the
stdline, what it is, and how it operates. Detailed
descriptions of each component's workings are located in
separate files. The central object of the stdline is the line controller.
This works like a central operator for the line. All of the
major work happens there. It keeps track of data on the
line, stores the players' statues on the line, and all
standard configuration of the line happens there. The controller is interacted with by the line statues on the
machine end of things, and the line inherits on the player
end of things. The flow looks sort of like this:
player a------line inherit a statue a
\ / \
player b------line inherit b-controller-statue b-soul
/ | \ /
player c------line inherit c | statue c
|
reviewer The player interacts with the line controller by using the
line inherit, which serves simply as a means of relaying
commands from the player to the controller. Very little
actual coding happens here. The line statue is a little more complex on the LPC side of
things, but literally no configuration happens here unless
the programmer wishes to use a nonstandard statue. Both the statue and the controller (and the reviewer, which
will be discussed later) use a common interface to the
controller, which is a separate inheritable object. To create your own line, you need to do the following:
* Create your line_inherit.
This involves all of 2 lines of code unique to stdline.
You either need to create a new autoloader that inherits
the line_inherit, or have an existing autoloader inherit
it. The line_inherit inherits basic_thing; if you have to
inherit simple_armour or some other std object in your
autoloader, you will have to make special provisions,
detailed in the line_inherit document.
* Create your line controller.
This is a little bit more involved, but if you don't want
anything real fancy in your line, it will be just about as
easy as creating a sword or a room, as long as you stick to
the line_control document. That's all. The line player, the optional features of the
line, and just about everything else, are already set up. In
the old /obj/line, it was similar; just a .h file and a few
lines of code in your autoloader. The thing that's different
about stdline is that personalizing your line is much easier
to do. If you don't like the way a command works, you can
just write a new one to use instead of the old. That was
difficult to do with a /obj/line because of the way the
default line functions were written. The only other really new thing to come with stdline is the
addition of an optional default 'reviewer'. This lets the
players review the last 20 (or whatever it's set to) things
said on the line. Sorry, no tell histories for now. Usage
of the standard reviewer is detailed in 'help line_control'. Anyway, the documents you need to read next are:
* line_inherit - this includes the control_interface
documentation
* line_control - this is where the meat of stdline is located As the line_player and the reviewer are intended as entirely
internal objects, no documentation need be written for them.
NOTE
One last note: This implementation of the stdline has very
little security to speak of. If you desire this for your
line, you will have code it yourself, or wait for a
complex_line_control, complex_line_inherit, etc, to come
along. And you will probably be waiting a long time.
NOTE
Refreshing an stdline:
You refresh the code for an stdline like this:
(using the shell)
update filename.c
print .clones.env.ffilter("filename"->signal_init(x))
NOTE
Where is the filename of your guildmark
and filename (on both lines) is the name of your line controller.
NOTE
There is also a tool, /std/line/line_updater.c, which does the same
thing as the 'print' line from the shell, which can't be done in the
wizmod. Clone and exa it for syntax.