// look.cpp -- Commands which look at things.
//
// $Id: look.cpp,v 1.35 2005/10/16 20:48:14 sdennis Exp $
//
// MUX 2.4
// Copyright (C) 1998 through 2004 Solid Vertical Domains, Ltd. All
// rights not explicitly given are reserved.
//
#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "ansi.h"
#include "attrs.h"
#include "command.h"
#include "interface.h"
#include "powers.h"
#ifdef REALITY_LVLS
#include "levels.h"
#endif /* REALITY_LVLS */
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
#define NORMAL_REALM 0
#define UMBRA_REALM 1
#define SHROUD_REALM 2
#define MATRIX_REALM 3
#define FAE_REALM 4
#define CHIMERA_REALM 5
#define BLIND_REALM 6
#define STAFF_REALM 7
#define NUMBER_OF_REALMS 8
int RealmActions[NUMBER_OF_REALMS] =
{
REALM_DO_NORMALLY_SEEN,
REALM_DO_SHOW_UMBRADESC,
REALM_DO_SHOW_WRAITHDESC,
REALM_DO_SHOW_MATRIXDESC,
REALM_DO_SHOW_FAEDESC,
REALM_DO_SHOW_FAEDESC,
REALM_DO_HIDDEN_FROM_YOU,
REALM_DO_NORMALLY_SEEN
};
// Umbra and Matrix are realms unto themselves, so if you aren't in the same
// realm as what you're looking at, you can't see it.
//
// Normal things can't see shroud things, but shroud things can see normal things.
//
// Only Fae and Chimera can see Chimera.
//
#define MAP_SEEN 0 // Show this to that.
#define MAP_HIDE 1 // Always hide this from that.
#define MAP_NO_ADESC 2 // Don't trigger DESC actions on that.
#define MAP_MEDIUM 4 // Hide this from that unless that is a medium and this is moving or talking.
int RealmHiddenMap[NUMBER_OF_REALMS][NUMBER_OF_REALMS] =
{
/* NORMAL LOOKER */ { MAP_SEEN, MAP_HIDE, MAP_MEDIUM, MAP_HIDE, MAP_SEEN, MAP_HIDE, MAP_NO_ADESC, MAP_SEEN},
/* UMBRA LOOKER */ { MAP_HIDE, MAP_SEEN, MAP_MEDIUM, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_SEEN},
/* SHROUD LOOKER */ { MAP_NO_ADESC, MAP_HIDE, MAP_SEEN, MAP_HIDE, MAP_NO_ADESC, MAP_HIDE, MAP_NO_ADESC, MAP_SEEN},
/* MATRIX LOOKER */ { MAP_HIDE, MAP_HIDE, MAP_MEDIUM, MAP_SEEN, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_SEEN},
/* FAE LOOKER */ { MAP_SEEN, MAP_HIDE, MAP_MEDIUM, MAP_HIDE, MAP_SEEN, MAP_SEEN, MAP_NO_ADESC, MAP_SEEN},
/* CHIMERA LOOKER */ { MAP_NO_ADESC, MAP_HIDE, MAP_MEDIUM, MAP_HIDE, MAP_SEEN, MAP_SEEN, MAP_NO_ADESC, MAP_SEEN},
/* BLIND LOOKER */ { MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_SEEN},
/* STAFF LOOKER */ { MAP_SEEN, MAP_SEEN, MAP_SEEN, MAP_SEEN, MAP_SEEN, MAP_SEEN, MAP_SEEN, MAP_SEEN}
};
int RealmExitsMap[NUMBER_OF_REALMS][NUMBER_OF_REALMS] =
{
/* NORMAL LOOKER */ { MAP_SEEN, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE},
/* UMBRA LOOKER */ { MAP_SEEN, MAP_SEEN, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE},
/* SHROUD LOOKER */ { MAP_SEEN, MAP_HIDE, MAP_SEEN, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE},
/* MATRIX LOOKER */ { MAP_SEEN, MAP_HIDE, MAP_HIDE, MAP_SEEN, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE},
/* FAE LOOKER */ { MAP_SEEN, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_SEEN, MAP_SEEN, MAP_HIDE, MAP_HIDE},
/* CHIMERA LOOKER */ { MAP_SEEN, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_SEEN, MAP_SEEN, MAP_HIDE, MAP_HIDE},
/* BLIND LOOKER */ { MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE, MAP_HIDE},
/* STAFF LOOKER */ { MAP_SEEN, MAP_SEEN, MAP_SEEN, MAP_SEEN, MAP_SEEN, MAP_SEEN, MAP_SEEN, MAP_SEEN}
};
int WhichRealm(dbref what, bool bPeering)
{
int realm = NORMAL_REALM;
if (isMatrix(what)) realm = MATRIX_REALM;
else if (isUmbra(what)) realm = UMBRA_REALM;
else if (isShroud(what)) realm = SHROUD_REALM;
else if (isChimera(what)) realm = CHIMERA_REALM;
else if (isFae(what)) realm = FAE_REALM;
if (bPeering)
{
char *buff;
dbref owner;
int flags;
int iPeeringRealm = get_atr("PEERING_REALM");
if (0 < iPeeringRealm)
{
buff = atr_get(what, iPeeringRealm, &owner, &flags);
if (*buff)
{
if (mux_stricmp(buff, "FAE") == 0) realm = FAE_REALM;
else if (mux_stricmp(buff, "CHIMERA") == 0) realm = CHIMERA_REALM;
else if (mux_stricmp(buff, "SHROUD") == 0) realm = SHROUD_REALM;
else if (mux_stricmp(buff, "UMBRA") == 0) realm = UMBRA_REALM;
else if (mux_stricmp(buff, "MATRIX") == 0) realm = MATRIX_REALM;
else if (mux_stricmp(buff, "NORMAL") == 0) realm = NORMAL_REALM;
else if (mux_stricmp(buff, "BLIND") == 0) realm = BLIND_REALM;
else if (mux_stricmp(buff, "STAFF") == 0) realm = STAFF_REALM;
}
free_lbuf(buff);
}
}
return realm;
}
int HandleObfuscation(dbref looker, dbref lookee, int threshhold)
{
int iReturn = REALM_DO_NORMALLY_SEEN;
if (isObfuscate(lookee))
{
char *buff;
int iObfuscateLevel = 0;
dbref owner;
int flags;
buff = atr_get(lookee, get_atr("OBF_LEVEL"), &owner, &flags);
if (*buff)
{
iObfuscateLevel = mux_atol(buff);
}
free_lbuf(buff);
// For OBF_LEVELS of 0, 1, and 2, we show the regular description.
// 3 and above start showing a different OBFDESC.
//
if (3 <= iObfuscateLevel)
{
iReturn = REALM_DO_SHOW_OBFDESC;
}
if (threshhold < iObfuscateLevel)
{
int iHeightenSensesLevel = 0;
if (isHeightenedSenses(looker))
{
buff = atr_get(looker, get_atr("HSS_LEVEL"), &owner, &flags);
if (*buff)
{
iHeightenSensesLevel = mux_atol(buff);
}
free_lbuf(buff);
}
if (iHeightenSensesLevel < iObfuscateLevel)
{
iReturn = REALM_DO_HIDDEN_FROM_YOU;
}
else if (iObfuscateLevel == iHeightenSensesLevel)
{
if (RandomINT32(0,1))
{
iReturn = REALM_DO_HIDDEN_FROM_YOU;
}
}
}
}
return iReturn;
}
int DoThingToThingVisibility(dbref looker, dbref lookee, int action_state)
{
// If the looker is a room, then there is some contents/recursion stuff
// that happens in the rest of the game code. We'll be called later for
// each item in the room, things that are nearby the room, etc.
//
if (isRoom(looker))
{
return REALM_DO_NORMALLY_SEEN;
}
if (Staff(looker))
{
if (Connected(looker))
{
// Staff players can see everything
//
return REALM_DO_NORMALLY_SEEN;
}
if (isThing(looker))
{
// Wizard things in the master room can see everything.
//
if (Location(looker) == mudconf.master_room)
{
return REALM_DO_NORMALLY_SEEN;
}
}
}
int realmLooker = WhichRealm(looker, isPeering(looker));
int realmLookee = WhichRealm(lookee, false);
// You can always see yourself.
//
if (looker == lookee)
{
return RealmActions[realmLooker];
}
bool bDisableADESC = false;
if (isRoom(lookee) || isExit(lookee))
{
// All realms see normal rooms and exits, however, if a realm
// specific description exists, they use that one. If a room or exit
// is flagged with a specific realm, then -only- players and things of
// that realm can see it.
//
// Fae and Chimera are treated as the same realm for this purpose.
//
if (RealmExitsMap[realmLooker][realmLookee] == MAP_HIDE)
{
return REALM_DO_HIDDEN_FROM_YOU;
}
}
else
{
if (Staff(lookee))
{
// Staff players are seen in every realm.
//
if (Connected(lookee))
{
return REALM_DO_NORMALLY_SEEN;
}
if (isThing(lookee))
{
// Everyone can use wizard things in the master room.
//
// Wizard things that aren't in the master room follow the same
// realm-rules as everything else.
//
if (Location(lookee) == mudconf.master_room)
{
return REALM_DO_NORMALLY_SEEN;
}
}
}
int iMap = RealmHiddenMap[realmLooker][realmLookee];
if (iMap & MAP_HIDE)
{
return REALM_DO_HIDDEN_FROM_YOU;
}
if (iMap & MAP_MEDIUM)
{
if (isMedium(looker))
{
if (action_state == ACTION_IS_STATIONARY)
{
// Even Mediums can't hear it if the Wraith is just standing still.
//
return REALM_DO_HIDDEN_FROM_YOU;
}
}
else
{
return REALM_DO_HIDDEN_FROM_YOU;
}
}
if (iMap & MAP_NO_ADESC)
{
bDisableADESC = true;
}
}
// Do default see rules.
//
int iReturn = RealmActions[realmLooker];
if (iReturn == REALM_DO_HIDDEN_FROM_YOU)
{
return iReturn;
}
// Do Obfuscate/Heighten Senses rules.
//
int threshhold = 0;
switch (action_state)
{
case ACTION_IS_STATIONARY:
threshhold = 0;
break;
case ACTION_IS_MOVING:
threshhold = 1;
break;
case ACTION_IS_TALKING:
if (bDisableADESC)
{
iReturn |= REALM_DISABLE_ADESC;
}
return iReturn;
}
int iObfReturn = HandleObfuscation(looker, lookee, threshhold);
switch (iObfReturn)
{
case REALM_DO_SHOW_OBFDESC:
case REALM_DO_HIDDEN_FROM_YOU:
iReturn = iObfReturn;
break;
}
// Decide whether to disable ADESC or not. If we can look at them,
// and ADESC isn't -already- disabled via SHROUD looking at NORMAL (see above).
// then, ADESC may be disabled here if the looker is Obfuscated to the lookee.
//
if (iReturn != REALM_DO_HIDDEN_FROM_YOU && !bDisableADESC)
{
if (REALM_DO_HIDDEN_FROM_YOU == HandleObfuscation(lookee, looker, 0))
{
bDisableADESC = true;
}
}
if (bDisableADESC)
{
iReturn |= REALM_DISABLE_ADESC;
}
return iReturn;
}
void LetDescriptionsDefault(dbref thing, int *piDESC, int *piADESC, int RealmDirective)
{
int iDesc = 0;
dbref owner;
int flags;
*piDESC = A_DESC;
*piADESC = A_ADESC;
if (RealmDirective & REALM_DISABLE_ADESC)
{
*piADESC = 0;
}
switch (RealmDirective & REALM_DO_MASK)
{
case REALM_DO_SHOW_OBFDESC:
iDesc = get_atr("OBFDESC");
break;
case REALM_DO_SHOW_WRAITHDESC:
iDesc = get_atr("WRAITHDESC");
*piADESC = 0;
break;
case REALM_DO_SHOW_UMBRADESC:
iDesc = get_atr("UMBRADESC");
break;
case REALM_DO_SHOW_MATRIXDESC:
iDesc = get_atr("MATRIXDESC");
break;
case REALM_DO_SHOW_FAEDESC:
iDesc = get_atr("FAEDESC");
break;
}
if (iDesc > 0)
{
char *buff = atr_pget(thing, iDesc, &owner, &flags);
if (buff)
{
if (*buff)
{
*piDESC = iDesc;
}
free_lbuf(buff);
}
}
}
#endif
static void look_exits(dbref player, dbref loc, const char *exit_name)
{
// Make sure location has exits.
//
if ( !Good_obj(loc)
|| !Has_exits(loc))
{
return;
}
dbref thing, parent;
char *buff, *e, *buff1, *e1;
const char *s;
// make sure there is at least one visible exit.
//
bool bFoundAnyDisplayable = false;
bool bFoundAny = false;
int key = 0;
int lev;
#ifdef REALITY_LVLS
if (Dark(loc) || !IsReal(player, loc))
#else
if (Dark(loc))
#endif /* REALITY_LVLS */
{
key |= VE_BASE_DARK;
}
ITER_PARENTS(loc, parent, lev)
{
key &= ~VE_LOC_DARK;
if (Dark(parent))
{
key |= VE_LOC_DARK;
}
DOLIST(thing, Exits(parent))
{
bFoundAny = true;
if (exit_displayable(thing, player, key))
{
bFoundAnyDisplayable = true;
break;
}
}
if (bFoundAnyDisplayable)
{
break;
}
}
if (!bFoundAny)
{
return;
}
// Retrieve the ExitFormat attribute from the location, evaluate and display
// the results in lieu of the traditional exits list if it exists.
//
dbref aowner;
int aflags;
char *ExitFormatBuffer = atr_pget(loc, A_EXITFORMAT, &aowner, &aflags);
char *ExitFormat = ExitFormatBuffer;
bool bDisplayExits = bFoundAnyDisplayable;
if (*ExitFormat)
{
char *VisibleObjectList = alloc_lbuf("look_exits.VOL");
char *tPtr = VisibleObjectList;
ITL pContext;
ItemToList_Init(&pContext, VisibleObjectList, &tPtr, '#');
ITER_PARENTS(loc, parent, lev)
{
key &= ~VE_LOC_DARK;
if (Dark(parent))
{
key |= VE_LOC_DARK;
}
bool bShortCircuit = false;
DOLIST(thing, Exits(parent))
{
if ( exit_displayable(thing, player, key)
&& !ItemToList_AddInteger(&pContext, thing))
{
bShortCircuit = true;
break;
}
}
if (bShortCircuit) break;
}
ItemToList_Final(&pContext);
char *FormatOutput = alloc_lbuf("look_exits.FO");
tPtr = FormatOutput;
char *preserve[MAX_GLOBAL_REGS];
int preserve_len[MAX_GLOBAL_REGS];
save_and_clear_global_regs("look_exits_save", preserve, preserve_len);
mux_exec(FormatOutput, &tPtr, loc, player, player,
EV_FCHECK | EV_EVAL | EV_TOP,
&ExitFormat, &VisibleObjectList, 1);
restore_global_regs("look_exits_restore", preserve, preserve_len);
notify(player, FormatOutput);
free_lbuf(FormatOutput);
free_lbuf(VisibleObjectList);
bDisplayExits = 0;
}
free_lbuf(ExitFormatBuffer);
if (!bDisplayExits)
{
return;
}
// Display the list of exit names
//
notify(player, exit_name);
e = buff = alloc_lbuf("look_exits");
e1 = buff1 = alloc_lbuf("look_exits2");
ITER_PARENTS(loc, parent, lev)
{
key &= ~VE_LOC_DARK;
if (Dark(parent))
{
key |= VE_LOC_DARK;
}
if (Transparent(loc))
{
DOLIST(thing, Exits(parent))
{
if (exit_displayable(thing, player, key))
{
strcpy(buff, Name(thing));
for (e = buff; *e && *e != ';'; e++)
{
; // Nothing.
}
*e = '\0';
notify(player, tprintf("%s leads to %s.", buff, Name(Location(thing))));
}
}
}
else
{
DOLIST(thing, Exits(parent))
{
if (exit_displayable(thing, player, key))
{
e1 = buff1;
// Put the exit name in buff1.
//
// chop off first exit alias to display
//
if (buff != e)
{
safe_str(" ", buff, &e);
}
for (s = Name(thing); *s && (*s != ';'); s++)
{
safe_chr(*s, buff1, &e1);
}
*e1 = 0;
/* Copy the exit name into 'buff' */
if (Html(player))
{
/* XXX The exit name needs to be HTML escaped. */
safe_str("<a xch_cmd=\"", buff, &e);
safe_str(buff1, buff, &e);
safe_str("\"> ", buff, &e);
html_escape(buff1, buff, &e);
safe_str(" </a>", buff, &e);
}
else
{
/* Append this exit to the list */
safe_str(buff1, buff, &e);
}
}
}
}
}
if (!Transparent(loc))
{
if (Html(player))
{
safe_str("\r\n", buff, &e);
*e = 0;
notify_html(player, buff);
}
else
{
*e = 0;
notify(player, buff);
}
}
free_lbuf(buff);
free_lbuf(buff1);
}
#define CONTENTS_LOCAL 0
#define CONTENTS_NESTED 1
#define CONTENTS_REMOTE 2
static void look_contents(dbref player, dbref loc, const char *contents_name, int style)
{
dbref thing;
char *buff;
char *html_buff, *html_cp;
char remote_num[32];
// Check to see if he can see the location.
//
#ifdef REALITY_LVLS
bool can_see_loc = ( !Dark(loc) && IsReal(player, loc)
#else
bool can_see_loc = ( !Dark(loc)
#endif /* REALITY_LVLS */
|| (mudconf.see_own_dark && Examinable(player, loc)));
dbref aowner;
int aflags;
char *ContentsFormatBuffer = atr_pget(loc, A_CONFORMAT, &aowner, &aflags);
char *ContentsFormat = ContentsFormatBuffer;
bool bDisplayContents = true;
if (*ContentsFormat)
{
char *VisibleObjectList = alloc_lbuf("look_contents.VOL");
char *tPtr = VisibleObjectList;
ITL pContext;
ItemToList_Init(&pContext, VisibleObjectList, &tPtr, '#');
DOLIST(thing, Contents(loc))
{
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
if ( can_see(player, thing, can_see_loc)
&& (REALM_DO_HIDDEN_FROM_YOU != DoThingToThingVisibility(player,
thing, ACTION_IS_STATIONARY)) )
#else
if (can_see(player, thing, can_see_loc))
#endif
{
if (!ItemToList_AddInteger(&pContext, thing))
{
break;
}
}
}
ItemToList_Final(&pContext);
char *ContentsNameScratch = alloc_lbuf("look_contents.CNS");
tPtr = ContentsNameScratch;
safe_str(contents_name, ContentsNameScratch, &tPtr);
*tPtr = '\0';
char *FormatOutput = alloc_lbuf("look_contents.FO");
tPtr = FormatOutput;
char* ParameterList[] =
{ VisibleObjectList, ContentsNameScratch };
char *preserve[MAX_GLOBAL_REGS];
int preserve_len[MAX_GLOBAL_REGS];
save_and_clear_global_regs("look_contents_save", preserve, preserve_len);
mux_exec(FormatOutput, &tPtr, loc, player, player,
EV_FCHECK | EV_EVAL | EV_TOP,
&ContentsFormat, ParameterList, 2);
restore_global_regs("look_contents_restore", preserve, preserve_len);
notify(player, FormatOutput);
free_lbuf(FormatOutput);
free_lbuf(ContentsNameScratch);
free_lbuf(VisibleObjectList);
bDisplayContents = false;
}
free_lbuf(ContentsFormatBuffer);
if (!bDisplayContents)
{
return;
}
html_buff = html_cp = alloc_lbuf("look_contents");
// Check to see if there is anything there.
//
DOLIST(thing, Contents(loc))
{
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
if ( can_see(player, thing, can_see_loc)
&& (REALM_DO_HIDDEN_FROM_YOU != DoThingToThingVisibility(player, thing, ACTION_IS_STATIONARY)))
#else
if (can_see(player, thing, can_see_loc))
#endif
{
// Something exists! Show him everything.
//
notify(player, contents_name);
DOLIST(thing, Contents(loc))
{
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
if ( can_see(player, thing, can_see_loc)
&& (REALM_DO_HIDDEN_FROM_YOU != DoThingToThingVisibility(player, thing, ACTION_IS_STATIONARY)))
#else
if (can_see(player, thing, can_see_loc))
#endif
{
buff = unparse_object(player, thing, true);
html_cp = html_buff;
if (Html(player))
{
safe_str("<a xch_cmd=\"look ", html_buff, &html_cp);
switch (style)
{
case CONTENTS_LOCAL:
safe_str(Name(thing), html_buff, &html_cp);
break;
case CONTENTS_NESTED:
safe_str(Name(Location(thing)), html_buff, &html_cp);
safe_str("'s ", html_buff, &html_cp);
safe_str(Name(thing), html_buff, &html_cp);
break;
case CONTENTS_REMOTE:
remote_num[0] = '#';
mux_ltoa(thing, remote_num+1);
safe_str(remote_num, html_buff, &html_cp);
break;
default:
break;
}
safe_str("\">", html_buff, &html_cp);
html_escape(buff, html_buff, &html_cp);
safe_str("</a>\r\n", html_buff, &html_cp);
*html_cp = 0;
notify_html(player, html_buff);
}
else
{
notify(player, buff);
}
free_lbuf(buff);
}
}
break; // we're done.
}
}
free_lbuf(html_buff);
}
typedef struct
{
int mask;
int letter;
} ATTR_DECODE_ENTRY, *PATTR_DECODE_ENTRY;
static ATTR_DECODE_ENTRY attr_decode_table[] =
{
{ AF_LOCK, '+' },
{ AF_NOPROG, '$' },
{ AF_CASE, 'C' },
{ AF_HTML, 'H' },
{ AF_PRIVATE, 'I' },
{ AF_NOPARSE, 'P' },
{ AF_REGEXP, 'R' },
{ AF_VISUAL, 'V' },
{ AF_MDARK, 'M' },
{ AF_WIZARD, 'W' },
{ 0, 0 }
};
size_t decode_attr_flags(int aflags, char *buff)
{
char *p = buff;
PATTR_DECODE_ENTRY pEntry;
for (pEntry = attr_decode_table; pEntry->mask; pEntry++)
{
if (aflags & pEntry->mask)
{
*p++ = pEntry->letter;
}
}
*p = '\0';
return p - buff;
}
static void view_atr
(
dbref player,
dbref thing,
ATTR *ap,
char *text,
dbref aowner,
int aflags,
bool skip_tag
)
{
char *buf;
if (ap->flags & AF_IS_LOCK)
{
BOOLEXP *pBoolExp = parse_boolexp(player, text, true);
text = unparse_boolexp(player, pBoolExp);
free_boolexp(pBoolExp);
}
// If we don't control the object or own the attribute, hide the
// attr owner and flag info.
//
if ( !Controls(player, thing)
&& Owner(player) != aowner)
{
if ( skip_tag
&& ap->number == A_DESC)
{
buf = text;
}
else
{
buf = tprintf("%s%s:%s %s", ANSI_HILITE, ap->name, ANSI_NORMAL, text);
}
notify(player, buf);
return;
}
// Generate flags.
//
char xbuf[11];
decode_attr_flags(aflags, xbuf);
if ( aowner != Owner(thing)
&& aowner != NOTHING)
{
buf = tprintf("%s%s [#%d%s]:%s %s", ANSI_HILITE,
ap->name, aowner, xbuf, ANSI_NORMAL, text);
}
else if (*xbuf)
{
buf = tprintf("%s%s [%s]:%s %s", ANSI_HILITE, ap->name,
xbuf, ANSI_NORMAL, text);
}
else if ( !skip_tag
|| ap->number != A_DESC)
{
buf = tprintf("%s%s:%s %s", ANSI_HILITE, ap->name, ANSI_NORMAL, text);
}
else
{
buf = text;
}
notify(player, buf);
}
static void look_atrs1
(
dbref player,
dbref thing,
dbref othing,
bool check_exclude,
bool hash_insert
)
{
dbref aowner;
int ca, aflags;
ATTR *pattr;
char *as, *buf;
bool bFoundCommands = false;
bool bFoundListens = false;
ATTR cattr;
for (ca = atr_head(thing, &as); ca; ca = atr_next(&as))
{
if ( ca == A_DESC
|| ca == A_LOCK)
{
continue;
}
pattr = atr_num(ca);
if (!pattr)
{
continue;
}
memcpy(&cattr, pattr, sizeof(ATTR));
// Should we exclude this attr?
//
if ( check_exclude
&& ( (pattr->flags & AF_PRIVATE)
|| hashfindLEN(&ca, sizeof(ca), &mudstate.parent_htab)))
{
continue;
}
buf = atr_get(thing, ca, &aowner, &aflags);
if (!(aflags & AF_NOPROG))
{
switch (buf[0])
{
case AMATCH_CMD:
bFoundCommands = true;
break;
case AMATCH_LISTEN:
bFoundListens = true;
break;
}
}
if (bCanReadAttr(player, othing, &cattr, false))
{
if (!(check_exclude && (aflags & AF_PRIVATE)))
{
if (hash_insert)
{
hashaddLEN(&ca, sizeof(ca), pattr,
&mudstate.parent_htab);
}
view_atr(player, thing, &cattr, buf, aowner, aflags, false);
}
}
free_lbuf(buf);
}
if (bFoundCommands)
{
mudstate.bfNoCommands.Clear(thing);
mudstate.bfCommands.Set(thing);
}
else
{
mudstate.bfCommands.Clear(thing);
mudstate.bfNoCommands.Set(thing);
}
if (bFoundListens)
{
mudstate.bfNoListens.Clear(thing);
mudstate.bfListens.Set(thing);
}
else
{
mudstate.bfListens.Clear(thing);
mudstate.bfNoListens.Set(thing);
}
}
static void look_atrs(dbref player, dbref thing, bool check_parents)
{
dbref parent;
int lev;
bool check_exclude, hash_insert;
if (!check_parents)
{
look_atrs1(player, thing, thing, false, false);
}
else
{
hash_insert = true;
check_exclude = false;
hashflush(&mudstate.parent_htab);
ITER_PARENTS(thing, parent, lev)
{
if (!Good_obj(Parent(parent)))
{
hash_insert = false;
}
look_atrs1(player, parent, thing, check_exclude, hash_insert);
check_exclude = true;
}
}
}
static bool show_a_desc(dbref player, dbref loc)
{
int iDescDefault = A_DESC;
int iADescDefault = A_ADESC;
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
int iRealmDirective = DoThingToThingVisibility(player, loc, ACTION_IS_STATIONARY);
if (REALM_DO_HIDDEN_FROM_YOU == iRealmDirective)
{
return true;
}
LetDescriptionsDefault(loc, &iDescDefault, &iADescDefault, iRealmDirective);
#endif
bool ret = false;
dbref aowner;
int aflags;
bool indent = (isRoom(loc) && mudconf.indent_desc && atr_get_raw(loc, A_DESC));
char *DescFormatBuffer = atr_pget(loc, A_DESCFORMAT, &aowner, &aflags);
char *DescFormat = DescFormatBuffer;
if (*DescFormat)
{
char *FormatOutput = alloc_lbuf("look_description.FO");
char *tPtr = FormatOutput;
ATTR *cattr = atr_num(iDescDefault);
char *tbuf1 = atr_pget(loc, iDescDefault, &aowner, &aflags);
char *str = tbuf1;
char *temp = alloc_lbuf("look_description.ET");
char *bp = temp;
mux_exec(temp, &bp, loc, player, player,
EV_FCHECK | EV_EVAL | EV_TOP,
&str, (char **)NULL, 0);
*bp = '\0';
char *attrname = alloc_lbuf("look_description.AN");
char *cp = attrname;
safe_str(cattr->name, attrname, &cp);
*cp = '\0';
char* ParameterList[] =
{ temp, attrname };
mux_exec(FormatOutput, &tPtr, loc, player, player,
EV_FCHECK | EV_EVAL | EV_TOP,
&DescFormat, ParameterList, 2);
notify(player, FormatOutput);
#ifdef REALITY_LVLS
did_it_rlevel(player, loc, 0, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#else
did_it(player, loc, 0, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#endif /* REALITY_LVLS */
free_lbuf(tbuf1);
free_lbuf(attrname);
free_lbuf(FormatOutput);
free_lbuf(temp);
ret = true;
}
else
{
char *got;
if (Html(player))
{
got = atr_pget(loc, A_HTDESC, &aowner, &aflags);
if (*got)
{
#ifdef REALITY_LVLS
did_it_rlevel(player, loc, A_HTDESC, NULL, A_ODESC, NULL, A_ADESC, (char **) NULL, 0);
#else
did_it(player, loc, A_HTDESC, NULL, A_ODESC, NULL, A_ADESC, (char **) NULL, 0);
#endif /* REALITY_LVLS */
ret = true;
}
else
{
free_lbuf(got);
got = atr_pget(loc, iDescDefault, &aowner, &aflags);
if (*got)
{
if (indent)
{
raw_notify_newline(player);
}
#ifdef REALITY_LVLS
did_it_rlevel(player, loc, iDescDefault, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#else
did_it(player, loc, iDescDefault, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#endif /* REALITY_LVLS */
if (indent)
{
raw_notify_newline(player);
}
ret = true;
}
}
}
else if (*(got = atr_pget(loc, iDescDefault, &aowner, &aflags)))
{
if (indent)
{
raw_notify_newline(player);
}
#ifdef REALITY_LVLS
did_it_rlevel(player, loc, iDescDefault, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#else
did_it(player, loc, iDescDefault, NULL, A_ODESC, NULL, iADescDefault, (char **) NULL, 0);
#endif /* REALITY_LVLS */
if (indent)
{
raw_notify_newline(player);
}
ret = true;
}
free_lbuf(got);
}
free_lbuf(DescFormatBuffer);
return ret;
}
static void look_simple(dbref player, dbref thing, bool obey_terse)
{
// Only makes sense for things that can hear.
//
if (!Hearer(player))
{
return;
}
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
int iRealmDirective = DoThingToThingVisibility(player, thing, ACTION_IS_STATIONARY);
if (REALM_DO_HIDDEN_FROM_YOU == iRealmDirective)
{
notify(player, NOMATCH_MESSAGE);
return;
}
#endif
// Get the name and db-number if we can examine it.
//
int can_see_thing = Examinable(player, thing);
if (can_see_thing)
{
char *buff = unparse_object(player, thing, true);
notify(player, buff);
free_lbuf(buff);
}
int iDescDefault = A_DESC;
int iADescDefault = A_ADESC;
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
LetDescriptionsDefault(thing, &iDescDefault, &iADescDefault, iRealmDirective);
#endif
int pattr = (obey_terse && Terse(player)) ? 0 : iDescDefault;
if (!show_a_desc(player, thing))
{
notify(player, "You see nothing special.");
#ifdef REALITY_LVLS
did_it_rlevel(player, thing, 0, NULL, A_ODESC, NULL, iADescDefault,
(char **)NULL, 0);
#else
did_it(player, thing, pattr, NULL, A_ODESC, NULL, iADescDefault,
(char **)NULL, 0);
#endif /* REALITY_LVLS */
}
if ( !mudconf.quiet_look
&& ( !Terse(player)
|| mudconf.terse_look))
{
look_atrs(player, thing, false);
}
}
static void show_desc(dbref player, dbref loc, int key)
{
char *got;
dbref aowner;
int aflags;
if ( (key & LK_OBEYTERSE)
&& Terse(player))
{
#ifdef REALITY_LVLS
did_it_rlevel(player, loc, 0, NULL, A_ODESC, NULL, A_ADESC, (char **)NULL, 0);
#else
did_it(player, loc, 0, NULL, A_ODESC, NULL, A_ADESC, (char **)NULL, 0);
#endif /* REALITY_LVLS */
}
else if ( !isRoom(loc)
&& (key & LK_IDESC))
{
if (*(got = atr_pget(loc, A_IDESC, &aowner, &aflags)))
{
#ifdef REALITY_LVLS
did_it_rlevel(player, loc, A_IDESC, NULL, A_ODESC, NULL, A_ADESC, (char **)NULL, 0);
#else
did_it(player, loc, A_IDESC, NULL, A_ODESC, NULL, A_ADESC, (char **)NULL, 0);
#endif /* REALITY_LVLS */
}
else
{
show_a_desc(player, loc);
}
free_lbuf(got);
}
else
{
show_a_desc(player, loc);
}
}
void look_in(dbref player, dbref loc, int key)
{
// Only makes sense for things that can hear.
//
if (!Hearer(player))
{
return;
}
// If he needs the VMRL URL, send it:
//
if (key & LK_SHOWVRML)
{
show_vrml_url(player, loc);
}
// Use @nameformat (by Marlek) if it's present, otherwise, use the
// name and if the player can link to it, it's dbref as well.
//
dbref aowner;
int aflags;
char *NameFormatBuffer = atr_pget(loc, A_NAMEFORMAT, &aowner, &aflags);
char *NameFormat = NameFormatBuffer;
if (*NameFormat)
{
char *FormatOutput = alloc_lbuf("look_name.FO");
char *tPtr = FormatOutput;
char *preserve[MAX_GLOBAL_REGS];
int preserve_len[MAX_GLOBAL_REGS];
save_and_clear_global_regs("look_in_save", preserve, preserve_len);
mux_exec(FormatOutput, &tPtr, loc, player, player,
EV_FCHECK | EV_EVAL | EV_TOP,
&NameFormat, 0, 0);
restore_global_regs("look_in_restore", preserve, preserve_len);
notify(player, FormatOutput);
free_lbuf(FormatOutput);
}
else
{
// Okay, no @NameFormat. Show the normal name.
//
char *buff = unparse_object(player, loc, true);
if (Html(player))
{
notify_html(player, "<center><h3>");
notify(player, buff);
notify_html(player, "</h3></center>");
}
else
{
notify(player, buff);
}
free_lbuf(buff);
}
free_lbuf(NameFormatBuffer);
if (!Good_obj(loc))
{
// If we went to NOTHING et al, then skip the rest.
//
return;
}
// Tell him the description.
//
int showkey = 0;
if (loc == Location(player))
{
showkey |= LK_IDESC;
}
if (key & LK_OBEYTERSE)
{
showkey |= LK_OBEYTERSE;
}
show_desc(player, loc, showkey);
bool is_terse = (key & LK_OBEYTERSE) ? Terse(player) : false;
// Tell him the appropriate messages if he has the key.
//
if (isRoom(loc))
{
int pattr, oattr, aattr;
if (could_doit(player, loc, A_LOCK))
{
pattr = A_SUCC;
oattr = A_OSUCC;
aattr = A_ASUCC;
}
else
{
pattr = A_FAIL;
oattr = A_OFAIL;
aattr = A_AFAIL;
}
if (is_terse)
{
pattr = 0;
}
did_it(player, loc, pattr, NULL, oattr, NULL, aattr, (char **)NULL, 0);
}
// Tell him the attributes, contents and exits.
//
if ( (key & LK_SHOWATTR)
&& !mudconf.quiet_look
&& !is_terse)
{
look_atrs(player, loc, false);
}
if ( !is_terse
|| mudconf.terse_contents)
{
look_contents(player, loc, "Contents:", CONTENTS_LOCAL);
}
if ( (key & LK_SHOWEXIT)
&& ( !is_terse
|| mudconf.terse_exits))
{
look_exits(player, loc, "Obvious exits:");
}
}
void do_look(dbref executor, dbref caller, dbref enactor, int key, char *name)
{
int look_key = LK_SHOWATTR | LK_SHOWEXIT;
if (!mudconf.terse_look)
{
look_key |= LK_OBEYTERSE;
}
dbref loc = Location(executor);
dbref thing;
if (!name || !*name)
{
thing = loc;
if (Good_obj(thing))
{
if (key & LOOK_OUTSIDE)
{
if ( isRoom(thing)
|| Opaque(thing))
{
notify_quiet(executor, "You can't look outside.");
return;
}
thing = Location(thing);
}
look_in(executor, thing, look_key);
}
return;
}
// Look for the target locally.
//
thing = (key & LOOK_OUTSIDE) ? loc : executor;
init_match(thing, name, NOTYPE);
match_exit_with_parents();
match_neighbor();
match_possession();
if (Long_Fingers(executor))
{
match_absolute();
match_player();
}
match_here();
match_me();
match_master_exit();
thing = match_result();
// Not found locally, check possessive.
//
if (!Good_obj(thing))
{
thing = match_status(executor, match_possessed(executor,
((key & LOOK_OUTSIDE) ? loc : executor), name, thing, false));
}
// If we found something, go handle it.
//
if (Good_obj(thing))
{
#ifdef REALITY_LVLS
if (!IsReal(executor, thing))
return;
#endif /* REALITY_LVLS */
switch (Typeof(thing))
{
case TYPE_ROOM:
look_in(executor, thing, look_key);
break;
case TYPE_THING:
case TYPE_PLAYER:
look_simple(executor, thing, !mudconf.terse_look);
if ( !Opaque(thing)
&& ( mudconf.terse_contents
|| !Terse(executor)))
{
look_contents(executor, thing, "Carrying:", CONTENTS_NESTED);
}
break;
case TYPE_EXIT:
look_simple(executor, thing, !mudconf.terse_look);
if ( Transparent(thing)
&& Location(thing) != NOTHING)
{
look_key &= ~LK_SHOWATTR;
look_in(executor, Location(thing), look_key);
}
break;
default:
look_simple(executor, thing, !mudconf.terse_look);
break;
}
}
}
static void debug_examine(dbref player, dbref thing)
{
dbref aowner;
char *buf;
int aflags, ca;
BOOLEXP *pBoolExp;
ATTR *pattr;
char *as, *cp;
notify(player, tprintf("Number = %d", thing));
if (!Good_obj(thing))
{
return;
}
notify(player, tprintf("Name = %s", Name(thing)));
notify(player, tprintf("Location= %d", Location(thing)));
notify(player, tprintf("Contents= %d", Contents(thing)));
notify(player, tprintf("Exits = %d", Exits(thing)));
notify(player, tprintf("Link = %d", Link(thing)));
notify(player, tprintf("Next = %d", Next(thing)));
notify(player, tprintf("Owner = %d", Owner(thing)));
notify(player, tprintf("Pennies = %d", Pennies(thing)));
notify(player, tprintf("Zone = %d", Zone(thing)));
buf = flag_description(player, thing);
notify(player, tprintf("Flags = %s", buf));
free_mbuf(buf);
buf = powers_list(player, thing);
notify(player, tprintf("Powers = %s", buf));
free_lbuf(buf);
#ifdef REALITY_LVLS
buf = rxlevel_description(player, thing);
notify(player, tprintf("RxLevel = %s", buf));
free_lbuf(buf);
buf = txlevel_description(player, thing);
notify(player, tprintf("TxLevel = %s", buf));
free_lbuf(buf);
#endif /* REALITY_LVLS */
buf = atr_get(thing, A_LOCK, &aowner, &aflags);
pBoolExp = parse_boolexp(player, buf, true);
free_lbuf(buf);
notify(player, tprintf("Lock = %s", unparse_boolexp(player, pBoolExp)));
free_boolexp(pBoolExp);
buf = alloc_lbuf("debug_dexamine");
cp = buf;
safe_str("Attr list: ", buf, &cp);
for (ca = atr_head(thing, &as); ca; ca = atr_next(&as))
{
pattr = atr_num(ca);
if (!pattr)
{
continue;
}
atr_get_info(thing, ca, &aowner, &aflags);
if (bCanReadAttr(player, thing, pattr, false))
{
if (pattr)
{
// Valid attr.
//
safe_str(pattr->name, buf, &cp);
safe_chr(' ', buf, &cp);
}
else
{
safe_str(tprintf("%d ", ca), buf, &cp);
}
}
}
*cp = '\0';
notify(player, buf);
free_lbuf(buf);
for (ca = atr_head(thing, &as); ca; ca = atr_next(&as))
{
pattr = atr_num(ca);
if (!pattr)
{
continue;
}
buf = atr_get(thing, ca, &aowner, &aflags);
if (bCanReadAttr(player, thing, pattr, false))
{
view_atr(player, thing, pattr, buf, aowner, aflags, 0);
}
free_lbuf(buf);
}
}
static void exam_wildattrs
(
dbref player,
dbref thing,
bool do_parent
)
{
int atr;
bool got_any = false;
for (atr = olist_first(); atr != NOTHING; atr = olist_next())
{
ATTR *ap = atr_num(atr);
if (!ap)
{
continue;
}
int aflags;
dbref aowner;
char *buf;
if ( do_parent
&& !(ap->flags & AF_PRIVATE))
{
buf = atr_pget(thing, atr, &aowner, &aflags);
}
else
{
buf = atr_get(thing, atr, &aowner, &aflags);
}
// Decide if the player should see the attr: If obj is
// Examinable and has rights to see, yes. If a player and has
// rights to see, yes... except if faraway, attr=DESC, and
// remote DESC-reading is not turned on. If I own the attrib
// and have rights to see, yes... except if faraway, attr=DESC,
// and remote DESC-reading is not turned on.
//
if ( Examinable(player, thing)
&& bCanReadAttr(player, thing, ap, do_parent))
{
got_any = true;
view_atr(player, thing, ap, buf, aowner, aflags, 0);
}
else if (bCanReadAttr(player, thing, ap, isPlayer(thing) ? do_parent : false))
{
got_any = true;
if (aowner == Owner(player))
{
view_atr(player, thing, ap, buf, aowner, aflags, 0);
}
else if ( atr == A_DESC
&& ( mudconf.read_rem_desc
|| nearby(player, thing)))
{
show_desc(player, thing, 0);
}
else if (atr != A_DESC)
{
view_atr(player, thing, ap, buf, aowner, aflags, 0);
}
else
{
notify(player, "<Too far away to get a good look>");
}
}
free_lbuf(buf);
}
if (!got_any)
{
notify_quiet(player, "No matching attributes found.");
}
}
void do_examine(dbref executor, dbref caller, dbref enactor, int key, char *name)
{
// This command is pointless if the player can't hear.
//
if (!Hearer(executor))
{
return;
}
dbref content, exit, aowner, loc;
char savec;
char *temp, *buf, *buf2;
BOOLEXP *pBoolExp;
int aflags;
bool control;
bool do_parent = ((key & EXAM_PARENT) ? true : false);
dbref thing = NOTHING;
if ( !name
|| !*name)
{
thing = Location(executor);
if (thing == NOTHING)
{
return;
}
}
else
{
// Check for obj/attr first.
//
olist_push();
if (parse_attrib_wild(executor, name, &thing, do_parent, true, false))
{
exam_wildattrs(executor, thing, do_parent);
olist_pop();
return;
}
olist_pop();
// Look it up.
//
init_match(executor, name, NOTYPE);
match_everything(MAT_EXIT_PARENTS);
thing = noisy_match_result();
if (!Good_obj(thing))
{
return;
}
}
#if defined(WOD_REALMS) || defined(REALITY_LVLS)
if (REALM_DO_HIDDEN_FROM_YOU == DoThingToThingVisibility(executor, thing, ACTION_IS_STATIONARY))
{
notify(executor, NOMATCH_MESSAGE);
return;
}
#endif
// Check for the /debug switch.
//
if (key & EXAM_DEBUG)
{
if (!Examinable(executor, thing))
{
notify_quiet(executor, NOPERM_MESSAGE);
}
else
{
debug_examine(executor, thing);
}
return;
}
control = ( Examinable(executor, thing)
|| Link_exit(executor, thing));
if (control)
{
buf2 = unparse_object(executor, thing, false);
notify(executor, buf2);
free_lbuf(buf2);
if (mudconf.ex_flags)
{
buf2 = flag_description(executor, thing);
notify(executor, buf2);
free_mbuf(buf2);
}
}
else
{
if ( key == EXAM_DEFAULT
&& !mudconf.exam_public)
{
if (mudconf.read_rem_name)
{
buf2 = alloc_lbuf("do_examine.pub_name");
strcpy(buf2, Name(thing));
notify(executor,
tprintf("%s is owned by %s",
buf2, Name(Owner(thing))));
free_lbuf(buf2);
}
else
{
notify(executor, tprintf("Owned by %s", Name(Owner(thing))));
}
return;
}
}
temp = alloc_lbuf("do_examine.info");
if ( control
|| mudconf.read_rem_desc
|| nearby(executor, thing))
{
temp = atr_get_str(temp, thing, A_DESC, &aowner, &aflags);
if (*temp)
{
if ( Examinable(executor, thing)
|| (aowner == Owner(executor)))
{
view_atr(executor, thing, atr_num(A_DESC), temp,
aowner, aflags, true);
}
else
{
show_desc(executor, thing, 0);
}
}
}
else
{
notify(executor, "<Too far away to get a good look>");
}
if (control)
{
// Print owner, key, and value.
//
savec = mudconf.many_coins[0];
mudconf.many_coins[0] = mux_toupper(mudconf.many_coins[0]);
buf2 = atr_get(thing, A_LOCK, &aowner, &aflags);
pBoolExp = parse_boolexp(executor, buf2, true);
buf = unparse_boolexp(executor, pBoolExp);
free_boolexp(pBoolExp);
strcpy(buf2, Name(Owner(thing)));
notify(executor, tprintf("Owner: %s Key: %s %s: %d", buf2, buf, mudconf.many_coins, Pennies(thing)));
free_lbuf(buf2);
mudconf.many_coins[0] = savec;
// Print the zone
//
if (mudconf.have_zones)
{
buf2 = unparse_object(executor, Zone(thing), false);
notify(executor, tprintf("Zone: %s", buf2));
free_lbuf(buf2);
}
// Print parent
//
loc = Parent(thing);
if (loc != NOTHING)
{
buf2 = unparse_object(executor, loc, false);
notify(executor, tprintf("Parent: %s", buf2));
free_lbuf(buf2);
}
buf2 = powers_list(executor, thing);
notify(executor, tprintf("Powers: %s", buf2));
free_lbuf(buf2);
#ifdef REALITY_LVLS
/* Show Rx and Tx levels */
buf2 = rxlevel_description(executor, thing);
notify(executor, buf2);
free_lbuf(buf2);
buf2 = txlevel_description(executor, thing);
notify(executor, buf2);
free_lbuf(buf2);
#endif /* REALITY_LVLS */
}
if (!(key & EXAM_BRIEF))
{
look_atrs(executor, thing, do_parent);
}
// Show him interesting stuff
//
if (control)
{
// Contents
//
if (Contents(thing) != NOTHING)
{
notify(executor, "Contents:");
DOLIST(content, Contents(thing))
{
buf2 = unparse_object(executor, content, false);
notify(executor, buf2);
free_lbuf(buf2);
}
}
// Show stuff that depends on the object type.
//
switch (Typeof(thing))
{
case TYPE_ROOM:
// Tell him about exits
//
if (Exits(thing) != NOTHING)
{
notify(executor, "Exits:");
DOLIST(exit, Exits(thing))
{
buf2 = unparse_object(executor, exit, false);
notify(executor, buf2);
free_lbuf(buf2);
}
}
else
{
notify(executor, "No exits.");
}
// print dropto if present
//
if (Dropto(thing) != NOTHING)
{
buf2 = unparse_object(executor, Dropto(thing), false);
notify(executor, tprintf("Dropped objects go to: %s", buf2));
free_lbuf(buf2);
}
break;
case TYPE_THING:
case TYPE_PLAYER:
// Tell him about exits
//
if (Exits(thing) != NOTHING)
{
notify(executor, "Exits:");
DOLIST(exit, Exits(thing))
{
buf2 = unparse_object(executor, exit, false);
notify(executor, buf2);
free_lbuf(buf2);
}
}
else
{
notify(executor, "No exits.");
}
// Print home
//
loc = Home(thing);
buf2 = unparse_object(executor, loc, false);
notify(executor, tprintf("Home: %s", buf2));
free_lbuf(buf2);
// print location if player can link to it
//
loc = Location(thing);
if ( Location(thing) != NOTHING
&& ( Examinable(executor, loc)
|| Examinable(executor, thing)
|| Linkable(executor, loc)))
{
buf2 = unparse_object(executor, loc, false);
notify(executor, tprintf("Location: %s", buf2));
free_lbuf(buf2);
}
break;
case TYPE_EXIT:
buf2 = unparse_object(executor, Exits(thing), false);
notify(executor, tprintf("Source: %s", buf2));
free_lbuf(buf2);
// print destination.
//
switch (Location(thing))
{
case NOTHING:
// Special case. unparse_object() normally returns -1 as '*NOTHING*'.
//
notify(executor, "Destination: *UNLINKED*");
break;
default:
buf2 = unparse_object(executor, Location(thing), false);
notify(executor, tprintf("Destination: %s", buf2));
free_lbuf(buf2);
break;
}
break;
default:
break;
}
}
else if ( !Opaque(thing)
&& nearby(executor, thing))
{
if (Has_contents(thing))
{
look_contents(executor, thing, "Contents:", CONTENTS_REMOTE);
}
if (!isExit(thing))
{
look_exits(executor, thing, "Obvious exits:");
}
}
free_lbuf(temp);
if (!control)
{
if (mudconf.read_rem_name)
{
buf2 = alloc_lbuf("do_examine.pub_name");
strcpy(buf2, Name(thing));
notify(executor, tprintf("%s is owned by %s", buf2, Name(Owner(thing))));
free_lbuf(buf2);
}
else
{
notify(executor, tprintf("Owned by %s", Name(Owner(thing))));
}
}
}
void do_score(dbref executor, dbref caller, dbref enactor, int key)
{
notify(executor, tprintf("You have %d %s.", Pennies(executor),
(Pennies(executor) == 1) ? mudconf.one_coin : mudconf.many_coins));
}
void do_inventory(dbref executor, dbref caller, dbref enactor, int key)
{
dbref thing;
char *buff, *e;
const char *s;
thing = Contents(executor);
if (thing == NOTHING)
{
notify(executor, "You aren't carrying anything.");
}
else
{
notify(executor, "You are carrying:");
DOLIST(thing, thing)
{
buff = unparse_object(executor, thing, true);
notify(executor, buff);
free_lbuf(buff);
}
}
thing = Exits(executor);
if (thing != NOTHING)
{
notify(executor, "Exits:");
e = buff = alloc_lbuf("look_exits");
DOLIST(thing, thing)
{
// Chop off first exit alias to display.
//
for (s = Name(thing); *s && (*s != ';'); s++)
{
safe_chr(*s, buff, &e);
}
safe_str(" ", buff, &e);
}
*e = 0;
notify(executor, buff);
free_lbuf(buff);
}
do_score(executor, caller, executor, 0);
}
void do_entrances(dbref executor, dbref caller, dbref enactor, int key, char *name)
{
dbref thing, i, j;
char *exit, *message;
int control_thing, count, low_bound, high_bound;
FWDLIST *fp;
parse_range(&name, &low_bound, &high_bound);
if ( !name
|| !*name)
{
if (Has_location(executor))
{
thing = Location(executor);
}
else
{
thing = executor;
}
if (!Good_obj(thing))
{
return;
}
}
else
{
init_match(executor, name, NOTYPE);
match_everything(MAT_EXIT_PARENTS);
thing = noisy_match_result();
if (!Good_obj(thing))
{
return;
}
}
if (!payfor(executor, mudconf.searchcost))
{
notify(executor, tprintf("You don't have enough %s.",
mudconf.many_coins));
return;
}
message = alloc_lbuf("do_entrances");
control_thing = Examinable(executor, thing);
count = 0;
for (i = low_bound; i <= high_bound; i++)
{
if (control_thing || Examinable(executor, i))
{
switch (Typeof(i))
{
case TYPE_EXIT:
if (Location(i) == thing)
{
exit = unparse_object(executor, Exits(i), false);
notify(executor, tprintf("%s (%s)", exit, Name(i)));
free_lbuf(exit);
count++;
}
break;
case TYPE_ROOM:
if (Dropto(i) == thing)
{
exit = unparse_object(executor, i, false);
notify(executor, tprintf("%s [dropto]", exit));
free_lbuf(exit);
count++;
}
break;
case TYPE_THING:
case TYPE_PLAYER:
if (Home(i) == thing)
{
exit = unparse_object(executor, i, false);
notify(executor, tprintf("%s [home]", exit));
free_lbuf(exit);
count++;
}
break;
}
// Check for parents.
//
if (Parent(i) == thing)
{
exit = unparse_object(executor, i, false);
notify(executor, tprintf("%s [parent]", exit));
free_lbuf(exit);
count++;
}
// Check for forwarding.
//
if (H_Fwdlist(i))
{
fp = fwdlist_get(i);
if (!fp)
{
continue;
}
for (j = 0; j < fp->count; j++)
{
if (fp->data[j] != thing)
{
continue;
}
exit = unparse_object(executor, i, false);
notify(executor, tprintf("%s [forward]", exit));
free_lbuf(exit);
count++;
}
}
}
}
free_lbuf(message);
notify(executor, tprintf("%d entrance%s found.", count,
(count == 1) ? "" : "s"));
}
// Check the current location for bugs.
//
static void sweep_check(dbref player, dbref what, int key, bool is_loc)
{
bool canhear = false;
bool cancom = false;
bool isplayer = false;
bool ispuppet = false;
bool isconnected = false;
bool is_parent = false;
if (key & SWEEP_LISTEN)
{
if ( ( ( isExit(what)
|| is_loc)
&& Audible(what))
|| H_Listen(what))
{
canhear = true;
}
else if (Monitor(what))
{
dbref aowner;
int aflags;
char *as, *buff, *s;
ATTR *ap;
buff = alloc_lbuf("sweep_check.Hearer");
for (int atr = atr_head(what, &as); atr; atr = atr_next(&as))
{
ap = atr_num(atr);
if ( !ap
|| (ap->flags & AF_NOPROG))
{
continue;
}
atr_get_str(buff, what, atr, &aowner, &aflags);
// Make sure we can execute it.
//
if ( (buff[0] != AMATCH_LISTEN)
|| (aflags & AF_NOPROG))
{
continue;
}
// Make sure there's a : in it.
//
for (s = buff + 1; *s && (*s != ':'); s++)
{
; // Nothing.
}
if (s)
{
canhear = true;
break;
}
}
free_lbuf(buff);
}
}
if ( (key & SWEEP_COMMANDS)
&& !isExit(what))
{
// Look for commands on the object and parents too.
//
dbref parent;
int lev;
ITER_PARENTS(what, parent, lev)
{
if (Commer(parent))
{
cancom = true;
if (lev)
{
is_parent = true;
break;
}
}
}
}
if (key & SWEEP_CONNECT)
{
if ( Connected(what)
|| ( Puppet(what)
&& Connected(Owner(what)))
|| ( mudconf.player_listen
&& isPlayer(what)
&& canhear
&& Connected(Owner(what))))
{
isconnected = true;
}
}
if ( (key & SWEEP_PLAYER)
|| isconnected)
{
if (isPlayer(what))
{
isplayer = true;
}
if (Puppet(what))
{
ispuppet = true;
}
}
if ( canhear
|| cancom
|| isplayer
|| ispuppet
|| isconnected)
{
char *buf, *buf2, *bp;
buf = alloc_lbuf("sweep_check.types");
bp = buf;
if (cancom)
{
safe_str("commands ", buf, &bp);
}
if (canhear)
{
safe_str("messages ", buf, &bp);
}
if (isplayer)
{
safe_str("player ", buf, &bp);
}
if (ispuppet)
{
safe_str("puppet(", buf, &bp);
safe_str(Name(Owner(what)), buf, &bp);
safe_str(") ", buf, &bp);
}
if (isconnected)
{
safe_str("connected ", buf, &bp);
}
if (is_parent)
{
safe_str("parent ", buf, &bp);
}
bp[-1] = '\0';
if (!isExit(what))
{
notify(player, tprintf(" %s is listening. [%s]",
Name(what), buf));
}
else
{
buf2 = alloc_lbuf("sweep_check.name");
strcpy(buf2, Name(what));
for (bp = buf2; *bp && (*bp != ';'); bp++) ;
*bp = '\0';
notify(player, tprintf(" %s is listening. [%s]", buf2, buf));
free_lbuf(buf2);
}
free_lbuf(buf);
}
}
void do_sweep(dbref executor, dbref caller, dbref enactor, int key, char *where)
{
dbref here, sweeploc;
int where_key, what_key;
where_key = key & (SWEEP_ME | SWEEP_HERE | SWEEP_EXITS);
what_key = key & (SWEEP_COMMANDS | SWEEP_LISTEN | SWEEP_PLAYER | SWEEP_CONNECT);
if (where && *where)
{
sweeploc = match_controlled(executor, where);
if (!Good_obj(sweeploc))
{
return;
}
}
else
{
sweeploc = executor;
}
if (!where_key)
where_key = -1;
if (!what_key)
what_key = -1;
else if (what_key == SWEEP_VERBOSE)
what_key = SWEEP_VERBOSE | SWEEP_COMMANDS;
// Check my location. If I have none or it is dark, check just me.
//
if (where_key & SWEEP_HERE)
{
notify(executor, "Sweeping location...");
if (Has_location(sweeploc))
{
here = Location(sweeploc);
if ( here == NOTHING
|| ( Dark(here)
&& !mudconf.sweep_dark
&& !Examinable(executor, here)))
{
notify_quiet(executor,
"Sorry, it is dark here and you can't search for bugs");
sweep_check(executor, sweeploc, what_key, false);
}
else
{
sweep_check(executor, here, what_key, true);
for (here = Contents(here); here != NOTHING; here = Next(here))
{
sweep_check(executor, here, what_key, false);
}
}
}
else
{
sweep_check(executor, sweeploc, what_key, false);
}
}
// Check exits in my location
//
if ( (where_key & SWEEP_EXITS)
&& Has_location(sweeploc))
{
notify(executor, "Sweeping exits...");
for (here = Exits(Location(sweeploc)); here != NOTHING; here = Next(here))
{
sweep_check(executor, here, what_key, false);
}
}
// Check my inventory
//
if ( (where_key & SWEEP_ME)
&& Has_contents(sweeploc))
{
notify(executor, "Sweeping inventory...");
for (here = Contents(sweeploc); here != NOTHING; here = Next(here))
{
sweep_check(executor, here, what_key, false);
}
}
// Check carried exits
//
if ( (where_key & SWEEP_EXITS)
&& Has_exits(sweeploc))
{
notify(executor, "Sweeping carried exits...");
for (here = Exits(sweeploc); here != NOTHING; here = Next(here))
{
sweep_check(executor, here, what_key, false);
}
}
notify(executor, "Sweep complete.");
}
/* Output the sequence of commands needed to duplicate the specified
* object. If you're moving things to another system, your mileage
* will almost certainly vary. (i.e. different flags, etc.)
*/
extern NAMETAB indiv_attraccess_nametab[];
void do_decomp
(
dbref executor,
dbref caller,
dbref enactor,
int key,
int nargs,
char *name,
char *qual
)
{
BOOLEXP *pBoolExp;
char *got, *thingname, *as, *ltext, *buff;
dbref aowner, thing;
int val, aflags, ca;
ATTR *pattr;
NAMETAB *np;
bool wild_decomp;
// Check for obj/attr first.
//
olist_push();
if (parse_attrib_wild(executor, name, &thing, false, true, false))
{
wild_decomp = true;
}
else
{
wild_decomp = false;
init_match(executor, name, TYPE_THING);
match_everything(MAT_EXIT_PARENTS);
thing = noisy_match_result();
}
// get result
//
if (thing == NOTHING)
{
olist_pop();
return;
}
if (!Examinable(executor, thing))
{
notify_quiet(executor,
"You can only decompile things you can examine.");
olist_pop();
return;
}
thingname = atr_get(thing, A_LOCK, &aowner, &aflags);
pBoolExp = parse_boolexp(executor, thingname, true);
// Determine the name of the thing to use in reporting and then
// report the command to make the thing.
//
if (qual && *qual)
{
strcpy(thingname, qual);
}
else
{
if (key == DECOMP_DBREF)
{
strcpy(thingname, tprintf("#%d",thing));
}
else
{
switch (Typeof(thing))
{
case TYPE_THING:
strcpy(thingname, Name(thing));
val = OBJECT_DEPOSIT(Pennies(thing));
notify(executor,
tprintf("@create %s=%d", translate_string(thingname, true),
val));
break;
case TYPE_ROOM:
strcpy(thingname, "here");
notify(executor, tprintf("@dig/teleport %s",
translate_string(Name(thing), true)));
break;
case TYPE_EXIT:
strcpy(thingname, Name(thing));
notify(executor,
tprintf("@open %s", translate_string(thingname, true)));
for (got = thingname; *got; got++)
{
if (*got == EXIT_DELIMITER)
{
*got = '\0';
break;
}
}
break;
case TYPE_PLAYER:
if (executor == thing)
{
strcpy(thingname, "me");
}
else
{
strcpy(thingname, Name(thing));
}
break;
}
}
}
// Strip out ANSI in one place rather than have it done in
// several places.
//
size_t len;
char *p = strip_ansi(thingname, &len);
memcpy(thingname, p, len+1);
// Report the lock (if any).
//
if ( !wild_decomp
&& pBoolExp != TRUE_BOOLEXP)
{
notify(executor, tprintf("@lock %s=%s", thingname,
unparse_boolexp_decompile(executor, pBoolExp)));
}
free_boolexp(pBoolExp);
// Report attributes.
//
buff = alloc_mbuf("do_decomp.attr_name");
for (ca = (wild_decomp ? olist_first() : atr_head(thing, &as));
(wild_decomp) ? (ca != NOTHING) : (ca != 0);
ca = (wild_decomp ? olist_next() : atr_next(&as)))
{
if ( ca == A_NAME
|| ca == A_LOCK)
{
continue;
}
pattr = atr_num(ca);
if (!pattr)
{
continue;
}
if ( (pattr->flags & AF_NOCMD)
&& !(pattr->flags & AF_IS_LOCK))
{
continue;
}
got = atr_get(thing, ca, &aowner, &aflags);
if (bCanReadAttr(executor, thing, pattr, false))
{
if (pattr->flags & AF_IS_LOCK)
{
pBoolExp = parse_boolexp(executor, got, true);
ltext = unparse_boolexp_decompile(executor, pBoolExp);
free_boolexp(pBoolExp);
notify(executor, tprintf("@lock/%s %s=%s", pattr->name,
thingname, ltext));
}
else
{
strcpy(buff, pattr->name);
notify(executor, tprintf("%c%s %s=%s", ((ca < A_USER_START) ?
'@' : '&'), buff, thingname, got));
for (np = indiv_attraccess_nametab; np->name; np++)
{
if ( (aflags & np->flag)
&& check_access(executor, np->perm)
&& (!(np->perm & CA_NO_DECOMP)))
{
notify(executor, tprintf("@set %s/%s = %s", thingname,
buff, np->name));
}
}
if (aflags & AF_LOCK)
{
notify(executor, tprintf("@lock %s/%s", thingname, buff));
}
}
}
free_lbuf(got);
}
free_mbuf(buff);
if (!wild_decomp)
{
decompile_flags(executor, thing, thingname);
decompile_powers(executor, thing, thingname);
#ifdef REALITY_LVLS
decompile_rlevels(executor, thing, thingname);
#endif /* REALITY_LVLS */
}
// If the object has a parent, report it.
//
if ( !wild_decomp
&& (Parent(thing) != NOTHING))
{
notify(executor, tprintf("@parent %s=#%d", thingname, Parent(thing)));
}
// If the object has a zone, report it.
//
int zone;
if ( !wild_decomp
&& Good_obj(zone = Zone(thing)))
{
notify(executor, tprintf("@chzone %s=#%d", thingname, zone));
}
free_lbuf(thingname);
olist_pop();
}
// show_vrml_url
//
void show_vrml_url(dbref thing, dbref loc)
{
char *vrml_url;
dbref aowner;
int aflags;
// If they don't care about HTML, just return.
//
if (!Html(thing))
{
return;
}
vrml_url = atr_pget(loc, A_VRML_URL, &aowner, &aflags);
if (*vrml_url)
{
char *vrml_message, *vrml_cp;
vrml_message = vrml_cp = alloc_lbuf("show_vrml_url");
safe_str("<img xch_graph=load href=\"", vrml_message, &vrml_cp);
safe_str(vrml_url, vrml_message, &vrml_cp);
safe_str("\">", vrml_message, &vrml_cp);
*vrml_cp = 0;
notify_html(thing, vrml_message);
free_lbuf(vrml_message);
}
else
{
notify_html(thing, "<img xch_graph=hide>");
}
free_lbuf(vrml_url);
}