! Written by Daniel Barkalow, v1.0, Sat Jan 29 2000.

! This file defines objects which will determine what rooms are
! visible from a given location. This is useful for having open spaces
! comprised of multiple game locations. It is not able to change
! dynamically, however. The simplest example is of a setup where the
! player has some way of seeing what's in adjacent locations (perhaps
! a LOOK <DIRECTION> command), and the game isn't responsible for
! mentioning objects in the other room all the time. To do this,
! simply create a Scoper with the adjacent locations in the "locs"
! property, and the directions to the locations in the "dirs"
! property.

! Note that objects found_in distant locations do not get added to
! scope with this mechanism. However, if an object which provides
! found_in is listed in the "locs" property of a Scoper, the object as
! well as its contents will be added to the scope.

! In order to have a single conceptual room with multiple locations,
! you want all of the objects, including the ones in different parts
! of the room to be listed when the room contents are listed. To
! handle this, use Locale() in the after Look method of each room to
! list the contents of other rooms with appropriate information.

! For instance:
!   Room1
!    ...
!   after [;
!    Look:
!     if (Locale(Room2, "You see", "You also see"))
!       print " on the other side of the room.^";
!    ]
!    ...
! Scoper ->
!  with locs Room2,
!       dirs "on the other side of the room";

! The player is permitted to Examine and Listen to objects in the
! distance, which prints a message saying 
! In order to permit further interaction with distant objects (beyond
! Examine and Listen), add the verbs to the list at the beginning of
! react_before.

! To find out where an object is, use the procedure
! Scoper_locate(obj), which returns the "dirs" entry corresponding to
! the "locs" entry that got the object added. This probably won't work
! with things added by the add_to_scope property of an object.

! TestScope(obj) reports true if the thing is in scope via a scoper;
! the ScopeCeiling(obj) does not get transferred, however, which can
! distinguish distant objects. Note that TestScope(actor1, actor2)
! might not be the same as TestScope(acter2, actor1) now, since
! Scopers aren't necessarily commutative.

Class 	Scoper	
  with 	locs 0,
 	dirs 0,
	add_to_scope
	[i j k l n;
	  n = self.#locs;
	  k = self.&locs;
	  l = self.&dirs;
	  for (j = 0 : (2 * j) < n : j++)
	   {
	    if ((k-->j) provides found_in)
	      AddToScope(k-->j);
	    else
	      objectloop (i in k-->j)
	        if (~~(i ofclass Scoper))
		  AddToScope(i);
	   }
	],
	react_before
	[i j k n;
	 Listen, Examine: ! Add other generally permissible actions here
	  i = Scoper_locate(noun);
	  if (i)
	    print "(", (the) noun, " ", (string) i, ")^";
	  rfalse;
	  ! This would be a good place to add traps for things that
	  ! the scoper should handle, like figuring out where a named
	  ! object actually is.
	 default:
	  if (inp1 ~= 1 && noun ~= 0) ! test for permissible actions
	    ! with noun.
	   {
	    i = Scoper_locate(noun);
	    if (i)
	      print_ret "You can't reach ", (the) noun, ", since it's ",
		(string) i, ". ";
	   }
	  if (inp2 == 1 || second == 0 || action == ##ThrowAt) ! add
	    ! permissible actions with second here.
	    rfalse;
	  i = Scoper_locate(second);
	  if (i)
	    print_ret "You can't reach ", (the) second, ", since it's ",
	      (string) i, ". ";
	],
  has 	concealed;

[Scoper_locate obj i j k l n;
  objectloop (i ofclass Scoper)
    if (parent(i) == real_location)
      l = i;
  if (~~l)
    rfalse; ! no scoper here.
  i = ScopeCeiling(obj);
  k = l.&locs;
  n = l.#locs;
  for (j = 0 : (2 * j) < n : j++)
   {
    if (i == k-->j)
      return l.&dirs-->j;
   }
  rfalse; ! not added via a scoper
];