Architecture

#include "items/properties.hpp"

// Check a property flag
if (has_property(*item, item_property::PROP_DROPLESS)) {
    // item never drops seeds
}

// Check a category flag
if (has_category(*item, item_category::CAT_RETURN)) {
    // item returns to inventory on break
}

class item {
public:
    u_short id{};
    u_char property{};     // bitfield flags
    u_char cat{};           // category flags
    u_char type{};          // item type (FIST, LOCK, SEED, etc.)
    std::string raw_name{};
    int ingredient{};
    u_char collision{};     // collision type
    u_char hits{};
    int hit_reset{};
    u_char cloth_type{};
    short rarity{};
    int tick{};             // growth/production timer (seconds)
    std::string info{};
    std::array<u_short, 2> splice{};  // splice recipe pair
};

// Register a behavior for a specific item ID
void item_registry::register_item(
    u_short item_id,
    item_behavior_fn fn,
    const std::string& name = ""
);

// Lookup — returns nullptr if not registered
const item_behavior_fn* item_registry::get_handler(u_short item_id);

#include "items/registry.hpp"

struct item_context {
    class peer* pPeer;      // player data
    class world* world;     // current world
    class block* block;     // the tile being interacted with
    const class item* item; // the item definition
    struct state state;     // tank packet state
    ENetEvent& event;       // network event
};

enum class item_action : u_char {
    NONE,           // continue with default pipeline
    HANDLED,        // skip remaining defaults
    BREAK,          // break the block
    RETURN_ITEM,    // return item to inventory
    CONSUME,        // consume 1 from inventory
    CANCEL,         // abort silently
};

using item_behavior_fn = std::function<item_action(item_context& ctx)>;

// 1. Write the handler
static item_action on_my_item(item_context& ctx) {
    // do something with ctx.block, ctx.pPeer, ctx.world
    send_varlist(ctx.event.peer, { "OnTalkBubble", ctx.pPeer->netid, "Hello!", 0u, 1u });
    return item_action::CONSUME;
}

// 2. Register it
void register_item_behaviors() {
    item_registry::register_item(1234, on_my_item, "My Custom Item");
}

enum collision : u_char {
    NO_COLLISION,   // air — free pass
    FULL,           // solid wall
    ON_TOP,         // platform — stand on top, jump through
    IF_ACCESS,      // requires world access
    TOGGLE,         // toggleable barrier
    HORIZONTAL,     // one-way (horizontal)
    IF_VIP,         // VIP entrance
    VERTICAL,       // one-way (vertical)
    ADVENTURE_ITEM,
    ACTIVATE,       // triggers on contact
    BALLOON_WARZ_TEAM,
    IF_GUILD,       // guild entrance
    STEP_ON         // triggered when stepped on
};

namespace collision_check {

enum class movement_rule : u_char {
    BLOCK,      // solid — cannot pass
    PASS,       // free — walk through
    PLATFORM,   // stand on top, jump through from below
    SLAB,       // half-height block
    ONE_WAY_X,  // pass from left only
    ONE_WAY_Y,  // pass from above only
    ACCESS,     // pass only if in world access list
    VIP,        // pass only if VIP
    GUILD,      // pass only if same guild
    ACTIVATE,   // pass triggers activation
};

if (!collision_check::can_place_at(item->collision, state.pos, state.punch))
    return;

collision_check::movement_rule rule = collision_check::get_movement_rule(
    static_cast<::collision>(item.collision)
);

if (rule == collision_check::movement_rule::BLOCK) {
    // Reject movement through solid tiles
    state_visuals(*event.peer, std::move(state));
    return;
}

CREATE TABLE IF NOT EXISTS world_state (
    name       VARCHAR(100) PRIMARY KEY,
    owner      INT NOT NULL DEFAULT 0,
    data       MEDIUMBLOB,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

// Load world from DB (in join_request.cpp)
load_world(*it);
// If no data, generate fresh world:
if (empty) generate_world(*it, big_name);

// Save when last player leaves (in quit_to_exit.cpp)
if (--world->visitors <= 0) {
    save_world(*world);
    worlds.erase(world);
}

// Save all worlds on shutdown (in peer.cpp)
void safe_disconnect_peers(int code) {
    for (auto& w : worlds)
        save_world(w);
    // ...shutdown sequence...
}

include/
├── items/
│   ├── properties.hpp      # Property + category flag enums
│   ├── registry.hpp        # Behavior registry class
│   ├── registry.cpp         # Registry implementation
│   ├── init_behaviors.hpp  # Registration function declaration
│   ├── init_behaviors.cpp  # All item handlers + registrations
│   └── collision.hpp       # Collision checking namespace
└── database/
    ├── world.hpp            # World + block structs
    ├── world.cpp            # World functions
    ├── world_db.hpp         # Persistence API
    └── world_db.cpp         # Binary serialization + DB operations