src/create.c File Reference

#include "copyright.h"
#include "config.h"
#include "mudconf.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"

Include dependency graph for create.c:

Go to the source code of this file.

Functions
static dbref	parse_linkable_room (dbref player, char *room_name)
static void	open_exit (dbref player, dbref loc, char *direction, char *linkto)
void	do_open (dbref player, dbref cause, int key, char *direction, char *links[], int nlinks)
static void	link_exit (dbref player, dbref exit, dbref dest)
void	do_link (dbref player, dbref cause, int key, char *what, char *where)
void	do_parent (dbref player, dbref cause, int key, char *tname, char *pname)
void	do_dig (dbref player, dbref cause, int key, char *name, char *args[], int nargs)
void	do_create (dbref player, dbref cause, int key, char *name, char *coststr)
void	do_clone (dbref player, dbref cause, int key, char *name, char *arg2)
void	do_pcreate (dbref player, dbref cause, int key, char *name, char *pass)
static int	can_destroy_exit (dbref player, dbref exit)
static int	destroyable (dbref victim)
static int	can_destroy_player (dbref player, dbref victim)
void	do_destroy (dbref player, dbref cause, int key, char *what)

---

Function Documentation

static int can_destroy_exit	(	dbref	player,
		dbref	exit
	)			[static]

Definition at line 682 of file create.c.

References Exits, loc, Location, notify_quiet, and Wizard.

Referenced by do_destroy().

{
        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;
}

static int can_destroy_player	(	dbref	player,
		dbref	victim
	)			[static]

Definition at line 710 of file create.c.

References notify_quiet, and Wizard.

Referenced by do_destroy().

{
        if(!Wizard(player)) {
                notify_quiet(player, "Sorry, no suicide allowed.");
                return 0;
        }
        if(Wizard(victim)) {
                notify_quiet(player, "You may not destroy Wizards!");
                return 0;
        }
        return 1;
}

static int destroyable

(

dbref

victim

)

[static]

Definition at line 700 of file create.c.

References confdata::default_home, God, confdata::master_room, mudconf, confdata::start_home, and confdata::start_room.

Referenced by do_destroy().

{
        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;
}

void do_clone	(	dbref	player,
		dbref	cause,
		int	key,
		char *	name,
		char *	arg2
	)

Definition at line 463 of file create.c.

References A_ACLONE, AMBIGUOUS, atr_cpy(), atr_free(), clone_home(), CLONE_INHERIT, CLONE_INVENTORY, CLONE_PARENT, CLONE_PRESERVE, CLONE_SET_COST, Controls, create_obj(), confdata::createmax, confdata::createmin, did_it(), confdata::digcost, Dropto, Examinable, Exits, Flags, Good_obj, Has_location, IMMORTAL, INHERIT, Inherits, init_match(), insert_first(), isPlayer, link_exit(), loc, Location, match_everything(), move_via_generic(), mudconf, Name(), noisy_match_result(), NOTHING, notify_printf(), notify_quiet, NOTYPE, OBJECT_DEPOSIT, ok_name(), Owner, Parent, Parent_ok, Pennies(), Quiet, s_Dropto, s_Exits, s_Flags, s_Halted, s_Home, s_Location, s_Name(), s_Parent, tprintf(), TYPE_EXIT, TYPE_ROOM, TYPE_THING, Typeof, and WIZARD.

{
        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_printf(player,
                                                  "%s cloned as %s, new copy is object #%d.",
                                                  Name(thing), arg2, clone);
                else
                        notify_printf(player, "%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);
        }
}

void do_create	(	dbref	player,
		dbref	cause,
		int	key,
		char *	name,
		char *	coststr
	)

Definition at line 431 of file create.c.

References create_obj(), MBUF_SIZE, move_via_generic(), Name(), new_home(), NOTHING, notify_printf(), notify_quiet, Quiet, s_Home, strip_ansi_r(), and TYPE_THING.

{
        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_printf(player, "%s created as object #%d", Name(thing), thing);
        }
}

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

Definition at line 723 of file create.c.

References A_DESTROYER, atr_add_raw(), c_Hardcode, can_destroy_exit(), can_destroy_player(), controls, DEST_OVERRIDE, destroy_exit(), destroy_obj(), Destroy_ok, destroy_player(), destroy_thing(), destroyable(), DisposeSpecialObject(), empty_obj(), Going, Hardcode, init_match(), isThing, last_match_result(), Location, match_controlled_quiet(), match_exit(), match_possession(), match_status(), Name(), NOPERM, NOTHING, notify, notify_all, notify_quiet, Owner, Quiet, s_Going, Safe, tprintf(), TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, and Typeof.

