mux/src/misc.h File Reference

#include "copyright.h"
#include "powers.h"

Include dependency graph for misc.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	search_type
struct	stats_type
Typedefs
typedef search_type	SEARCH
typedef stats_type	STATS
Functions
bool	search_setup (dbref, char *, SEARCH *)
void	search_perform (dbref executor, dbref caller, dbref enactor, SEARCH *)
bool	get_stats (dbref, dbref, STATS *)

---

Typedef Documentation

typedef struct search_type SEARCH

Definition at line 15 of file misc.h.

typedef struct stats_type STATS

Definition at line 33 of file misc.h.

---

Function Documentation

bool get_stats	(	dbref	,
		dbref	,
		STATS *
	)

Definition at line 118 of file walkdb.cpp.

References Controls, DO_WHOLE_DB, Going, Good_obj, info(), confdata::many_coins, mudconf, NOPERM_MESSAGE, NOTHING, notify, Owner, payfor(), confdata::searchcost, Stat_Any, tprintf(), TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, and Typeof.

Referenced by do_stats(), and FUNCTION().

{
    // Do we have permission?
    //
    if (Good_obj(who) && !Controls(player, who) && !Stat_Any(player))
    {
        notify(player, NOPERM_MESSAGE);
        return false;
    }

    // Can we afford it?
    //
    if (!payfor(player, mudconf.searchcost))
    {
        notify(player, tprintf("You don't have enough %s.", mudconf.many_coins));
        return false;
    }
    info->s_total = 0;
    info->s_rooms = 0;
    info->s_exits = 0;
    info->s_things = 0;
    info->s_players = 0;
    info->s_garbage = 0;

    dbref i;
    DO_WHOLE_DB(i)
    {
        if ((who == NOTHING) || (who == Owner(i)))
        {
            info->s_total++;
            if (Going(i) && (Typeof(i) != TYPE_ROOM))
            {
                info->s_garbage++;
                continue;
            }
            switch (Typeof(i))
            {
            case TYPE_ROOM:

                info->s_rooms++;
                break;

            case TYPE_EXIT:

                info->s_exits++;
                break;

            case TYPE_THING:

                info->s_things++;
                break;

            case TYPE_PLAYER:

                info->s_players++;
                break;

            default:

                info->s_garbage++;
            }
        }
    }
    return true;
}

void search_perform	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		SEARCH *
	)

Definition at line 741 of file walkdb.cpp.

References alloc_lbuf, alloc_sbuf, ANY_OWNER, db, EV_EVAL, EV_FCHECK, EV_NOTRACE, FLAG_WORD1, FLAG_WORD3, free_lbuf, statedata::func_invk_ctr, Going, search_type::low_bound, mudstate, mux_exec(), mux_ltoa(), NOTHING, NOTYPE, olist_add(), Owner, Parent, Powers, Powers2, PureName(), replace_tokens(), search_type::s_fset, search_type::s_parent, search_type::s_pset, search_type::s_rst_eval, search_type::s_rst_name, search_type::s_rst_owner, search_type::s_rst_type, search_type::s_zone, string_prefix(), Typeof, flagset::word, powerset::word1, powerset::word2, xlate(), and Zone.

Referenced by do_search(), and FUNCTION().

{
    POWER thing1powers, thing2powers;
    char *result, *bp, *str;

    char *buff = alloc_sbuf("search_perform.num");
    int save_invk_ctr = mudstate.func_invk_ctr;

    dbref thing;
    for (thing = parm->low_bound; thing <= parm->high_bound; thing++)
    {
        mudstate.func_invk_ctr = save_invk_ctr;

        // Check for matching type.
        //
        if (  (parm->s_rst_type != NOTYPE)
           && (parm->s_rst_type != Typeof(thing)))
        {
            continue;
        }

        // Check for matching owner.
        //
        if (  (parm->s_rst_owner != ANY_OWNER)
           && (parm->s_rst_owner != Owner(thing)))
        {
            continue;
        }

        // Toss out destroyed things.
        //
        if (Going(thing))
        {
            continue;
        }

        // Check for matching parent.
        //
        if (  (parm->s_parent != NOTHING)
           && (parm->s_parent != Parent(thing)))
        {
            continue;
        }

        // Check for matching zone.
        //
        if (  (parm->s_zone != NOTHING)
           && (parm->s_zone != Zone(thing)))
        {
            continue;
        }

        // Check for matching flags.
        //
        bool b = false;
        for (int i = FLAG_WORD1; i <= FLAG_WORD3; i++)
        {
            FLAG f = parm->s_fset.word[i];
            if ((db[thing].fs.word[i] & f) != f)
            {
                b = true;
                break;
            }
        }
        if (b)
        {
            continue;
        }

        // Check for matching power.
        //
        thing1powers = Powers(thing);
        thing2powers = Powers2(thing);
        if ((thing1powers & parm->s_pset.word1) != parm->s_pset.word1)
        {
            continue;
        }
        if ((thing2powers & parm->s_pset.word2) != parm->s_pset.word2)
        {
            continue;
        }

        // Check for matching name.
        //
        if (parm->s_rst_name != NULL)
        {
            if (!string_prefix(PureName(thing), parm->s_rst_name))
                continue;
        }

        // Check for successful evaluation.
        //
        if (parm->s_rst_eval != NULL)
        {
            buff[0] = '#';
            mux_ltoa(thing, buff+1);
            char *buff2 = replace_tokens(parm->s_rst_eval, buff, NULL, NULL);
            result = bp = alloc_lbuf("search_perform");
            str = buff2;
            mux_exec(result, &bp, executor, caller, enactor,
                EV_FCHECK | EV_EVAL | EV_NOTRACE, &str, (char **)NULL, 0);
            *bp = '\0';
            free_lbuf(buff2);
            if (!*result || !xlate(result))
            {
                free_lbuf(result);
                continue;
            }
            free_lbuf(result);
        }

        // It passed everything. Amazing.
        //
        olist_add(thing);
    }
    free_sbuf(buff);
    mudstate.func_invk_ctr = save_invk_ctr;
}

