/*
 * create.c -- Commands that create new objects 
 */

/*
 * $Id: create.c,v 1.2 2005/08/08 09:43:06 murrayma Exp $ 
 */

#include "copyright.h"
#include "config.h"

#include "mudconf.h"
#include "config.h"
#include "db.h"
#include "interface.h"
#include "externs.h"
#include "match.h"
#include "command.h"
#include "alloc.h"
#include "attrs.h"
#include "powers.h"

/*
 * ---------------------------------------------------------------------------
 * * parse_linkable_room: Get a location to link to.
 */

static dbref parse_linkable_room(player, room_name)
    dbref player;
    char *room_name;
{
    dbref room;

    init_match(player, room_name, NOTYPE);
    match_everything(MAT_NO_EXITS | MAT_NUMERIC | MAT_HOME);
    room = match_result();

    /*
     * HOME is always linkable 
     */

    if (room == HOME)
        return HOME;

    /*
     * Make sure we can link to it 
     */

    if (!Good_obj(room)) {
        notify_quiet(player, "That's not a valid object.");
        return NOTHING;
    } else if (!Has_contents(room) || !Linkable(player, room)) {
        notify_quiet(player, "You can't link to that.");
        return NOTHING;
    } else {
        return room;
    }
}

/*
 * ---------------------------------------------------------------------------
 * * open_exit, do_open: Open a new exit and optionally link it somewhere.
 */

static void open_exit(player, loc, direction, linkto)
    dbref player, loc;
    char *direction, *linkto;
{
    dbref exit;

    if (!Good_obj(loc))
        return;

    if (!direction || !*direction) {
        notify_quiet(player, "Open where?");
        return;
    } else if (!controls(player, loc)) {
        notify_quiet(player, "Permission denied.");
        return;
    }
    exit = create_obj(player, TYPE_EXIT, direction, 0);
    if (exit == NOTHING)
        return;

    /*
     * Initialize everything and link it in. 
     */

    s_Exits(exit, loc);
    s_Next(exit, Exits(loc));
    s_Exits(loc, exit);

    /*
     * and we're done 
     */

    notify_quiet(player, "Opened.");

    /*
     * See if we should do a link 
     */

    if (!linkto || !*linkto)
        return;

    loc = parse_linkable_room(player, linkto);
    if (loc != NOTHING) {

        /*
         * Make sure the player passes the link lock 
         */

        if (!could_doit(player, loc, A_LLINK)) {
            notify_quiet(player, "You can't link to there.");
            return;
        }
        /*
         * Link it if the player can pay for it 
         */

        if (!payfor(player, mudconf.linkcost)) {
            notify_quiet(player,
                    tprintf("You don't have enough %s to link.",
                        mudconf.many_coins));
        } else {
            s_Location(exit, loc);
            notify_quiet(player, "Linked.");
        }
    }
}

void do_open(player, cause, key, direction, links, nlinks)
    dbref player, cause;
    int key, nlinks;
    char *direction, *links[];
{
    dbref loc, destnum;
    char *dest;

    /*
     * Create the exit and link to the destination, if there is one 
     */

    if (nlinks >= 1)
        dest = links[0];
    else
        dest = NULL;

    if (key == OPEN_INVENTORY)
        loc = player;
    else
        loc = Location(player);

    open_exit(player, loc, direction, dest);

    /*
     * Open the back link if we can 
     */

    if (nlinks >= 2) {
        destnum = parse_linkable_room(player, dest);
        if (destnum != NOTHING) {
            open_exit(player, destnum, links[1], tprintf("%d", loc));
        }
    }
}

/*
 * ---------------------------------------------------------------------------
 * * link_exit, do_link: Set destination(exits), dropto(rooms) or
 * * home(player,thing)
 */

