doc/KURS/LPC-KURS2/chapter1

Intermediate LPC
Descartes of Borg
Novermber 1993

                         Chapter 1: Introduction

1.1 LPC Basics
Anyone reading this textbook should either have read the textbook LPC
Basics or be familiar enough with mud realm coding such that not only are
they capable of building rooms and other such objects involved in area
coding, but they also have a good idea of what is going on when the code
they write is executing.  If you do not feel you are at this point, then go
back and read LPC Basics before continuing.  If you do so, you will find
that what you read here will be much more meaningful to you.

1.2 Goals of This Textbook
The introductory textbook was meant to take people new to LPC from
knowing nothing to being able to code a nice realm on any LPMud.  There
is naturally much more to LPC and to LPMud building, however, than
building rooms, armours, monsters, and weapons.  As you get into more
complicated concepts like guilds, or desire to do more involved things with
your realm, you will find the concepts detailed in LPC Basics to be lacking
in support for these projects.  Intermediate LPC is designed to take you
beyond the simple realm building process into a full knowledge of LPC for
functioning as a realm builder on an LPMud.  The task of mudlib building
itself is left to a later text.  After reading this textbook and working through
it by experimenting with actual code, the reader should be able to code game
objects to fit any design or idea they have in mind, so long as I have been
successful.

1.3 An Overview
What more is there?  Well many of you are quite aware that LPC supports
mappings and arrays and have been asking me why those were not detailed
in LPC Basics.  I felt that those concepts were beyond the scope of what I
was trying to do with that textbook and were more fitting to this textbook. 
But new tools are all fine and dandy, what matters, however, is what you
can do with those tools.  The goal of LPC Basics was to get you to building
quality LPMud realms.  Mappings and arrays are not necessary to do that. 
The goal of this book is to allow you to code any idea you might want to
code in your area.  That ability requires the knowledge of mappings and
arrays.

Any idea you want to code in an LPMud is possible.  LPC is a language
which is amazingly well suited to this task.  All that prevents you from
coding your ideas is your knowledge of LPC or an inadequate mudlib or
your mudÕs theme or administrative policies.  This textbook cannot make
the mudlib you are working with any better, and it cannot change the mud
theme or the mudÕs administrative policies.  Never once think that LPC is
incapable of doing what you want to do.  If your idea is prevented by
administrative policies or themes, then it is simply not an idea for your
current mud.  If the mudlib is inadequate, talk to the people in charge of
your mudlib about what can be done at the mudlib level to facilitate it.  You
would be surprised by what is actually in the mudlib you did not know
about.  More important, after reading this textbook, you should be able to
read all of the mudlib code in your mudÕs mudlib and understand what is
going on at each line in the mudlib code.  You may not as yet be able to
reproduce that code on your own, but at least you can understand what is
going on at the mudlib level.

This textbook starts out with a discussion about what the LPMud driver is
doing.  One nice thing about this textbook, in general it is completely driver
and mudlib independent (excepting for the Dworkin Game Driver).  The
chapter on the game driver does not get into actual implementation, but
instead deals with what all game drivers basically do in order to run the
mud.

Next I discuss those magic topics everyone wants to know more about,
arrays and mappings.  Mappings may be simultaneously the easiest and
most difficult data type to understand.  Since they are sort of complex arrays
in a loose sense, you really need to understand arrays before discussing
them.  All the same, once you understand them, they are much easier than
arrays to use in real situations.  At any rate, spend most of your time
working with that chapter, because it is probably the most difficult, yet most
useful chapter in the book.

After that follows a brief chapter on the LPC pre-compiler, a tool you can
use for sorting out how your code will look before it gets sent to the
compiler.  Despite my horrid intro to it here, this chapter is perhaps the
easiest chapter in the textbook.  I put it after the mappings and arrays
chapter for exactly that reason.

Strings are re-introduced next, going into more detail with how you can do
such things as advanced command handling by breaking up strings.  Once
you understand arrays fairly well, this chapter should be really simple.

The next chapter is the second most important in the book.  It may be the
most important if you ever intend to go beyond the intermediate stage and
dive into mudlib coding.  That chapter involves the complex ideas behind
LPC inheritance.  Since the goal of this textbook is not to teach mudlib
programming, the chapter is not a detailed discussion on object oriented
programming.  Understanding this chapter, however, will give you some
good insights into what is involved with object oriented programming, as
well as allow you to build more complex objects by overriding functions
and defining your own base classes.

Finally, the textbook ends with a simple discussion of code debugging. 
This is not an essential chapter, but instead it is meant as more of an
auxiliary supplement to what the knowledge you have accumulated so far.

1.4 Not Appearing in This Textbook
Perhaps what might appear to some as the most glaring omission of this
textbook is largely a political omission, shadows.  Never have I ever
encountered an example of where a shadow was either the best or most
effecient manner of doing anything.  It does not follow from that, however,
that there are no uses for shadows.  My reasoning for omitting shadows
from this textbook is that the learner is best served by learning the concepts
in this textbook first and having spent time with them before dealing with
the subject of shadows.  In that way, I feel the person learning LPC will be
better capable of judging the merits of using a shadow down the road.  I
will discuss shadows in a future textbook.

If you are someone who uses shadows some or a lot, please do not take the
above paragraph as a personal attack.  There may be some perfectly valid
uses for shadows somewhere which I have yet to encounter.  Nevertheless,
they are not the ideal way to accomplish any given task, and therefore they
are not considered for the purposes of this textbook an intermediate coding
tool.

I have also omitted discussions of security and object oriented
programming.  Both are quite obviously mudlib issues.  Many people,
however, might take exception with my leaving out a discussion of object
oriented programming.  I chose to leave that for a later text, since most area
builders code for the creativity, not for the computer science theory.  In both
the intermediate and beginner textbooks, I have chosen only to discuss
theory where it is directly applicable to practical LPC programming.  For
people who are starting out green in LPC and want to code the next great
mudlib, perhaps theory would be more useful.  But for the purposes of this
book, a discussion of object oriented programming is simply a snoozer.  I
do plan to get heavy into theory with the next textbook.

1.5 Summary
LPC is not difficult to learn.  It is a language which, although pathetic
compared to any other language for performing most computer language
tasks, is incredibly powerful and unequalled for the tasks of building an
area in MUD type games.  For the beginner, it allows you to easily jump in
and code useful objects without even knowing what you are doing.  For the
intermediate person, it allows you to turn any idea you have into textual
virtual reality.  And for the advanced person, itÕs object oriented features
can allow you to build one of the most popular games on the internet.  What
you can do is simply limited by how much you know.  And learning more
does not require a computer science degree.

Copyright (c) George Reese 1993