void Message_Service::Show_Warning (char *format, ...)
{
if (format == NULL) {
format = "Show_Warning is NULL";
}
if (Quiet () && warnings == 0) {
Quiet (false);
Show_Banner ();
Quiet (true);
}
warnings++;
if (warnings <= max_warnings) {
char text [STRING_BUFFER];
va_list args;
va_start (args, format);
str_args (text, sizeof (text), format, args);
va_end (args);
printf ("\n\tWarning: %s", text);
fflush (stdout);
} else if (warning_flag) {
Show_Error ("Maximum Warning Messages %d Exceeded", max_warnings);
}
}
void Message_Service::Show_Error (char *format, ...)
{
if (format == NULL) {
format = "Show_Error is NULL";
}
if (Quiet () && warnings == 0) {
Quiet (false);
Show_Banner ();
}
char text [STRING_BUFFER];
va_list args;
va_start (args, format);
str_args (text, sizeof (text), format, args);
va_end (args);
if (Program_Status () == FATAL) {
printf ("\n\t%s", text);
fflush (stdout);
} else {
printf ("\n\n\tError: %s", text);
fflush (stdout);
Pause (true);
Exit_Stat (FATAL);
}
}
// ---------------------------------------------------------------------------
// do_queue: Queue management
//
void do_queue(dbref executor, dbref caller, dbref enactor, int eval, int key, char *arg)
{
UNUSED_PARAMETER(caller);
UNUSED_PARAMETER(enactor);
UNUSED_PARAMETER(eval);
if (key == QUEUE_KICK)
{
int i = mux_atol(arg);
int save_minPriority = scheduler.GetMinPriority();
if (save_minPriority <= PRIORITY_CF_DEQUEUE_DISABLED)
{
notify(executor, "Warning: automatic dequeueing is disabled.");
scheduler.SetMinPriority(PRIORITY_CF_DEQUEUE_ENABLED);
}
CLinearTimeAbsolute lsaNow;
lsaNow.GetUTC();
scheduler.ReadyTasks(lsaNow);
int ncmds = scheduler.RunTasks(i);
scheduler.SetMinPriority(save_minPriority);
if (!Quiet(executor))
{
notify(executor, tprintf("%d commands processed.", ncmds));
}
}
else if (key == QUEUE_WARP)
{
int iWarp = mux_atol(arg);
ltdWarp.SetSeconds(iWarp);
if (scheduler.GetMinPriority() <= PRIORITY_CF_DEQUEUE_DISABLED)
{
notify(executor, "Warning: automatic dequeueing is disabled.");
}
scheduler.TraverseUnordered(CallBack_Warp);
if (Quiet(executor))
{
return;
}
if (iWarp > 0)
{
notify(executor, tprintf("WaitQ timer advanced %d seconds.", iWarp));
}
else if (iWarp < 0)
{
notify(executor, tprintf("WaitQ timer set back %d seconds.", iWarp));
}
else
{
notify(executor, "Object queue appended to player queue.");
}
}
}
/** Set flags on a lock (user interface).
* \verbatim
* This implements @lset.
* \endverbatim
* \param player the enactor.
* \param what string in the form obj/lock.
* \param flags list of flags to set.
*/
void
do_lset(dbref player, char *what, char *flags)
{
dbref thing;
lock_list *l;
char *lname;
int flag;
int unset = 0;
if ((lname = strchr(what, '/')) == NULL) {
notify(player, T("No lock name given."));
return;
}
*lname++ = '\0';
if ((thing = match_controlled(player, what)) == NOTHING)
return;
if (*flags == '!') {
unset = 1;
flags++;
}
if ((flag = string_to_lockflag(flags)) < 0) {
notify(player, T("Unrecognized lock flag."));
return;
}
l = getlockstruct_noparent(thing, lname);
if (!l || !Can_Read_Lock(player, thing, L_TYPE(l))) {
notify(player, T("No such lock."));
return;
}
if (!can_write_lock(player, thing, l)) {
notify(player, T("Permission denied."));
return;
}
if (unset)
L_FLAGS(l) &= ~flag;
else
L_FLAGS(l) |= flag;
if (!Quiet(player) && !(Quiet(thing) && (Owner(thing) == player)))
notify_format(player, "%s/%s - %s.", Name(thing), L_TYPE(l),
unset ? T("lock flags unset") : T("lock flags set"));
if (!IsPlayer(thing)) {
char lmbuf[1024];
ModTime(thing) = mudtime;
snprintf(lmbuf, 1023, "lflags - %s[#%d]", flags, player);
lmbuf[strlen(lmbuf)+1] = '\0';
set_lmod(thing, lmbuf);
}
}
/** Set flags on a lock (user interface).
* \verbatim
* This implements @lset.
* \endverbatim
* \param player the enactor.
* \param what string in the form obj/lock.
* \param flags list of flags to set.
*/
void
do_lset(dbref player, char *what, char *flags)
{
dbref thing;
lock_list *l;
char *lname;
privbits flag;
bool unset = 0;
if ((lname = strchr(what, '/')) == NULL) {
notify(player, T("No lock name given."));
return;
}
*lname++ = '\0';
if ((thing = match_controlled(player, what)) == NOTHING)
return;
if (*flags == '!') {
unset = 1;
flags++;
}
if (string_to_lockflag(player, flags, &flag) < 0) {
notify(player, T("Unrecognized lock flag."));
return;
}
l = getlockstruct_noparent(thing, lname);
if (!l || !Can_Read_Lock(player, thing, L_TYPE(l))) {
notify(player, T("No such lock."));
return;
}
if (!can_write_lock(player, thing, l)) {
notify(player, T("Permission denied."));
return;
}
if (unset)
L_FLAGS(l) &= ~flag;
else
L_FLAGS(l) |= flag;
if (!Quiet(player) && !(Quiet(thing) && (Owner(thing) == player)))
notify_format(player, "%s/%s - %s.", AName(thing, AN_SYS, NULL), L_TYPE(l),
unset ? T("lock flags unset") : T("lock flags set"));
if (!IsPlayer(thing))
ModTime(thing) = mudtime;
}
void Message_Service::Show_Banner ()
{
if (!Quiet ()) {
Banner ();
printf ("\n");
}
}
void Message_Service::Show_Message (int num_lines)
{
if (!Quiet ()) {
while (num_lines-- > 0) {
fputs ("\n", stdout);
}
fflush (stdout);
}
}
void power_set(dbref target, dbref 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, NOPERM_MESSAGE);
} else if (!(key & SET_QUIET) && !Quiet(player)) {
notify(player, (negate ? "Cleared." : "Set."));
s_Modified(target);
}
return;
}
static void
link_exit(dbref player, dbref exit, dbref dest, int key)
{
int cost, quot;
/* Make sure we can link there */
if ((dest != HOME) &&
((!controls(player, dest) && !Link_ok(dest)) ||
!could_doit(player, dest, A_LLINK, 1, 0))) {
notify_quiet(player, "Permission denied.");
return;
}
/* Exit must be unlinked or controlled by you */
if ((Location(exit) != NOTHING) && !controls(player, exit)) {
notify_quiet(player, "Permission denied.");
return;
}
/* If exit is unlinked and mudconf 'paranoid_exit_linking' is enabled
* Do not allow the exit to be linked if you do not control it
*/
if ( (mudconf.paranoid_exit_linking == 1) && !controls(player,exit) ) {
notify_quiet(player, "Permission denied.");
return;
}
/* handle costs */
cost = mudconf.linkcost;
quot = 0;
if (Owner(exit) != Owner(player)) {
cost += mudconf.opencost;
quot += mudconf.exit_quota;
}
if (!canpayfees(player, player, cost, quot, TYPE_EXIT))
return;
/* Pay the owner for his loss */
/* Ok, if paranoid_exit_linking is enabled the linker does NOT own exit */
if (!(mudconf.paranoid_exit_linking)) {
if (Owner(exit) != Owner(player)) {
giveto(Owner(exit), mudconf.opencost, NOTHING);
add_quota(Owner(exit), quot, TYPE_EXIT);
s_Owner(exit, Owner(player));
s_Flags(exit, (Flags(exit) & ~(INHERIT | WIZARD)) | HALT);
}
}
/* link has been validated and paid for, do it and tell the player */
s_Location(exit, dest);
if (!(Quiet(player) || (key & SIDEEFFECT)) )
notify_quiet(player, "Linked.");
}
void Message_Service::End_Progress (void)
{
if (!Quiet ()) {
if (Batch ()) {
printf ("\n\tRecord: %d\n", progress);
fflush (stdout);
} else {
printf (" %d\n", progress);
}
}
}
void Message_Service::Pause_Process (void)
{
if (!Quiet () && !No_Pause () && !Batch ()) {
char pause [10];
printf ("\n\n\tPress Enter to Continue");
fflush (stdout);
fgets (pause, sizeof (pause), stdin);
}
}
void Message_Service::End_Progress (char *text)
{
if (!Quiet ()) {
if (Batch ()) {
printf ("\n\tRecord: %s\n", text);
fflush (stdout);
} else {
printf (" %-16.16s\n", text);
}
}
}
void helpindex_load(dbref player)
{
for (int i = 0; i < mudstate.nHelpDesc; i++)
{
helpindex_read(i);
}
if ( player != NOTHING
&& !Quiet(player))
{
notify(player, T("Cache for help indexes refreshed."));
}
}
void flag_set( dbref target, dbref player, char *flag, int key ) {
FLAGENT *fp;
int negate, result;
/*
* Trim spaces, and handle the negation character
*/
negate = 0;
while( *flag && isspace( *flag ) ) {
flag++;
}
if( *flag == '!' ) {
negate = 1;
flag++;
}
while( *flag && isspace( *flag ) ) {
flag++;
}
/*
* Make sure a flag name was specified
*/
if( *flag == '\0' ) {
if( negate ) {
notify( player, "You must specify a flag to clear." );
} else {
notify( player, "You must specify a flag to set." );
}
return;
}
fp = find_flag( target, flag );
if( fp == NULL ) {
notify( player, "I don't understand that flag." );
return;
}
/*
* Invoke the flag handler, and print feedback
*/
result = fp->handler( target, player, fp->flagvalue,
fp->flagflag, negate );
if( !result ) {
notify( player, NOPERM_MESSAGE );
} else if( !( key & SET_QUIET ) && !Quiet( player ) ) {
notify( player, ( negate ? "Cleared." : "Set." ) );
s_Modified( target );
}
return;
}
void Message_Service::Show_Progress (char *text)
{
progress++;
if (!Quiet ()) {
if ((progress % progress_step) == 1) {
if (Batch ()) {
printf ("\n\tRecord: %s", text);
fflush (stdout);
} else {
printf (" %-16.16s\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b", text);
}
}
}
}
void Message_Service::Show_Message (char *format, ...)
{
if (format == NULL) {
Show_Error ("Show_Message is NULL");
}
if (!Quiet ()) {
char text [STRING_BUFFER];
va_list args;
va_start (args, format);
str_args (text, sizeof (text), format, args);
va_end (args);
fputs ("\n\t", stdout);
fputs (text, stdout);
fflush (stdout);
}
}
void Message_Service::Show_Progress (int value)
{
if (value < 1) {
value = ++progress;
} else {
progress = value;
}
if (!Quiet ()) {
if ((value % progress_step) == 0) {
if (Batch ()) {
printf ("\n\tRecord: %d", value);
fflush (stdout);
} else {
printf (" %-10d\b\b\b\b\b\b\b\b\b\b\b", value);
}
}
}
}
void GboxInstance::HandleMessage(const pp::Var& var_message) {
if (!var_message.is_string()) return;
std::string message = var_message.AsString();
pp::Var var_reply;
if (message == kHelloString) {
theLog.info("message: '%s'", message.c_str());
Hello();
} else if (message == kPaintMethodId) {
Paint();
} else if (message == kClockMethodId) {
Clock();
} else if (message == "quiet") {
theLog.info("message: '%s'", message.c_str());
Quiet();
} else {
theLog.info("other message: '%s'", message.c_str());
Other(message);
}
}
//----------------------------------------------------------------------
void CGunTurret::DestroyedGeometry(bool use)
{
m_destroyed = use;
CItem::DestroyedGeometry(use);
if(!m_geometry[eIGS_Destroyed].empty())
{
if(use)
{
GetEntity()->SetSlotLocalTM(eIGS_Destroyed, GetEntity()->GetSlotLocalTM(eIGS_ThirdPerson, false));
}
DrawSlot(eIGS_Aux1,!use);
SetAspectProfile(eEA_Physics, eIPhys_PhysicalizedRigid);
UpdatePhysics();
}
if(use)
{
EnableUpdate(false, eIUS_General);
Quiet();
}
}
void
do_link(dbref player, dbref cause, int key, char *what, char *where)
{
dbref thing, room;
char *buff;
int nomtest;
if ( (key & SIDEEFFECT) && !SideFX(player) ) {
notify(player, "#-1 FUNCTION DISABLED");
return;
}
/* Find the thing to link */
init_match(player, what, TYPE_EXIT);
match_everything(0);
thing = noisy_match_result();
if (thing == NOTHING)
return;
nomtest = ((NoMod(thing) && !WizMod(player)) || (DePriv(player,Owner(thing),DP_MODIFY,POWER7,NOTHING) && (Owner(thing) != Owner(player))) || (Backstage(player) && NoBackstage(thing) && !Immortal(player)));
/* Allow unlink if where is not specified */
if (!where || !*where) {
if (!nomtest)
do_unlink(player, cause, key, what);
else
notify(player,"Permission denied.");
return;
}
switch (Typeof(thing)) {
case TYPE_EXIT:
/* Set destination */
room = parse_linkable_room(player, where);
if (room != NOTHING) {
if (!nomtest)
link_exit(player, thing, room, key);
else
notify(player,"Permission denied.");
}
break;
case TYPE_PLAYER:
case TYPE_THING:
/* Set home */
if (!Controls(player, thing) || nomtest) {
notify_quiet(player, "Permission denied.");
break;
}
init_match(player, where, NOTYPE);
match_everything(MAT_NO_EXITS);
room = noisy_match_result();
if (!Good_obj(room))
break;
if (!Has_contents(room)) {
notify_quiet(player, "Can't link to an exit.");
break;
}
if (!can_set_home(player, thing, room) ||
!could_doit(player, room, A_LLINK, 1, 0)) {
notify_quiet(player, "Permission denied.");
} else if (room == HOME) {
notify_quiet(player, "Can't set home to home.");
} else {
s_Home(thing, room);
if (!(Quiet(player) || (key & SIDEEFFECT)) )
notify_quiet(player, "Home set.");
}
break;
case TYPE_ROOM:
/* Set dropto */
if (!Controls(player, thing) || nomtest) {
notify_quiet(player, "Permission denied.");
break;
}
room = parse_linkable_room(player, where);
if (!Good_obj(room) && (room != HOME)) {
notify_quiet(player, "Permission denied.");
break;
}
if ((room != HOME) && !isRoom(room)) {
notify_quiet(player, "That is not a room!");
} else if ((room != HOME) &&
((!controls(player, room) && !Link_ok(room)) ||
!could_doit(player, room, A_LLINK, 1, 0))) {
notify_quiet(player, "Permission denied.");
} else {
s_Dropto(thing, room);
if (!Quiet(player))
notify_quiet(player, "Dropto set.");
}
break;
default:
STARTLOG(LOG_BUGS, "BUG", "OTYPE")
buff = alloc_mbuf("do_link.LOG.badtype");
sprintf(buff, "Strange object type: object #%d = %d",
thing, Typeof(thing));
log_text(buff);
free_mbuf(buff);
ENDLOG
}
}
/** Link an exit, room, player, or thing.
* \verbatim
* This is the top-level function for @link, which is used to link an
* exit to a destination, set a player or thing's home, or set a
* drop-to on a room.
*
* Linking an exit usually seizes ownership of the exit and costs 1 penny.
* 1 penny is also transferred to the former owner.
* \endverbatim
* \param player the enactor.
* \param name the name of the object to link.
* \param room_name the name of the link destination.
* \param preserve if 1, preserve ownership and zone data on exit relink.
*/
void
do_link(dbref player, const char *name, const char *room_name, int preserve)
{
/* Use this to link to a room that you own.
* It usually seizes ownership of the exit and costs 1 penny,
* plus a penny transferred to the exit owner if they aren't you.
* You must own the linked-to room AND specify it by room number.
*/
dbref thing;
dbref room;
if (!room_name || !*room_name) {
do_unlink(player, name);
return;
}
if (!IsRoom(player) && GoodObject(Location(player)) &&
IsExit(Location(player))) {
notify(player, T("You somehow wound up in a exit. No biscuit."));
return;
}
if ((thing = noisy_match_result(player, name, TYPE_EXIT, MAT_EVERYTHING))
!= NOTHING) {
switch (Typeof(thing)) {
case TYPE_EXIT:
if ((room = check_var_link(room_name)) == NOTHING)
room = parse_linkable_room(player, room_name);
if (room == NOTHING)
return;
if (GoodObject(room) && !can_link_to(player, room)) {
notify(player, T("Permission denied."));
break;
}
/* We may link an exit if it's unlinked and we pass the link-lock
* or if we control it.
*/
if (!(controls(player, thing)
|| ((Location(thing) == NOTHING)
&& eval_lock(player, thing, Link_Lock)))) {
notify(player, T("Permission denied."));
return;
}
if (preserve && !Wizard(player)) {
notify(player, T("Permission denied."));
return;
}
/* handle costs */
if (Owner(thing) == Owner(player)) {
if (!payfor(player, LINK_COST)) {
notify_format(player, T("It costs %d %s to link this exit."),
LINK_COST, ((LINK_COST == 1) ? MONEY : MONIES));
return;
}
} else {
if (!payfor(player, LINK_COST + EXIT_COST)) {
int a = LINK_COST + EXIT_COST;
notify_format(player, T("It costs %d %s to link this exit."), a,
((a == 1) ? MONEY : MONIES));
return;
} else if (!preserve) {
/* pay the owner for his loss */
giveto(Owner(thing), EXIT_COST);
chown_object(player, thing, player, 0);
}
}
/* link has been validated and paid for; do it */
if (!preserve) {
Owner(thing) = Owner(player);
Zone(thing) = Zone(player);
}
Location(thing) = room;
/* notify the player */
notify_format(player, T("Linked exit #%d to %s"), thing,
unparse_object(player, room));
break;
case TYPE_PLAYER:
case TYPE_THING:
if ((room =
noisy_match_result(player, room_name, NOTYPE,
MAT_EVERYTHING)) == NOTHING) {
notify(player, T("No match."));
return;
}
if (IsExit(room)) {
notify(player, T("That is an exit."));
return;
}
if (thing == room) {
notify(player, T("You may not link something to itself."));
return;
}
/* abode */
if (!controls(player, room) && !Abode(room)) {
notify(player, T("Permission denied."));
break;
}
if (!controls(player, thing)) {
notify(player, T("Permission denied."));
} else if (room == HOME) {
notify(player, T("Can't set home to home."));
} else {
/* do the link */
Home(thing) = room; /* home */
if (!Quiet(player) && !(Quiet(thing) && (Owner(thing) == player)))
notify(player, T("Home set."));
}
break;
case TYPE_ROOM:
if ((room = parse_linkable_room(player, room_name)) == NOTHING)
return;
if ((room != HOME) && (!IsRoom(room))) {
notify(player, T("That is not a room!"));
return;
}
if (!controls(player, thing)) {
notify(player, T("Permission denied."));
} else {
/* do the link, in location */
Location(thing) = room; /* dropto */
notify(player, T("Dropto set."));
}
break;
default:
notify(player, T("Internal error: weird object type."));
do_log(LT_ERR, NOTHING, NOTHING,
"Weird object! Type of #%d is %d", thing, Typeof(thing));
break;
}
}
}
void do_kill (dbref player, dbref cause, int key, char *what, char *costchar)
{
dbref victim;
char *buf1, *buf2;
int cost;
init_match(player, what, TYPE_PLAYER);
match_neighbor();
match_me();
match_here();
if (Wizard(player)) {
match_player();
match_absolute();
}
victim = match_result();
switch (victim) {
case NOTHING:
notify(player, "I don't see that player here.");
break;
case AMBIGUOUS:
notify(player, "I don't know who you mean!");
break;
default:
if ((Typeof(victim) != TYPE_PLAYER) &&
(Typeof(victim) != TYPE_THING)) {
notify(player,
"Sorry, you can only kill players and things.");
break;
}
if ((Haven(Location(victim)) && !Wizard(player)) ||
(controls(victim, Location(victim)) &&
!controls(player, Location(victim))) ||
Immortal(victim)) {
notify(player, "Sorry.");
break;
}
if (key == KILL_SLAY) {
if (Builder(player) && Builder(victim)) {
notify(player, "Sorry.");
break;
}
}
/* go for it */
cost = atoi(costchar);
if (key == KILL_KILL) {
if (HasPriv(victim,player,POWER_NOKILL,POWER4,NOTHING)) {
notify(player, "Sorry.");
break;
}
if (cost < mudconf.killmin)
cost = mudconf.killmin;
if (cost > mudconf.killmax)
cost = mudconf.killmax;
/* see if it works */
if (!payfor(player, cost)) {
notify(player,
unsafe_tprintf("You don't have enough %s.",
mudconf.many_coins));
return;
}
} else {
cost = 0;
}
if (!(((random() % mudconf.killguarantee) < cost) ||
(key == KILL_SLAY)) ||
Wizard(victim)) {
/* Failure: notify player and victim only */
notify(player, "Your murder attempt failed.");
buf1 = alloc_lbuf("do_kill.failed");
sprintf(buf1, "%s tried to kill you!", Name(player));
notify_with_cause(victim, player, buf1);
if (Suspect(player)) {
strcpy(buf1, Name(player));
if (player == Owner(player)) {
raw_broadcast(0, WIZARD,
"[Suspect] %s tried to kill %s(#%d).",
buf1, Name(victim), victim);
} else {
buf2 = alloc_lbuf("do_kill.SUSP.failed");
strcpy(buf2, Name(Owner(player)));
raw_broadcast(0, WIZARD,
"[Suspect] %s <via %s(#%d)> tried to kill %s(#%d).",
buf2, buf1, player,
Name(victim), victim);
free_lbuf(buf2);
}
}
free_lbuf(buf1);
break;
}
/* Success! You killed him */
buf1 = alloc_lbuf("do_kill.succ.1");
buf2 = alloc_lbuf("do_kill.succ.2");
if (Suspect(player)) {
strcpy(buf1, Name(player));
if (player == Owner(player)) {
raw_broadcast(0, WIZARD,
"[Suspect] %s killed %s(#%d).",
buf1, Name(victim), victim);
} else {
strcpy(buf2, Name(Owner(player)));
raw_broadcast(0, WIZARD,
"[Suspect] %s <via %s(#%d)> killed %s(#%d).",
buf2, buf1, player, Name(victim),
victim);
}
}
sprintf(buf1, "You killed %s!", Name(victim));
sprintf(buf2, "killed %s!", Name(victim));
if (Typeof(victim) != TYPE_PLAYER)
if (halt_que(NOTHING, victim) > 0)
if (!Quiet(victim))
notify(Owner(victim), "Halted.");
did_it(player, victim, A_KILL, buf1, A_OKILL, buf2, A_AKILL,
(char **)NULL, 0);
/* notify victim */
sprintf(buf1, "%s killed you!", Name(player));
notify_with_cause(victim, player, buf1);
/* Pay off the bonus */
if (key == KILL_KILL) {
cost /= 2; /* victim gets half */
if (Pennies(Owner(victim)) < mudconf.paylimit) {
sprintf(buf1,
"Your insurance policy pays %d %s.",
cost, mudconf.many_coins);
notify(victim, buf1);
giveto(Owner(victim), cost, NOTHING);
} else {
notify(victim,
"Your insurance policy has been revoked.");
}
}
free_lbuf(buf1);
free_lbuf(buf2);
/* send him home */
move_via_generic(victim, HOME, NOTHING, 0);
divest_object(victim);
break;
}
}
void do_notify
(
dbref executor,
dbref caller,
dbref enactor,
int key,
int nargs,
char *what,
char *count
)
{
UNUSED_PARAMETER(caller);
UNUSED_PARAMETER(enactor);
UNUSED_PARAMETER(nargs);
char *obj = parse_to(&what, '/', 0);
init_match(executor, obj, NOTYPE);
match_everything(0);
dbref thing = noisy_match_result();
if (!Good_obj(thing))
{
return;
}
if (!Controls(executor, thing) && !Link_ok(thing))
{
notify(executor, NOPERM_MESSAGE);
}
else
{
int atr = A_SEMAPHORE;
if ( what
&& what[0] != '\0')
{
int i = mkattr(executor, what);
if (0 < i)
{
atr = i;
if (atr != A_SEMAPHORE)
{
// Do they have permission to set this attribute?
//
ATTR *ap = (ATTR *)anum_get(atr);
if (!bCanSetAttr(executor, thing, ap))
{
notify_quiet(executor, NOPERM_MESSAGE);
return;
}
}
}
}
int loccount;
if ( count
&& count[0] != '\0')
{
loccount = mux_atol(count);
}
else
{
loccount = 1;
}
if (loccount > 0)
{
nfy_que(thing, atr, key, loccount);
if ( (!(Quiet(executor) || Quiet(thing)))
&& key != NFY_QUIET)
{
if (key == NFY_DRAIN)
{
notify_quiet(executor, "Drained.");
}
else
{
notify_quiet(executor, "Notified.");
}
}
}
}
}
// ---------------------------------------------------------------------------
// do_halt: Command interface to halt_que.
//
void do_halt(dbref executor, dbref caller, dbref enactor, int eval, int key, char *target)
{
UNUSED_PARAMETER(caller);
UNUSED_PARAMETER(enactor);
UNUSED_PARAMETER(eval);
dbref executor_targ, obj_targ;
if ((key & HALT_ALL) && !Can_Halt(executor))
{
notify(executor, NOPERM_MESSAGE);
return;
}
// Figure out what to halt.
//
if (!target || !*target)
{
obj_targ = NOTHING;
if (key & HALT_ALL)
{
executor_targ = NOTHING;
}
else
{
executor_targ = Owner(executor);
if (!isPlayer(executor))
{
obj_targ = executor;
}
}
}
else
{
if (Can_Halt(executor))
{
obj_targ = match_thing(executor, target);
}
else
{
obj_targ = match_controlled(executor, target);
}
if (!Good_obj(obj_targ))
{
return;
}
if (key & HALT_ALL)
{
notify(executor, "Can't specify a target and /all");
return;
}
if (isPlayer(obj_targ))
{
executor_targ = obj_targ;
obj_targ = NOTHING;
}
else
{
executor_targ = NOTHING;
}
}
int numhalted = halt_que(executor_targ, obj_targ);
if (Quiet(executor))
{
return;
}
notify(Owner(executor), tprintf("%d queue entr%s removed.", numhalted, numhalted == 1 ? "y" : "ies"));
}
// ---------------------------------------------------------------------------
// flag_set: Set or clear a specified flag on an object.
//
void flag_set(dbref target, dbref player, UTF8 *flag, int key)
{
bool bDone = false;
do
{
// Trim spaces, and handle the negation character.
//
while (mux_isspace(*flag))
{
flag++;
}
bool bNegate = false;
if (*flag == '!')
{
bNegate = true;
do
{
flag++;
} while (mux_isspace(*flag));
}
// Beginning of flag name is now 'flag'.
//
UTF8 *nflag = flag;
while ( *nflag != '\0'
&& !mux_isspace(*nflag))
{
nflag++;
}
if (*nflag == '\0')
{
bDone = true;
}
else
{
*nflag = '\0';
}
// Make sure a flag name was specified.
//
if (*flag == '\0')
{
if (bNegate)
{
notify(player, T("You must specify a flag to clear."));
}
else
{
notify(player, T("You must specify a flag to set."));
}
}
else
{
FLAGNAMEENT *fp = find_flag(flag);
if (!fp)
{
notify(player, T("I do not understand that flag."));
}
else
{
FLAGBITENT *fbe = fp->fbe;
bool bClearSet = bNegate;
if (!fp->bPositive)
{
bNegate = !bNegate;
}
// Invoke the flag handler, and print feedback.
//
if (!fbe->handler(target, player, fbe->flagvalue, fbe->flagflag, bNegate))
{
notify(player, NOPERM_MESSAGE);
}
else if (!(key & SET_QUIET) && !Quiet(player))
{
notify(player, (bClearSet ? T("Cleared.") : T("Set.")));
}
}
}
flag = nflag + 1;
} while (!bDone);
}