| 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 |