Intermediate LPC-Introduction

1.1 Basic LPC
The person reading this textbook should have read the basic LPC textbook or be familiar with the mud world.ProgramWriting.
It's not just about building rooms and writing objects in the area, but also about what the programs you write are doing. if you feel that you are not enough, go back to read the basic LPC and take a fancy to the level LPC textbook. if you meet your requirements, you will find that what you read here makes sense to you.

1.2 objectives of intermediate LPC textbooks
This introductory textbook is intended for people who do not know anything about LPC, so that they can write a good gaming world in any lpmud. for LPC and lpmud, it is more difficult than building rooms, armor, monsters, and weapons. when you enter a more complex concept, such as a guild, or want to go deeper into your game world, you will find that the concepts detailed in the basic LPC do not have these things. the design of the intermediate LPC is to bring you a complete understanding of the LPC from the simple world construction process to the knowledge of the lpmud world builder. write mudlib itself for later. after reading this textbook and actually writing some experimental program code, your readers should be able to write game objects that match any design or idea, as long as I have achieved this goal.

1.3 Overview
What else is there? Well, most of you know that LPC supports mapping and array, and you have asked me why I didn't describe them in detail. I think those concepts are beyond the scope of my attempt to describe them in the basic LPC textbook, but they are suitable for this textbook. however, new tools are great, and what's important is what you can do with them. the goal of the basic LPC textbook is to allow you to build a qualified lpmud area without the need for mapping and array. the goal of this textbook is to enable you to implement any ideas in your region. This requires knowledge of images and arrays. in lpmud, any idea you want to write can be implemented. surprisingly, the LPC language is ideal for achieving these goals. the reason you cannot write your ideas is: your knowledge of LPC, inappropriate mudlib, your mud subject, and mud management policy. this textbook cannot make your mudlib job better, nor change your mud subject or mud management policy. never think that LPC cannot do what you want. if your ideas are not applicable to mud topics or management policies, your ideas cannot be implemented in your current mud. if mudlib does not match, tell the person in charge of mudlib what can be done at the mudlib level to improve it. you will be surprised that there are actually a lot of things you don't know in mudlib. more importantly, after reading this textbook, you should be able to read the mudlib program that understands your mud. Code To understand what each program is doing. at present, you should not be able to write such program code yourself, but at least you can understand what the mudlib layer is doing. at the beginning of this textbook, we will discuss what lpmud driver is doing. one advantage of this textbook is that the content in it has nothing to do with driver and mudlib (except Dworkin game driver ). the game driver section does not go deep into the actual driver program architecture, but is basically what all game drivers need to do to run mud. next, I will discuss the topics that everyone wants to learn more about-array and mapping ). it is probably the simplest and most difficult thing to understand the data type of images. generally, the image is a complex number. Before discussing the image, you should first understand the array. once you understand them, the image is actually much better than the array. regardless of the speed, it takes you the most time to study this chapter, because this chapter is probably the most difficult and useful chapter in this textbook. later, we will discuss LPC pre-compiler in a chapter. Before your program code is sent to compiler, you can use it to orchestrate your program code. although I have a terrible introduction here, this chapter is probably the simplest one in this textbook. so I put it after the chapter introducing images and arrays. next, I will introduce the string again to teach you how to process strings in more detail, such as advanced command processing techniques such as breaking strings. as long as you understand arrays, this chapter should be very simple. the next chapter is the second important part of this textbook. this is probably the most important part if you want to go beyond the level of the intermediate level and go deep into the mudlib program code. this chapter introduces the complex concept of LPC inheritance. since the objective of this textbook is not to teach you how to design a mudlib program, this chapter will not discuss in detail object-oriented programming. understanding this chapter will allow you to understand some of the meanings of object-oriented programming, and also allow you to write more complex objects with overriding, and define your own role basic occupation. finally, the textbook briefly discusses program code debugging. this is not an important chapter, but it also indicates that this chapter does not just supplement your current knowledge.

1.4 What this textbook does not have
For some people, the biggest and Policy omission in this textbook is "shadow ). I have never seen examples where projection is the best or most efficient. however, this does not mean that projection is useless. the reason I didn't describe projection in this textbook is that the LPC learner had better learn concepts from this textbook and spend time to get familiar with these concepts before encountering projection. in this way, I think the LPC learner will be able to decide whether to use projection. I will discuss projection in future textbooks. if you often use many projections, do not consider the above text as a criticism for you. I have also seen many excellent uses of projection. however, projection is not a good method to complete the work, so projection is not suitable for the goal of this intermediate textbook. I also deleted the part about system security and object-oriented programming. the two are obviously discussing mudlib issues. however, many may disagree with the practice of object-oriented programming. I decided to leave this topic for the future, because most regional designers write code for creation rather than information theory. in the middle-level and basic textbooks, I decided to discuss the theory of object-oriented programming only where the actual LPC programming can be directly applied. for LPC veterans who want to write a huge mudlib, the theory may be much more practical. however, for the purpose of this textbook, discussing object-oriented programming is just a sleep topic. I plan to discuss this theory more in the next textbook.

1.5 conclusion
LPC is not difficult to learn. although it is not as powerful as most of other computer languages do, it is amazing that no other language is comparable to it in building a mud game. for beginners, it makes it easy for you to learn and write useful objects even when you do not know what to do. for people of the central level, it turns any of your ideas into a textual virtual reality. for advanced people, its object-oriented feature allows you to build a favorite game on the Internet. the only limit you get is how much you know. further study does not require an information degree.