static void link_exit(player, exit, dest)
    dbref player, exit, dest;
{
    int cost, quot;

    /*
     * Make sure we can link there 
     */

    if ((dest != HOME) && ((!controls(player, dest) && !Link_ok(dest)) ||
                !could_doit(player, dest, A_LLINK))) {
        notify_quiet(player, "Permission denied.");
        return;
    }
    /*
     * Exit must be unlinked or controlled by you 
     */

    if ((Location(exit) != NOTHING) && !controls(player, exit)) {
        notify_quiet(player, "Permission denied.");
        return;
    }
    /*
     * handle costs 
     */

    cost = mudconf.linkcost;
    quot = 0;
    if (Owner(exit) != Owner(player)) {
        cost += mudconf.opencost;
        quot += mudconf.exit_quota;
    }
    if (!canpayfees(player, player, cost, quot))
        return;

    /*
     * Pay the owner for his loss 
     */

    if (Owner(exit) != Owner(player)) {
        giveto(Owner(exit), mudconf.opencost);
        add_quota(Owner(exit), quot);
        s_Owner(exit, Owner(player));
        s_Flags(exit, (Flags(exit) & ~(INHERIT | WIZARD)) | HALT);
    }
    /*
     * link has been validated and paid for, do it and tell the player 
     */

    s_Location(exit, dest);
    if (!Quiet(player))
        notify_quiet(player, "Linked.");
}

void do_link(player, cause, key, what, where)
    dbref player, cause;
    int key;
    char *what, *where;
{
    dbref thing, room;
    char *buff;

    /*
     * Find the thing to link 
     */

    init_match(player, what, TYPE_EXIT);
    match_everything(0);
    thing = noisy_match_result();
    if (thing == NOTHING)
        return;

    /*
     * Allow unlink if where is not specified 
     */

    if (!where || !*where) {
        do_unlink(player, cause, key, what);
        return;
    }
    switch (Typeof(thing)) {
        case TYPE_EXIT:

            /*
             * Set destination 
             */

            room = parse_linkable_room(player, where);
            if (room != NOTHING)
                link_exit(player, thing, room);
            break;
        case TYPE_PLAYER:
        case TYPE_THING:

            /*
             * Set home 
             */

            if (!Controls(player, thing)) {
                notify_quiet(player, "Permission denied.");
                break;
            }
            init_match(player, where, NOTYPE);
            match_everything(MAT_NO_EXITS);
            room = noisy_match_result();
            if (!Good_obj(room))
                break;
            if (!Has_contents(room)) {
                notify_quiet(player, "Can't link to an exit.");
                break;
            }
            if (!can_set_home(player, thing, room) ||
                    !could_doit(player, room, A_LLINK)) {
                notify_quiet(player, "Permission denied.");
            } else if (room == HOME) {
                notify_quiet(player, "Can't set home to home.");
            } else {
                s_Home(thing, room);
                if (!Quiet(player))
                    notify_quiet(player, "Home set.");
            }
            break;
        case TYPE_ROOM:

            /*
             * Set dropto 
             */

            if (!Controls(player, thing)) {
                notify_quiet(player, "Permission denied.");
                break;
            }
            room = parse_linkable_room(player, where);
            if (!(Good_obj(room) || (room == HOME)))
                break;

            if ((room != HOME) && !isRoom(room)) {
                notify_quiet(player, "That is not a room!");
            } else if ((room != HOME) && ((!controls(player, room) &&
                            !Link_ok(room)) ||
                        !could_doit(player, room, A_LLINK))) {
                notify_quiet(player, "Permission denied.");
            } else {
                s_Dropto(thing, room);
                if (!Quiet(player))
                    notify_quiet(player, "Dropto set.");
            }
            break;
        case TYPE_GARBAGE:
            notify_quiet(player, "Permission denied.");
            break;
        default:
            STARTLOG(LOG_BUGS, "BUG", "OTYPE") {
                buff = alloc_mbuf("do_link.LOG.badtype");
                sprintf(buff, "Strange object type: object #%d = %d", thing,
                        Typeof(thing));
                log_text(buff);
                free_mbuf(buff);
                ENDLOG;
            }
    }
}

/*
 * ---------------------------------------------------------------------------
 * * do_parent: Set an object's parent field.
 */

