mux/src/player_c.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "attrs.h"

Include dependency graph for player_c.cpp:

Go to the source code of this file.

Data Structures
struct	player_cache
	structure to hold cached data for player-type objects. More...
Defines
#define	PF_REF   0x0002
#define	PF_MONEY_CH   0x0004
Typedefs
typedef player_cache	PCACHE
	structure to hold cached data for player-type objects.
Functions
void	pcache_init (void)
	Initializes the player cache.
static void	pcache_reload1 (dbref player, PCACHE *pp)
	Updates player cache items from the database.
static PCACHE *	pcache_find (dbref player)
	Returns a player's cache record.
static void	pcache_save (PCACHE *pp)
	Saves any dirty player data items to the database.
void	pcache_reload (dbref player)
	Re-initializes Money and QueueMax items from the database.
void	pcache_trim (void)
	Ages and trims the player cache of stale entries.
void	pcache_sync (void)
	Flushes any dirty player items to the database.
int	a_Queue (dbref player, int adj)
	Adjusts the count of queued commands up or down.
int	QueueMax (dbref player)
	Returns the player's upper limit of queued commands.
int	Pennies (dbref obj)
	Returns how many coins are in a player's or things's purse.
void	s_Pennies (dbref obj, int howfew)
	Sets the number of coins in a player's or thing's purse.
void	s_PenniesDirect (dbref obj, int howfew)
	A shortcut method of initializing the coins in a object's purse.
Variables
static CHashTable	pcache_htab
	Hash Table which maps player dbref to PCACHE entry.
static PCACHE *	pcache_head
	The head of a singly-linked list of all PCACHE entries.

---

Detailed Description

Player cache routines.

Id

player_c.cpp,v 1.18 2007/02/03 04:32:52 sdennis Exp

Frequenty-used items which appear on every object generally find a home in the db[] structure managed in db.cpp. However, there are a few items related only to players which are still accessed frequently enough that they should be cached. These items are money, current number of queued commands, and the limit on the number of queued commands.

Definition in file player_c.cpp.

---

Define Documentation

#define PF_MONEY_CH   0x0004

Definition at line 42 of file player_c.cpp.

Referenced by pcache_reload1(), pcache_save(), and s_Pennies().

#define PF_REF   0x0002

Definition at line 41 of file player_c.cpp.

Referenced by pcache_find(), and pcache_trim().

---

Typedef Documentation

typedef struct player_cache PCACHE

structure to hold cached data for player-type objects.

---

Function Documentation

int a_Queue	(	dbref	player,
		int	adj
	)

Adjusts the count of queued commands up or down.

cque.cpp uses this as it schedules and performs queued commands.

Parameters:

	player	dbref of player object responsible for command.
	adj	new (+) or completed (-) commands being queued.

Returns:

None.

Definition at line 239 of file player_c.cpp.

References Good_obj, OwnsOthers, pcache_find(), and player_cache::queue.

Referenced by CallBack_HaltQueue(), CallBack_NotifySemaphoreDrainOrAll(), halt_que(), setup_que(), and Task_RunQueueEntry().

{
    if (  Good_obj(player)
       && OwnsOthers(player))
    {
        PCACHE *pp = pcache_find(player);
        pp->queue += adj;
        return pp->queue;
    }
    return 0;
}

static PCACHE* pcache_find

(

dbref

player

)

[static]

Returns a player's cache record.

Whether created from scratch or found in the cache, pcache_find() always returns a valid player cache record for the requested player object dbref. This function uses Hash Table access primarily, but it maintains the singly-linked list as well.

Parameters:

player

player object dbref.

Returns:

Pointer to new or existing player cache record.

Definition at line 109 of file player_c.cpp.

References alloc_pcache, player_cache::cflags, hashaddLEN(), hashfindLEN(), player_cache::next, pcache_head, pcache_htab, pcache_reload1(), PF_REF, player_cache::player, and player_cache::queue.

Referenced by a_Queue(), pcache_reload(), Pennies(), QueueMax(), and s_Pennies().

{
    PCACHE *pp = (PCACHE *)hashfindLEN(&player, sizeof(player), &pcache_htab);
    if (pp)
    {
        pp->cflags |= PF_REF;
        return pp;
    }
    pp = alloc_pcache("pcache_find");
    pp->queue = 0;
    pp->cflags = PF_REF;
    pp->player = player;
    pcache_reload1(player, pp);
    pp->next = pcache_head;
    pcache_head = pp;
    hashaddLEN(&player, sizeof(player), pp, &pcache_htab);
    return pp;
}

void pcache_init

(

void

)

Initializes the player cache.

This is called once to initialize the player cache and supporting data structures: Player cache structures are pooled, the Hash Table initializes itself, and the singly-linked list is started.

Returns:

None.

Definition at line 53 of file player_c.cpp.

