/* create.c -- Commands that create new objects */ #include "autoconf.h" #include "copyright.h" #ifndef lint static char RCSid[] = "$Id: create.c,v 1.10 1995/03/21 23:07:48 ambar Exp $"; USE(RCSid); #endif #include "externs.h" #include "interface.h" #include "match.h" #include "command.h" #include "alloc.h" #include "attrs.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) && (!Wizard(player) || mudconf.wiz_obey_linklock)) { 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, buf[20]; /* 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) { ltos(buf, loc); open_exit(player, destnum, links[1], buf); } } } /* --------------------------------------------------------------------------- * 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) && (!Wizard(player) || mudconf.wiz_obey_linklock)))) { 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, TYPE_EXIT)) return; else payfees(player, cost, quot, TYPE_EXIT); /* Pay the owner for his loss */ if (Owner(exit) != Owner(player)) { payfees(Owner(exit), -mudconf.opencost, -quot, TYPE_EXIT); 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) && (!Wizard(player) || mudconf.wiz_obey_linklock))) { 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) && (!Wizard(player) || mudconf.wiz_obey_linklock)))) { notify_quiet(player, "Permission denied."); } else { s_Dropto(thing, room); if (!Quiet(player)) notify_quiet(player, "Dropto set."); } 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, is_zone; /* get victim */ init_match(player, tname, NOTYPE); match_everything(0); thing = noisy_match_result(); if (thing == NOTHING) return; /* Check permissions */ is_zone = (key & PARENT_ZONE) ? 1 : 0; if (is_zone) { if (!mudconf.parent_zones) { notify_quiet(player, "This option is not supported on this MUSH."); return; } if (Typeof(thing) != TYPE_ROOM) { notify_quiet(player, "Only rooms can be zoned."); 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; } if (is_zone) { s_Next(thing, parent); if (!Quiet(thing) && !Quiet(player)) { if (parent == NOTHING) notify_quiet(player, "Zone cleared."); else notify_quiet(player, "Zone set."); } } else { 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]) { ltos(buff, room); open_exit(player, Location(player), args[0], buff); } if ((nargs >= 2) && args[1] && *args[1]) { ltos(buff, 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(player, cause, key, name, coststr) dbref player, cause; int key; char *name, *coststr; { dbref thing; int cost; cost = atoi(coststr); if (!name || !*name) { 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; register int cost = 1; const char *clone_name; 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); 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; } if (key & CLONE_SET_COST) { cost = atoi(arg2); arg2 = NULL; } /* Go make the clone object */ 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 */ al_destroy(clone); if (key & CLONE_PARENT) s_Parent(clone, thing); else atr_cpy(player, clone, thing); if ((arg2 && *arg2) && ok_name(arg2)) { clone_name = arg2; s_Name(clone, arg2); } else { clone_name = Name(thing); } s_Name(clone, clone_name); /* 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); rmv_flags = SUSPECT | BUILDER | CONNECTED | SLAVE; s_Flags2(clone, Flags2(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), clone_name, 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, A_NULL, NULL, A_NULL, 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); 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 } } /* --------------------------------------------------------------------------- * destroy_exit, destroy_thing, destroy_player, do_destroy: Destroy things. */ static void destroy_exit(player, exit) dbref player, exit; { dbref loc; loc = Exits(exit); if ((loc != Location(player)) && (loc != player) && !Wizard(player)) { notify_quiet(player, "You cannot destroy exits in another room."); return; } s_Exits(loc, remove_first(Exits(loc), exit)); destroy_obj(player, exit); } static void destroy_thing(player, thing) dbref player, thing; { move_via_generic(thing, NOTHING, player, 0); empty_obj(thing); destroy_obj(player, thing); } /* --------------------------------------------------------------------------- * 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) || God(victim) || (victim == 0)) return 0; return 1; } static void destroy_player(player, victim) dbref player, victim; { dbref aowner; int count, aflags; char *buf; if (!Wizard(player)) { notify_quiet(player, "Sorry, no suicide allowed."); return; } if (Wizard(victim)) { notify_quiet(player, "Even you can't do that!"); return; } /* Bye bye... */ boot_off(victim, (char *) "You have been destroyed!"); halt_que(victim, NOTHING); count = chown_all(victim, player); /* Remove the name from the name hash table */ delete_player_name(victim, Name(victim)); buf = atr_pget(victim, A_ALIAS, &aowner, &aflags); delete_player_name(victim, buf); free_lbuf(buf); move_via_generic(victim, NOTHING, player, 0); destroy_obj(player, victim); notify_quiet(player, tprintf("(%d objects @chowned to you)", count)); } void do_destroy(player, cause, key, what) dbref player, cause; int key; char *what; { dbref thing; /* Check for things I control. We do this first, because what we want * is probably something we control, and this allows us to check for * absolute references first. */ thing = match_controlled_quiet(player, what); /* If you control a location, you can destroy any exits in it. */ if ((thing == NOTHING) && controls(player, Location(player))) { init_match(player, what, TYPE_EXIT); match_exit(); thing = last_match_result(); } /* You can destroy DESTROY_OK things if you're carrying them. */ if (thing == NOTHING) { init_match(player, what, TYPE_THING); match_possession(); thing = last_match_result(); if ((thing != NOTHING) && !(isThing(thing) && Destroy_ok(thing))) { thing = NOTHING; notify(player, "Permission denied."); } } /* If we haven't found anything to destroy yet, return an error. */ 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: destroy_exit(player, thing); break; case TYPE_THING: destroy_thing(player, thing); break; case TYPE_PLAYER: destroy_player(player, thing); break; case TYPE_ROOM: if (Going(thing)) { notify_quiet(player, "No sense beating a dead room."); } 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)); s_Going(thing); } } }