void do_parent(player, cause, key, tname, pname)
    dbref player, cause;
    int key;
    char *tname, *pname;
{
    dbref thing, parent, curr;
    int lev;

    /*
     * get victim 
     */

    init_match(player, tname, NOTYPE);
    match_everything(0);
    thing = noisy_match_result();
    if (thing == NOTHING)
        return;

    /*
     * Make sure we can do it 
     */

    if (!Controls(player, thing)) {
        notify_quiet(player, "Permission denied.");
        return;
    }
    /*
     * Find out what the new parent is 
     */

    if (*pname) {
        init_match(player, pname, Typeof(thing));
        match_everything(0);
        parent = noisy_match_result();
        if (parent == NOTHING)
            return;

        /*
         * Make sure we have rights to set parent 
         */

        if (!Parentable(player, parent)) {
            notify_quiet(player, "Permission denied.");
            return;
        }
        /*
         * Verify no recursive reference 
         */

        ITER_PARENTS(parent, curr, lev) {
            if (curr == thing) {
                notify_quiet(player,
                        "You can't have yourself as a parent!");
                return;
            }
        }
    } else {
        parent = NOTHING;
    }

    s_Parent(thing, parent);
    if (!Quiet(thing) && !Quiet(player)) {
        if (parent == NOTHING)
            notify_quiet(player, "Parent cleared.");
        else
            notify_quiet(player, "Parent set.");
    }
}

/*
 * ---------------------------------------------------------------------------
 * * do_dig: Create a new room.
 */

void do_dig(player, cause, key, name, args, nargs)
    dbref player, cause;
    int key, nargs;
    char *name, *args[];
{
    dbref room;
    char *buff;

    /*
     * we don't need to know player's location!  hooray! 
     */

    if (!name || !*name) {
        notify_quiet(player, "Dig what?");
        return;
    }
    room = create_obj(player, TYPE_ROOM, name, 0);
    if (room == NOTHING)
        return;

    notify(player, tprintf("%s created with room number %d.", name, room));

    buff = alloc_sbuf("do_dig");
    if ((nargs >= 1) && args[0] && *args[0]) {
        sprintf(buff, "%d", room);
        open_exit(player, Location(player), args[0], buff);
    }
    if ((nargs >= 2) && args[1] && *args[1]) {
        sprintf(buff, "%d", Location(player));
        open_exit(player, room, args[1], buff);
    }
    free_sbuf(buff);
    if (key == DIG_TELEPORT)
        (void) move_via_teleport(player, room, cause, 0);
}

/*
 * ---------------------------------------------------------------------------
 * * do_create: Make a new object.
 */

void do_create(dbref player, dbref cause, int key, char *name, char *coststr) {
    dbref thing;
    int cost;
    char clearbuffer[MBUF_SIZE];

    cost = atoi(coststr);
    strip_ansi_r(clearbuffer, name, MBUF_SIZE);
    if (!name || !*name || (strlen(clearbuffer) == 0)) {
        notify_quiet(player, "Create what?");
        return;
    } else if (cost < 0) {
        notify_quiet(player,
                "You can't create an object for less than nothing!");
        return;
    }
    thing = create_obj(player, TYPE_THING, name, cost);
    if (thing == NOTHING)
        return;

    move_via_generic(thing, player, NOTHING, 0);
    s_Home(thing, new_home(player));
    if (!Quiet(player)) {
        notify(player, tprintf("%s created as object #%d", Name(thing),
                    thing));
    }
}


/*
 * ---------------------------------------------------------------------------
 * * do_clone: Create a copy of an object.
 */

