mux/src/flags.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "command.h"
#include "powers.h"

Include dependency graph for flags.cpp:

Go to the source code of this file.

Functions
static bool	fh_any (dbref target, dbref player, FLAG flag, int fflags, bool reset)
static bool	fh_god (dbref target, dbref player, FLAG flag, int fflags, bool reset)
static bool	fh_wiz (dbref target, dbref player, FLAG flag, int fflags, bool reset)
static bool	fh_wizroy (dbref target, dbref player, FLAG flag, int fflags, bool reset)
static bool	fh_restrict_player (dbref target, dbref player, FLAG flag, int fflags, bool reset)
static bool	fh_privileged (dbref target, dbref player, FLAG flag, int fflags, bool reset)
static bool	fh_inherit (dbref target, dbref player, FLAG flag, int fflags, bool reset)
static bool	fh_dark_bit (dbref target, dbref player, FLAG flag, int fflags, bool reset)
static bool	fh_going_bit (dbref target, dbref player, FLAG flag, int fflags, bool reset)
static bool	fh_hear_bit (dbref target, dbref player, FLAG flag, int fflags, bool reset)
static bool	fh_player_bit (dbref target, dbref player, FLAG flag, int fflags, bool reset)
static bool	fh_staff (dbref target, dbref player, FLAG flag, int fflags, bool reset)
void	init_flagtab (void)
void	display_flagtab (dbref player)
char *	MakeCanonicalFlagName (const char *pName, int *pnName, bool *pbValid)
static FLAGNAMEENT *	find_flag (char *flagname)
void	flag_set (dbref target, dbref player, char *flag, int key)
char *	decode_flags (dbref player, FLAGSET *fs)
bool	has_flag (dbref player, dbref it, char *flagname)
char *	flag_description (dbref player, dbref target)
char *	unparse_object_numonly (dbref target)
char *	unparse_object (dbref player, dbref target, bool obey_myopic)
	CF_HAND (cf_flag_access)
bool	convert_flags (dbref player, char *flaglist, FLAGSET *fset, FLAG *p_type)
void	decompile_flags (dbref player, dbref thing, char *thingname)
static bool	flag_rename (char *alias, char *newname)
void	do_flag (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *flag1, char *flag2)
	CF_HAND (cf_flag_name)
