src/mguests.c File Reference

#include <stdlib.h>
#include "config.h"
#include "copyright.h"
#include "mudconf.h"
#include "externs.h"
#include "mguests.h"
#include "db.h"
#include "interface.h"
#include "mail.h"
#include "attrs.h"
#include "powers.h"

Include dependency graph for mguests.c:

Go to the source code of this file.

Typedefs
typedef int	object_flag_type
Functions
void	destroy_player (dbref)
void	do_lock (dbref player, dbref cause, int key, char *name, char *keytext)
dbref	create_guest (char *name, char *password)
void	destroy_guest (dbref guest)
char *	make_guest (DESC *d)

---

Typedef Documentation

typedef int object_flag_type

Definition at line 22 of file mguests.c.

---

Function Documentation

dbref create_guest	(	char *	name,
		char *	password
	)

Definition at line 24 of file mguests.c.

References A_LENTER, A_LOCK, alloc_lbuf, atr_cpy(), create_player(), do_lock(), Flags, free_lbuf, GOD, Good_obj, confdata::guest_char, confdata::guest_nuker, log_text(), move_object(), mudconf, NOTHING, Parent, Pennies(), s_Flags, s_Guest, s_Parent, s_Pennies(), s_Zone, confdata::start_room, tprintf(), Wizard, WIZARD, and Zone.

{
        dbref player;
        char *buff;

        if(!Wizard(mudconf.guest_nuker) || !Good_obj(mudconf.guest_nuker))
                mudconf.guest_nuker = 1;

        buff = alloc_lbuf("create_guest");

        /*
         * Make the player. 
         */

        player = create_player(name, password, mudconf.guest_nuker, 0, 1);

        if(player == NOTHING) {
                log_text("GUEST: failed in create_player\n");
                return NOTHING;
        }
        /*
         * Turn the player into a guest. 
         */

        s_Guest(player);
        move_object(player, mudconf.start_room);
        s_Flags(player, Flags(player) & ~WIZARD);
        s_Pennies(player, Pennies(mudconf.guest_char));
        s_Zone(player, Zone(mudconf.guest_char));
        s_Parent(player, Parent(mudconf.guest_char));

        /*
         * Make sure the guest is locked. 
         */
        do_lock(player, player, A_LOCK, tprintf("#%d", player), "me");
        do_lock(player, player, A_LENTER, tprintf("#%d", player), "me");

        /*
         * Copy all attributes. 
         */
        atr_cpy(GOD, player, mudconf.guest_char);
        free_lbuf(buff);
        return player;
}

void destroy_guest

(

dbref

guest

)

Definition at line 69 of file mguests.c.

References A_DESTROYER, atr_add_raw(), destroy_obj(), destroy_player(), Good_obj, Guest, confdata::guest_nuker, mudconf, toast_player(), tprintf(), and Wizard.

Referenced by make_guest().

{
        if(!Wizard(mudconf.guest_nuker) || !Good_obj(mudconf.guest_nuker))
                mudconf.guest_nuker = 1;

        if(!Guest(guest))
                return;

        toast_player(guest);
        atr_add_raw(guest, A_DESTROYER, tprintf("%d", mudconf.guest_nuker));
        destroy_player(guest);
        destroy_obj(mudconf.guest_nuker, guest);
}

void destroy_player

(

dbref

victim

)

Destroys a player.

Definition at line 567 of file object.c.

References A_ALIAS, A_DESTROYER, atr_get_raw(), atr_pget(), boot_off(), chown_all(), delete_player_name(), destroy_obj(), do_mail_clear(), do_mail_purge(), free_lbuf, halt_que(), move_via_generic(), Name(), NOTHING, notify_quiet, toast_player(), and tprintf().

{
        dbref aowner, player;
        int count, aflags;
        char *buf;

        /*
         * Bye bye... 
         */
        player = (dbref) atoi(atr_get_raw(victim, A_DESTROYER));
        toast_player(victim);
        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);
        do_mail_clear(victim, NULL);
        do_mail_purge(victim);
        destroy_obj(NOTHING, victim);
        notify_quiet(player, tprintf("(%d objects @chowned to you)", count));
}

void do_lock	(	dbref	player,
		dbref	cause,
		int	key,
		char *	name,
		char *	keytext
	)

Definition at line 343 of file set.c.