void do_clone(player, cause, key, name, arg2)
    dbref player, cause;
    int key;
    char *name, *arg2;
{
    dbref clone, thing, new_owner, loc;
    FLAG rmv_flags;
    int cost;

    if ((key & CLONE_INVENTORY) || !Has_location(player))
        loc = player;
    else
        loc = Location(player);

    if (!Good_obj(loc))
        return;

    init_match(player, name, NOTYPE);
    match_everything(0);
    thing = noisy_match_result();
    if ((thing == NOTHING) || (thing == AMBIGUOUS))
        return;

    /*
     * Let players clone things set VISUAL.  It's easier than retyping in
     * all that data 
     */

    if (!Examinable(player, thing)) {
        notify_quiet(player, "Permission denied.");
        return;
    }
    if (isPlayer(thing)) {
        notify_quiet(player, "You cannot clone players!");
        return;
    }
    /*
     * You can only make a parent link to what you control 
     */

    if (!Controls(player, thing) && !Parent_ok(thing) &&
            (key & CLONE_PARENT)) {
        notify_quiet(player,
                tprintf("You don't control %s, ignoring /parent.",
                    Name(thing)));
        key &= ~CLONE_PARENT;
    }
    /*
     * Determine the cost of cloning 
     */

    new_owner = (key & CLONE_PRESERVE) ? Owner(thing) : Owner(player);
    if (key & CLONE_SET_COST) {
        cost = atoi(arg2);
        if (cost < mudconf.createmin)
            cost = mudconf.createmin;
        if (cost > mudconf.createmax)
            cost = mudconf.createmax;
        arg2 = NULL;
    } else {
        cost = 1;
        switch (Typeof(thing)) {
            case TYPE_THING:
                cost =
                    OBJECT_DEPOSIT((mudconf.
                                clone_copy_cost) ? Pennies(thing) : 1);
                break;
            case TYPE_ROOM:
                cost = mudconf.digcost;
                break;
            case TYPE_EXIT:
                if (!Controls(player, loc)) {
                    notify_quiet(player, "Permission denied.");
                    return;
                }
                cost = mudconf.digcost;
                break;
        }
    }

    /*
     * Go make the clone object 
     */

    if ((arg2 && *arg2) && ok_name(arg2))
        clone = create_obj(new_owner, Typeof(thing), arg2, cost);
    else
        clone = create_obj(new_owner, Typeof(thing), Name(thing), cost);
    if (clone == NOTHING)
        return;

    /*
     * Wipe out any old attributes and copy in the new data 
     */

    atr_free(clone);
    if (key & CLONE_PARENT)
        s_Parent(clone, thing);
    else
        atr_cpy(player, clone, thing);

    /*
     * Reset the name, since we cleared the attributes 
     */

    if ((arg2 && *arg2) && ok_name(arg2))
        s_Name(clone, arg2);
    else
        s_Name(clone, Name(thing));

    /*
     * Clear out problem flags from the original 
     */

    rmv_flags = WIZARD;
    if (!(key & CLONE_INHERIT) || (!Inherits(player)))
        rmv_flags |= INHERIT | IMMORTAL;
    s_Flags(clone, Flags(thing) & ~rmv_flags);

    /*
     * Tell creator about it 
     */

    if (!Quiet(player)) {
        if (arg2 && *arg2)
            notify(player,
                    tprintf("%s cloned as %s, new copy is object #%d.",
                        Name(thing), arg2, clone));
        else
            notify(player, tprintf("%s cloned, new copy is object #%d.",
                        Name(thing), clone));
    }
    /*
     * Put the new thing in its new home.  Break any dropto or link, then
     * * * * * * * try to re-establish it. 
     */

    switch (Typeof(thing)) {
        case TYPE_THING:
            s_Home(clone, clone_home(player, thing));
            move_via_generic(clone, loc, player, 0);
            break;
        case TYPE_ROOM:
            s_Dropto(clone, NOTHING);
            if (Dropto(thing) != NOTHING)
                link_exit(player, clone, Dropto(thing));
            break;
        case TYPE_EXIT:
            s_Exits(loc, insert_first(Exits(loc), clone));
            s_Exits(clone, loc);
            s_Location(clone, NOTHING);
            if (Location(thing) != NOTHING)
                link_exit(player, clone, Location(thing));
            break;
    }

    /*
     * If same owner run ACLONE, else halt it.  Also copy parent * if we
     * * * * * * can 
     */

    if (new_owner == Owner(thing)) {
        if (!(key & CLONE_PARENT))
            s_Parent(clone, Parent(thing));
        did_it(player, clone, 0, NULL, 0, NULL, A_ACLONE, (char **) NULL,
                0);
    } else {
        if (!(key & CLONE_PARENT) && (Controls(player, thing) ||
                    Parent_ok(thing)))
            s_Parent(clone, Parent(thing));
        s_Halted(clone);
    }
}

