home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Shareware Overload
/
ShartewareOverload.cdr
/
games
/
tinymud2.zip
/
CREATE.C
< prev
next >
Wrap
C/C++ Source or Header
|
1990-09-02
|
9KB
|
337 lines
#include "copyright.h"
/* Commands that create new objects */
#include "db.h"
#include "config.h"
#include "interface.h"
#include "externs.h"
/* utility for open and link */
static dbref parse_linkable_room(dbref player, object_flag_type thing,
const char *room_name)
{
dbref room;
/* skip leading NUMBER_TOKEN if any */
if(*room_name == NUMBER_TOKEN) room_name++;
/* parse room */
if(!string_compare(room_name, "here")) {
room = db[player].location;
} else if(!string_compare(room_name, "home")) {
return HOME; /* HOME is always linkable */
} else {
room = parse_dbref(room_name);
}
/* check room */
if(room < 0 || room >= db_top
|| Typeof(room) != TYPE_ROOM) {
notify(player, "That's not a room!");
return NOTHING;
} else if(!can_link_to(player, thing, room)) {
notify(player, "You can't link to that.");
return NOTHING;
} else {
return room;
}
}
/* use this to create an exit */
void do_open(dbref player, const char *direction, const char *linkto)
{
dbref loc;
dbref exit;
#ifdef RESTRICTED_BUILDING
if(!Builder(player)) {
notify(player, "That command is restricted to authorized builders.");
return;
}
#endif /* RESTRICTED_BUILDING */
if((loc = getloc(player)) == NOTHING) return;
if(!*direction) {
notify(player, "Open where?");
return;
} else if(!ok_name(direction)) {
notify(player, "That's a strange name for an exit!");
return;
}
if(!controls(player, loc)) {
notify(player, "Permission denied.");
} else if(!payfor(player, EXIT_COST)) {
notify(player,
"Sorry, you don't have enough pennies to open an exit.");
} else {
/* create the exit */
exit = new_object();
/* initialize everything */
db[exit].name = alloc_string(direction);
db[exit].owner = player;
db[exit].flags = TYPE_EXIT;
/* link it in */
PUSH(exit, db[loc].exits);
/* and we're done */
notify(player, "Opened.");
/* check second arg to see if we should do a link */
if(*linkto != '\0') {
notify(player, "Trying to link...");
if((loc = parse_linkable_room(player, TYPE_EXIT, linkto)) !=
NOTHING) {
if(!payfor(player, LINK_COST)) {
notify(player, "You don't have enough pennies to link.");
} else {
/* it's ok, link it */
db[exit].location = loc;
notify(player, "Linked.");
}
}
}
}
}
/* use this to link to a room that you own */
/* it seizes ownership of the exit */
/* costs 1 penny */
/* plus a penny transferred to the exit owner if they aren't you */
/* you must own the linked-to room AND specify it by room number */
void do_link(dbref player, const char *name, const char *room_name)
{
dbref thing;
dbref room;
init_match(player, name, TYPE_EXIT);
match_exit();
match_neighbor();
match_possession();
match_me();
match_here();
if(Wizard(player)) {
match_absolute();
match_player();
}
if((thing = noisy_match_result()) != NOTHING) {
if((room = parse_linkable_room(player, Typeof(thing), room_name)) ==
NOTHING)
return;
switch(Typeof(thing)) {
case TYPE_EXIT:
/* we're ok, check the usual stuff */
if(db[thing].location != NOTHING) {
if(controls(player, thing)) {
/*
* Changed 5/18/90 Fuzzy - exits linked to *home*
* break 'Typeof() call'
*/
if(db[thing].location >= 0 &&
Typeof(db[thing].location) == TYPE_PLAYER) {
notify(player, "That exit is being carried.");
} else {
notify(player, "That exit is already linked.");
}
} else {
notify(player, "Permission denied.");
}
} else {
/* handle costs */
if(db[thing].owner == player) {
if(!payfor(player, LINK_COST)) {
notify(player,
"It costs a penny to link this exit.");
return;
}
} else {
if(!payfor(player, LINK_COST + EXIT_COST)) {
notify(player,
"It costs two pennies to link this exit.");
return;
#ifdef RESTRICTED_BUILDING
} else if(!Builder(player)) {
notify(player,
"Only authorized builders may seize exits.");
#endif /* RESTRICTED_BUILDING */
} else {
/* pay the owner for his loss */
db[db[thing].owner].pennies += EXIT_COST;
}
}
/* link has been validated and paid for; do it */
db[thing].owner = player;
db[thing].location = room;
/* notify the player */
notify(player, "Linked.");
}
break;
case TYPE_PLAYER:
case TYPE_THING:
if(!controls(player, thing)) {
notify(player, "Permission denied.");
} else if(room == HOME) {
notify(player, "Can't set home to home.");
} else {
/* do the link */
db[thing].exits = room; /* home */
notify(player, "Home set.");
}
break;
case TYPE_ROOM:
if(!controls(player, thing)) {
notify(player, "Permission denied.");
} else {
/* do the link, in location */
db[thing].location = room; /* dropto */
notify(player, "Dropto set.");
}
break;
default:
notify(player, "Internal error: weird object type.");
writelog("PANIC weird object: Typeof(%d) = %d\n",
thing, Typeof(thing));
break;
}
}
}
/* use this to create a room */
void do_dig(dbref player, const char *name)
{
dbref room;
char buf[BUFFER_LEN];
#ifdef RESTRICTED_BUILDING
if(!Builder(player)) {
notify(player, "That command is restricted to authorized builders.");
return;
}
#endif /* RESTRICTED_BUILDING */
/* we don't need to know player's location! hooray! */
if(*name == '\0') {
notify(player, "Dig what?");
} else if(!ok_name(name)) {
notify(player, "That's a silly name for a room!");
} else if(!payfor(player, ROOM_COST)) {
notify(player, "Sorry, you don't have enough pennies to dig a room.");
} else {
room = new_object();
/* Initialize everything */
db[room].name = alloc_string(name);
db[room].owner = player;
db[room].flags = TYPE_ROOM;
sprintf(buf, "%s created with room number %d.", name, room);
notify(player, buf);
}
}
/* use this to create an object */
void do_create(dbref player, char *name, int cost)
{
dbref loc;
dbref thing;
#ifdef RESTRICTED_BUILDING
if(!Builder(player)) {
notify(player, "That command is restricted to authorized builders.");
return;
}
#endif /* RESTRICTED_BUILDING */
if(*name == '\0') {
notify(player, "Create what?");
return;
} else if(!ok_name(name)) {
notify(player, "That's a silly name for a thing!");
return;
} else if(cost < 0) {
notify(player, "You can't create an object for less than nothing!");
return;
} else if(cost < OBJECT_COST) {
cost = OBJECT_COST;
}
if(!payfor(player, cost)) {
notify(player, "Sorry, you don't have enough pennies.");
} else {
/* create the object */
thing = new_object();
/* initialize everything */
db[thing].name = alloc_string(name);
db[thing].location = player;
db[thing].owner = player;
db[thing].pennies = OBJECT_ENDOWMENT(cost);
db[thing].flags = TYPE_THING;
/* endow the object */
if(db[thing].pennies > MAX_OBJECT_ENDOWMENT) {
db[thing].pennies = MAX_OBJECT_ENDOWMENT;
}
/* home is here (if we can link to it) or player's home */
if((loc = db[player].location) != NOTHING
&& controls(player, loc)) {
db[thing].exits = loc; /* home */
} else {
db[thing].exits = db[player].exits; /* home */
}
/* link it in */
PUSH(thing, db[player].contents);
/* and we're done */
notify(player, "Created.");
}
}
#ifdef REGISTRATION
void do_pcreate (dbref player, char *newplayer, char *newpass)
{
dbref ptmp;
#ifdef GOD_MODE && GOD_ONLY_PCREATE
if (!God(player))
#ifndef TINKER
notify (player, "Only GOD can create a new player.");
#else TINKER
notify (player, "Only the Master Tinker can create a new player.");
#endif TINKER
#else GOD_MODE && GOD_ONLY_PCREATE
if (!Wizard(player))
#ifndef TINKER
notify (player, "Only a Wizard can create a new player.");
#else TINKER
notify (player, "Only a Tinker can create a new player.");
#endif TINKER
#endif GOD_MODE && GOD_ONLY_PCREATE
else if (!*newplayer || !*newpass)
notify (player, "You must specify name and password.");
else {
ptmp = create_player (newplayer, newpass);
if (ptmp == NOTHING) {
notify(player, "Either there is already a player with that name, or that name is illegal.");
writelog("FAILED CREATE %s by %s\n",newplayer,db[player].name);
} else {
char buf[512];
sprintf(buf, "%s created as object #%d.",db[ptmp].name,ptmp);
notify(player, buf);
writelog("CREATED %s(%d) by %s\n",db[ptmp].name,ptmp,
db[player].name);
}
}
}
#endif REGISTRATION