// ---------------------------------------------------------------------------
// setup_que: Set up a queue entry.
//
static BQUE *setup_que
(
dbref executor,
dbref caller,
dbref enactor,
int eval,
char *command,
int nargs,
char *args[],
reg_ref *sargs[]
)
{
// Can we run commands at all?
//
if (Halted(executor))
{
return NULL;
}
// Make sure executor can afford to do it.
//
int a = mudconf.waitcost;
if (mudconf.machinecost && RandomINT32(0, mudconf.machinecost-1) == 0)
{
a++;
}
if (!payfor(executor, a))
{
notify(Owner(executor), "Not enough money to queue command.");
return NULL;
}
// Wizards and their objs may queue up to db_top+1 cmds. Players are
// limited to QUEUE_QUOTA. -mnp
//
a = QueueMax(Owner(executor));
if (a_Queue(Owner(executor), 1) > a)
{
a_Queue(Owner(executor), -1);
notify(Owner(executor),
"Run away objects: too many commands queued. Halted.");
halt_que(Owner(executor), NOTHING);
// Halt also means no command execution allowed.
//
s_Halted(executor);
return NULL;
}
// We passed all the tests.
//
// Calculate the length of the save string.
//
size_t tlen = 0;
static size_t nCommand;
static size_t nLenEnv[NUM_ENV_VARS];
if (command)
{
nCommand = strlen(command) + 1;
tlen = nCommand;
}
if (nargs > NUM_ENV_VARS)
{
nargs = NUM_ENV_VARS;
}
for (a = 0; a < nargs; a++)
{
if (args[a])
{
nLenEnv[a] = strlen(args[a]) + 1;
tlen += nLenEnv[a];
}
}
// Create the qeue entry and load the save string.
//
BQUE *tmp = alloc_qentry("setup_que.qblock");
tmp->comm = NULL;
char *tptr = tmp->text = (char *)MEMALLOC(tlen);
ISOUTOFMEMORY(tptr);
if (command)
{
memcpy(tptr, command, nCommand);
tmp->comm = tptr;
tptr += nCommand;
}
for (a = 0; a < nargs; a++)
{
if (args[a])
{
memcpy(tptr, args[a], nLenEnv[a]);
tmp->env[a] = tptr;
tptr += nLenEnv[a];
}
else
{
tmp->env[a] = NULL;
}
}
for ( ; a < NUM_ENV_VARS; a++)
{
tmp->env[a] = NULL;
}
if (sargs)
{
for (a = 0; a < MAX_GLOBAL_REGS; a++)
{
tmp->scr[a] = sargs[a];
if (sargs[a])
{
RegAddRef(sargs[a]);
}
}
}
else
{
for (a = 0; a < MAX_GLOBAL_REGS; a++)
{
tmp->scr[a] = NULL;
}
}
// Load the rest of the queue block.
//
tmp->executor = executor;
tmp->IsTimed = false;
tmp->sem = NOTHING;
tmp->attr = 0;
tmp->enactor = enactor;
tmp->caller = caller;
tmp->eval = eval;
tmp->nargs = nargs;
return tmp;
}
static void promote_match(dbref what, int confidence)
{
#ifdef REALITY_LVLS
// Check is the object is visible.
//
if ( Good_obj(what)
&& (confidence & CON_LOCAL)
&& !IsReal(md.player, what)
&& what != Location(md.player))
{
return;
}
#endif // REALITY_LVLS
// Check for type and locks, if requested.
//
if (md.pref_type != NOTYPE)
{
if ( Good_obj(what)
&& Typeof(what) == md.pref_type)
{
confidence |= CON_TYPE;
}
}
if (md.check_keys)
{
MSTATE save_md;
save_match_state(&save_md);
if ( Good_obj(what)
&& could_doit(md.player, what, A_LOCK))
{
confidence |= CON_LOCK;
}
restore_match_state(&save_md);
}
// If nothing matched, take it.
//
if (md.count == 0)
{
md.match = what;
md.confidence = confidence;
md.count = 1;
return;
}
// If confidence is lower, ignore.
//
if (confidence < md.confidence)
{
return;
}
// If confidence is higher, replace.
//
if (confidence > md.confidence)
{
md.match = what;
md.confidence = confidence;
md.count = 1;
return;
}
// Equal confidence, pick randomly.
//
md.count++;
if (RandomINT32(1,md.count) == 1)
{
md.match = what;
}
return;
}
