"A dump of #10161 on Sun Dec 17 13:05:28 1995 PST

@create #258 named Department of Environmental Protection:Department of Environmental Protection
@prop #10161."recycler" #4455 rc
@prop #10161."hah" {} rc
;;#10161.("hah") = {#155, #4038}
@prop #10161."armour" {} rc
;;#10161.("armour") = {#457, #1247, #2138, #20864, #20865}
@prop #10161."thrown" {} rc
;;#10161.("thrown") = {#10902, #3089, #8833, #8909}
@prop #10161."missiles" {} rc
;;#10161.("missiles") = {#8833, #8909}
@prop #10161."weapons" {} rc
;;#10161.("weapons") = {#76, #159, #243, #1394, #1454, #1660, #2231, #3791, #8751, #283, #20769, #20868}
@prop #10161."monsters" {} rc
@prop #10161."threshold" 7776000 rc
@prop #10161."targets" {} rc
@prop #10161."objects" {} rc
@prop #10161."cycle" 18000 rc
@prop #10161."protected" {} rc
@prop #10161."doomed" {} r
@prop #10161."cemetery" #1131 rc
@prop #10161."cycle_task" 576990671 r
@prop #10161."reap_in_progress" 0 r
@prop #10161."rotten" {} r
@prop #10161."sweep_log" {} rc
@prop #10161.dumps {} r
@prop #10161.dumpers {} r
@prop #10161.warehouses {#175, #1138} r
@prop #10161.doomed_dolls {} r
@prop #10161.rpg_things {} r

@verb #10161:"killable" this none this
@program #10161:killable
":killable(object) => True if object may be recycled.";
what = args[1];
if (!$recycler:valid(what))
  "... let GMs recycle invalid objects";
  return what.owner == this.owner;
elseif (!valid(parent(what)))
  "... If an child of $nothing is recycled it will probably break some
 exitfuncs.  Just add it to the 'rotten' list for now.";
  this.rotten = setadd(this.rotten, what);
  return 0;
elseif (this:unique(@args))
  "... Hey this is somethin' special.";
  return 0;
elseif (this:in_use(@args))
  "... Somebody's using it.";
  return 0;
elseif (what.location in this.warehouses)
  "elseif ($object_utils:isa(what.location, #25476))";
  "... In an RPG-shop storeroom. Maybe add a .warehouses property later, but
 this'll do for now.";
  return 0;
else
  return 1;
endif
"DR 06-MAY-1995 -- Using in_use_test, a more correct (and hopefully bug free)
 version of the old, nasty in_use";
"Profane 15-MAR-95 13:06EST - Dunno what #25476 was supposed to be, but it's
 nothing now. Added warehouses stuff.";
"Slither 6/15/95 -- Got rid of the old in_use, and replaced it with what used
 to be in_use_test, so changed the reference here.";
.