Variables
static FLAGBITENT	fbeAbode = { ABODE, 'A', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeAnsi = { ANSI, 'X', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeAudible = { HEARTHRU, 'a', FLAG_WORD1, 0, fh_hear_bit}
static FLAGBITENT	fbeAuditorium = { AUDITORIUM, 'b', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeBlind = { BLIND, 'B', FLAG_WORD2, 0, fh_wiz}
static FLAGBITENT	fbeChownOk = { CHOWN_OK, 'C', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeConnected = { CONNECTED, 'c', FLAG_WORD2, CA_NO_DECOMP, fh_god}
static FLAGBITENT	fbeDark = { DARK, 'D', FLAG_WORD1, 0, fh_dark_bit}
static FLAGBITENT	fbeDestroyOk = { DESTROY_OK, 'd', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeEnterOk = { ENTER_OK, 'e', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeFixed = { FIXED, 'f', FLAG_WORD2, 0, fh_restrict_player}
static FLAGBITENT	fbeFloating = { FLOATING, 'F', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeGagged = { GAGGED, 'j', FLAG_WORD2, 0, fh_wiz}
static FLAGBITENT	fbeGoing = { GOING, 'G', FLAG_WORD1, CA_NO_DECOMP, fh_going_bit}
static FLAGBITENT	fbeHalted = { HALT, 'h', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeHasDaily = { HAS_DAILY, '*', FLAG_WORD2, CA_GOD|CA_NO_DECOMP, fh_god}
static FLAGBITENT	fbeHasForwardList = { HAS_FWDLIST, '&', FLAG_WORD2, CA_GOD|CA_NO_DECOMP, fh_god}
static FLAGBITENT	fbeHasListen = { HAS_LISTEN, '@', FLAG_WORD2, CA_GOD|CA_NO_DECOMP, fh_god}
static FLAGBITENT	fbeHasStartup = { HAS_STARTUP, '+', FLAG_WORD1, CA_GOD|CA_NO_DECOMP, fh_god}
static FLAGBITENT	fbeHaven = { HAVEN, 'H', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeHead = { HEAD_FLAG, '?', FLAG_WORD2, 0, fh_wiz}
static FLAGBITENT	fbeHtml = { HTML, '(', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeImmortal = { IMMORTAL, 'i', FLAG_WORD1, 0, fh_wiz}
static FLAGBITENT	fbeInherit = { INHERIT, 'I', FLAG_WORD1, 0, fh_inherit}
static FLAGBITENT	fbeJumpOk = { JUMP_OK, 'J', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeKeepAlive = { CKEEPALIVE, 'k', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeKey = { KEY, 'K', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeLight = { LIGHT, 'l', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeLinkOk = { LINK_OK, 'L', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeMonitor = { MONITOR, 'M', FLAG_WORD1, 0, fh_hear_bit}
static FLAGBITENT	fbeMyopic = { MYOPIC, 'm', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeNoCommand = { NO_COMMAND, 'n', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeNoAccents = { NOACCENTS, '~', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeNoBleed = { NOBLEED, '-', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeNoSpoof = { NOSPOOF, 'N', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeOpaque = { TM_OPAQUE, 'O', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeOpenOk = { OPEN_OK, 'z', FLAG_WORD2, 0, fh_wiz}
static FLAGBITENT	fbeParentOk = { PARENT_OK, 'Y', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbePlayerMails = { PLAYER_MAILS, ' ', FLAG_WORD2, CA_GOD|CA_NO_DECOMP, fh_god}
static FLAGBITENT	fbePuppet = { PUPPET, 'p', FLAG_WORD1, 0, fh_hear_bit}
static FLAGBITENT	fbeQuiet = { QUIET, 'Q', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeRobot = { ROBOT, 'r', FLAG_WORD1, 0, fh_player_bit}
static FLAGBITENT	fbeRoyalty = { ROYALTY, 'Z', FLAG_WORD1, 0, fh_wiz}
static FLAGBITENT	fbeSafe = { SAFE, 's', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeSlave = { SLAVE, 'x', FLAG_WORD2, CA_WIZARD, fh_wiz}
static FLAGBITENT	fbeStaff = { STAFF, 'w', FLAG_WORD2, 0, fh_wiz}
static FLAGBITENT	fbeSticky = { STICKY, 'S', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeSuspect = { SUSPECT, 'u', FLAG_WORD2, CA_WIZARD, fh_wiz}
static FLAGBITENT	fbeTerse = { TERSE, 'q', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeTrace = { TRACE, 'T', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeTransparent = { SEETHRU, 't', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeUnfindable = { UNFINDABLE, 'U', FLAG_WORD2, 0, fh_any}
static FLAGBITENT	fbeUninspected = { UNINSPECTED, 'g', FLAG_WORD2, 0, fh_wizroy}
static FLAGBITENT	fbeVacation = { VACATION, '|', FLAG_WORD2, 0, fh_restrict_player}
static FLAGBITENT	fbeVerbose = { VERBOSE, 'v', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeVisual = { VISUAL, 'V', FLAG_WORD1, 0, fh_any}
static FLAGBITENT	fbeWizard = { WIZARD, 'W', FLAG_WORD1, 0, fh_god}
static FLAGBITENT	fbeSitemon = { SITEMON, '$', FLAG_WORD3, 0, fh_wiz}
static FLAGBITENT	fbeMarker0 = { MARK_0, '0', FLAG_WORD3, 0, fh_god}
static FLAGBITENT	fbeMarker1 = { MARK_1, '1', FLAG_WORD3, 0, fh_god}
static FLAGBITENT	fbeMarker2 = { MARK_2, '2', FLAG_WORD3, 0, fh_god}
static FLAGBITENT	fbeMarker3 = { MARK_3, '3', FLAG_WORD3, 0, fh_god}
static FLAGBITENT	fbeMarker4 = { MARK_4, '4', FLAG_WORD3, 0, fh_god}
static FLAGBITENT	fbeMarker5 = { MARK_5, '5', FLAG_WORD3, 0, fh_god}
static FLAGBITENT	fbeMarker6 = { MARK_6, '6', FLAG_WORD3, 0, fh_god}
static FLAGBITENT	fbeMarker7 = { MARK_7, '7', FLAG_WORD3, 0, fh_god}
static FLAGBITENT	fbeMarker8 = { MARK_8, '8', FLAG_WORD3, 0, fh_god}
static FLAGBITENT	fbeMarker9 = { MARK_9, '9', FLAG_WORD3, 0, fh_god}
FLAGNAMEENT	gen_flag_names []
OBJENT	object_types [8]

---

Function Documentation

CF_HAND

(

cf_flag_name

)

Definition at line 1259 of file flags.cpp.

References flag_rename(), mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(vp);
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);
    UNUSED_PARAMETER(player);
    UNUSED_PARAMETER(cmd);

    MUX_STRTOK_STATE tts;
    mux_strtok_src(&tts, str);
    mux_strtok_ctl(&tts, " \t=,");
    char *flagstr = mux_strtok_parse(&tts);
    char *namestr = mux_strtok_parse(&tts);

    if (  !flagstr
       || !*flagstr
       || !namestr
       || !*namestr)
    {
        return -1;
    }

    if (flag_rename(flagstr, namestr))
    {
        return 0;
    }
    else
    {
        return -1;
    }
}

CF_HAND

(

cf_flag_access

)

Definition at line 943 of file flags.cpp.

References cf_log_notfound(), ENDLOG, flag_name_entry::fbe, fh_any(), fh_god(), fh_privileged(), fh_restrict_player(), fh_staff(), fh_wiz(), fh_wizroy(), find_flag(), flag_name_entry::flagname, flag_bit_entry::handler, LOG_CONFIGMODS, log_text(), mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), STARTLOG, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(vp);
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);

    MUX_STRTOK_STATE tts;
    mux_strtok_src(&tts, str);
    mux_strtok_ctl(&tts, " \t=,");
    char *fstr = mux_strtok_parse(&tts);
    char *permstr = mux_strtok_parse(&tts);

    if (!fstr || !*fstr)
    {
        return -1;
    }

    FLAGNAMEENT *fp;
    if ((fp = find_flag(fstr)) == NULL)
    {
        cf_log_notfound(player, cmd, "No such flag", fstr);
        return -1;
    }
    FLAGBITENT *fbe = fp->fbe;

    // Don't change the handlers on special things.
    //
    if (  (fbe->handler != fh_any)
       && (fbe->handler != fh_wizroy)
       && (fbe->handler != fh_wiz)
       && (fbe->handler != fh_god)
       && (fbe->handler != fh_restrict_player)
       && (fbe->handler != fh_privileged))
    {
        STARTLOG(LOG_CONFIGMODS, "CFG", "PERM");
        log_text("Cannot change access for flag: ");
        log_text(fp->flagname);
        ENDLOG;
        return -1;
    }

    if (!strcmp(permstr, "any"))
    {
        fbe->handler = fh_any;
    }
    else if (!strcmp(permstr, "royalty"))
    {
        fbe->handler = fh_wizroy;
    }
    else if (!strcmp(permstr, "wizard"))
    {
        fbe->handler = fh_wiz;
    }
    else if (!strcmp(permstr, "god"))
    {
        fbe->handler = fh_god;
    }
    else if (!strcmp(permstr, "restrict_player"))
    {
        fbe->handler = fh_restrict_player;
    }
    else if (!strcmp(permstr, "privileged"))
    {
        fbe->handler = fh_privileged;
    }
    else if (!strcmp(permstr, "staff"))
    {
        fbe->handler = fh_staff;
    }
    else
    {
        cf_log_notfound(player, cmd, "Flag access", permstr);
        return -1;
    }
    return 0;
}

bool convert_flags	(	dbref	player,
		char *	flaglist,
		FLAGSET *	fset,
		FLAG *	p_type
	)

Definition at line 1026 of file flags.cpp.

References flag_name_entry::bPositive, CA_ADMIN, CA_GOD, CA_STAFF, CA_WIZARD, flag_name_entry::fbe, FLAG_WORD1, FLAG_WORD2, FLAG_WORD3, flag_name_entry::flagname, gen_flag_names, God, notify, NOTYPE, object_types, Staff, tprintf(), Wizard, WizRoy, and flagset::word.

Referenced by handle_flaglists(), and search_setup().

{
    FLAG type = NOTYPE;
    FLAGSET flagmask;
    flagmask.word[FLAG_WORD1] = 0;
    flagmask.word[FLAG_WORD2] = 0;
    flagmask.word[FLAG_WORD3] = 0;
    int i;

    char *s;
    bool handled;
    for (s = flaglist; *s; s++)
    {
        handled = false;

        // Check for object type.
        //
        for (i = 0; i <= 7 && !handled; i++)
        {
            if (  object_types[i].lett == *s
               && !(  (  (object_types[i].perm & CA_STAFF)
                      && !Staff(player))
                   || (  (object_types[i].perm & CA_ADMIN)
                      && !WizRoy(player))
                   || (  (object_types[i].perm & CA_WIZARD)
                      && !Wizard(player))
                   || (  (object_types[i].perm & CA_GOD)
                      && !God(player))))
            {
                if (  type != NOTYPE
                   && type != i)
                {
                    char *p = tprintf("%c: Conflicting type specifications.",
                        *s);
                    notify(player, p);
                    return false;
                }
                type = i;
                handled = true;
            }
        }

        // Check generic flags.
        //
        if (handled)
        {
            continue;
        }
        FLAGNAMEENT *fp;
        for (fp = gen_flag_names; fp->flagname && !handled; fp++)
        {
            FLAGBITENT *fbe = fp->fbe;
            if (  !fp->bPositive
               || fbe->flaglett == ' ')
            {
                continue;
            }
            if (  fbe->flaglett == *s
               && !(  (  (fbe->listperm & CA_STAFF)
                      && !Staff(player))
                   || (  (fbe->listperm & CA_ADMIN)
                      && !WizRoy(player))
                   || (  (fbe->listperm & CA_WIZARD)
                      && !Wizard(player))
                   || (  (fbe->listperm & CA_GOD)
                      && !God(player))))
            {
                flagmask.word[fbe->flagflag] |= fbe->flagvalue;
                handled = true;
            }
        }

        if (!handled)
        {
            notify(player,
                   tprintf("%c: Flag unknown or not valid for specified object type",
                       *s));
            return false;
        }
    }

    // Return flags to search for and type.
    //
    *fset = flagmask;
    *p_type = type;
    return true;
}

char* decode_flags	(	dbref	player,
		FLAGSET *	fs
	)

Definition at line 661 of file flags.cpp.

References alloc_sbuf, flag_name_entry::bPositive, CA_ADMIN, CA_GOD, CA_STAFF, CA_WIZARD, CONNECTED, DARK, flag_name_entry::fbe, FLAG_WORD1, FLAG_WORD2, flag_name_entry::flagname, gen_flag_names, God, Good_obj, mux_isdigit, object_types, safe_sb_chr, See_Hidden, Staff, TYPE_MASK, TYPE_PLAYER, Wizard, WIZARD, WizRoy, and flagset::word.

Referenced by FUNCTION(), list_df_flags(), shutdownsock(), and unparse_object().

{
    char *buf, *bp;
    buf = bp = alloc_sbuf("decode_flags");
    *bp = '\0';

    if (!Good_obj(player))
    {
        strcpy(buf, "#-2 ERROR");
        return buf;
    }
    int flagtype = fs->word[FLAG_WORD1] & TYPE_MASK;
    bool bNeedColon = true;
    if (object_types[flagtype].lett != ' ')
    {
        safe_sb_chr(object_types[flagtype].lett, buf, &bp);
        bNeedColon = false;
    }

    FLAGNAMEENT *fp;
    for (fp = gen_flag_names; fp->flagname; fp++)
    {
        FLAGBITENT *fbe = fp->fbe;
        if (  !fp->bPositive
           || fbe->flaglett == ' ')
        {
            // Only look at positive-sense entries that have non-space flag
            // letters.
            //
            continue;
        }
        if (fs->word[fbe->flagflag] & fbe->flagvalue)
        {
            if (  (  (fbe->listperm & CA_STAFF)
                  && !Staff(player))
               || (  (fbe->listperm & CA_ADMIN)
                  && !WizRoy(player))
               || (  (fbe->listperm & CA_WIZARD)
                  && !Wizard(player))
               || (  (fbe->listperm & CA_GOD)
                  && !God(player)))
            {
                continue;
            }

            // Don't show CONNECT on dark wizards to mortals
            //
            if (  flagtype == TYPE_PLAYER
               && fbe->flagflag == FLAG_WORD2
               && fbe->flagvalue == CONNECTED
               && (fs->word[FLAG_WORD1] & (WIZARD | DARK)) == (WIZARD | DARK)
               && !See_Hidden(player))
            {
                continue;
            }

            if (  bNeedColon
               && mux_isdigit(fbe->flaglett))
            {
                // We can't allow numerical digits at the beginning.
                //
                safe_sb_chr(':', buf, &bp);
            }
            safe_sb_chr(fbe->flaglett, buf, &bp);
            bNeedColon = false;
        }
    }
    *bp = '\0';
    return buf;
}

void decompile_flags	(	dbref	player,
		dbref	thing,
		char *	thingname
	)

Definition at line 1119 of file flags.cpp.

References flag_name_entry::bPositive, CA_NO_DECOMP, check_access(), db, flag_name_entry::fbe, flag_name_entry::flagname, object::fs, gen_flag_names, notify, strip_ansi(), tprintf(), and flagset::word.

{
    // Report generic flags.
    //
    FLAGNAMEENT *fp;
    for (fp = gen_flag_names; fp->flagname; fp++)
    {
        FLAGBITENT *fbe = fp->fbe;

        // Only handle positive-sense entries.
        // Skip if we shouldn't decompile this flag.
        // Skip if this flag isn't set.
        // Skip if we can't see this flag.
        //
        if (  !fp->bPositive
           || (fbe->listperm & CA_NO_DECOMP)
           || (db[thing].fs.word[fbe->flagflag] & fbe->flagvalue) == 0
           || !check_access(player, fbe->listperm))
        {
            continue;
        }

        // Report this flag.
        //
        notify(player, tprintf("@set %s=%s", strip_ansi(thingname),
            fp->flagname));
    }
}

void display_flagtab

(

dbref

player

)

Definition at line 483 of file flags.cpp.

References alloc_lbuf, flag_name_entry::bPositive, CA_GOD, CA_WIZARD, flag_name_entry::fbe, flag_name_entry::flagname, free_lbuf, gen_flag_names, God, notify, safe_chr, safe_str, and Wizard.

Referenced by do_list().

{
    char *buf, *bp;
    FLAGNAMEENT *fp;

    bp = buf = alloc_lbuf("display_flagtab");
    safe_str("Flags:", buf, &bp);
    for (fp = gen_flag_names; fp->flagname; fp++)
    {
        FLAGBITENT *fbe = fp->fbe;
        if (  (  (fbe->listperm & CA_WIZARD)
              && !Wizard(player))
           || (  (fbe->listperm & CA_GOD)
              && !God(player)))
        {
            continue;
        }
        safe_chr(' ', buf, &bp);
        safe_str(fp->flagname, buf, &bp);
        if (fbe->flaglett != ' ')
        {
            safe_chr('(', buf, &bp);
            if (!fp->bPositive)
            {
                safe_chr('!', buf, &bp);
            }
            safe_chr(fbe->flaglett, buf, &bp);
            safe_chr(')', buf, &bp);
        }
    }
    *bp = '\0';
    notify(player, buf);
    free_lbuf(buf);
}

void do_flag	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	flag1,
		char *	flag2
	)

Definition at line 1201 of file flags.cpp.

References FLAG_REMOVE, flag_rename(), flag_name_entry::flagname, statedata::flags_htab, hashdeleteLEN(), hashfindLEN(), MakeCanonicalFlagName(), MEMFREE, mudstate, mux_stricmp(), notify, flag_name_entry::pOrigName, tprintf(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    if (key & FLAG_REMOVE)
    {
        if (nargs == 2)
        {
            notify(executor, "Extra argument ignored.");
        }
        int nAlias;
        bool bValidAlias;
        char *pCheckedAlias = MakeCanonicalFlagName(flag1, &nAlias, &bValidAlias);
        if (bValidAlias)
        {
            FLAGNAMEENT *lookup;
            lookup = (FLAGNAMEENT *)hashfindLEN(pCheckedAlias, nAlias, &mudstate.flags_htab);
            if (lookup)
            {
                if (  lookup->flagname != lookup->pOrigName
                   && mux_stricmp(lookup->flagname, pCheckedAlias) == 0)
                {
                    MEMFREE(lookup->flagname);
                    lookup->flagname = lookup->pOrigName;
                    hashdeleteLEN(pCheckedAlias, nAlias, &mudstate.flags_htab);
                    notify(executor, tprintf("Flag name '%s' removed from the hash table.", pCheckedAlias));
                }
                else
                {
                    notify(executor, "Error: You can't remove the present flag name from the hash table.");
                }
            }
        }
    }
    else
    {
        if (nargs < 2)
        {
            notify(executor, "You must specify a flag and a name.");
            return;
        }
        if (flag_rename(flag1, flag2))
        {
            notify(executor, "Flag name changed.");
        }
        else
        {
            notify(executor, "Error: Bad flagname given or flag not found.");
        }
    }
}

static bool fh_any	(	dbref	target,
		dbref	player,
		FLAG	flag,
		int	fflags,
		bool	reset
	)			[static]

Definition at line 18 of file flags.cpp.

References db, FLAG_WORD1, object::fs, God, notify, WIZARD, and flagset::word.

Referenced by CF_HAND(), fh_dark_bit(), fh_god(), fh_going_bit(), fh_hear_bit(), fh_inherit(), fh_player_bit(), fh_privileged(), fh_restrict_player(), fh_staff(), fh_wiz(), and fh_wizroy().

{
    // Never let God drop his/her own wizbit.
    //
    if (  God(target)
       && reset
       && flag == WIZARD
       && fflags == FLAG_WORD1)
    {
        notify(player, "You cannot make God mortal.");
        return false;
    }

    // Otherwise we can go do it.
    //
    if (reset)
    {
        db[target].fs.word[fflags] &= ~flag;
    }
    else
    {
        db[target].fs.word[fflags] |= flag;
    }
    return true;
}

static bool fh_dark_bit	(	dbref	target,
		dbref	player,
		FLAG	flag,
		int	fflags,
		bool	reset
	)			[static]

Definition at line 154 of file flags.cpp.

References Can_Hide, fh_any(), isPlayer, and Wizard.

{
    if (  !reset
       && isPlayer(target)
       && !(  (target == player)
           && Can_Hide(player))
       && !Wizard(player))
    {
        return false;
    }
    return (fh_any(target, player, flag, fflags, reset));
}

static bool fh_god	(	dbref	target,
		dbref	player,
		FLAG	flag,
		int	fflags,
		bool	reset
	)			[static]

Definition at line 48 of file flags.cpp.

References fh_any(), and God.

Referenced by CF_HAND().

{
    if (!God(player))
    {
        return false;
    }
    return (fh_any(target, player, flag, fflags, reset));
}

static bool fh_going_bit	(	dbref	target,
		dbref	player,
		FLAG	flag,
		int	fflags,
		bool	reset
	)			[static]

Definition at line 172 of file flags.cpp.

References confdata::default_home, fh_any(), God, Going, confdata::master_room, mudconf, notify, confdata::start_home, confdata::start_room, TYPE_GARBAGE, and Typeof.

{
    if (  Going(target)
       && reset
       && (Typeof(target) != TYPE_GARBAGE))
    {
        notify(player, "Your object has been spared from destruction.");
        return (fh_any(target, player, flag, fflags, reset));
    }
    if (!God(player))
    {
        return false;
    }

    // Even God should not be allowed set protected dbrefs GOING.
    //
    if (  !reset
       && (  target == 0
          || God(target)
          || target == mudconf.start_home
          || target == mudconf.start_room
          || target == mudconf.default_home
          || target == mudconf.master_room))
    {
        return false;
    }
    return (fh_any(target, player, flag, fflags, reset));
}

static bool fh_hear_bit	(	dbref	target,
		dbref	player,
		FLAG	flag,
		int	fflags,
		bool	reset
	)			[static]

Definition at line 206 of file flags.cpp.

References Can_Monitor, fh_any(), handle_ears(), Hearer(), isPlayer, and MONITOR.

{
    if (isPlayer(target) && (flag & MONITOR))
    {
        if (Can_Monitor(player))
        {
            return (fh_any(target, player, flag, fflags, reset));
        }
        else
        {
            return false;
        }
    }

    bool could_hear = Hearer(target);
    bool result = fh_any(target, player, flag, fflags, reset);
    handle_ears(target, could_hear, Hearer(target));
    return result;
}

static bool fh_inherit	(	dbref	target,
		dbref	player,
		FLAG	flag,
		int	fflags,
		bool	reset
	)			[static]

Definition at line 140 of file flags.cpp.

References fh_any(), and Inherits.

{
    if (!Inherits(player))
    {
        return false;
    }
    return (fh_any(target, player, flag, fflags, reset));
}

static bool fh_player_bit	(	dbref	target,
		dbref	player,
		FLAG	flag,
		int	fflags,
		bool	reset
	)			[static]

Definition at line 231 of file flags.cpp.

References fh_any(), and isPlayer.

{
    if (isPlayer(target))
    {
        return false;
    }
    return (fh_any(target, player, flag, fflags, reset));
}

static bool fh_privileged	(	dbref	target,
		dbref	player,
		FLAG	flag,
		int	fflags,
		bool	reset
	)			[static]

Definition at line 114 of file flags.cpp.

References db, fh_any(), God, isPlayer, and Owner.

Referenced by CF_HAND().

{
    if (!God(player))
    {
        if (  !isPlayer(player)
           || player != Owner(player)
           || isPlayer(target)
           || (db[player].fs.word[fflags] & flag) == 0)
        {
            return false;
        }
    }
    return (fh_any(target, player, flag, fflags, reset));
}

static bool fh_restrict_player	(	dbref	target,
		dbref	player,
		FLAG	flag,
		int	fflags,
		bool	reset
	)			[static]

Definition at line 92 of file flags.cpp.

References fh_any(), isPlayer, and Wizard.

Referenced by CF_HAND().

{
    if (  isPlayer(target)
       && !Wizard(player))
    {
        return false;
    }
    return (fh_any(target, player, flag, fflags, reset));
}

static bool fh_staff	(	dbref	target,
		dbref	player,
		FLAG	flag,
		int	fflags,
		bool	reset
	)			[static]

Definition at line 251 of file flags.cpp.

References fh_any(), God, and Staff.

Referenced by CF_HAND().

{
    if (!Staff(player) && !God(player))
    {
        return false;
    }
    return (fh_any(target, player, flag, fflags, reset));
}