References pcache_head, pool_init(), and POOL_PCACHE.

Referenced by main().

{
    pool_init(POOL_PCACHE, sizeof(PCACHE));
    pcache_head = NULL;
}

void pcache_reload

(

dbref

player

)

Re-initializes Money and QueueMax items from the database.

Parameters:

player

player object dbref.

Returns:

None.

Definition at line 151 of file player_c.cpp.

References Good_obj, OwnsOthers, pcache_find(), pcache_reload1(), and pcache_save().

Referenced by atr_add_raw_LEN(), and atr_clr().

{
    if (  Good_obj(player)
       && OwnsOthers(player))
    {
        PCACHE *pp = pcache_find(player);
        pcache_save(pp);
        pcache_reload1(player, pp);
    }
}

static void pcache_reload1	(	dbref	player,
		PCACHE *	pp
	)			[static]

Updates player cache items from the database.

The Money and QueueMax attributes are used to initialize the corresponding items in the player cache. If a Money attribute does not exist for some strange reason, it it initialized to zero and marked as dirty. If a QueueMax attribute doesn't exist or is negative, then the game will choose a reasonable limit later in QueueMax().

Parameters:

	player	player object to begin caching.
	pp	pointer to PCACHE structure.

Returns:

None.

Definition at line 72 of file player_c.cpp.

References A_MONEY, A_QUEUEMAX, atr_get_raw(), player_cache::cflags, player_cache::money, mux_atol(), PF_MONEY_CH, and player_cache::qmax.

Referenced by pcache_find(), and pcache_reload().

{
    const char *cp = atr_get_raw(player, A_MONEY);
    if (cp && *cp)
    {
        pp->money = mux_atol(cp);
    }
    else
    {
        pp->cflags |= PF_MONEY_CH;
        pp->money = 0;
    }

    int m = -1;
    cp = atr_get_raw(player, A_QUEUEMAX);
    if (cp && *cp)
    {
        m = mux_atol(cp);
        if (m < 0)
        {
            m = -1;
        }
    }
    pp->qmax = m;
}

static void pcache_save

(

PCACHE *

pp

)

[static]

Saves any dirty player data items to the database.

Parameters:

pp

pointer to potentially dirty PCACHE structure.

Returns:

None.

Definition at line 134 of file player_c.cpp.

References A_MONEY, atr_add_raw(), player_cache::cflags, player_cache::money, mux_ltoa(), PF_MONEY_CH, and player_cache::player.

Referenced by pcache_reload(), pcache_sync(), and pcache_trim().

{
    if (pp->cflags & PF_MONEY_CH)
    {
        IBUF tbuf;
        mux_ltoa(pp->money, tbuf);
        atr_add_raw(pp->player, A_MONEY, tbuf);
        pp->cflags &= ~PF_MONEY_CH;
    }
}

void pcache_sync

(

void

)

Flushes any dirty player items to the database.

The primary access is via the singly-linked list. Upon return, all the player cache records are marked as clean.

Returns:

None.

Definition at line 220 of file player_c.cpp.

References pcache_head, and pcache_save().

Referenced by do_dbclean(), do_restart(), do_shutdown(), dump_database(), fork_and_dump(), and sighandler().

{
    PCACHE *pp = pcache_head;
    while (pp)
    {
        pcache_save(pp);
        pp = pp->next;
    }
}

void pcache_trim

(

void

)

Ages and trims the player cache of stale entries.

pcache_trim() relies primarily on the singly-linked list, but it also maintains the Hash Table. To be trimmed, a player cache record must not have outstanding commands in the command queue.

The one level of aging is accomplished with PR_REF. On the first pass through the linked list, the PR_REF bit is removed. On the second pass through the list, the record is trimmed.

Returns:

None.

Definition at line 175 of file player_c.cpp.

References player_cache::cflags, free_pcache, hashdeleteLEN(), player_cache::next, pcache_head, pcache_htab, pcache_save(), PF_REF, player_cache::player, and player_cache::queue.

Referenced by dispatch_FreeListReconstruction().

{
    PCACHE *pp = pcache_head;
    PCACHE *pplast = NULL;
    while (pp)
    {
        PCACHE *ppnext = pp->next;
        if (  pp->queue
           || (pp->cflags & PF_REF))
        {
            // This entry either has outstanding commands in the queue or we
            // need to let it age.
            //
            pp->cflags &= ~PF_REF;
            pplast = pp;
        }
        else
        {
            // Unlink and destroy this entry.
            //
            if (pplast)
            {
                pplast->next = ppnext;
            }
            else
            {
                pcache_head = ppnext;
            }

            pcache_save(pp);
            hashdeleteLEN(&(pp->player), sizeof(pp->player), &pcache_htab);
            free_pcache(pp);
        }
        pp = ppnext;
    }
}

int Pennies

