/*
* powers.c - power manipulation routines
*/
/*
* $Id: powers.c,v 1.3 2005/08/08 09:43:07 murrayma Exp $
*/
#include "copyright.h"
#include "config.h"
#include "db.h"
#include "mudconf.h"
#include "externs.h"
#include "command.h"
#include "powers.h"
#include "alloc.h"
#ifndef STANDALONE
/*
* ---------------------------------------------------------------------------
* * ph_any: set or clear indicated bit, no security checking
*/
int ph_any(target, player, power, fpowers, reset)
dbref target, player;
POWER power;
int fpowers, reset;
{
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;
}
/*
* ---------------------------------------------------------------------------
* * ph_god: only GOD may set or clear the bit
*/
int ph_god(target, player, power, fpowers, reset)
dbref target, player;
POWER power;
int fpowers, reset;
{
if (!God(player))
return 0;
return (ph_any(target, player, power, fpowers, reset));
}
/*
* ---------------------------------------------------------------------------
* * ph_wiz: only WIZARDS (or GOD) may set or clear the bit
*/
int ph_wiz(target, player, power, fpowers, reset)
dbref target, player;
POWER power;
int fpowers, reset;
{
if (!Wizard(player) & !God(player))
return 0;
return (ph_any(target, player, power, fpowers, reset));
}
/*
* ---------------------------------------------------------------------------
* * ph_wizroy: only WIZARDS, ROYALTY, (or GOD) may set or clear the bit
*/
int ph_wizroy(target, player, power, fpowers, reset)
dbref target, player;
POWER power;
int fpowers, reset;
{
if (!WizRoy(player) & !God(player))
return 0;
return (ph_any(target, player, power, fpowers, reset));
}
/*
* ---------------------------------------------------------------------------
* * ph_inherit: only players may set or clear this bit.
*/
int ph_inherit(target, player, power, fpowers, reset)
dbref target, player;
POWER power;
int fpowers, reset;
{
if (!Inherits(player))
return 0;
return (ph_any(target, player, power, fpowers, reset));
}
/* *INDENT-OFF* */
POWERENT gen_powers[] =
{
{(char *)"quota", POW_CHG_QUOTAS, 0, 0, ph_wiz},
{(char *)"chown_anything", POW_CHOWN_ANY, 0, 0, ph_wiz},
{(char *)"announce", POW_ANNOUNCE, 0, 0, ph_wiz},
{(char *)"boot", POW_BOOT, 0, 0, ph_wiz},
{(char *)"halt", POW_HALT, 0, 0, ph_wiz},
{(char *)"control_all", POW_CONTROL_ALL,0, 0, ph_god},
{(char *)"expanded_who", POW_WIZARD_WHO, 0, 0, ph_wiz},
{(char *)"see_all", POW_EXAM_ALL, 0, 0, ph_wiz},
{(char *)"prog", POW_PROG, 0, 0, ph_wiz},
{(char *)"find_unfindable", POW_FIND_UNFIND,0, 0, ph_wiz},
{(char *)"free_money", POW_FREE_MONEY, 0, 0, ph_wiz},
{(char *)"free_quota", POW_FREE_QUOTA, 0, 0, ph_wiz},
{(char *)"hide", POW_HIDE, 0, 0, ph_wiz},
{(char *)"idle", POW_IDLE, 0, 0, ph_wiz},
{(char *)"search", POW_SEARCH, 0, 0, ph_wiz},
{(char *)"long_fingers", POW_LONGFINGERS,0, 0, ph_wiz},
{(char *)"comm_all", POW_COMM_ALL, 0, 0, ph_wiz},
{(char *)"see_queue", POW_SEE_QUEUE, 0, 0, ph_wiz},
{(char *)"see_hidden", POW_SEE_HIDDEN, 0, 0, ph_wiz},
{(char *)"monitor", POW_MONITOR, 0, 0, ph_wiz},
{(char *)"poll", POW_POLL, 0, 0, ph_wiz},
{(char *)"no_destroy", POW_NO_DESTROY, 0, 0, ph_wiz},
{(char *)"guest", POW_GUEST, 0, 0, ph_god},
{(char *)"stat_any", POW_STAT_ANY, 0, 0, ph_wiz},
{(char *)"steal_money", POW_STEAL, 0, 0, ph_wiz},
{(char *)"tel_anywhere", POW_TEL_ANYWHR, 0, 0, ph_wiz},
{(char *)"tel_anything", POW_TEL_UNRST, 0, 0, ph_wiz},
{(char *)"unkillable", POW_UNKILLABLE, 0, 0, ph_wiz},
{(char *)"pass_locks", POW_PASS_LOCKS, 0, 0, ph_wiz},
{(char *)"builder", POW_BUILDER, POWER_EXT, 0, ph_wiz},
/* mecha stuff */
{(char *)"mech", POW_MECH, POWER_EXT, 0, ph_wiz},
{(char *)"security", POW_SECURITY, POWER_EXT, 0, ph_wiz},
{(char *)"mechrep", POW_MECHREP, POWER_EXT, 0, ph_wiz},
{(char *)"map", POW_MAP, POWER_EXT, 0, ph_wiz},
{(char *)"tech", POW_TECH, POWER_EXT, 0, ph_wiz},
{(char *)"template", POW_TEMPLATE, POWER_EXT, 0, ph_wiz},
/* mecha stuff end */
{NULL, 0, 0, 0, 0}};
#endif /* STANDALONE */
/* *INDENT-ON* */
#ifndef STANDALONE
/*
* ---------------------------------------------------------------------------
* * init_powertab: initialize power hash tables.
*/
void init_powertab(void)
{
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);
}
/*
* ---------------------------------------------------------------------------
* * display_powers: display available powers.
*/
void display_powertab(player)
dbref player;
{
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(thing, powername)
dbref thing;
char *powername;
{
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 decode_power(player, powername, pset)
dbref player;
char *powername;
POWERSET *pset;
{
POWERENT *pent;
pset->word1 = 0;
pset->word2 = 0;
pent = (POWERENT *) hashfind(powername, &mudstate.powers_htab);
if (!pent) {
notify(player, tprintf("%s: Power not found.", powername));
return 0;
}
if (pent->powerpower & POWER_EXT)
pset->word2 = pent->powervalue;
else
pset->word1 = pent->powervalue;
return 1;
}
/*
* ---------------------------------------------------------------------------
* * power_set: Set or clear a specified power on an object.
*/
void power_set(target, player, power, key)
dbref target, player;
char *power;
int key;
{
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(player, (negate ? "Cleared." : "Set."));
return;
}
/*
* ---------------------------------------------------------------------------
* * has_power: does object have power visible to player?
*/
int has_power(player, it, powername)
dbref player, it;
char *powername;
{
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;
}
/*
* ---------------------------------------------------------------------------
* * power_description: Return an mbuf containing the type and powers on thing.
*/
char *power_description(player, target)
dbref player, target;
{
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;
}
/*
* ---------------------------------------------------------------------------
* * decompile_powers: Produce commands to set powers on target.
*/
void decompile_powers(player, thing, thingname)
dbref player, thing;
char *thingname;
{
POWER f1, f2;
POWERENT *fp;
/*
* 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
*/
notify(player, tprintf("@power %s=%s", strip_ansi(thingname),
fp->powername));
}
}
#endif /*
* STANDALONE
*/