@verb #10161:"cycle" this none this
@program #10161:cycle
"Fork once a day, this.cycle seconds past midnight.";
"Fork off the actual :reap, in case something messes it up.";
if (caller_perms() == this.owner)
  fork tid (#2487:time_til_midnite() + this.cycle)
    fork (0)
      this.reap_in_progress = {time(), task_id()};
      this:reap();
      this.reap_in_progress = 0;
    endfork
    this:cycle();
  endfork
  this.cycle_task = tid;
else
  return E_PERM;
endif
"DR 30-NOV-94 -- Modified to reap just once a day, at a low-lag time.";
.

@verb #10161:"in_use(old)" this none this rx
@program #10161:in_use(old)
dumps = this.dumps;
if ((where = args[1]) in {@this.protected, dumps})
  return 1;
endif
adb = $local.rpg;
max = time() - ((((60 * 60) * 24) * 30) * 3);
ok = listdelete(args, 1);
dumpers = this.dumpers;
while (valid(where = where.location))
  if (where in ok)
    return 0;
  elseif (valid(doll = adb:get_doll(where)) && (doll:get_att("last_action") >
 max))
    "On an RPG character.";
    return 1;
  elseif (((((owner = where.owner).home == where) || index(where.name,
 owner.name)) && valid(doll = adb:get_doll(owner))) && (doll:get_att("last_acti
 on") > max))
    return 1;
  elseif (((i = where in dumps) && valid(doll = adb:get_doll(who =
 dumpers[i]))) && (doll:get_att("last_action") > max))
    return 1;
  endif
endwhile
"Quinn 20-APR-93 0236 ET> New :in_use hacked by me (Quinn) to check
 this.protected instead of looping through all kids of generic monster (#259).
 #10161.protected is updated with #259:set_mine, and the .mine property is now
 owned by G_M (!c).";
"Quinn 17-JUN-93 0945 ET> Now less liberal in deciding which objects are
 reaped. If a player hasn't made an RPG-action in the last month, eir stuff is
 a candidate for reaping.  My guess is this'll cut idle objects by about 40%.";
"Quinn 03-SEP-93 2355 ET> Added .dumps/dumpers property, renamed this object
 to DEP, made it a room, added Harvey the clerk. 'dumps' are places safe from
 sweeping (unless over-crowded).  Raised inactivity max to 3 months.";
.

@verb #10161:"unique_old" this none this
@program #10161:unique_old
y = args[1];
if (((((((valid(y) && (y.owner == this.owner)) && (y.name == (par =
 parent(y)).name)) && (!children(y))) && (!properties(y))) && (!verbs(y))) &&
 (!($object_utils:has_property(y, "unique") && y.unique))) && (!(y in
 $local.rpg.grabber.dispenses)))
  return 0;
else
  return 1;
endif
"Quinn 08-OCT-93 0438: Added check for object being dispensed.";
.

@verb #10161:"cull_players" none none none rxd
@program #10161:cull_players
addb = $local.rpg;
nn = args ? args[1] | 0;
if (addb:trusted(caller_perms()))
  player:tell("Length: ", len = length(addb.pcs));
  t = time();
  for k in [1..len]
    n = (len + 1) - k;
    who = addb.pcs[n];
    doll = addb.dolls[n];
    if ((!valid(doll)) || (!$object_utils:isa(doll, addb.doll)))
      addb.dolls = listdelete(addb.dolls, n);
      addb.pcs = listdelete(addb.pcs, n);
    elseif (doll.character != who)
      player:tell("Inconsistent: ", n);
      nn = nn - 1;
      if (nn < 0)
        return;
      endif
    elseif ((!valid(who)) || ((!is_player(who)) && (!$object_utils:has_callable
 _verb(who, "die"))))
      addb.dolls = listdelete(addb.dolls, n);
      addb.pcs = listdelete(addb.pcs, n);
      this.recycler:_recycle(doll);
    elseif (is_player(who) && ((doll.last_action + this.threshold) < t))
      addb.dolls = listdelete(addb.dolls, n);
      addb.pcs = listdelete(addb.pcs, n);
      this.recycler:_recycle(doll);
      player:tell("> ", who.name, " (", who, ")");
    elseif ((doll.last_action + this.threshold) < t)
      player:tell("* ", who.name, " (", who, ")");
    endif
    addb:time_stop();
  endfor
endif
player:tell("Length: ", length(addb.pcs));
"DR 30-NOV-94 -- Now test doll.last_action, not the player's last_connect.";
"If the person hasn't done any RPG stuff in .threshold time, they die.";
.

@verb #10161:"cull_weapons" none none none rx
@program #10161:cull_weapons
"Disarm players who are dead and who haven't connected in a long time.  Out of
 paranoia, make sure the weapon is owned by Grand_Master.";
culls = {};
now = time();
for p in (players())
  $local.rpg:time_stop();
  if (((p.last_connect_time + this.threshold) < now) && (!(p in
 $local.rpg.pcs)))
    for target in (p.contents)
      if ($object_utils:isa(target, #517) && (target.owner == this.owner))
        $local.rpg:time_stop();
        do_cull = 1;
        if ($object_utils:isa(target, #9350))
          "descend into it if it's a backpack in case its contents aren't RPG
 items.  If so, don't flush the pack either.";
          for item in (target.contents)
            if ((item.owner != this.owner) || (!$object_utils:isa(item, #517)))
              do_cull = 0;
            endif
          endfor
        endif
        if (do_cull)
          culls = {target, @culls};
        endif
      endif
    endfor
  endif
endfor
for item in (culls)
  "move it somewhere random, let the regular vacuum cleaner sweep it up.";
  player:tell("Moving ", item:title(), "(", item, ") from ", item.location.name
 , "(", item.location, ")");
  item:moveto(#-1);
  $local.rpg:time_stop();
endfor
.

@verb #10161:"is_named_weapon" this none this
@program #10161:is_named_weapon
"return 1 if this object is a 'named' weapon, 0 if it is not.";
"Called by cull_weapons.";
target = args[1];
return ($object_utils:has_property(target, "title") ? target.title | 0) ||
 ($object_utils:has_property(target, "crest") ? target.crest | 0);
.

@verb #10161:"cycle(fancy)" this none this
@program #10161:cycle(fancy)
if (caller_perms() == this.owner)
  fork (this.cycle)
    this:cycle();
  endfork
  if (this.objects == {})
    this.objects = $object_utils:leaves_suspended(#517);
  endif
  y = this.objects[1];
  this.objects = listdelete(this.objects, 1);
  if (this:killable(y))
    this.owner:tell("I think ", y.name, " (", y, ") is garbage.");
    this.targets = listappend(this.targets, {y, time() + this.delay,
 y.location});
    if (valid(y.location) && $object_utils:has_verb(y, "announce_all_but"))
      y.location:announce_all_but({this}, y.name + " fades away.");
    endif
    y:moveto(#1131);
  endif
  if (this.targets != {})
    y = this.targets[1];
    if (y[2] < time())
      this.targets = listdelete(this.targets, 1);
      if (this:killable(what = y[1]) && (what.location == #1131))
        this.owner:tell("Killing ", what.name, " (", what, ")");
        this.recycler:_recycle(what);
      elseif ($recycler:valid(what))
        this.owner:tell("Rescuing ", what.name, " (", what, ")");
        what:moveto(y[3]);
      endif
    endif
  endif
else
  player:tell("Permission denied by RPG system.");
endif
.

@verb #10161:"reap" this none this
@program #10161:reap
":reap() -- Recycle all those damned weapons lying around.";
if (caller_perms() != this.owner)
  return E_PERM;
endif
start_time = time();
this.owner:tell(tostr(this, "> ", task_id(), " Beginning RPG Sweep ..."));
doomed = this.doomed;
scythe = this.recycler;
cemetery = this.cemetery;
recycled = 0;
msg = {};
for thing in (leaves = $object_utils:leaves_suspended($local.rpg.thing))
  "...loop through all kids of adventure gear.";
  "...if killable and already doomed, recycle.";
  "...else, add to the doomed list.";
  $local.rpg:time_stop(5 + random(10));
  if (this:killable(thing))
    if ((thing in doomed) || (thing.location in {$nothing, cemetery}))
      locs = {};
      where = thing;
      while (valid(where = where.location))
        locs = {@locs, where};
      endwhile
      msg = {@msg, {$string_utils:nn(thing), thing in doomed, locs}};
      "Dump out the contents. Can't do this inna :recycle verb, since the";
      "thing is moved to #-1 BEFORE :recycle is called.";
      for junk in (thing.contents)
        junk:moveto(thing.location);
        $local.rpg:time_stop(5 + random(10));
      endfor
      scythe:_recycle(thing);
      recycled = recycled + 1;
      doomed = setremove(doomed, thing);
      leaves = setremove(leaves, thing);
    else
      doomed = setadd(doomed, thing);
    endif
  else
    doomed = setremove(doomed, thing);
  endif
endfor
this.doomed = doomed;
this.rpg_things = leaves;
"Now, destroy all the doomed dolls that are still there";
doomed_dolls = this.doomed_dolls;
"Reset the doomed dolls list, to avoid race conditions";
this.doomed_dolls = {};
dollmsg = {};
dollsrecycled = 0;
for doll in (doomed_dolls)
  $local.rpg:time_stop(7);
  "make sure that the thing is still a doll, and still not on the dolls list";
  if (($recycler:valid(doll) && $object_utils:isa(doll, $local.rpg.doll)) &&
 (!(doll in $local.rpg.dolls)))
    dollmsg = {@dollmsg, {"recycled", doll, doll.name, doll.character}};
    scythe:_recycle(doll);
    dollsrecycled = dollsrecycled + 1;
  endif
endfor
"Go through dolls list, seeing which ones can be doomed";
for doll in ($local.rpg.dolls)
  $local.rpg:time_stop(7);
  "make sure its still there!";
  if (doll in $local.rpg.dolls)
    if (this:doll_reapable(doll))
      dollmsg = {@dollmsg, {"doomed", doll, doll.name, doll.character}};
      this:reap_doll(doll);
    endif
  endif
endfor
info = {start_time, time(), length(leaves), recycled, length(doomed), msg,
 length(this.doomed_dolls), dollsrecycled, dollmsg, length($local.rpg.dolls)};
this.sweep_log = log = {info, @this.sweep_log};
this.sweep_log = log[1..min(5, length(log))];
this.owner:tell(tostr(this, "> ", task_id(), " Finished RPG Sweep.  Elapsed
 time: ", $time_utils:english_time(time() - start_time)));
"Profane 14-APR-95 20:45EST - Added contents dumping.";
"   (People were having their unclaimed packs reaped, thus dumping their nice";
"    claimed stuff in #-1, where it got rapidly auto-unclaimed and reaped.)";
"Slither July 5, 1995 -- removed check of .protected";
"                     -- added storage of .rpg_things";
"                     -- added destruction of doomed dolls, and doll reaping.";
.

@verb #10161:"cleanup" this none this
@program #10161:cleanup
":cleanup() => remove invalid stuff from various lists.";
if (!(caller_perms() in $local.rpg.grand_masters))
  return E_PERM;
else
  len = length($local.rpg.gms);
  for dude in ($local.rpg.gms)
    if ((!$recycler:valid(dude)) || (!is_player(dude)))
      $local.rpg.gms = setremove($local.rpg.gms, dude);
    endif
    $command_utils:suspend_if_needed(5, "Checking validity of all GMs. . .");
  endfor
  player:tell("Eliminated ", tostr(len - length($local.rpg.GMs)), " bad GMs.");
  player:tell("Number of dolls before: ", tostr(len = length($local.rpg.dolls))
 );
  for k in [1..len]
    n = (len + 1) - k;
    doll = $local.rpg.dolls[n];
    if (((!$object_utils:isa(doll, $local.rpg.doll)) || (!$recycler:valid(dude
 = doll.character))) || ((!is_player(dude)) && (!$local.rpg:trusted_verb(dude,
 "die"))))
      $local.rpg.dolls = listdelete($local.rpg.dolls, n);
      $local.rpg.pcs = listdelete($local.rpg.pcs, n);
    endif
    $command_utils:suspend_if_needed(5, ("Checked " + tostr(k)) + " dolls. .
 .");
  endfor
  player:tell("Number of dolls after: ", tostr(length($local.rpg.dolls)));
  this.monsters = $object_utils:descendents_suspended($local.rpg.monster);
  player:tell("Reset #10161.monsters");
  len = length(this.protected);
  for thing in (this.protected)
    if (!$object_utils:isa(thing, $local.rpg.thing))
      this.protected = setremove(this.protected, thing);
    endif
    $command_utils:suspend_if_needed(5, "Checking validity of #10161.protected
 objects. . .");
  endfor
  player:tell("Eliminated ", tostr(len - length(this.protected)), " bad
 .protected objects.");
  len = length(this.doomed);
  for thing in (this.doomed)
    if (!$object_utils:isa(thing, $local.rpg.thing))
      this.doomed = setremove(this.doomed, thing);
    endif
    $command_utils:suspend_if_needed(5, "Checking validity of #10161.doomed
 objects. . .");
  endfor
  player:tell("Eliminated ", tostr(len - length(this.doomed)), " bad .doomed
 objects.");
  player:tell("Number of dumpers before: ", tostr(len = length(this.dumpers)));
  for k in [1..len]
    n = (len + 1) - k;
    if (((!$recycler:valid(dude = this.dumpers[n])) || (!is_player(dude))) ||
 (!$recycler:valid(this.dumps[n])))
      this.dumps = listdelete(this.dumps, n);
      this.dumpers = listdelete(this.dumpers, n);
    endif
    $command_utils:suspend_if_needed(5, ("Checked " + tostr(k)) + " dumpers. .
 .");
  endfor
  player:tell("Number of dumpers after: ", tostr(length(this.dumpers)));
endif
"Profane 6-APR-95 16:24EST -- Added.";
.

@verb #10161:"in_use_old" this none this rx
@program #10161:in_use_old
dumps = this.dumps;
if ((where = args[1]) in {@this.protected, dumps})
  return 1;
endif
adb = $local.rpg;
max = time() - this.threshold;
ok = listdelete(args, 1);
dumpers = this.dumpers;
claimed = valid(who = where:claimed_by());
while (valid(where = where.location))
  if (where in ok)
    return 0;
  elseif (valid(doll = adb:get_doll(where)) && (doll:get_att("last_action") >
 max))
    "On an RPG character.";
    return 1;
  elseif ((((claimed && ((owner = where.owner).home == where)) ||
 index(where.name, owner.name)) && valid(doll = adb:get_doll(owner))) &&
 (doll:get_att("last_action") > max))
    return 1;
  elseif (((claimed && (i = where in dumps)) && valid(doll = adb:get_doll(who
 = dumpers[i]))) && (doll:get_att("last_action") > max))
    return 1;
  endif
endwhile
if (claimed)
  args[1]:unclaim_for(who);
  return 1;
endif
"Quinn 20-APR-93 0236 ET> New :in_use hacked by me (Quinn) to check
 this.protected instead of looping through all kids of generic monster (#259).
 #10161.protected is updated with #259:set_mine, and the .mine property is now
 owned by G_M (!c).";
"Quinn 17-JUN-93 0945 ET> Now less liberal in deciding which objects are
 reaped. If a player hasn't made an RPG-action in the last month, eir stuff is
 a candidate for reaping.  My guess is this'll cut idle objects by about 40%.";
"Quinn 03-SEP-93 2355 ET> Added .dumps/dumpers property, renamed this object
 to DEP, made it a room, added Harvey the clerk. 'dumps' are places safe from
 sweeping (unless over-crowded).  Raised inactivity max to 3 months.";
"Profane 19-MAR-95 15:01EST - Put in claim checking stuph.";
.

@verb #10161:"in_use" this none this
@program #10161:in_use
":in_use(OBJ thing, [OBJ deadly location, ... ]) => 0 if not in use, ";
"                                       or a positive value otherwise.";
"If an object is in a deadly location, it is always considered";
"not to be in use.";
thing = args[1];
where = args[1].location;
" ... if the location is #-1, axe it.  Thanks, Slither ... ";
if (!valid(where))
  return 0;
endif
ok_to_destroy_here = listdelete(args, 1);
while (valid(where))
  " ... if the thing is in a place the caller said was a `lethal zone' ... ";
  if (where in ok_to_destroy_here)
    " ... give it the kiss of death ... ";
    return 0;
  endif
  " ... if the thing is being held by a monster ... ";
  if ($object_utils:isa(where, $local.rpg.monster) && (where.owner in
 $local.rpg.gms))
    " ... say it's in use ... ";
    return 1;
  endif
  "... if the thing is being help by a RPG player, save it";
  if (is_player(where) && valid($local.rpg:get_doll(where)))
    return 2;
  endif
  where = where.location;
endwhile
if (valid(claimant = thing:claimed_by()))
  " ... if the thing is claimed and the person is still in the RPG ... ";
  if (valid($local.rpg:get_doll(claimant)))
    " ... let it be considered in_use ... ";
    return 3;
  else
    thing:unclaim_for(claimant);
    return 0;
  endif
endif
"DR 06-MAY-95 -- Major rewrite.  Removed .dumps and .protected checks, as
 people are now supposed to claim the stuff they want to keep.  Monsters owned
 by GMs are exempt.";
"Quinn 20-APR-93 0236 ET> New :in_use hacked by me (Quinn) to check
 this.protected instead of looping through all kids of generic monster (#259).
 #10161.protected is updated with #259:set_mine, and the .mine property is now
 owned by G_M (!c).";
"Quinn 17-JUN-93 0945 ET> Now less liberal in deciding which objects are
 reaped. If a player hasn't made an RPG-action in the last month, eir stuff is
 a candidate for reaping.  My guess is this'll cut idle objects by about 40%.";
"Quinn 03-SEP-93 2355 ET> Added .dumps/dumpers property, renamed this object
 to DEP, made it a room, added Harvey the clerk. 'dumps' are places safe from
 sweeping (unless over-crowded).  Raised inactivity max to 3 months.";
"Profane 19-MAR-95 15:01EST - Put in claim checking stuph.";
"Slither 6/16/95 -- made stuff on players in use.";
.

@verb #10161:"reap_old" this none this
@program #10161:reap_old
":reap() -- Recycle all those damned weapons lying around.";
if (caller_perms() != this.owner)
  return E_PERM;
endif
start_time = time();
this.owner:tell(tostr(this, "> ", task_id(), " Beginning RPG Sweep ..."));
doomed = this.doomed;
scythe = this.recycler;
cemetery = this.cemetery;
recycled = 0;
msg = {};
for thing in (leaves = $object_utils:leaves_suspended($local.rpg.thing))
  "...loop through all kids of adventure gear.";
  "...if killable and already doomed, recycle.";
  "...else, add to the doomed list.";
  $local.rpg:time_stop(5 + random(10));
  if (this:killable(thing))
    if ((thing in doomed) || (thing.location in {$nothing, cemetery}))
      locs = {};
      where = thing;
      while (valid(where = where.location))
        locs = {@locs, where};
      endwhile
      msg = {@msg, {$string_utils:nn(thing), thing in doomed, locs}};
      if (!(thing in this.protected))
        "Dump out the contents. Can't do this inna :recycle verb, since the
 thing is moved to #-1 BEFORE :recycle is called.";
        for junk in (thing.contents)
          junk:moveto(thing.location);
          $local.rpg:time_stop(5 + random(10));
        endfor
        scythe:_recycle(thing);
      else
        "AYE!  Bad recycler!  Bad recycler!";
        string1 = "!!!!  #10161:reap - reaping invalid object";
        string2 = ((("!!!!  OBJECT: " + thing.name) + " (") + tostr(thing)) +
 ")";
        string3 = "!!!!  Callers: " + $string_utils:from_value(callers(), 1,
 11);
        #21077:log(string1);
        #21077:log(string2);
        #21077:log(string3);
      endif
      recycled = recycled + 1;
      doomed = setremove(doomed, thing);
    else
      doomed = setadd(doomed, thing);
    endif
  else
    doomed = setremove(doomed, thing);
  endif
endfor
this.doomed = doomed;
info = {start_time, time(), length(leaves) - recycled, recycled,
 length(doomed), msg};
this.sweep_log = log = {info, @this.sweep_log};
this.sweep_log = log[1..min(5, length(log))];
this.owner:tell(tostr(this, "> ", task_id(), " Finished RPG Sweep.  Elapsed
 time: ", $time_utils:english_time(time() - start_time)));
"Profane 14-APR-95 20:45EST - Added contents dumping. (People were having
 their unclaimed packs reaped, thus dumping their nice claimed stuff in #-1,
 where it got rapidly auto-unclaimed and reaped.)";
.

@verb #10161:"reap(outdated)" this none this rx
@program #10161:reap(outdated)
":reap() -- Recycle all those damned weapons lying around.";
if (caller_perms() != this.owner)
  return E_PERM;
endif
start_time = time();
this.owner:tell(tostr(this, "> ", task_id(), " Beginning RPG Sweep ..."));
doomed = this.doomed;
scythe = this.recycler;
cemetery = this.cemetery;
recycled = 0;
msg = {};
for thing in (leaves = $object_utils:leaves_suspended($local.rpg.thing))
  "...loop through all kids of adventure gear.";
  "...if killable and already doomed, recycle.";
  "...else, add to the doomed list.";
  $local.rpg:time_stop(5 + random(10));
  if (this:killable(thing))
    locs = {};
    where = thing;
    while (valid(where = where.location))
      locs = {@locs, where};
    endwhile
    msg = {@msg, {$string_utils:nn(thing), thing in doomed, locs}};
    if (!(thing in this.protected))
      "Dump out the contents. Can't do this inna :recycle verb, since the
 thing is moved to #-1 BEFORE :recycle is called.";
      for junk in (thing.contents)
        junk:moveto(thing.location);
        $local.rpg:time_stop(5 + random(10));
      endfor
      scythe:_recycle(thing);
      recycled = recycled + 1;
      doomed = setremove(doomed, thing);
    endif
  else
    doomed = setadd(doomed, thing);
  endif
endfor
this.doomed = doomed;
info = {start_time, time(), length(leaves) - recycled, recycled,
 length(doomed), msg};
this.sweep_log = log = {info, @this.sweep_log};
this.sweep_log = log[1..min(5, length(log))];
this.owner:tell(tostr(this, "> ", task_id(), " Finished RPG Sweep.  Elapsed
 time: ", $time_utils:english_time(time() - start_time)));
"DR 06-MAY-95 -- Simplified the case, don't care where things are anymore, if
 they are killable, and not in .protected, recycle them!";
"Profane 14-APR-95 20:45EST - Added contents dumping. (People were having
 their unclaimed packs reaped, thus dumping their nice claimed stuff in #-1,
 where it got rapidly auto-unclaimed and reaped.)";
.

@verb #10161:"unique" this none this
@program #10161:unique
y = args[1];
if ((((((valid(y) && (y.owner == this.owner)) && (!children(y))) &&
 (!properties(y))) && (!verbs(y))) && (!($object_utils:has_property(y,
 "unique") && y.unique))) && (!(y in $local.rpg.grabber.dispenses)))
  return 0;
else
  return 1;
endif
"Quinn 08-OCT-93 0438: Added check for object being dispensed.";
"Slither 6/22/95 removed check that y.name == parent(y).name";
.

@verb #10161:"doll_reapable" this none this
@program #10161:doll_reapable
":doll_reapable(OBJ doll) => true if doll can be reaped";
thing = args[1];
"If doesn't exist, or isn't a G_M owned doll, forget about it";
if ((!$recycler:valid(thing)) || (!$object_utils:isa(thing, $local.rpg.doll)))
  return 0;
elseif (thing.owner != this.owner)
  return 0;
endif
"If character isn't a player or a monster, then reap!";
character = thing.character;
if ((!is_player(character)) && (!$object_utils:isa(character, $local.rpg.monste
 r)))
  return 1;
else
  return 0;
endif
"July 3, 1995  Slither -- first version";
.

@verb #10161:"reap_doll" this none this
@program #10161:reap_doll
":reap_doll(OBJ doll) => true if successful   may suspend";
"Removes a doll from the database, and prepares it to be recycled.";
if (caller_perms() != this.owner)
  return E_PERM;
endif
doll = args[1];
ad = $local.rpg;
if (!$object_utils:isa(doll, ad.doll))
  return E_INVARG;
endif
$command_utils:suspend_if_needed(0);
"remove any claims";
for item in (doll.claimed_objects)
  $command_utils:suspend_if_needed(0);
  if ($recycler:valid(item) && $object_utils:isa(item, ad.thing))
    item.claimed_by = $nothing;
  endif
endfor
"remove from database";
result = ad:rm_doll(doll);
if (typeof(result) != ERR)
  this.doomed_dolls = {@this.doomed_dolls, doll};
  return 1;
else
  return 0;
endif
"July 3, 1995  Slither -- first version";
.

"***finished***