Learning LPC Programming

LPC uses a C-like syntax with strong typing. This lesson covers the fundamental types and syntax rules you'll use in every LPC program.

Primitive Types

• int - Integer numbers
• string - Text strings
• object - Reference to another LPC object
• void - No return value

Variable Declaration & Assignment

int health = 100;
string name = "Wizard";
object *inventory;  // Array of objects

Comments

// Single-line comment
/* Multi-line
   comment */

Type Conversion

int x = 42;
string s = to_string(x);
int y = to_int("100");

Key Takeaway: Strong typing in LPC prevents many bugs. Always declare your types explicitly.

Objects are the core of LPC. Everything in an LPC MUD is an object. Learn how to create objects and use inheritance to build hierarchies.

Creating a Simple Object

#pragma strict_types

#include "/include/globals.h"

inherit "/std/object";

void create() {
    ::create();
    set_name("sword");
    set_id(({{ "sword", "blade" }}));
    set_short("a long sword");
}

Object Inheritance

inherit "/std/monster";

void create() {
    ::create();
    set_race("orc");
    set_gender("male");
    set_body_type("humanoid");
}

Common Methods

void init() {
    add_action("look_fn", "look");
}

int look_fn(string str) {
    write("You examine: " + str);
    return 1;
}

Key Takeaway: Inheritance is crucial for code reuse. Build a solid object hierarchy.

LPC uses properties (member variables) and methods to define object behavior. Visibility controls access.

// Object properties
private int hitpoints;
public string name;
static int total_kills;

// Getter/setter methods
int query_hp() { return hitpoints; }

void set_hp(int new_hp) {
    if (new_hp < 0) new_hp = 0;
    if (new_hp > 100) new_hp = 100;
    hitpoints = new_hp;
}

// Initialization
void create() {
    name = "Adventurer";
    hitpoints = 100;
}

LPC provides familiar C-style control structures for conditional logic and loops.

// If/else
void check_health(int hp) {
    if (hp > 75) {
        write("You feel great!");
    } else if (hp > 25) {
        write("Wounded.");
    } else {
        write("Near death!");
    }
}

// Switch
void handle_command(string cmd) {
    switch(cmd) {
        case "north": move_player("north"); break;
        case "south": move_player("south"); break;
        default: write("Unknown command.");
    }
}

// For loop
void list_inventory(object *items) {
    for (int i = 0; i < sizeof(items); i++) {
        write(items[i]->query_name());
    }
}

Living objects represent players and NPCs. Verbs are commands that objects respond to via add_action.

inherit "/std/living";

void create() {
    ::create();
    set_name("goblin");
    set_short("a small goblin");
    set_hp(50);
}

void init() {
    ::init();
    add_action("do_poke", "poke");
}

int do_poke(string str) {
    if (!str || str != "goblin") return 0;
    write("You poke the goblin.");
    this_object()->attack_object(this_player());
    return 1;
}

LPC provides events and timing mechanisms through signals, heart beats, and alarms.

// Heart beat (periodic events)
void create() {
    set_heart_beat(2);  // Every 2 seconds
}

void heart_beat() {
    // Called every 2 seconds
    if (query_hp() < query_max_hp()) {
        set_hp(query_hp() + 1);
    }
}

// Call out (delayed execution)
void delayed_message() {
    write("Now!");
}

void init() {
    write("Wait for it...");
    call_out("delayed_message", 3);  // Call after 3 seconds
}

// Remove scheduled call
int alarm_id;
void cancel_alarm() {
    remove_call_out(alarm_id);
}

LPC provides save_object and restore_object for easy persistence, plus file operations.

// Save object state
string name;
int level;
int gold;

void save_player() {
    save_object("/data/players/" + name);
}

// Restore object state
void restore_player(string player_name) {
    name = player_name;
    restore_object("/data/players/" + name);
}

// File operations
void write_log(string message) {
    write_file("/log/game.log", message + "\n");
}

string read_data() {
    return read_file("/data/config.txt");
}

string *read_lines() {
    return explode(read_file("/data/items.txt"), "\n");
}

Lesson content placeholder. Topics: closures, mapping, arrays, advanced control flow.