mux/src/powers.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 powers.cpp:

Go to the source code of this file.

Functions
static bool	ph_any (dbref target, dbref player, POWER power, int fpowers, bool reset)
static bool	ph_god (dbref target, dbref player, POWER power, int fpowers, bool reset)
static bool	ph_wiz (dbref target, dbref player, POWER power, int fpowers, bool reset)
void	init_powertab (void)
void	display_powertab (dbref player)
static POWERENT *	find_power (dbref thing, char *powername)
bool	decode_power (dbref player, char *powername, POWERSET *pset)
void	power_set (dbref target, dbref player, char *power, int key)
bool	has_power (dbref player, dbref it, char *powername)
char *	powers_list (dbref player, dbref target)
void	decompile_powers (dbref player, dbref thing, char *thingname)
Variables
static POWERENT	gen_powers []

---

Function Documentation

bool decode_power	(	dbref	player,
		char *	powername,
		POWERSET *	pset
	)

Definition at line 208 of file powers.cpp.

References hashfindLEN(), mudstate, notify, POWER_EXT, power_entry::powerpower, statedata::powers_htab, power_entry::powervalue, tprintf(), powerset::word1, and powerset::word2.

{
    pset->word1 = 0;
    pset->word2 = 0;

    POWERENT *pent = (POWERENT *)hashfindLEN(powername, strlen(powername), &mudstate.powers_htab);
    if (!pent)
    {
        notify(player, tprintf("%s: Power not found.", powername));
        return false;
    }
    if (pent->powerpower & POWER_EXT)
    {
        pset->word2 = pent->powervalue;
    }
    else
    {
        pset->word1 = pent->powervalue;
    }
    return true;
}

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

Definition at line 386 of file powers.cpp.

References CA_NO_DECOMP, gen_powers, power_entry::listperm, POWER_EXT, power_entry::powername, power_entry::powerpower, Powers, Powers2, and power_entry::powervalue.

{
    POWERENT *fp;

    // Report generic powers.
    //
    POWER f1 = Powers(thing);
    POWER f2 = Powers2(thing);

    for (fp = gen_powers; fp->powername; fp++)
    {
        // Skip if we shouldn't decompile this power
        //
        if (fp->listperm & CA_NO_DECOMP)
        {
            continue;
        }

        // Skip if this power is not set.
        //
        if (fp->powerpower & POWER_EXT)
        {
            if (!(f2 & fp->powervalue))
            {
                continue;
            }
        }
        else
        {
            if (!(f1 & fp->powervalue))
            {
                continue;
            }
        }

        // Skip if we can't see this power.
        //
        if (!check_access(player, fp->listperm))
        {
            continue;
        }

        // We made it this far, report this power.
        //
        notify(player, tprintf("@power %s=%s", strip_ansi(thingname), fp->powername));
    }
}

void display_powertab

(

dbref

player

)

Definition at line 168 of file powers.cpp.

References alloc_lbuf, CA_GOD, CA_WIZARD, free_lbuf, gen_powers, God, power_entry::listperm, notify, power_entry::powername, safe_chr, safe_str, and Wizard.

Referenced by do_list().

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

    bp = buf = alloc_lbuf("display_powertab");
    safe_str("Powers:", buf, &bp);
    for (fp = gen_powers; fp->powername; fp++)
    {
        if ((fp->listperm & CA_WIZARD) && !Wizard(player))
        {
            continue;
        }
        if ((fp->listperm & CA_GOD) && !God(player))
        {
            continue;
        }
        safe_chr(' ', buf, &bp);
        safe_str(fp->powername, buf, &bp);
    }
    *bp = '\0';
    notify(player, buf);
    free_lbuf(buf);
}

static POWERENT* find_power	(	dbref	thing,
		char *	powername
	)			[static]

Definition at line 193 of file powers.cpp.

References alloc_sbuf, free_sbuf, hashfindLEN(), mudstate, mux_strlwr(), statedata::powers_htab, SBUF_SIZE, and UNUSED_PARAMETER.

Referenced by has_power(), and power_set().

{
    UNUSED_PARAMETER(thing);

    // Convert powername to canonical lowercase.
    //
    char *buff = alloc_sbuf("find_power");
    strncpy(buff, powername, SBUF_SIZE);
    buff[SBUF_SIZE-1] = '\0';
    mux_strlwr(buff);
    POWERENT *p = (POWERENT *)hashfindLEN(buff, strlen(buff), &mudstate.powers_htab);
    free_sbuf(buff);
    return p;
}

bool has_power	(	dbref	player,
		dbref	it,
		char *	powername
	)

Definition at line 293 of file powers.cpp.

References CA_GOD, CA_WIZARD, find_power(), God, power_entry::listperm, POWER_EXT, power_entry::powerpower, Powers, Powers2, power_entry::powervalue, and Wizard.

Referenced by FUNCTION().

{
    POWERENT *fp = find_power(it, powername);
    if (!fp)
    {
        return false;
    }

    POWER fv;
    if (fp->powerpower & POWER_EXT)
    {
        fv = Powers2(it);
    }
    else
    {
        fv = Powers(it);
    }

    if (fv & fp->powervalue)
    {
        if ((fp->listperm & CA_WIZARD) && !Wizard(player))
        {
            return false;
        }
        if ((fp->listperm & CA_GOD) && !God(player))
        {
            return false;
        }
        return true;
    }
    return false;
}

