src/powers.c File Reference

#include "copyright.h"
#include "config.h"
#include "db.h"
#include "mudconf.h"
#include "externs.h"
#include "command.h"
#include "powers.h"
#include "alloc.h"

Include dependency graph for powers.c:

Go to the source code of this file.

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

---

Function Documentation

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

Definition at line 171 of file powers.c.

References hashfind(), mudstate, notify_printf(), POWER_EXT, power_entry::powerpower, statedata::powers_htab, power_entry::powervalue, powerset::word1, and powerset::word2.

Referenced by search_setup().

{
        POWERENT *pent;

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

        pent = (POWERENT *) hashfind(powername, &mudstate.powers_htab);
        if(!pent) {
                notify_printf(player, "%s: Power not found.", powername);
                return 0;
        }
        if(pent->powerpower & POWER_EXT)
                pset->word2 = pent->powervalue;
        else
                pset->word1 = pent->powervalue;

        return 1;
}

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

Produce commands to set powers on target.

Definition at line 319 of file powers.c.

References CA_NO_DECOMP, check_access(), gen_powers, LBUF_SIZE, power_entry::listperm, notify_printf(), POWER_EXT, power_entry::powername, power_entry::powerpower, Powers, Powers2, power_entry::powervalue, and strip_ansi_r().

{
        POWER f1, f2;
        POWERENT *fp;
        char new[LBUF_SIZE];

        /*
         * Report generic powers 
         */

        f1 = Powers(thing);
        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 
                 */
                strncpy(new, thingname, LBUF_SIZE-1);
                notify_printf(player, "@power %s=%s", strip_ansi_r(new,thingname,strlen(thingname)),
                                          fp->powername);
        }
}

void display_powertab

(

dbref

player

)

Display available powers.

Definition at line 138 of file powers.c.

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((char *) "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((char *) fp->powername, buf, &bp);
        }
        *bp = '\0';
        notify(player, buf);
        free_lbuf(buf);
}

POWERENT* find_power	(	dbref	thing,
		char *	powername
	)

Definition at line 158 of file powers.c.

References hashfind(), mudstate, statedata::powers_htab, and ToLower.

Referenced by has_power(), and power_set().

{
        char *cp;

        /*
         * Make sure the power name is valid 
         */

        for(cp = powername; *cp; cp++)
                *cp = ToLower(*cp);
        return (POWERENT *) hashfind(powername, &mudstate.powers_htab);
}

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

Does object have power visible to player?

Definition at line 246 of file powers.c.

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 fun_haspower().

{
        POWERENT *fp;
        POWER fv;

        fp = find_power(it, powername);
        if(fp == NULL)
                return 0;

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

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

void init_powertab

(

void

)

Initialize power hash tables.

Definition at line 119 of file powers.c.

References alloc_sbuf, free_sbuf, gen_powers, HASH_FACTOR, hashadd(), hashinit(), mudstate, power_entry::powername, statedata::powers_htab, and ToLower.

Referenced by main().

{
        POWERENT *fp;
        char *nbuf, *np, *bp;

        hashinit(&mudstate.powers_htab, 15 * HASH_FACTOR);
        nbuf = alloc_sbuf("init_powertab");
        for(fp = gen_powers; fp->powername; fp++) {
                for(np = nbuf, bp = (char *) fp->powername; *bp; np++, bp++)
                        *np = ToLower(*bp);
                *np = '\0';
                hashadd(nbuf, (int *) fp, &mudstate.powers_htab);
        }
        free_sbuf(nbuf);
}

int ph_any	(	dbref	target,
		dbref	player,
		POWER	power,
		int	fpowers,
		int	reset
	)

set or clear indicated bit, no security checking

Definition at line 18 of file powers.c.

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

Referenced by ph_god(), ph_inherit(), ph_wiz(), and ph_wizroy().

{
        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 1;
}

int ph_god	(	dbref	target,
		dbref	player,
		POWER	power,
		int	fpowers,
		int	reset
	)

Only GOD may set or clear the bit

Definition at line 37 of file powers.c.

References God, and ph_any().

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

int ph_inherit	(	dbref	target,
		dbref	player,
		POWER	power,
		int	fpowers,
		int	reset
	)

Only players may set or clear this bit.

Definition at line 67 of file powers.c.

References Inherits, and ph_any().

{
        if(!Inherits(player))
                return 0;
        return (ph_any(target, player, power, fpowers, reset));
}

int ph_wiz	(	dbref	target,
		dbref	player,
		POWER	power,
		int	fpowers,
		int	reset
	)

Only WIZARDS (or GOD) may set or clear the bit

Definition at line 47 of file powers.c.

References God, ph_any(), and Wizard.

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

int ph_wizroy	(	dbref	target,
		dbref	player,
		POWER	power,
		int	fpowers,
		int	reset
	)

Only WIZARDS, ROYALTY, (or GOD) may set or clear the bit

Definition at line 57 of file powers.c.

References God, ph_any(), and WizRoy.

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

char* power_description	(	dbref	player,
		dbref	target
	)

Return an mbuf containing the type and powers on thing.

Definition at line 273 of file powers.c.

References alloc_mbuf, CA_GOD, CA_WIZARD, gen_powers, God, power_entry::listperm, POWER_EXT, power_entry::powername, power_entry::powerpower, Powers, Powers2, power_entry::powervalue, safe_mb_chr, safe_mb_str, Typeof, and Wizard.

Referenced by debug_examine(), and do_examine().

{
        char *buff, *bp;
        POWERENT *fp;
        int otype;
        POWER fv;

        /*
         * Allocate the return buffer 
         */

        otype = Typeof(target);
        bp = buff = alloc_mbuf("power_description");

        /*
         * Store the header strings and object type 
         */

        safe_mb_str((char *) "Powers:", buff, &bp);

        for(fp = gen_powers; fp->powername; fp++) {
                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;
                        safe_mb_chr(' ', buff, &bp);
                        safe_mb_str((char *) fp->powername, buff, &bp);
                }
        }

        /*
         * Terminate the string, and return the buffer to the caller 
         */

        *bp = '\0';
        return buff;
}

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

Definition at line 194 of file powers.c.

References find_power(), power_entry::handler, Name(), notify, notify_printf(), power_entry::powername, power_entry::powerpower, power_entry::powervalue, Quiet, and SET_QUIET.

Referenced by do_power().

{
        POWERENT *fp;
        int negate, result;

        /*
         * Trim spaces, and handle the negation character 
         */

        negate = 0;
        while (*power && isspace(*power))
                power++;
        if(*power == '!') {
                negate = 1;
                power++;
        }
        while (*power && 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;
        }
        fp = find_power(target, power);
        if(fp == NULL) {
                notify(player, "I don't understand that power.");
                return;
        }
        /*
         * Invoke the power handler, and print feedback 
         */

        result =
                fp->handler(target, player, fp->powervalue, fp->powerpower, negate);
        if(!result)
                notify(player, "Permission denied.");
        else if(!(key & SET_QUIET) && !Quiet(player))
                notify_printf(player, "%s - %s %s", Name(target), fp->powername,
                                          negate ? "removed." : "granted.");
        return;
}

---

Variable Documentation

POWERENT gen_powers[]

Definition at line 75 of file powers.c.

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

---