/*
 * ---------------------------------------------------------------------------
 * * do_pcreate: Create new players and robots.
 */

void do_pcreate(player, cause, key, name, pass)
    dbref player, cause;
    int key;
    char *name, *pass;
{
    int isrobot;
    dbref newplayer;

    isrobot = (key == PCRE_ROBOT) ? 1 : 0;
    newplayer = create_player(name, pass, player, isrobot, 0);
    if (newplayer == NOTHING) {
        notify_quiet(player, tprintf("Failure creating '%s'", name));
        return;
    }
    if (isrobot) {
        move_object(newplayer, Location(player));
        notify_quiet(player,
                tprintf("New robot '%s' created with password '%s'", name,
                    pass));
        notify_quiet(player, "Your robot has arrived.");
        STARTLOG(LOG_PCREATES, "CRE", "ROBOT") {
            log_name(newplayer);
            log_text((char *) " created by ");
            log_name(player);
            ENDLOG;
        }} else {
            move_object(newplayer, mudconf.start_room);
            notify_quiet(player,
                    tprintf("New player '%s' created with password '%s'", name,
                        pass));
            STARTLOG(LOG_PCREATES | LOG_WIZARD, "WIZ", "PCREA") {
                log_name(newplayer);
                log_text((char *) " created by ");
                log_name(player);
                ENDLOG;
            }}
}

/*
 * ---------------------------------------------------------------------------
 * * can_destroy_exit, can_destroy_player, do_destroy:
 * * Destroy things.
 */

static int can_destroy_exit(player, exit)
    dbref player, exit;
{
    dbref loc;

    loc = Exits(exit);
    if ((loc != Location(player)) && (loc != player) && !Wizard(player)) {
        notify_quiet(player, "You can not destroy exits in another room.");
        return 0;
    }
    return 1;
}

/*
 * ---------------------------------------------------------------------------
 * * destroyable: Indicates if target of a @destroy is a 'special' object in
 * * the database.
 */

static int destroyable(victim)
    dbref victim;
{
    if ((victim == mudconf.default_home) || (victim == mudconf.start_home)
            || (victim == mudconf.start_room) ||
            (victim == mudconf.master_room) || (victim == (dbref) 0) ||
            (God(victim)))
        return 0;
    return 1;
}


static int can_destroy_player(player, victim)
    dbref player, victim;
{
    if (!Wizard(player)) {
        notify_quiet(player, "Sorry, no suicide allowed.");
        return 0;
    }
    if (Wizard(victim)) {
        notify_quiet(player, "Even you can't do that!");
        return 0;
    }
    return 1;
}

