Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/doc/KURS/LPC-KURS/chapter3 b/doc/KURS/LPC-KURS/chapter3
new file mode 100644
index 0000000..f7e89a4
--- /dev/null
+++ b/doc/KURS/LPC-KURS/chapter3
@@ -0,0 +1,185 @@
+ LPC Basics
+ Written by Descartes of Borg
+ first edition: 23 april 1993
+ second edition: 17 june 1993
+
+CHAPTER 3: LPC Data Types
+
+3.1 What you should know by now
+LPC object are made up of zero or more variables manipulated by one or
+more functions. The order in which these functions appear in code is
+irrelevant. The driver uses the LPC code you write by loading copies of
+it into memory whenever it is first referenced and additional copies
+through cloning. When each object is loaded into memory, all the variables
+initially point to no value. The reset() function in compat muds, and
+create() in native muds are used to give initial values to variables in
+objects. The function for creation is called immediately after the object
+is loaded into memory. However, if you are reading this textbook with no
+prior programming experience, you may not know what a function is or how
+it gets called. And even if you have programming experience, you may
+be wondering how the process of functions calling each other gets started
+in newly created objects. Before any of these questions get answered,
+however, you need to know more about what it is the functions are
+manipulating. You therefore should thouroughly come to know the concept
+behind LPC data types. Certainly the most boring subject in this manual,
+yet it is the most crucial, as 90% of all errors (excepting misplaced
+{} and ()) involve the improper usage of LPC data types. So bear through
+this important chapter, because it is my feeling that understanding this
+chapter alone can help you find coding much, much easier.
+
+3.2 Communicating with the computer
+You possibly already know that computers cannot understand the letters
+and numbers used by humans. Instead, the "language" spoken by computers
+consists of an "alphabet" of 0's and 1's. Certainly you know computers
+do not understand natural human languages. But in fact, they do not
+understand the computer languages we write for them either. Computer
+languages like BASIC, C, C++, Pascal, etc. are all intermediate
+languages. They allow you to structure your thoughts more coherently
+for translation into the 0's and 1's of the computer's languages.
+
+There are two methods in which translation is done: compilation and
+interpretation. These simply are differences betweem when the
+programming language is translated into computer language. With
+compiled languages, the programmer writes the code then uses a program
+called a compiler to translate the program into the computer's
+language. This translation occurs before the program is run. With
+interpreted languages however, the process of translation occurs as
+the program is being run. Since the translation of the program is
+occurring during the time of the program's running in interpreted
+languages, interpreted languages make much slower programs than
+compiled languages.
+
+The bottom line is, no matter what language you are writing in, at
+some point this has to be changed into 0's and 1's which can be
+understood by the computer. But the variables which you store in
+memory are not simply 0's and 1's. So you have to have a way in
+your programming languages of telling the computer whether or not
+the 0's and 1's should be treated as decimal numbers or characters or
+strings or anything else. You do this through the use of data types.
+
+For example, say you have a variable which you call 'x' and you give
+it the decimal whole number value 65. In LPC you would do this through
+the statement:
+
+-----
+x = 65;
+-----
+
+You can later do things like:
+
+_____
+write(x+"\n"); /* \n is symbolically represents a carriage return */
+y = x + 5;
+-----
+
+The first line allows you to send 65 and a carriage return to someone's screen.
+The second line lets you set the value of y to 70.
+The problem for the computer is that it does not know what '65' means when
+you tell it x = 65;. What you think of 65, it might think of as:
+00000000000000000000000001000001
+But, also, to the computer, the letter 'A' is represented as:
+00000000000000000000000001000001
+So, whenever you instruct the computer write(x+"\n");, it must have some
+way of knowing that you want to see '65' and not 'A'.
+
+The computer can tell the difference between '65' and 'A' through the use
+of data types. A data types simply says what type of data is being stored
+by the memory location pointed to by a given variable. Thus, each LPC
+variable has a variable type which guides conversions. In the example
+given above, you would have had the following line somewhere in the
+code *before* the lines shown above:
+
+-----
+int x;
+-----
+
+This one line tells the driver that whatever value x points to, it will
+be used as the data type "int", which is short for integer, or whole
+number. So you have a basic introduction into the reason why data types
+exist. They exist so the driver can make sense of the 0's and 1's that
+the computer is storing in memory.
+
+3.3 The data types of LPC
+All LPMud drivers have the following data types:
+
+void, status, int, string, object, int *, string *, object *, mixed *
+
+Many drivers, but not all have the following important data types which
+are important to discuss:
+
+float, mapping, float *, mapping *
+
+And there are a few drivers with the following rarely used data types
+which are not important to discuss:
+
+function, enum, struct, char
+
+3.4 Simple data types
+This introductory textbook will deal with the data types void, status,
+int, float, string, object, mand mixed. You can find out about the
+more complex data types like mappings and arrays in the intermediate
+textbook. This chapter deals with the two simplest data types (from the
+point of view of the LPC coder), int and string.
+
+An int is any whole number. Thus 1, 42, -17, 0, -10000023 are all type int.
+A string is one or more alphanumeric characters. Thus "a", "we are borg",
+"42", "This is a string" are all strings. Note that strings are always
+enclosed in "" to allow the driver to distinguish between the int 42 and
+the string "42" as well as to distinguish between variable names (like x)
+and strings by the same names (like "x").
+
+When you use a variable in code, you must first let the driver know
+what type of data to which that variable points. This process is
+called *declaration*. You do this at the beginning of the function
+or at the beginning of the object code (outside of functions before all
+functions which use it). This is done by placing the name of the data type
+before the name of the variable like in the following example:
+
+-----
+void add_two_and_two() {
+ int x;
+ int y;
+
+ x = 2;
+ y = x + x;
+}
+-----
+
+Now, this is a complete function. The name of the function is
+add_two_and_two(). The function begins with the declaration of an
+int variable named x followed by the declaration of an in variable
+named y. So now, at this point, the driver now has two variables which
+point to NULL values, and it expects what ever values end up there to be
+of type int.
+
+A note about the data types void and status:
+Void is a trivial data type which points to nothing. It is not used
+with respect to variables, but instead with respect to functions. You
+will come to understand this better later. For now, you need only
+understand that it points to no value.
+
+The data type status is a boolean data type. That is, it can only have
+1 or 0 as a value. This is often referred to as being true or false.
+
+3.5 Chapter summary
+For variables, the driver needs to know how the 0's and 1's the computer
+stores in memory get converted into the forms in which you intend them
+to be used. The simplest LPC data types are void, status, int, and string.
+You do not user variables of type void, but the data type does come
+into play with respect to functions. In addition to being used for
+translation from one form to the next, data types are used in determining
+what rules the driver uses for such operations as +, -, etc. For example,
+in the expression 5+5, the driver knows to add the values of 5 and 5
+together to make 10. With strings however, the rules for int addition
+make no sense. So instead, with "a"+"b", it appends "b" to the string "a"
+so that the final string is "ab". Errors can thus result if you mistakenly
+try to add "5"+5. Since int addition makes no sense with strings, the
+driver will convert the second 5 to "5" and use string addition. The final
+result would be "55". If you were looking for 10, you would therefore
+have ended up with erroneous code. Keep in mind, however, that in most
+instances, the driver will not do something so useful as coming up with
+"55". It comes up with "55" cause it has a rule for adding a string
+to an int, namely to treat the int as a string. In most cases, if you
+use a data type for which an operation or function is not defined
+(like if you tried to divide "this is" by "nonsense", "this is"/"nonsense"),
+the driver will barf and report an error to you.