{
        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);
                        }
                }
        }
}

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

Definition at line 392 of file create.c.

References alloc_sbuf, create_obj(), DIG_TELEPORT, free_sbuf, Location, move_via_teleport(), NOTHING, notify_printf(), notify_quiet, open_exit(), and TYPE_ROOM.

{
        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_printf(player, "%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);
}

void do_link	(	dbref	player,
		dbref	cause,
		int	key,
		char *	what,
		char *	where
	)

Definition at line 217 of file create.c.

References A_LLINK, can_set_home(), controls, Controls, could_doit(), do_unlink(), Good_obj, Has_contents, HOME, init_match(), isRoom, link_exit(), Link_ok, LOG_BUGS, log_error(), MAT_NO_EXITS, match_everything(), noisy_match_result(), NOTHING, notify_quiet, NOTYPE, parse_linkable_room(), Quiet, s_Dropto, s_Home, TYPE_EXIT, TYPE_GARBAGE, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, and Typeof.

Referenced by fun_link().

{
        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:
        log_error(LOG_BUGS, "BUG", "OTYPE", "Strange object type: object #%d = %d", 
            thing, Typeof(thing));
        }
}

void do_open	(	dbref	player,
		dbref	cause,
		int	key,
		char *	direction,
		char *	links[],
		int	nlinks
	)

Definition at line 124 of file create.c.

References loc, Location, NOTHING, open_exit(), OPEN_INVENTORY, parse_linkable_room(), and tprintf().

{
        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));
                }
        }
}

void do_parent	(	dbref	player,
		dbref	cause,
		int	key,
		char *	tname,
		char *	pname
	)

Definition at line 322 of file create.c.

References Controls, init_match(), ITER_PARENTS, match_everything(), noisy_match_result(), NOTHING, notify_quiet, NOTYPE, Parentable, Quiet, s_Parent, and Typeof.

Referenced by do_examine().

{
        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.");
        }
}

void do_pcreate	(	dbref	player,
		dbref	cause,
		int	key,
		char *	name,
		char *	pass
	)

Definition at line 637 of file create.c.

References create_player(), ENDLOG, Location, log_name(), LOG_PCREATES, log_text(), LOG_WIZARD, move_object(), mudconf, NOTHING, notify_quiet, PCRE_ROBOT, confdata::start_room, STARTLOG, and tprintf().

{
        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' (#%d) created with password '%s'", name,
                                          newplayer, 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' (#%d) created with password '%s'",
                                          name, newplayer, pass));

                STARTLOG(LOG_PCREATES | LOG_WIZARD, "WIZ", "PCREA") {
                        log_name(newplayer);
                        log_text((char *) " created by ");
                        log_name(player);
                        ENDLOG;
        }}
}

static void link_exit	(	dbref	player,
		dbref	exit,
		dbref	dest
	)			[static]

Definition at line 164 of file create.c.

References A_LLINK, add_quota(), canpayfees(), controls, could_doit(), confdata::exit_quota, Flags, giveto(), HALT, HOME, INHERIT, Link_ok, confdata::linkcost, Location, mudconf, NOTHING, notify_quiet, confdata::opencost, Owner, Quiet, s_Flags, s_Location, s_Owner, and WIZARD.

Referenced by do_clone(), and do_link().

{
        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.");
}

static void open_exit	(	dbref	player,
		dbref	loc,
		char *	direction,
		char *	linkto
	)			[static]

Definition at line 59 of file create.c.

References A_LLINK, controls, could_doit(), create_obj(), Exits, Good_obj, confdata::linkcost, confdata::many_coins, mudconf, NOTHING, notify_quiet, parse_linkable_room(), payfor(), s_Exits, s_Location, s_Next, tprintf(), and TYPE_EXIT.

Referenced by do_dig(), and do_open().

{
        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.");
                }
        }
}

static dbref parse_linkable_room	(	dbref	player,
		char *	room_name
	)			[static]

Definition at line 24 of file create.c.

References Good_obj, Has_contents, HOME, init_match(), Linkable, MAT_HOME, MAT_NO_EXITS, MAT_NUMERIC, match_everything(), match_result(), NOTHING, notify_quiet, and NOTYPE.

Referenced by do_link(), do_open(), and open_exit().

{
        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;
        }
}

---