// create.cpp -- Commands that create new objects // // $Id: create.cpp,v 1.8 2000/09/18 18:56:28 sdennis Exp $ // #include "copyright.h" #include "autoconf.h" #include "config.h" #include "externs.h" #include "mudconf.h" #include "db.h" #include "interface.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(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(dbref player, dbref loc, char *direction, char *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, NOPERM_MESSAGE); 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(dbref player, dbref cause, int key, char *direction, char *links[], int nlinks) { 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) { char buff[12]; Tiny_ltoa(loc, buff); open_exit(player, destnum, links[1], buff); } } } /* * --------------------------------------------------------------------------- * * link_exit, do_link: Set destination(exits), dropto(rooms) or * * home(player,thing) */ static void link_exit(dbref player, dbref exit, dbref 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, NOPERM_MESSAGE); return; } // Exit must be unlinked or controlled by you // if ((Location(exit) != NOTHING) && !controls(player, exit)) { notify_quiet(player, NOPERM_MESSAGE); 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(dbref player, dbref cause, int key, char *what, char *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, NOPERM_MESSAGE); 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(dbref player, dbref cause, int key, char *tname, char *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 (isGarbage(thing) || Going(thing) || !Controls(player, thing)) { notify_quiet(player, NOPERM_MESSAGE); 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(dbref player, dbref cause, int key, char *name, char *args[], int nargs) { 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]) { Tiny_ltoa(room, buff); open_exit(player, Location(player), args[0], buff); } if ((nargs >= 2) && args[1] && *args[1]) { Tiny_ltoa(Location(player), buff); 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; cost = Tiny_atol(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(dbref player, dbref cause, int key, char *name, char *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 = Tiny_atol(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. // BOOL bValid; int nValidName; char *pValidName = MakeCanonicalObjectName(arg2, &nValidName, &bValid); char *clone_name; if (bValid) { clone_name = pValidName; } else { clone_name = Name(thing); } clone = create_obj(new_owner, Typeof(thing), clone_name, 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. // s_Name(clone, clone_name); /* * Reset the pennies, since it looks like we stamped on that, too. */ s_Pennies(clone, OBJECT_ENDOWMENT(cost)); /* * 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(dbref player, dbref cause, int key, char *name, char *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; #ifdef GAME_DOOFERMUX // Added by D.Piper (del@delphinian.com) 2000-APR // atr_add_raw(newplayer, A_REGINFO, "*Requires Registration*"); #endif // GAME_DOOFERMUX } } /* * --------------------------------------------------------------------------- * * can_destroy_exit, can_destroy_player, do_destroy: * * Destroy things. */ static int can_destroy_exit(dbref player, dbref 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(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(dbref player, dbref 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(dbref player, dbref 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; } // Make sure we can do it, on a type-specific basis. // char *NameOfType; int can_doit; switch (Typeof(thing)) { case TYPE_EXIT: NameOfType = "exit"; can_doit = can_destroy_exit(player, thing); break; case TYPE_PLAYER: NameOfType = "player"; can_doit = can_destroy_player(player, thing); break; case TYPE_ROOM: NameOfType = "room"; can_doit = 1; break; case TYPE_THING: NameOfType = "thing"; can_doit = 1; break; default: NameOfType = "weird"; can_doit = 1; break; } if (!can_doit) { return; } if (Going(thing)) { notify_quiet(player, tprintf("No sense beating a dead %s.", NameOfType)); return; } // Check whether we should perform instant destruction. // if (Destroy_ok(thing) || Destroy_ok(Owner(thing))) { switch (Typeof(thing)) { case TYPE_EXIT: destroy_exit(thing); break; case TYPE_PLAYER: atr_add_raw(thing, A_DESTROYER, Tiny_ltoa_t(player)); destroy_player(player, thing); break; case TYPE_ROOM: empty_obj(thing); destroy_obj(NOTHING, thing); break; case TYPE_THING: destroy_thing(thing); break; default: notify(player, "Weird object type cannot be destroyed."); break; } return; } // Otherwise we queue things up for destruction. // if (!isRoom(thing)) { notify(player, tprintf("The %s shakes and begins to crumble.", NameOfType)); } 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)); } if (isPlayer(thing)) { atr_add_raw(thing, A_DESTROYER, Tiny_ltoa_t(player)); } s_Going(thing); }