References A_LOCK, AF_LOCK, AMBIGUOUS, atr_add_raw(), atr_get_info(), atr_num(), atr_set_flags(), controls, free_boolexp(), God, init_match(), MAT_EXIT_PARENTS, match_everything(), match_result(), NOTHING, notify_quiet, NOTYPE, Owner, parse_attrib(), parse_boolexp(), Quiet, Set_attr, TRUE_BOOLEXP, unparse_boolexp_quiet(), and Wizard.

Referenced by create_guest().

{
        dbref thing, aowner;
        int atr, aflags;
        ATTR *ap;
        struct boolexp *okey;

        if(parse_attrib(player, name, &thing, &atr)) {
                if(atr != NOTHING) {
                        if(!atr_get_info(thing, atr, &aowner, &aflags)) {
                                notify_quiet(player, "Attribute not present on object.");
                                return;
                        }
                        ap = atr_num(atr);

                        /*
                         * You may lock an attribute if: * you could write *
                         * * * the attribute if it were stored on * yourself
                         * * * * * --and-- * you own the attribute or are a * 
                         * wizard as  *  * * long as * you are not #1 and are 
                         * 
                         * * trying to do * * something to #1. 
                         */

                        if(ap && (God(player) || (!God(thing) &&
                                                                          (Set_attr(player, player, ap, 0)
                                                                           && (Wizard(player)
                                                                                   || aowner == Owner(player)))))) {
                                aflags |= AF_LOCK;
                                atr_set_flags(thing, atr, aflags);
                                if(!Quiet(player) && !Quiet(thing))
                                        notify_quiet(player, "Attribute locked.");
                        } else {
                                notify_quiet(player, "Permission denied.");
                        }
                        return;
                }
        }
        init_match(player, name, NOTYPE);
        match_everything(MAT_EXIT_PARENTS);
        thing = match_result();

        switch (thing) {
        case NOTHING:
                notify_quiet(player, "I don't see what you want to lock!");
                return;
        case AMBIGUOUS:
                notify_quiet(player, "I don't know which one you want to lock!");
                return;
        default:
                if(!controls(player, thing)) {
                        notify_quiet(player, "You can't lock that!");
                        return;
                }
        }

        okey = parse_boolexp(player, keytext, 0);
        if(okey == TRUE_BOOLEXP) {
                notify_quiet(player, "I don't understand that key.");
        } else {

                /*
                 * everything ok, do it 
                 */

                if(!key)
                        key = A_LOCK;
                atr_add_raw(thing, key, unparse_boolexp_quiet(player, okey));
                if(!Quiet(player) && !Quiet(thing))
                        notify_quiet(player, "Locked.");
        }
        free_boolexp(okey);
}

char* make_guest

(

DESC *

d

)

Definition at line 83 of file mguests.c.

References Connected, destroy_guest(), GOD, confdata::guest_prefix, lookup_player(), mudconf, name, NOTHING, confdata::number_guests, and queue_string().

Referenced by check_connect().

{
        int i;
        dbref player, p2;
        static char name[50];

        /*
         * Nuke extra guests as new guests connect. 
         */

        for(i = 0; i < mudconf.number_guests; i++) {
                sprintf(name, "%s%d", mudconf.guest_prefix, i + 1);
                p2 = lookup_player(GOD, name, 0);
                if(p2 != NOTHING && !Connected(p2))
                        destroy_guest(p2);
        }

        /*
         * Locate a free guest ID, and eat it. 
         */

        for(i = 0; i < mudconf.number_guests; i++) {
                sprintf(name, "%s%d", mudconf.guest_prefix, i + 1);
                player = lookup_player(GOD, name, 0);
                if(player == NOTHING)
                        break;
        }

        if(i == mudconf.number_guests) {
                queue_string(d,
                                         "GAME: All guest ID's are busy, please try again later.\n");
                return NULL;
        }
        sprintf(name, "%s%d", mudconf.guest_prefix, i + 1);
        player = create_guest(name, mudconf.guest_prefix);

        if(player == NOTHING) {
                queue_string(d,
                                         "GAME: Error creating guest ID, please try again later.\n");
                log_text(tprintf
                                 ("GUEST: Error creating guest ID. '%s' already exists.\n",
                                  name));
                return NULL;
        }
        return Name(player);
}

---