void init_powertab

(

void

)

Definition at line 145 of file powers.cpp.

References alloc_sbuf, gen_powers, hashaddLEN(), hashfindLEN(), mudstate, mux_strlwr(), power_entry::powername, statedata::powers_htab, and SBUF_SIZE.

Referenced by main().

{
    POWERENT *fp;
    char *nbuf = alloc_sbuf("init_powertab");

    for (fp = gen_powers; fp->powername; fp++)
    {
        strncpy(nbuf, fp->powername, SBUF_SIZE);
        nbuf[SBUF_SIZE-1] = '\0';
        mux_strlwr(nbuf);

        if (!hashfindLEN(nbuf, strlen(nbuf), &mudstate.powers_htab))
        {
            hashaddLEN(nbuf, strlen(nbuf), fp, &mudstate.powers_htab);
        }
    }
    free_sbuf(nbuf);
}

static bool ph_any	(	dbref	target,
		dbref	player,
		POWER	power,
		int	fpowers,
		bool	reset
	)			[static]

Definition at line 18 of file powers.cpp.

References POWER_EXT, Powers, Powers2, s_Powers, s_Powers2, and UNUSED_PARAMETER.

Referenced by ph_god(), and ph_wiz().

{
    UNUSED_PARAMETER(player);

    if (fpowers & POWER_EXT)
    {
        if (reset)
        {
            s_Powers2(target, Powers2(target) & ~power);
        }
        else
        {
            s_Powers2(target, Powers2(target) | power);
        }
    }
    else
    {
        if (reset)
        {
            s_Powers(target, Powers(target) & ~power);
        }
        else
        {
            s_Powers(target, Powers(target) | power);
        }
    }
    return true;
}

static bool ph_god	(	dbref	target,
		dbref	player,
		POWER	power,
		int	fpowers,
		bool	reset
	)			[static]

Definition at line 51 of file powers.cpp.

References God, and ph_any().

{
    if (!God(player))
    {
        return false;
    }
    return (ph_any(target, player, power, fpowers, reset));
}

static bool ph_wiz	(	dbref	target,
		dbref	player,
		POWER	power,
		int	fpowers,
		bool	reset
	)			[static]

Definition at line 64 of file powers.cpp.

References ph_any(), and Wizard.

{
    if (!Wizard(player))
    {
        return false;
    }
    return (ph_any(target, player, power, fpowers, reset));
}

void power_set	(	dbref	target,
		dbref	player,
		char *	power,
		int	key
	)

Definition at line 234 of file powers.cpp.

References find_power(), power_entry::handler, mux_isspace, NOPERM_MESSAGE, notify, power_entry::powerpower, power_entry::powervalue, Quiet, and SET_QUIET.

Referenced by do_power().

{
    // Trim spaces, and handle the negation character.
    //
    while (mux_isspace(*power))
    {
        power++;
    }

    bool negate = false;
    if (*power == '!')
    {
        negate = true;
        power++;
    }
    while (mux_isspace(*power))
    {
        power++;
    }

    // Make sure a power name was specified.
    //
    if (*power == '\0')
    {
        if (negate)
        {
            notify(player, "You must specify a power to clear.");
        }
        else
        {
            notify(player, "You must specify a power to set.");
        }
        return;
    }
    POWERENT *fp = find_power(target, power);
    if (fp == NULL)
    {
        notify(player, "I don't understand that power.");
        return;
    }

    // Invoke the power handler, and print feedback.
    //
    bool result = fp->handler(target, player, fp->powervalue,
                 fp->powerpower, negate);
    if (!result)
    {
        notify(player, NOPERM_MESSAGE);
    }
    else if (!(key & SET_QUIET) && !Quiet(player))
    {
        notify(player, (negate ? "Cleared." : "Set."));
    }
}

char* powers_list	(	dbref	player,
		dbref	target
	)

Definition at line 330 of file powers.cpp.

References alloc_lbuf, CA_GOD, CA_WIZARD, gen_powers, God, power_entry::listperm, POWER_EXT, power_entry::powername, power_entry::powerpower, Powers, Powers2, power_entry::powervalue, safe_chr, safe_str, and Wizard.

Referenced by debug_examine(), do_examine(), and FUNCTION().

{
    // Allocate the return buffer.
    //
    char *buff = alloc_lbuf("powers_list");
    char *bp = buff;

    bool bFirst = true;
    POWERENT *fp;
    for (fp = gen_powers; fp->powername; fp++)
    {
        POWER fv;
        if (fp->powerpower & POWER_EXT)
        {
            fv = Powers2(target);
        }
        else
        {
            fv = Powers(target);
        }

        if (fv & fp->powervalue)
        {
            if (  (fp->listperm & CA_WIZARD)
               && !Wizard(player))
            {
                continue;
            }
            if (  (fp->listperm & CA_GOD)
               && !God(player))
            {
                continue;
            }
            if (bFirst)
            {
                bFirst = false;
            }
            else
            {
                safe_chr(' ', buff, &bp);
            }
            safe_str(fp->powername, buff, &bp);
        }
    }

    // Terminate the string, and return the buffer to the caller.
    //
    *bp = '\0';
    return buff;
}

---

Variable Documentation

POWERENT gen_powers[] [static]

Definition at line 102 of file powers.cpp.

Referenced by decompile_powers(), display_powertab(), init_powertab(), and powers_list().

---