(

dbref

obj

)

Returns how many coins are in a player's or things's purse.

Parameters:

player

dbref of player object.

Returns:

None.

Definition at line 295 of file player_c.cpp.

References A_MONEY, atr_get_raw(), statedata::bStandAlone, Good_obj, player_cache::money, mudstate, mux_atol(), OwnsOthers, and pcache_find().

Referenced by canpayfees(), check_pennies(), CGuests::Create(), db_write_object(), debug_examine(), destroy_obj(), do_chown(), do_clone(), do_decomp(), do_examine(), do_kill(), do_poor(), do_score(), FUNCTION(), give_money(), giveto(), CGuests::MakeGuestChar(), move_object(), payfor(), and shutdownsock().

{
    if (Good_obj(obj))
    {
        if (  !mudstate.bStandAlone
           && OwnsOthers(obj))
        {
            PCACHE *pp = pcache_find(obj);
            return pp->money;
        }
        else
        {
            const char *cp = atr_get_raw(obj, A_MONEY);
            if (cp)
            {
                return mux_atol(cp);
            }
        }
    }
    return 0;
}

int QueueMax

(

dbref

player

)

Returns the player's upper limit of queued commands.

If a QueueMax is set on the player, we use that. Otherwise, there is a configurable game-wide limit (given by player_queue_limit) unless the player is a Wizard in which case, we reason that well behaved Wizard code should be able to schedule as much work as there are objects in the database -- larger game, more work to be expected in the queue.

Parameters:

player

dbref of player object.

Returns:

None.

Definition at line 263 of file player_c.cpp.

References statedata::db_top, Good_obj, mudconf, mudstate, OwnsOthers, pcache_find(), player_cache::qmax, confdata::queuemax, and Wizard.

Referenced by setup_que().

{
    int m = 0;
    if (  Good_obj(player)
       && OwnsOthers(player))
    {
        PCACHE *pp = pcache_find(player);
        if (pp->qmax >= 0)
        {
            m = pp->qmax;
        }
        else
        {
            // @queuemax was not valid so we use the game-wide limit.
            //
            m = mudconf.queuemax;
            if (  Wizard(player)
               && m < mudstate.db_top + 1)
            {
                m = mudstate.db_top + 1;
            }
        }
    }
    return m;
}

void s_Pennies	(	dbref	obj,
		int	howfew
	)

Sets the number of coins in a player's or thing's purse.

This changes the number of coins a player holds and sets this attribute as dirty so that it will be updated in the attribute database later.

Parameters:

	player	dbref of player object responsible for command.
	howfew	Number of coins

Returns:

None.

Definition at line 328 of file player_c.cpp.

References A_MONEY, atr_add_raw(), statedata::bStandAlone, player_cache::cflags, Good_obj, player_cache::money, mudstate, mux_ltoa(), OwnsOthers, pcache_find(), and PF_MONEY_CH.

Referenced by check_pennies(), CGuests::Create(), create_obj(), db_make_minimal(), destroy_bad_obj(), destroy_obj(), do_clone(), do_fixdb(), do_poor(), do_toad(), giveto(), CGuests::MakeGuestChar(), and payfor().

{
    if (Good_obj(obj))
    {
        if (  !mudstate.bStandAlone
           && OwnsOthers(obj))
        {
            PCACHE *pp = pcache_find(obj);
            pp->money = howfew;
            pp->cflags |= PF_MONEY_CH;
        }
        else
        {
            IBUF tbuf;
            mux_ltoa(howfew, tbuf);
            atr_add_raw(obj, A_MONEY, tbuf);
        }
    }
}

void s_PenniesDirect	(	dbref	obj,
		int	howfew
	)

A shortcut method of initializing the coins in a object's purse.

This method should only be used from db_rw.cpp while loading the database. From there, the object will be in a half-way state, and has not been fully loaded. The object type is not known. Likewise, at database load time, using the player cache is ineffective -- causing a read request for A_MONEY to obtain a value for coins (probably zero) that we immediate change again.

Parameters:

	obj	dbref of object.
	howfew	Number of coins

Returns:

None.

Definition at line 361 of file player_c.cpp.

References A_MONEY, atr_add_raw(), and mux_ltoa().

Referenced by db_read().

{
    IBUF tbuf;
    mux_ltoa(howfew, tbuf);
    atr_add_raw(obj, A_MONEY, tbuf);
}

---

Variable Documentation

PCACHE* pcache_head [static]

The head of a singly-linked list of all PCACHE entries.

Definition at line 39 of file player_c.cpp.

Referenced by pcache_find(), pcache_init(), pcache_sync(), and pcache_trim().

CHashTable pcache_htab [static]

Hash Table which maps player dbref to PCACHE entry.

Definition at line 35 of file player_c.cpp.

Referenced by pcache_find(), and pcache_trim().

---