void do_destroy(player, cause, key, what)
    dbref player, cause;
    int key;
    char *what;
{
    dbref thing;

    /*
     * You can destroy anything you control 
     */

    thing = match_controlled_quiet(player, what);

    /*
     * If you own a location, you can destroy its exits 
     */

    if ((thing == NOTHING) && controls(player, Location(player))) {
        init_match(player, what, TYPE_EXIT);
        match_exit();
        thing = last_match_result();
    }
    /*
     * You may destroy DESTROY_OK things in your inventory 
     */

    if (thing == NOTHING) {
        init_match(player, what, TYPE_THING);
        match_possession();
        thing = last_match_result();
        if ((thing != NOTHING) && !(isThing(thing) && Destroy_ok(thing))) {
            thing = NOPERM;
        }
    }
    /*
     * Return an error if we didn't find anything to destroy 
     */

    if (match_status(player, thing) == NOTHING) {
        return;
    }
    /*
     * Check SAFE and DESTROY_OK flags 
     */

    if (Safe(thing, player) && !(key & DEST_OVERRIDE) && !(isThing(thing)
                && Destroy_ok(thing))) {
        notify_quiet(player,
                "Sorry, that object is protected.  Use @destroy/override to destroy it.");
        return;
    }
    /*
     * Make sure we're not trying to destroy a special object 
     */

    if (!destroyable(thing)) {
        notify_quiet(player, "You can't destroy that!");
        return;
    }
    /*
     * Go do it 
     */

    switch (Typeof(thing)) {
        case TYPE_EXIT:
            if (can_destroy_exit(player, thing)) {
                if (Going(thing)) {
                    notify_quiet(player, "No sense beating a dead exit.");
                } else {
                    if (Hardcode(thing)) {
                        DisposeSpecialObject(player, thing);
                        c_Hardcode(thing);
                    }
                    if (Destroy_ok(thing) || Destroy_ok(Owner(thing))) {
                        destroy_exit(thing);
                    } else {
                        notify(player,
                                "The exit shakes and begins to crumble.");
                        if (!Quiet(thing) && !Quiet(Owner(thing)))
                            notify_quiet(Owner(thing),
                                    tprintf
                                    ("You will be rewarded shortly for %s(#%d).",
                                     Name(thing), thing));
                        if ((Owner(thing) != player) && !Quiet(player)) {
                            notify_quiet(player,
                                    tprintf("Destroyed. #%d's %s(#%d)",
                                        Owner(thing), Name(thing), thing));
                            s_Going(thing);
                        }
                    }
                }
            }
            break;
        case TYPE_THING:
            if (Going(thing)) {
                notify_quiet(player, "No sense beating a dead object.");
            } else {
                if (Hardcode(thing)) {
                    DisposeSpecialObject(player, thing);
                    c_Hardcode(thing);
                }
                if (Destroy_ok(thing) || Destroy_ok(Owner(thing))) {
                    destroy_thing(thing);
                } else {
                    notify(player, "The object shakes and begins to crumble.");
                    if (!Quiet(thing) && !Quiet(Owner(thing)))
                        notify_quiet(Owner(thing),
                                tprintf
                                ("You will be rewarded shortly for %s(#%d).",
                                 Name(thing), thing));
                    if ((Owner(thing) != player) && !Quiet(player))
                        notify_quiet(player, tprintf("Destroyed. %s's %s(#%d)",
                                    Name(Owner(thing)), Name(thing), thing));
                    s_Going(thing);
                }
            }
            break;
        case TYPE_PLAYER:
            if (can_destroy_player(player, thing)) {
                if (Going(thing)) {
                    notify_quiet(player, "No sense beating a dead player.");
                } else {
                    if (Hardcode(thing)) {
                        DisposeSpecialObject(player, thing);
                        c_Hardcode(thing);
                    }
                    if (Destroy_ok(thing)) {
                        atr_add_raw(thing, A_DESTROYER, tprintf("%d", player));
                        destroy_player(thing);
                    } else {
                        notify(player,
                                "The player shakes and begins to crumble.");
                        s_Going(thing);
                        atr_add_raw(thing, A_DESTROYER, tprintf("%d", player));
                    }
                }
            }
            break;
        case TYPE_ROOM:
            if (Going(thing)) {
                notify_quiet(player, "No sense beating a dead room.");
            } else {
                if (Destroy_ok(thing) || Destroy_ok(Owner(thing))) {
                    empty_obj(thing);
                    destroy_obj(NOTHING, thing);
                } else {
                    notify_all(thing, player,
                            "The room shakes and begins to crumble.");
                    if (!Quiet(thing) && !Quiet(Owner(thing)))
                        notify_quiet(Owner(thing),
                                tprintf
                                ("You will be rewarded shortly for %s(#%d).",
                                 Name(thing), thing));
                    if ((Owner(thing) != player) && !Quiet(player))
                        notify_quiet(player, tprintf("Destroyed. %s's %s(#%d)",
                                    Name(Owner(thing)), Name(thing), thing));
                    s_Going(thing);
                }
            }
    }
}