bool search_setup	(	dbref	,
		char *	,
		SEARCH *
	)

Definition at line 389 of file walkdb.cpp.

References ANY_OWNER, convert_flags(), EV_STRIP_TS, FLAG_WORD1, FLAG_WORD3, Good_obj, search_type::high_bound, lookup_player(), search_type::low_bound, match_controlled, mux_atol(), mux_strlwr(), NOTHING, notify, NOTYPE, Owner, parse_range(), parse_to(), search_type::s_fset, search_type::s_owner, search_type::s_parent, search_type::s_pset, search_type::s_rst_eval, search_type::s_rst_name, search_type::s_rst_owner, search_type::s_rst_type, search_type::s_wizard, search_type::s_zone, Search, string_prefix(), tprintf(), TYPE_EXIT, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, Typeof, flagset::word, powerset::word1, and powerset::word2.

Referenced by do_search(), and FUNCTION().

{
    // Crack arg into <pname> <type>=<targ>,<low>,<high>
    //
    char *pname = parse_to(&searchfor, '=', EV_STRIP_TS);
    if (!pname || !*pname)
    {
        pname = "me";
    }
    else
    {
        mux_strlwr(pname);
    }

    char *searchtype;
    if (searchfor && *searchfor)
    {
        searchtype = strrchr(pname, ' ');
        if (searchtype)
        {
            *searchtype++ = '\0';
        }
        else
        {
            searchtype = pname;
            pname = "";
        }
    }
    else
    {
        searchtype = "";
    }

    // If the player name is quoted, strip the quotes.
    //
    if (*pname == '\"')
    {
        size_t k = strlen(pname) - 1;
        if (pname[k] == '"')
        {
            pname[k] = '\0';
            pname++;
        }
    }

    // Strip any range arguments.
    //
    parse_range(&searchfor, &parm->low_bound, &parm->high_bound);


    // Set limits on who we search.
    //
    parm->s_owner = Owner(player);
    parm->s_wizard = Search(player);
    parm->s_rst_owner = NOTHING;
    if (!*pname)
    {
        parm->s_rst_owner = parm->s_wizard ? ANY_OWNER : player;
    }
    else if (pname[0] == '#')
    {
        parm->s_rst_owner = mux_atol(&pname[1]);
        if (!Good_obj(parm->s_rst_owner))
        {
            parm->s_rst_owner = NOTHING;
        }
        else if (Typeof(parm->s_rst_owner) != TYPE_PLAYER)
        {
            parm->s_rst_owner = NOTHING;
        }

    }
    else if (strcmp(pname, "me") == 0)
    {
        parm->s_rst_owner = player;
    }
    else
    {
        parm->s_rst_owner = lookup_player(player, pname, true);
    }

    if (parm->s_rst_owner == NOTHING)
    {
        notify(player, tprintf("%s: No such player", pname));
        return false;
    }

    // Set limits on what we search for.
    //
    int err = 0;
    parm->s_rst_name = NULL;
    parm->s_rst_eval = NULL;
    parm->s_rst_type = NOTYPE;
    parm->s_parent = NOTHING;
    parm->s_zone = NOTHING;
    for (int i = FLAG_WORD1; i <= FLAG_WORD3; i++)
    {
        parm->s_fset.word[i] = 0;
    }
    parm->s_pset.word1 = 0;
    parm->s_pset.word2 = 0;

    switch (searchtype[0])
    {
    case '\0':

        // The no class requested class  :)
        //
        break;

    case 'e':

        if (string_prefix("exits", searchtype))
        {
            parm->s_rst_name = searchfor;
            parm->s_rst_type = TYPE_EXIT;
        }
        else if (string_prefix("evaluate", searchtype))
        {
            parm->s_rst_eval = searchfor;
        }
        else if (string_prefix("eplayer", searchtype))
        {
            parm->s_rst_type = TYPE_PLAYER;
            parm->s_rst_eval = searchfor;
        }
        else if (string_prefix("eroom", searchtype))
        {
            parm->s_rst_type = TYPE_ROOM;
            parm->s_rst_eval = searchfor;
        }
        else if (string_prefix("eobject", searchtype))
        {
            parm->s_rst_type = TYPE_THING;
            parm->s_rst_eval = searchfor;
        }
        else if (string_prefix("ething", searchtype))
        {
            parm->s_rst_type = TYPE_THING;
            parm->s_rst_eval = searchfor;
        }
        else if (string_prefix("eexit", searchtype))
        {
            parm->s_rst_type = TYPE_EXIT;
            parm->s_rst_eval = searchfor;
        }
        else
        {
            err = 1;
        }
        break;

    case 'f':

        if (string_prefix("flags", searchtype))
        {
            // convert_flags ignores previous values of flag_mask and
            // s_rst_type while setting them.
            //
            if ( !convert_flags( player, searchfor, &parm->s_fset,
                                &parm->s_rst_type) )
            {
                return false;
            }
        }
        else
        {
            err = 1;
        }
        break;

    case 'n':

        if (string_prefix("name", searchtype))
        {
            parm->s_rst_name = searchfor;
        }
        else
        {
            err = 1;
        }
        break;

    case 'o':

        if (string_prefix("objects", searchtype))
        {
            parm->s_rst_name = searchfor;
            parm->s_rst_type = TYPE_THING;
        }
        else
        {
            err = 1;
        }
        break;

    case 'p':

        if (string_prefix("players", searchtype))
        {
            parm->s_rst_name = searchfor;
            parm->s_rst_type = TYPE_PLAYER;
            if (!*pname)
            {
                parm->s_rst_owner = ANY_OWNER;
            }
        }
        else if (string_prefix("parent", searchtype))
        {
            parm->s_parent = match_controlled(player, searchfor);
            if (!Good_obj(parm->s_parent))
            {
                return false;
            }
            if (!*pname)
            {
                parm->s_rst_owner = ANY_OWNER;
            }
        }
        else if (string_prefix("power", searchtype))
        {
            if (!decode_power(player, searchfor, &parm->s_pset))
            {
                return false;
            }
        }
        else
        {
            err = 1;
        }
        break;

    case 'r':

        if (string_prefix("rooms", searchtype))
        {
            parm->s_rst_name = searchfor;
            parm->s_rst_type = TYPE_ROOM;
        }
        else
        {
            err = 1;
        }
        break;

    case 't':

        if (string_prefix("type", searchtype))
        {
            if (searchfor[0] == '\0')
            {
                break;
            }
            if (string_prefix("rooms", searchfor))
            {
                parm->s_rst_type = TYPE_ROOM;
            }
            else if (string_prefix("exits", searchfor))
            {
                parm->s_rst_type = TYPE_EXIT;
            }
            else if (string_prefix("objects", searchfor))
            {
                parm->s_rst_type = TYPE_THING;
            }
            else if (string_prefix("things", searchfor))
            {
                parm->s_rst_type = TYPE_THING;
            }
            else if (string_prefix("garbage", searchfor))
            {
                parm->s_rst_type = TYPE_GARBAGE;
            }
            else if (string_prefix("players", searchfor))
            {
                parm->s_rst_type = TYPE_PLAYER;
                if (!*pname)
                {
                    parm->s_rst_owner = ANY_OWNER;
                }
            }
            else
            {
                notify(player, tprintf("%s: unknown type", searchfor));
                return false;
            }
        }
        else if (string_prefix("things", searchtype))
        {
            parm->s_rst_name = searchfor;
            parm->s_rst_type = TYPE_THING;
        }
        else
        {
            err = 1;
        }
        break;

    case 'z':

        if (string_prefix("zone", searchtype))
        {
            parm->s_zone = match_controlled(player, searchfor);
            if (!Good_obj(parm->s_zone))
            {
                return false;
            }
            if (!*pname)
            {
                parm->s_rst_owner = ANY_OWNER;
            }
        }
        else
        {
            err = 1;
        }
        break;

    default:

        err = 1;
    }

    if (err)
    {
        notify(player, tprintf("%s: unknown class", searchtype));
        return false;
    }

    // Make sure player is authorized to do the search.
    //
    if (  !parm->s_wizard
       && (parm->s_rst_type != TYPE_PLAYER)
       && (parm->s_rst_owner != player)
       && (parm->s_rst_owner != ANY_OWNER))
    {
        notify(player, "You need a search warrant to do that!");
        return false;
    }

    // Make sure player has money to do the search.
    //
    if (!payfor(player, mudconf.searchcost))
    {
        notify(player,
            tprintf("You don't have enough %s to search. (You need %d)",
                 mudconf.many_coins, mudconf.searchcost));
        return false;
    }
    return true;
}

---