From the NannyMUD documentation

LAST CHANGE

2000-12-12

NAME

        stdline - An addition to the std library for lines.

DESCRIPTION

	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.