extern MRESULT EXPENTRY Button_Processor ( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) {
static PWINDOWPROC DefaultProcessor = 0 ;
switch ( msg ) {
case WM_CREATE: {
CLASSINFO ClassInfo ;
WinQueryClassInfo ( WinQueryAnchorBlock(hwnd), WC_BUTTON, &ClassInfo ) ;
DefaultProcessor = ClassInfo.pfnWindowProc ;
break; }
case WM_SETFOCUS: {
USHORT Id = WinQueryWindowUShort ( hwnd, QWS_ID ) ;
if ( mp2 ) {
Sys_SendMessage( hwnd, BM_SETDEFAULT, MPFROMSHORT(TRUE), 0 ) ;
Sys_SendMessage( OWNER(hwnd), WM_CONTROL, MPFROM2SHORT(Id,BN_SETFOCUS), 0 ) ;
} else {
Sys_SendMessage( hwnd, BM_SETDEFAULT, MPFROMSHORT(FALSE), 0 ) ;
Sys_SendMessage( OWNER(hwnd), WM_CONTROL, MPFROM2SHORT(Id,BN_KILLFOCUS), 0 ) ;
} /* endif */
break; }
} /* endswitch */
return ( DefaultProcessor ? DefaultProcessor ( hwnd, msg, mp1, mp2 ) : 0 ) ;
}
const char *
mfn_controls(MFUNARGS)
{
dbref obj;
dbref obj2;
obj = mesg_dbref_raw(player, what, perms, argv[0]);
if (obj == AMBIGUOUS || obj == NOTHING || obj == UNKNOWN)
ABORT_MPI("CONTROLS","Match failed. (1)");
if (obj == PERMDENIED)
ABORT_MPI("CONTROLS","Permission denied. (1)");
if (obj == HOME) obj = DBFETCH(player)->sp.player.home;
if (argc > 1) {
obj2 = mesg_dbref_raw(player, what, perms, argv[1]);
if (obj2 == AMBIGUOUS || obj2 == NOTHING || obj2 == UNKNOWN)
ABORT_MPI("CONTROLS","Match failed. (2)");
if (obj2 == PERMDENIED)
ABORT_MPI("CONTROLS","Permission denied. (2)");
if (obj2 == HOME) obj2 = DBFETCH(player)->sp.player.home;
if (Typeof(obj2) != TYPE_PLAYER) obj2 = OWNER(obj2);
} else {
obj2 = OWNER(perms);
}
if (controls(obj2, obj)) {
return "1";
} else {
return "0";
}
}
Core::Command* Jumping::
onInit()
{
// TODO return command to change texture
Base::EventManager::process(new MakeTriggerForPlatforms(OWNER(), true));
return new Jump(OWNER(), 20 * m_power);
}
int
mesg_read_perms(dbref player, dbref perms, dbref obj)
{
if ((obj == 0) || (obj == player) || (obj == perms)) return 1;
if (OWNER(perms) == OWNER(obj)) return 1;
if (Wizperms(perms)) return 1;
return 0;
}
Core::Command* EnemyMove::
onInit()
{
// TODO return command to change texture and set direction
assert(0 != OWNER());
assert(0 != OWNER()->component<Core::TextureRenderer>());
OWNER()->component<Core::TextureRenderer>()->setDirection(m_direction);
return 0;
}
int
blessprops_wildcard(dbref player, dbref thing, const char *dir, const char *wild, int blessp)
{
char propname[BUFFER_LEN];
char wld[BUFFER_LEN];
char buf[BUFFER_LEN];
char buf2[BUFFER_LEN];
char *ptr, *wldcrd = wld;
PropPtr propadr, pptr;
int i, cnt = 0;
int recurse = 0;
#ifdef GOD_PRIV
if(tp_strict_god_priv && !God(player) && God(OWNER(thing))) {
notify(player,"Only God may touch what is God's.");
return 0;
}
#endif
strcpyn(wld, sizeof(wld), wild);
i = strlen(wld);
if (i && wld[i - 1] == PROPDIR_DELIMITER)
strcatn(wld, sizeof(wld), "*");
for (wldcrd = wld; *wldcrd == PROPDIR_DELIMITER; wldcrd++) ;
if (!strcmp(wldcrd, "**"))
recurse = 1;
for (ptr = wldcrd; *ptr && *ptr != PROPDIR_DELIMITER; ptr++) ;
if (*ptr)
*ptr++ = '\0';
propadr = first_prop(thing, (char *) dir, &pptr, propname, sizeof(propname));
while (propadr) {
if (equalstr(wldcrd, propname)) {
snprintf(buf, sizeof(buf), "%s%c%s", dir, PROPDIR_DELIMITER, propname);
if (!Prop_System(buf) && ((!Prop_Hidden(buf) && !(PropFlags(propadr) & PROP_SYSPERMS))
|| Wizard(OWNER(player)))) {
if (!*ptr || recurse) {
cnt++;
if (blessp) {
set_property_flags(thing, buf, PROP_BLESSED);
snprintf(buf2, sizeof(buf2), "Blessed %s", buf);
} else {
clear_property_flags(thing, buf, PROP_BLESSED);
snprintf(buf2, sizeof(buf2), "Unblessed %s", buf);
}
notify(player, buf2);
}
if (recurse)
ptr = "**";
cnt += blessprops_wildcard(player, thing, buf, ptr, blessp);
}
}
propadr = next_prop(pptr, propadr, propname, sizeof(propname));
}
return cnt;
}
const char *
safegetprop_strict(dbref player, dbref what, dbref perms, const char *inbuf)
{
const char *ptr;
char bbuf[BUFFER_LEN];
char vl[32];
if (!inbuf) {
notify_nolisten(player, "PropFetch: Propname required.", 1);
return NULL;
}
while (*inbuf == PROPDIR_DELIMITER)
inbuf++;
if (!*inbuf) {
notify_nolisten(player, "PropFetch: Propname required.", 1);
return NULL;
}
strcpy(bbuf, inbuf);
if (!Archperms(perms)) {
if (Prop_Hidden(bbuf)) {
notify_nolisten(player, "PropFetch: Permission denied.", 1);
return NULL;
}
if (Prop_Private(bbuf) && OWNER(perms) != OWNER(what)) {
notify_nolisten(player, "PropFetch: Permission denied.", 1);
return NULL;
}
}
ptr = get_property_class(what, bbuf);
if (!ptr) {
int i;
i = get_property_value(what, bbuf);
if (!i) {
dbref dd;
dd = get_property_dbref(what, bbuf);
if (dd == NOTHING) {
*vl = '\0';
ptr = vl;
return ptr;
} else {
sprintf(vl, "#%d", dd);
ptr = vl;
}
} else {
sprintf(vl, "%d", i);
ptr = vl;
}
}
#ifdef COMPRESS
ptr = uncompress(ptr);
#endif
return ptr;
}
int
mesg_local_perms(dbref player, dbref perms, dbref obj)
{
if (OWNER(perms) == OWNER(getloc(obj))) return 1;
if (isneighbor(perms, obj)) return 1;
if (isneighbor(player, obj)) return 1;
if (Mageperms(perms)) return 1;
if (mesg_read_perms(player, perms, obj)) return 1;
return 0;
}
void OnLadder::
onKeyEvent2(Base::Event* e)
{
Core::KeyEvent* k = Core::KeyEvent::cast(e);
assert(0 != k);
if (k->mode() == Core::KeyEvent::Mode::Down
&& k->key() == Core::InputManager::Key::Jump) {
Base::EventManager::process(new Core::OnAir(OWNER()));
OWNER()->changeState(this, new Jumping);
}
}
int
mesg_read_perms(dbref player, dbref perms, dbref obj, int mesgtyp)
{
if ((obj == 0) || (obj == player) || (obj == perms))
return 1;
if (OWNER(perms) == OWNER(obj))
return 1;
if ((mesgtyp & MPI_ISBLESSED))
return 1;
return 0;
}
Core::Command* SwitchState::
onInit()
{
// TODO return command to change texture
assert(0 != OWNER());
assert(0 != OWNER()->component<Core::TextureRenderer>());
OWNER()->component<Core::TextureRenderer>()->setDirection((m_status)
? Core::HorizontalDirection::Left
: Core::HorizontalDirection::Right);
return 0;
}
void SwitchActive::
atTheSwitch(Base::Event* e)
{
AtTheSwitch* as = AtTheSwitch::cast(e);
assert(0 != as);
if (as->switchObject() != OWNER()
&& as->status() == true) {
return;
}
OWNER()->changeState(this, new SwitchInactive);
}
void SwitchState::
onToggle(Base::Event* e)
{
ToggleTheSwitch* t = ToggleTheSwitch::cast(e);
assert(0 != t);
if (t->switchObject() != OWNER()) {
return;
}
assert(0 != OWNER());
OWNER()->changeState(this, new SwitchState(!m_status));
}
dbref
mesg_dbref_strict(int descr, dbref player, dbref what, dbref perms, char *buf)
{
dbref obj = mesg_dbref_raw(descr, player, what, perms, buf);
if (obj == UNKNOWN) return obj;
if (!Wizperms(perms) && OWNER(perms) != OWNER(obj)) {
obj = PERMDENIED;
}
return obj;
}
dbref
mesg_dbref_strict(int descr, dbref player, dbref what, dbref perms, char *buf, int mesgtyp)
{
dbref obj = mesg_dbref_raw(descr, player, what, perms, buf);
if (obj == UNKNOWN)
return obj;
if (!(mesgtyp & MPI_ISBLESSED) && OWNER(perms) != OWNER(obj)) {
obj = PERMDENIED;
}
return obj;
}
static void
msg_unparse_macro(dbref player, dbref what, dbref perms, char *name, int argc, argv_typ argv, char *rest, int maxchars)
{
const char *ptr;
char *ptr2;
char buf[BUFFER_LEN];
char buf2[BUFFER_LEN];
dbref obj;
int i, p = 0;
strcpy(buf, rest);
sprintf(buf2, "_msgmacs/%s", name);
obj = what;
ptr = get_mfunc(name);
if (!ptr || !*ptr) ptr = safegetprop_strict(player, OWNER(obj), perms, buf2);
if (!ptr || !*ptr) ptr = safegetprop_limited(player, obj, OWNER(obj), perms, buf2);
if (!ptr || !*ptr) ptr = safegetprop_strict(player, 0, perms, buf2);
while (ptr && *ptr && p < (maxchars - 1)) {
if (*ptr == '\\') {
if (*(ptr+1) == 'r') {
rest[p++] = '\r';
ptr++; ptr++;
} else {
rest[p++] = *(ptr++);
rest[p++] = *(ptr++);
}
} else if (*ptr == MFUN_LEADCHAR) {
if (*(ptr+1) == MFUN_ARGSTART && isdigit(*(ptr + 2)) &&
*(ptr + 3) == MFUN_ARGEND) {
ptr++; ptr++;
i = *(ptr++) - '1';
ptr++;
if (i >= argc || i < 0) {
ptr2 = NULL;
} else {
ptr2 = argv[i];
}
while (ptr2 && *ptr2 && p < (maxchars - 1)) {
rest[p++] = *(ptr2++);
}
} else {
rest[p++] = *(ptr++);
}
} else {
rest[p++] = *(ptr++);
}
}
ptr2 = buf;
while (ptr2 && *ptr2 && p < (maxchars - 1)) {
rest[p++] = *(ptr2++);
}
rest[p] = '\0';
}
int
mesg_local_perms(dbref player, dbref perms, dbref obj, int mesgtyp)
{
if (getloc(obj) != NOTHING && OWNER(perms) == OWNER(getloc(obj)))
return 1;
if (isneighbor(perms, obj))
return 1;
if (isneighbor(player, obj))
return 1;
if (mesg_read_perms(player, perms, obj, mesgtyp))
return 1;
return 0;
}
dbref
find_mlev(dbref prog, struct frame * fr, int st)
{
if ((FLAGS(prog) & STICKY) && (FLAGS(prog) & HAVEN)) {
if ((st > 1) && (TrueWizard(OWNER(prog))))
return (find_mlev(fr->caller.st[st - 1], fr, st - 1));
}
if (MLevel(prog) < MLevel(OWNER(prog))) {
return (MLevel(prog));
} else {
return (MLevel(OWNER(prog)));
}
}
Core::Command* Jumping::
command()
{
assert(0 != OWNER()->component<Core::Physics>());
if (OWNER()->component<Core::Physics>()->velocity().y() < 0) {
OWNER()->changeState(this, new Falling);
return 0;
}
if (0 == m_count) {
return 0;
}
--m_count;
return new Jump(OWNER(), m_power);
}
void VerticalMovementState::
onLadder(Base::Event* e)
{
OnLadderEvent* ol = OnLadderEvent::cast(e);
assert(0 != ol);
if (ol->object() != OWNER()) {
return;
}
if (ol->direction() == Core::VerticalDirection::None) {
OWNER()->changeState(this, new OnLadder);
} else {
OWNER()->changeState(this, new MoveOnLadder(ol->direction()));
}
}
void self_statement_Or(Or *v2548,OID v1741,OID v332)
{ GC_BIND;
{ char * v1743 = GC_STRING(check_var_string(copy_string("v_or"),v1741,v332));
new_block_void();
interface_I_class(Kernel._boolean);
princ_string(v1743);
princ_string(copy_string(";"));
breakline_void();
{ OID gc_local;
ITERATE(v1744);
bag *v1744_support;
v1744_support = GC_OBJECT(list,v2548->args);
for (START(v1744_support); NEXT(v1744);)
{ new_block_void();
statement_any(v1744,_string_(v1743),v332);
princ_string(copy_string("if ("));
princ_string(v1743);
princ_string(copy_string(" == "));
(*Generate.produce)(Generate.PRODUCER->value,
Kernel.ctrue);
princ_string(copy_string(") "));
if (Kernel._string == OWNER(v1741))
{ c_princ_string(string_v(v1741));
princ_string(copy_string(" ="));
}
expression_boolean(CTRUE,v332);
princ_string(copy_string("; "));
breakline_void();
princ_string(copy_string("else "));
}
}
if (Kernel._string == OWNER(v1741))
{ c_princ_string(string_v(v1741));
princ_string(copy_string(" = "));
expression_boolean(CFALSE,v332);
princ_string(copy_string(";"));
}
else { expression_boolean(CFALSE,v332);
princ_string(copy_string(";"));
}
{ OID gc_local;
ITERATE(v1744);
bag *v1744_support;
v1744_support = GC_OBJECT(list,v2548->args);
for (START(v1744_support); NEXT(v1744);)
close_block_void();
}
close_block_void();
}
GC_UNBIND;}
void self_statement_Assign(Assign *v2548,OID v1741,OID v332)
{ GC_BIND;
{ OID v1743 = GC_OID(v2548->var);
OID v1744 = GC_OID(v2548->arg);
ClaireBoolean * v2454 = ((boolean_I_any(v332) == CTRUE) ? ((Optimize.OPT->loop_gc == CTRUE) ? ((inner2outer_ask_any(v1744) == CTRUE) ? CTRUE: CFALSE): CFALSE): CFALSE);
OID v1745;
{ if ((v2454 == CTRUE) &&
(INHERIT(OWNER(v1744),Optimize._to_protect)))
v1745 = (*Kernel.arg)(v1744);
else v1745 = v1744;
GC_OID(v1745);}
if (Kernel._string == OWNER(v1741))
{ new_block_void();
statement_any(v1745,v1741,v332);
princ_string(copy_string(" "));
if (v2454 == CTRUE)
(*Generate.gc_protection_exp)(Generate.PRODUCER->value,
v1743,
Kernel.cfalse,
v1741,
v332);
else { ident_symbol(OBJECT(Variable,v1743)->pname);
princ_string(copy_string(" = "));
(*Kernel.c_princ)(v1741);
princ_string(copy_string(""));
}
princ_string(copy_string(";"));
close_block_void();
princ_string(copy_string(""));
}
else if (v2454 == CTRUE)
{ new_block_void();
statement_any(v1745,GC_OID((*Generate.c_string)(Generate.PRODUCER->value,
v1743)),v332);
princ_string(copy_string(" "));
(*Generate.gc_protection_exp)(Generate.PRODUCER->value,
v1743,
Kernel.ctrue,
v1743,
v332);
princ_string(copy_string(";"));
close_block_void();
princ_string(copy_string(""));
}
else statement_any(v1744,GC_OID((*Generate.c_string)(Generate.PRODUCER->value,
v1743)),v332);
}
GC_UNBIND;}
void
prim_cancallp(PRIM_PROTOTYPE)
{
CHECKOP(2);
oper2 = POP(); /* string: public function name */
oper1 = POP(); /* dbref: Program dbref to check */
if (oper1->type != PROG_OBJECT)
abort_interp("Expected dbref argument. (1)");
if (!valid_object(oper1))
abort_interp("Invalid dbref (1)");
if (Typeof(oper1->data.objref) != TYPE_PROGRAM)
abort_interp("Object is not a MUF Program. (1)");
if (oper2->type != PROG_STRING)
abort_interp("Expected string argument. (2)");
if (!oper2->data.string)
abort_interp("Invalid Null string argument. (2)");
if (!(PROGRAM_CODE(oper1->data.objref))) {
struct line *tmpline;
tmpline = PROGRAM_FIRST(oper1->data.objref);
PROGRAM_SET_FIRST(oper1->data.objref,
(struct line *) read_program(oper1->data.objref));
do_compile(-1, OWNER(oper1->data.objref), oper1->data.objref, 0);
free_prog_text(PROGRAM_FIRST(oper1->data.objref));
PROGRAM_SET_FIRST(oper1->data.objref, tmpline);
}
result = 0;
if (ProgMLevel(oper1->data.objref) > 0 &&
(mlev >= 4 || OWNER(oper1->data.objref) == ProgUID || Linkable(oper1->data.objref))
) {
struct publics *pbs;
pbs = PROGRAM_PUBS(oper1->data.objref);
while (pbs) {
if (!strcasecmp(oper2->data.string->data, pbs->subname))
break;
pbs = pbs->next;
}
if (pbs && mlev >= pbs->mlev)
result = 1;
}
CHECKOFLOW(1);
CLEAR(oper1);
CLEAR(oper2);
PushInt(result);
}
void
moveto(dbref what, dbref where)
{
dbref loc;
/* do NOT move garbage */
if (what != NOTHING && Typeof(what) == TYPE_GARBAGE) {
return;
}
if(what != NOTHING && parent_loop_check(what, where)) {
/* Prevent stupid loop holes elsewhere */
return;
}
/* remove what from old loc */
if ((loc = DBFETCH(what)->location) != NOTHING) {
DBSTORE(loc, contents, remove_first(DBFETCH(loc)->contents, what));
}
/* test for special cases */
switch (where) {
case NOTHING:
DBSTORE(what, location, NOTHING);
return; /* NOTHING doesn't have contents */
case HOME:
switch (Typeof(what)) {
case TYPE_PLAYER:
where = DBFETCH(what)->sp.player.home;
break;
case TYPE_THING:
where = DBFETCH(what)->sp.thing.home;
if (parent_loop_check(what, where))
where = DBFETCH(OWNER(what))->sp.player.home;
break;
case TYPE_ROOM:
where = GLOBAL_ENVIRONMENT;
break;
case TYPE_PROGRAM:
where = OWNER(what);
break;
}
}
/* now put what in where */
PUSH(what, DBFETCH(where)->contents);
DBDIRTY(where);
DBSTORE(what, location, where);
}
void
interp_err(dbref player, dbref program, struct inst *pc,
struct inst *arg, int atop, dbref origprog, const char *msg1, const char *msg2)
{
char buf[BUFFER_LEN];
char buf2[BUFFER_LEN];
char tbuf[40];
int errcount;
time_t lt;
err++;
if (OWNER(origprog) == OWNER(player)) {
strcpyn(buf, sizeof(buf), "\033[1;31;40mProgram Error. Your program just got the following error.\033[0m");
} else {
snprintf(buf, sizeof(buf), "\033[1;31;40mProgrammer Error. Please tell %s what you typed, and the following message.\033[0m",
NAME(OWNER(origprog)));
}
notify_nolisten(player, buf, 1);
snprintf(buf, sizeof(buf), "\033[1m%s(#%d), line %d; %s: %s\033[0m",
NAME(program), program, pc ? pc->line : -1, msg1, msg2);
notify_nolisten(player, buf, 1);
lt = time(NULL);
#ifndef WIN32
format_time(tbuf, 32, "%c", localtime(<));
#else
format_time(tbuf, 32, "%c", uw32localtime(<));
#endif
strip_ansi(buf2, buf);
errcount = get_property_value(origprog, ".debug/errcount");
errcount++;
add_property(origprog, ".debug/errcount", NULL, errcount);
add_property(origprog, ".debug/lasterr", buf2, 0);
add_property(origprog, ".debug/lastcrash", NULL, (int)lt);
add_property(origprog, ".debug/lastcrashtime", tbuf, 0);
if (origprog != program) {
errcount = get_property_value(program, ".debug/errcount");
errcount++;
add_property(program, ".debug/errcount", NULL, errcount);
add_property(program, ".debug/lasterr", buf2, 0);
add_property(program, ".debug/lastcrash", NULL, (int)lt);
add_property(program, ".debug/lastcrashtime", tbuf, 0);
}
}
void
do_motd(dbref player, char *text)
{
time_t lt;
char buf[BUFFER_LEN];
if (!*text || !Wizard(OWNER(player))) {
spit_file(player, tp_file_motd);
return;
}
if (!strcasecmp(text, "clear")) {
unlink(tp_file_motd);
log2file(tp_file_motd, "%s %s", "- - - - - - - - - - - - - - - - - - -",
"- - - - - - - - - - - - - - - - - - -");
notify(player, "MOTD cleared.");
return;
}
lt = time(NULL);
strftime(buf, sizeof(buf), "%a %b %d %T %Z %Y", localtime(<));
log2file(tp_file_motd, "%s", buf);
add_motd_text_fmt(text);
log2file(tp_file_motd, "%s %s", "- - - - - - - - - - - - - - - - - - -",
"- - - - - - - - - - - - - - - - - - -");
notify(player, "MOTD updated.");
}
const char *
unparse_object(dbref player, dbref loc)
{
static char buf[BUFFER_LEN];
if (player == NOTHING)
goto islog;
if (Typeof(player) != TYPE_PLAYER)
player = OWNER(player);
islog:
switch (loc) {
case NOTHING:
return "*NOTHING*";
case AMBIGUOUS:
return "*AMBIGUOUS*";
case HOME:
return "*HOME*";
default:
if (loc < 0 || loc >= db_top)
return "*INVALID*";
if ((player == NOTHING) || (!(FLAGS(player) & STICKY) &&
(can_link_to(player, NOTYPE, loc) ||
((Typeof(loc) != TYPE_PLAYER) &&
(controls_link(player, loc) || (FLAGS(loc) & CHOWN_OK)))))) {
/* show everything */
snprintf(buf, sizeof(buf), "%.*s(#%d%s)", (BUFFER_LEN / 2), NAME(loc), loc, unparse_flags(loc));
return buf;
} else {
/* show only the name */
return NAME(loc);
}
}
}
void
prim_force(PRIM_PROTOTYPE)
{
struct inst *oper1, *oper2;
/* d s -- */
CHECKOP(2);
oper1 = POP(); /* string to @force */
oper2 = POP(); /* player dbref */
if (mlev < LARCH)
abort_interp("Arch prim");
if (fr->level > 8)
abort_interp("Interp call loops not allowed");
if (oper1->type != PROG_STRING)
abort_interp("Non-string argument (2)");
if (oper2->type != PROG_OBJECT)
abort_interp("Non-object argument (1)");
ref = oper2->data.objref;
if (ref < 0 || ref >= db_top)
abort_interp("Invalid object to force (1)");
if (Typeof(ref) != TYPE_PLAYER && Typeof(ref) != TYPE_THING)
abort_interp("Object to force not a thing or player (1)");
if (!oper1->data.string)
abort_interp("Null string argument (2)");
if (index(oper1->data.string->data, '\r'))
abort_interp("Carriage returns not allowed in command string (2)");
if (Man(oper2->data.objref) && !Man(OWNER(program)))
abort_interp("Cannot force the man (1)");
force_level++;
process_command(dbref_first_descr(oper2->data.objref), oper2->data.objref, oper1->data.string->data);
force_level--;
CLEAR(oper1);
CLEAR(oper2);
}
void
do_unbless(int descr, dbref player, const char *what, const char *propname)
{
dbref victim;
struct match_data md;
char buf[BUFFER_LEN];
int cnt;
if (!Wizard(player) || Typeof(player) != TYPE_PLAYER) {
notify(player, "Only Wizard players may use this command.");
return;
}
if (!propname || !*propname) {
notify(player, "Usage is @unbless object=propname.");
return;
}
/* get victim */
init_match(descr, player, what, NOTYPE, &md);
match_everything(&md);
if ((victim = noisy_match_result(&md)) == NOTHING) {
return;
}
if (!Wizard(OWNER(player))) {
notify(player, "Permission denied. (You're not a wizard)");
return;
}
cnt = blessprops_wildcard(player, victim, "", propname, 0);
snprintf(buf, sizeof(buf), "%d propert%s unblessed.", cnt, (cnt == 1)? "y" : "ies");
notify(player, buf);
}
Core::Command* Falling::
onInit()
{
// TODO return command to change texture
Base::EventManager::process(new MakeTriggerForPlatforms(OWNER(), false));
return 0;
}
