
		S C I    C H A N G E S   &   U P D A T E S
		******************************************
			
			in reverse chronological order
			------------------------------


			
7/12/91 Chad Bye

	Palette cycling now supports multiple ranges and multiple speeds.
	The third argument is now how many system ticks to wait between
	each palette shift.  The sign of the third argument still indicates
	which direction to cycle.  You can (and should) pass all ranges in a
	single call to Palette.

	Example:
	(Palette PALCycle start1 end1 numticks1 start2 end2 numticks2 ...)

7/11/91 Mark Wilden

	There is a new resource type for messages.  Messages are the analog
	in non-CD games of the CD resources, sync and audio.  You will need
	a messages= line in your WHERE file to find them.  You'll use the
	ME program to create them.  You'll use a new kernel call
	  (GetMessage moduleNum talkerNum msgNum @buffer)
	to access them.
			
7/10/91 Chad Bye

	Added picture mirroring as another option for DrawPic's showStyle.
	Options such as mirroring or blackout should be ORed with the
	showStyle.

	Example:
	(curRoom drawPic: pic (| IRISIN HMIRROR BLACKOUT))

	
	You can also now save the current palette and restore it later.
	The kernel call Palette now has functions PALSave and PALRestore.

	Example:
	(= savePalette (Palette PALSave))
	(Palette PALRestore savePalette)

	PALSave allocates memory to copy the palette into, and PALRestore
	disposes this memory.  Every time a palette is saved, it must
	either be restored later or disposed using
	(Memory MDisposePtr savePalette).
			
6/13/91 Pablo Ghenis

	Subj: Hunk reporting and requirements
	
	
	Configuration files are now case-insensitive.
	
	All configuration files (where, resource.cfg, etc.) must now 
	include a line of the form:
	
	minHunk = nk
	
	where n is a number between 1 and 1024. This specifies the 
	minimum amount of hunk (in kilobytes) required to run the game. 
	If your minHunk number is too large you will get a "not enough 
	memory" warning, if it is too small then any machine will appear 
	to have enough, and some will crash "out of hunk".
	
	To help you determine the correct minHunk, there is a new SCI 
	command line switch "U", which by default will create or append 
	to a file called hunk.use to report hunk usage throughout the 
	game as you play it. The report will include ONLY rooms where 
	hunk usage EXCEEDS the specified minHunk value, so if this never 
	happens then nothing will be reported. This is required for all 
	shipping versions (otherwise they might crash on a machine that 
	barely meets the minHunk requirement.) If you want the report to 
	go to a different file you can specify a file name immediately 
	after the "U", eclosed in double quotes. The "u" switch has been 
	enhanced to work the same way. This option is especially useful 
	when running on read-only media such as CD.
	
	Example:
	
	G:> scidh -dvu"c:\myres.use"U"c:\myhunk.use" c:\mywhere
	
	The recommended procedure is to start with minHunk = 1k and play 
	the game, going straight to the rooms that use the most hunk, 
	then exit. Near the bottom of hunk.use look for the last line 
	that ends in "NEW MAX!", it contains a better value for minHunk.
	Replace minHunk in your configuration file with this value, 
	delete hunk.use to get a fresh start and run again, until you end 
	up with no hunk.use file after running the game.

6/5/91 Eric Hart

	No one should be using the playBed or changeState methods of
	Sound any longer.  The information needed for 'playBed:' is
	now contained in the sound files, so simply 'play:' will
	suffice for every sound.  changeState: is no longer needed,
	because there are three new methods to change the state of
	a sound object:

		setVol:	newvol
		setPri:	newpri
		setLoop:	newloop

	No one should be setting the volume, priority, or loop
	properties directly any longer, but rather you should go
	through these methods.  (thus, there is no need to call a
	changeState method after you modify these properties)

	Another big change is the addition of priority information
	to sound files.  Sounds will now automatically set their
	own priorities, so no application should be setting them
	manually.  In the rare cases that this default must be changed,
	priority may be overrided by programmers using the setPri:
	method.  This will lock the sound object to the specified
	priority, regardless of the settings in the sound files, until
	the fixed priority is released by saying (sound setPri: -1).
	In a case where the sound file contains no priority information,
	the current value of the priority property will be used to
	play the sound regardless whether the priority is fixed or not.

	Sounds may also now be muted using the mute: method which
	takes a true or false value.  Mute: acts just like pause:,
	however the sound will continue to be parsed inaudibly until
	the sound is unmuted by a (sound mute: FALSE).  So unlike
	pause, the sound will continue where it should be, not where
	it left off.

	Also a new controller define has been added to system.sh,
	cMUTE.  This provides for muting individual channels of a
	sound.  We used to simply set the volume of channels that
	we didn't want to play to 0 by using code like:

		(sound send: 3 cVOLUME 0)

	But now we may mute them by using:

		(sound send: 3 cMUTE TRUE)    (or false to unMute)

	The advantage of this over using the cVOLUME way is that
	the musician may change the volume mix of his sound without
	the application programmer having to change code, and the
	channels and voices used by the channel being muted will be
	freed up for other simultaneous sounds to use.

	Existing code which uses the playBed and changeState methods,
	and that manually sets priority will still work for now, but
	after the products ship that need this compatibility (like
	KQ5 cd and Jones cd), these methods will be removed.

	More detailed information on these new methods may be found
	in the comments in sound.sc on s:


3/27/91 Mark Wilden

	Backquote key brings up debug, in addition to the regular
	Shift-Shift-Minus.
	New diagnostic resource cursors, selected by -cXX command line
	option, where XX represents the type of cursor.
	This is a decimal bitmapped number where the bits are as follows:
     	Bit 0:    Change cursor to disk on disk reads
     	Bit 1:    Move cursor to left on disk reads
     	Bit 2:    Change cursor to chip icon on ARM read/writes
     	Bit 4:    Move cursor up/down on ARM read/writes
	If you don't specify a -c command line option, there is no cursor
	diagnostics (thus not interfering with the game's cursor).  If
	you specify -c with no number following, the cursor will be as it
	was formerly (under -d):  changing based on disk and ARM access.

3/27/91 Mark Wilden
	FileSelector added readFiles: method, which must be called separately
	from init: (which is called at every arrow key!).  Added sort property
	which, if true, sorts the list.

12/06/90 Mark Hood & Mark Wilden
	VIEW.999 is displayed at startup, if it exists.

11/30/90 Mark Wilden
	DrawStatus can now take two optional arguments:  foreground and background
	color, which default to the usual black on white.  Note that these colors
	are indexes into the palette, so vRED is unlikely to be actually red (it 
	will select the 4th element of the current palette).

10/23/90 Mark Wilden
	FileSet was changed to FileSelector.  FileSet used to create an array
	of file names for use in a DSelector.  This function is now integrated
	into a selector.  The file was renamed from FILESET.SC to FILESEL.sc.

10/11/90 Mark H.
	A new function selector has been added to MemoryInfo.
	it is TotalHunk and returns the maximum hunk space that was allocated
	by sci at startup on a particular machine and configuration. This is to 
	give application programmers the ability to write conditional code based on
	the size of a certain machine (memory). It is called as: (for example)
		(Printf "Total Hunk = %d" (MemoryInfo TotalHunk))
	and returns the toal hunk in paragraphs. (1 paragraph = 16 bytes).
		

10/10/90 Mark H.
	The MoveCycle class now respects client cycleSpeed.

10/09/90 Mark H.
	The class PCycle has been added to the system to do palette cycling of
	Props. It tries to take the place of having many  different palette
 	cyclers by watching the parameter list. If one number is passed it 
	acts like a CycleTo cycling from the current palette to the passed palette:
 		(aProp setCycle:PCycle 5) cycles from current palette to palette 5.
 	If two numbers are passed it cycles through the range specified
 	in the proper direction (i.e. first number to second):
 		(aProp setCycle:PCycle 5 2) cycles from palette 5 to palette 2
 	If three numbers are passed it cycles through this range a number of times:
 		(aProp setCycle:PCycle 5 2 4) cycles from palette 5 to palette 2, 
		4 times.
 
 	Of course, a caller can be added to any of the above conventions,
 	to cue, as any decent Cycler should.


10/01/90 Mark H.
	The kernel call Lock has been added to lock and unlock resources.
	This is to allow the application	programmer to decide which
	resources should locked or unlocked. Lock takes three parameters--
		Resource type... VOCAB SCRIPT SOUND VIEW etc.
		Resource ID...	number of resource 999 002 etc.
		Lock or UnLock... TRUE or FALSE to Lock or Unlock.
	Be carefull!!! If you lock a resource yourself, it'll be in hunk forever,
	unless you unlock it yourself. Two new functions selectors
	have been added to the Memory kernel call. They are MReadWord
	and MWriteWord for referencing and dereferencing addresses.	Again,
	more power, but more responsibility. You are now free to mess up heap
	and hunk as much as you wish.


09/25/90 Mark H.
	Added Oscillate cycler that will cycle a Props cels forward and 
	then back a given number of times. Changed MoveCyc to take a local array 
	address instead of a bunch of points so that it can handle more points
	and save wods 'o heap. Removed Features default description and changed 
	handleEvent method to return FALSE if there is no description. Moved WordAt
	procedure from PolyPath to system.sc since it has been used a lot recently...
	it will, however be migrated to the kernel shortly. Added Erics changes to
	sound that should fix the restore problem. Changed Grooper to not dispose
	oldMover if it is also clients mover. Added global useObstacles that can 
	determine whether or not Ego will use a PolyPath if obstacles are present...
	same for an Actors setDirection.


09/21/90 Mark H.
	DPath now does an extra doit when reiniting itself to eliminate the
	pause at the end of each node. Stop updated actors will no longer pop
	through modeless dialogs when changing their update status.	Resource
	purging now uses a prioritized purging scheme based on resource type
	instead of just least recently used. This helps to reduce disk thrashing 
	when nearing the edge of Hunk space. To go along with this change, 
	VOCAB and TEXT type resources are now unlocked.	You may notice now that
	a Load will happen when typing a Said or printing text. If you are completely
	finished with a view in a Room you should use an explicit (UnLoad VIEW xxx)
	since VIEW resource type is one of the last to go otherwise.


09/06/90 Mark H.
	Actors delete method was changed to ensure that if a View is addToPic'd
	it will be placed on the features list instead of disposed so that all
	of your handleEvent/doVerb 's will work.
	
09/05/90 Mark H.
	A caller property has been added to theDialog class. This has made
	it possible to allow the Print procedure to take an optional parameter
	after the #dispose: that is who to cue upon disposal of the modelessDialog.
	The most useful example of this would probably be written as follows:

		(instance foo of Script
			(method (changeState newState)
				(switch (= state newState)
					(0
						(Print "This is a 5 second modeless dialog"
							#time:5
							#dispose:self
						)
					)
					(1
						(Print "I got cued by the dialog itself.")
					)
				)
			); changeState
		);foo
	Remember that the dispose method of Dialog has been rewritten
	to cue caller if present, so other applications may be possible.
			

08/30/90 Mark	H.
	The kernel call Sort has been added to speed up sorted features,
	however it has been written to be a general purpose sort and thus
	is available for your everyday sorting needs. . 
		It is used as follows:

		(Sort	unSortedList sortedList	scoringCode)

	where the unSortedList is the list to be sorted, sortedList is an 
	uninstantiated (empty) list where the sorted list is to be placed 
	by the kernel call, and scoringCode is a piece of code that determines
	the criteria for the sort. The scoringCode's doit should	return a
	number for each object that would determine its relative place in the 
	list. For example if you wished to sort the cast by their height on
	the screen (their y property) the code would look like this:

		(instance sortedList of List)
		(instance yScoreCode of Code
			(method (doit theObj)
				(return (theObj y?))
			)
		)
		(Sort cast sortedList yScoreCode)

	and sortedList would now contain the cast sorted by their y properties.
	The Sort algorithm is a simple modified bubble sort. Since most of our 
	applications will have less than a hundred elements this should be 
	close to optimum.	

	BE SURE TO DISPOSE OF THE sortedList!!!!	If you do not, you will
	definitely get hard to trace memory frags.

08/21/90 Mark H.
	Actors setDirection method has been changed to allow ego to turn
	if an arrow key was hit and he is up against an obstacle. Previously
	he would ignore the key completely.

08/14/90 Mark H.
	Polygons are here! The Polygon class was added to the system to
	support Larry's Polygon based avoider. The Polygons are created
	either manually or with Chad Bye's new Polygon Editor, and added
	to the obstacle list via the Rooms addObstacle method. The mover
	PolyPath is where the actual avoider stuff is hidden. It works
	just like a MoveTo only it will find its way around any polygon 
	in the obstacle list. AddToPics will automatically add a suitable
	Polygon to the obstacle list when the (addToPics doit:) is called
	if the addToPics ignrAct bit is not set. The Polygons have also
	found use in Features onMe method. To do this, redefine the Features
	onMe method to check if a click was in a surrogate Polygon. The kernel
	call AvoidPath will check if a given x,y is in a polygon if only these
	three parameters are passed. 

		
	Example:
		(local polyPts = [10 20 50 30 50 100 20 100 5 50])
		(instance myPoly of Polygon)
		(myPoly points:@polyPts, size:5)
		(instance fooFeat of Feature
			(method (onMe theObj)
				(return (AvoidPath (theObj x?)(theObj y?) myPoly))
			)
		)

	If this starts to get used alot, let me know and I'll automate the 
	process a little better. i.e. a polygon property of Feature.
	Also, the scads of includes that used to slow down your compiles 
	in system.sh are now in-line with a few exceptions. The following
	files are NOT included automatically now , and if you're using any 
	of the classes or procedures in their corresponding .sc files, you will
	now need to explicitly include them. A small price to pay for the speed
	up in my opinion.
		The .sh file that will need to be manually included are:

		cat.sh 		;; if you're using the Cat class
		demo.sh 		;; if you're using the Demo Demon
		namefind.sh	;; if you're using the NameFind procedure
		count.sh		;; if you're using the Count procedure
		lastlink.sh	;; if you're using the lastlink procedure
		gotosaid.sh	;; if you're using the gotosaid mechanisms

	There were also minor changes to Views	(a real isNotHidden method)
	and the Grooper. Unfortunately, this means that a rebuild is necessary 
	if	you use the Grooper. 

	Also, new tools thanks to Doug Oldfield and Mark Wilden and Chad Bye.	
	Doug has made two new cyclers that are in the system for your use. 
	MoveCycle which repositions the client for each cel. (This seems to be 
	the way alot of artists are doing things these days!) This saves the 
	need for a Script	that just positions and sets a cel in every state 
	(Hand carved animation). Also RandCycle that just picks cels at random 
	for a specified number of times, or forever. This is useful for mouth 
	animation while talking. Mark Wildon has created a Dialog building tool 
	that can really simplify 90 percent of your everyday dialog needs. It 
	is a procedure called PrintD and is also now in the system. Chad Bye has
	added an excellent Polygon Editor (and pather for the other avoider)	called
	pather. To invoke it, simply put (MakePath doit:) in the appropriate place
	in your debug module (or wherever).	Documentation for all is coming soon 
	(soon is a relative term), but for now, look at the modules for the 
	programmers	own docs. Sorry this is so long, but I have been delinquent
	at keeping this up to date, and a lot has happened. As always...
	we're looking for new tools, so let me know if you've	made something
	that is nice and general purpose and fills a gap in our current library.


08/04/90 Mark Wilden
	Added new FileIO functions fileFindFirst, fileFindNext and fileExists.
	Added Memory function MCopy.

08/02/90 Mark Wilden
	The function selectors for stack usage kernel calls were backwards;
	i.e. (StackUsage MStackSize) returned the size of the processor
	stack instead of the PMachine stack.

07/09/90 Mark Wilden
	IBMKBD.DRV and TANDYKBD.DRV were changed.  Now the only keyboard
	event modifiers are when shift keys (including Ctrl and Alt) are
	pressed.  The state of Ins, Caps Lock, etc. as well as differences
	in certain BIOSs are now ignored.  The new drivers are in I:, S:
	and the tester directory.

07/03/90 Mark H.

	The Feature class now allows the programmer to decide wether or not
	they would like the proximity checks done if a shift or control click 
	was detected. The define NOCHECKMOUSE should be or'ed with the verb
	number for the shftClick and contClick properties. 
		(i.e.	(theActor shftClick: (| NOCHECKMOUSE verbLook))
	Also a bug in the setChecks method was discovered and fixed. 
	The Feature writer now also will allow testing of features created
	and also allows editing of Features, Views etc that were already in 
	the room.

07/02/90 Mark H.

	Actors code property now gets done even if object is not updating .
	View and PicView can no longer inherit the dispose method of Feature
	since Feature's dispose now deletes it from the features list.

06/26/90 Mark H.

	There have been several additions to the interpreter.
	Memory allocation	and deallocation has been added as well as
	List manipulation functions. Heap memory allocation is handled through
	the kernel call Memory and has three enumerated function definitions:
		(= thePointer (Memory MNeedPtr amount)) - 
			requests	that "amount" bytes will be allocated and the pointer
			to the memory is returned to thePointer. If the memory is not
			available SCI aborts with the all to familiar "Out of Heap Space".

		(= thePointer (Memory MNewPtr amount))
			same as above, but simply returns a null pointer if memory is not 
			available.

		(Memory MDisposePtr thePointer)
			Deallocates the memory pointed to by pointer.

	This function should be used carefully and make sure to deallocate all
	the memory that you have allocated. List manipulations can now be sped up 
	with the ListOps kernel call. 

	The lines of Code below will speed up the list processing by approximately
	a factor of four.

	(method (eachElementDo theSelector)
		(ListOps LEachElementDo	theSelector &rest)
	)

	Also available as function definitions are LFirstTrue and LAllTrue.
	Bob has also put the kernel hooks in for the AIPath from the 
	Chris Iden. More about that later... Stay tuned.


06/20/90 Mark Wilden
     
  The File class and kernel calls have been changed and added to.  In
  the kernel there is now just one entry point for all file functions:
  FileIO.  An enumerated value is sent to FileIO to indicate the desired
  function (see kernel.txt or kernel.sh for these values).  Several new
  file functions were added:  read and write, which operate on arbitrary
  data; seek, which moves the file pointer; and unlink, which deletes a
  file.
  The File class was changed to reflect these modifications; in
  particular, the read: and write: methods now refer to raw file
  access--use readString: and writeString: to read or write zero-
  terminated strings.

06/13/90 Mark H.
	
	Added new cycler that takes care of the out of sync walk cycler
	with moveSpeeds greater than 1. Its called SyncWalk and it is in 
	Motion.sc. Also the need for the rebuild is that user has a property
	called verbMessager that lets you define your own verb message 
	numbers. This will make more sense when my documentation is finished.

06/11/90 Mark H.

	We have a new system, folks. A rebuild of your game will be
	necessary if you are using \games\sci\system. After receiving 
	a lot of great input from Bob, Pablo, Corey, Mark W., Chris I.,  
	the SQ4 crew and anyone else I forgot to mention, the Feature 
	class has been	completely rewritten (again). The documentation
	is following closely behind, so sometime tomorrow it should be 
	complete. Besides all the stuff added to Feature, User canInput
	is now a method. This gives you the ability to break on it and
	also allows redefinition of it to do things with the cursow 
	(or whatever). There is also a setHeading method of Actor
	that should now always be used. Instead of code like 
	(anActor	loop: facingSouth) you should write something like
	(anActor setHeading: 180). Besides keeping things consistant
	between an actors heading and his loop, (for those using sorted
	features), it also fires a looper if one is attached. There is an
	optional whoCares parameter (like motion and cyclers) that will
	cue something when the turn is completed. IF ANY BUGS OR 
	INCONSISTANCIES ARE DISCOVERED, PLEASE LET ME KNOW, POST HASTE.
	If you don't like the way something works don't abandon it!!!
	Tell me your suggestions and the system will be better for it.
	There	will be much better doco and examples coming soon.
	For those wanting to get started with the feature writer
	let me know and I'll step you through.

06/04/90 Mark H.
	
	The IsOffScreen procedure in sight.sc has been changed due
	to a bug pointed out by Mark W.. It now correctly used the
	southEdge define instead of the SCRNHIGH define. 0 is now
	also considered on screen. 

05/24/90 Mark H.

	Added MoveFwd Class. Just pass a distance you want to move
	and the Actor will move in the direction he is pointing.
	As usual, either preload the module or dispose of it when 
	you're done to prevent frags.	See module movefwd.sc for usage 
	info.
	
05/08/90 Corey

	Removed initialization of "version" in system.sh, since you
	can't auto-initialize a global variable to a string pointer.
	It is now *required* that you have a line such as:

		(= version {x.yyy____})

	(or anything else you want to initialize "version" to) in the
	(init) method of your room 0 instance of Game.  Actually, this
	was always needed, but simply gave you bad Save games before.

	Suggested strings are either {x.yyy____} or {x.yyy.zzz} for
	"incver" compatibility (either can be used for auto-incrementing
	version number via incver).


05/04/90 Mark Wilden & Corey Cole

	Fixed bugs in "Extra" class when minPause, minCycles, or hesitation zero.
	Also improved behavior of ExtraEndAndBeginLoop (now allows the pauseCel
	to be the last cel of the loop).


05/03/90 Bob

	GetTime SYSDATE returns date since 1980.


04/02/90 Mark	H.

	The module user.sc has a slight change to fix a bug pointed
	out by Mark W. and Gary K. If a horizon was non-zero in a room
	and ego was ignoreHorizon, Then if ego walked above the horizon
	he could walk east and not change rooms. Also a fix in demo.sc.


03/20/90 Larry & Corinna

	The op. code mod accomodates negative numbers now.


03/20/90 Corey

	Does not save control map if it's not going to draw into it
	for stop updated actors.


03/20/90 Larry & Corinna

	When get an "Out of heap space" error, if running with the
	sci debugging on (-d) it goes into the sci debugger then exits.
	If running without debugging on, it just exits (this is in
	case a customer runs into this error).


01/18/90 Stuart

	All new and some-what improved sound drivers in system directory.
	Changed restart controller to return to loop point in sound,
	instead of beginning of sound.  This change should not effect
	game programmers.


01/08/90 Bob
	
	Increased required "minimum hunk" available to 320K from 136K.
	This should not affect anyone during development, and is intended
	to reduce problems encountered in the field.  Please let me know
	if this change causes problems.


12/09/89 Bob

	Modified GetTime kernel call as follows to provide more functions:

	(GetTime) - returns low word of 60th second counter (unchanged)

	(GetTime SYSTIME1) OR (GetTime 1) or (GetTime TRUE) are all 
	equivalent and will return the same value as before, but NOTE
	the "1" or "TRUE" are the non-prefered forms although the value
	of SYSTIME1 is also 1.

	(GetTime SYSTIME2) - returns a 24 hour clock that is limited to
	2 seconds of resolution.

	(GetTime SYSDATE) - returns the systems concept of the day it is
	in a packed YEAR/MONTH/DAY word.

	The standard system files have been modified to conform to this new
	functionality. 
		****
		For those who have "frozen" systems and NEED new interpreter
		(required for those groups using LOGGER), changes were needed
		in system.sc, timer.sc, intrface.sc and kernel.sh
		**** 

	This change has a great degree of backward compatibility. To ensure
	that you have no problems, merely GREP for GetTime in all your
	source file and ensure that IF you passed an argument it was == to
	1 (ie "1" or TRUE).  If this is not the case change each occurrence
	and recompile.

	follows some code showing how to use each case.  Defines for each
	function have been placed in KERNEL.SH.

	; print current 12 hour time as in 01:30:22 (assume PM)
	(= tm (GetTime SYSTIME1))
	; HHHH|MMMM|MMSS|SSSS
	(Printf 
		"%02d:%02d:%02d"
		(>> tm 12)
		(& (>> tm 6) %111111)
		(& tm %111111)
	)
	; print current 24 hour time as in 13:30:22
	(= tm (GetTime SYSTIME2))
	; HHHH|HMMM|MMMS|SSSS
	(Printf 
		"%02d:%02d:%02d"
		(>> tm 11)
		(& (>> tm 5) %111111)
		(* (& tm %11111) 2)
	)
	; print current DATE as in 12/09/1989 (only good through 1999)
	; years value is number of years since 1980
	(= tm (GetTime SYSDATE))
	; YYYY|YYYM|MMMD|DDDD
	(Printf 
		"%02d/%02d/19%02d"
		(& (>> tm 5) %1111)
		(& tm %11111)
		(+ 80 (>> tm 9))	; you must add 80 to return value
	)

12/01/89 Stuart:

	Minor changes to INSTALL.HLP - 
	 1. A warning label for the MT-32
	 2. Changes in the text of Casio help screens

11/17/89 Jeff:

	There is now a "fragment analyser" built into the debugger.  It is
	invoked by 'F' and displays all allocated heap following the first
	free block.  Objects are displayed as usual.  Other allocated memory
	has a code inside angle brackets, followed by the address.  The codes
	are:

		<l>		a list
		<n>		a list node
		<e>		an event
		<mxxx>	module node for module xxx
		<sxxx>	sound node for sound xxx

	If people don't find this particularly useful, let me know.  We don't
	have the code space to make it more useful, and I'd like to pull it
	out (reducing interpreter size) if it's not being used.

	The SC compiler has a new switch (-w) which causes words in the
	output to be written in Motorola (high-byte/low-byte) rather
	than Intel (low-byte/high-byte) order.  This should lead to faster
	68K interpreters, at the price of recompiling the entire game & system
	source for the 68K.  Files affected are all script.* files, vocab.996
	(the class table), and vocab.994 (the property offset table).


11/16/89 Corey:
	Added "(DisposeScript LOADMANY)" as the last line of the LoadMany
	function so that it cleans up after itself.  Games that were already
	explicitly doing this (or using LOADMANY as the last argument to the
	LoadMany function) should probably remove said code.

11/15/89 Stuart:
	Wow! Three changes in a row.
	MT540.DRV and CSM1.DRV have been revised to correct the installation
	text.  The CT-460 is the same as a CSM-1, not an MT-540.

11/13/89 Stuart:
	Optimized MT32.DRV for master volume changes, reverb mode changes,
	and MIDI channel reassignments.  Should have no effect on previous
	games.

11/1/89 Stuart:
	Changes have been made to the following drivers over the last
	few weeks:

	   JR.DRV and TANDY.DRV
		Enhanced to allow musicians more accurate control over
		when a song is to start.
	   ADL.DRV
		Enhanced to respond to hold pedal MIDI data.
		Adjusted instrument voice volume levels to be more accurate.
	   MT540.DRV and CSM1.DRV
		Fixed a bug that prevented SOUND_DONE cue from happening
		when the sound was off.

	NOTICE TO ALL GAME PROGRAMMERS:
	   While a game is in development, it is HIGHLY advisable to use
	   G:\GAMES\SCI\SYSTEM for your music drivers.  By isolating the
	   current music drivers, the chance of sending Q.A. obsolete 
	   drivers is increased.  Also, space on the network will continue
	   to be a factor.

	   F.Y.I - There are currently 32 various ADL.DRV's on the network.
	

10/24/89 Corey:

	Fixed a bug in Print that caused various weird bugs when using
	modeless dialogs.


10/13/89	Jeff:

	The isStopped: method of Actor has been fixed so that it works
	properly.  You should now be able to vary cycleSpeed and moveSpeed
	independently for Actors on a Walk and have it work properly.


9/22/89	Pablo:	GOTOSAID: The end of "not close enough".

	TurnIfSaid is a new version of Mark Hood's procedure for making ego 	
	face whatever was mentioned. For example if the user types "look chair" 
	ego will	turn in place to face the chair before getting a response.
	
	GoToIfSaid is similar but, as the name implies, it moves ego to a 
	specified point or object vicinity before reprocessing the Said event.
	
	These procedures are only useful if sortedFeatures are in use. Grooper 
	and avoider are used to turn and move.
	
	* This takes up ZERO bytes if you don't use it.


9/22/89	Pablo:	AVOIDER: Great taste, less filling!

	* 28 bytes SMALLER!
	* Improved ability to get around convex obstacles (the most	common kind).
	* No longer tries to reach illegal destinations. This means that you can 
	leave an avoider on ego without it trying forever to get inside a table 
	if the user happened to click there. In such cases you get the same 
	behavior as if the avoider weren't even attached. The same is true for 
	cursor key presses: since off-screen destinations are not in the 
	avoider's department it leaves it all up to the mover, as it should!
	
	* This takes up ZERO bytes if you don't use it.


9/22/89	Mark Hood:	GROOPER: Great taste, less filling!

	* 112 bytes SMALLER!
	* More functional, restores arbitrary old loopers.
	* Now works correctly with avoiders.
	
	* This takes up ZERO bytes if you don't use it.
	

9/19/89	Jeff

	Joystick related stuff:
	There is a new kernel call named 'Joystick' to do things to the joystick.
	At present, it only has one function, 'JoyRepeat', which sets the joystick
	repeat rate.  Usage is

		(Joystick JoyRepeat n)

	where n may have the following values:

		-1		Just return the current repeat rate without changing it.
		0		Turn off joystick repeat.  In this case, the joystick will
				only return a direction event when the direction is changed.
		n		Have the joystick return a direction event (except for the
				'stopped' direction, 0) every 'n' system ticks (which occur
				at 1/60th of a second).

	The default repeat rate is 0, i.e. the joystick only reports direction
	changes.  For selecting items with the joystick (as in the MenuBar),
	setting the repeat rate to 30 (two direction events per second) gives
	a controllable repeat for selection.

	The JoyRepeat function always returns the previous value of the repeat
	rate.  Remember to set it back to this value when you're done!

		(= oldValue (Joystick JoyRepeat 30))
		... some user selection ...
		(Joystick JoyRepeat oldValue)



9/4/89	Pablo

	GRAMMAR and VOCABASE change.
	
	The bad news: the words "to", "from" and "about" were being improperly 
	handled, forcing programmers into some kludges to solve the problem. The 
	most infamous example was the need to use TWO said specs to trap the 
	sentences "ask about beer" and "ask bartender about beer"; ie. 
	'ask/beer<about' and 'ask//beer<about' (yeech!). Also, to and from were 
	sometimes modifiers to the verb and sometimes to the indirect object, 
	adding to the hit-and-miss nature of said-spec writing.
	
	The good news: This is fixed, so 'ask//beer' is enough to trap ALL 
	questions about beer, and to/from are always modifiers to the VERB. Life 
	is simpler...
	
	The price: You will want to grep through your code looking for 
	'ask/beer<about' and 'give/gold/dwarf<TO' style cases; and change them.
	My initial grep uncovered less than a dozen such cases per project, so 
	it's not so bad. If you were covering all bases by writing all possible 
	specs then the changes are largely optional. You will need to rebuild 
	regardless, since word numbers have changed...


8/29/89  Corey

	Added "track" method to Cat class.  Allows Cat to be init'ed after
	the appropriate mouse event has already occurred, and for cursor
	keys emulating mouse.  (External module invokes "track", which is
	equivalent to an existing Cat object receiving a mouse down.)
	Ask Pablo or me for details.


8/28/89	Pablo

	User now has a "curEvent" property which points to the last event 
	processed by User. This is especially useful for following the mouse.
	
	Demo Demon now has FakeMouseUp as well as FakeMouseDown, both of which 
	are really defines that use FakeMouse, which is now tied into User 
	curEvent.
	
	Cat changed to track (User curEvent?) in its doit unless doCast is TRUE 
	in which case it hogs processing. This is a safer implementation for 
	allowing background animation while tracking. Also helps programmatic 
	control of Cats.
	

8/28/89	Pablo

	Class Cat now accepts a caller that gets cue'd when the mouse is 
	released.
	
	Class Track of Motion has been added.
	
	;;	keep client at a certain x and y offset relative to position of
	;;	object who
	;;
	;;	client should come AFTER "who" in the cast
	;;
	;;	Usage: 
	;;		(theTracker setMotion: 
	;;				Track theTrackee xOffset yOffset zOffset theCaller)
	;;
	


8/11/89	Jeff

	Buttons other than the left button on multi-button mice are now
	supported:

		right button	->		shift-click of left button
		center button	->		ctrl-click of left button


8/10/89	Pablo

	QSOUND: Queued sounds now respond to the new sound protocol for cues, 
	where 1-127 are for ad-hoc cues (as before) and 128-64k are for 
	sequential cues. Sequential and ad-hoc cues may be mixed within a song, 
	although the check method of the QueuedSound instance would have to be 
	specialized. This change is backward-compatible.
	
	CAT: Is now a subclass of Actor instead of View, fixing a conceptual bug 
	in the first implementation. This will require you to rebuild.


8/7/89	Pablo

	New files FORCOUNT and LASTLINK
		
	;; Usage:
	;;			(LastLink #client thisScript)
	;;			(LastLink #script thisActor)
	;;			etc...

	;; ForwardCounter Cycle Class
	;; Saves states in scripts by cycleing a given number of times
	;; then cueing on completion.
	;; Usage : propName setCycle:ForwardCounter numOfCycles whoCares
		


8/3/89	Corey

	Corrected some of the comments in the StopWalk class.  There was
	an error in the StopWalk usage originally described here.  Correct
	usage example:

		(actor  setCycle: StopWalk stoppedView)

	The "walking view" is determined from actor's walking view when
	StopWalk invoked, not passed as an argument.


7/28/89	Bob

	The program, INSTAL.EXE has been modified to adapt to games
	that do not wish to support a joystick.  If the program finds
	a file named JOYSTICK.DRV on the disk, it will display the use
	options as normally.  If this file is NOT present, the use dialog
	will NOT be presented.
	PLEASE NOTE: This represents a significant deviation from standard
	Sierra policy, so be sure to inform Garuka of your decision, so that
	it can be coordinated with documentation and QA.


7/21/89	Bob
	
	OOPS!	
	On the 14 of June of the year 1989 I, Robert E. Heitman,
	made a change to the priority band placement in SCI.
	The absolute Y coordinate of every other priority band
	shifted down one pixel.  This has given rise to one problem
	in an older game, where a stop updated door was placed
	directly on a priority band in order to minimize the size
	of the control block.
	If you have experienced un-reconcilable priority problems
	with existing artwork that predated this change, please contact
	me.

7/20/89	Jeff

	A new compiler/SCI combination now lets SCI know whether to load the
	text.xxx resource when it loads script.xxx.  This should speed up disk
	access in general when loading a far-textless script, and prevents disk
	access when accessing a far-textless script which is in hunk.  You should
	rebuild your game as soon as possible.  If you can't do so right now, the
	old interpreter is in x:sciold.exe and x:scivold.exe.  The old interpreter
	will run files compiled with the new compiler just fine...

7/20/89	Bob

	A minor flaw in the debugger has been fixed.  The problem related
	to "crashing" when you bring up the debugger.  The crash could
	be manifested in many ways, the most common was "packhandles failure".
	Bringing up the debugger could have also caused delayed memory
	failures that are hard to pinpoint.  Please let me know if things
	appear to be less fragile memory wise.

7/18/89	Pablo

	QSCRIPT: fixed a couple of bugs in script overlaying mechanism, looks 
	much more solid now. Required minor bug fixes in game.sc and actor.sc as 
	well. There is no need to rebuild.

	LOADMANY: New procedure LoadMany allows you to load or unload several 
	resources with a single line of code.
	
	Loading examples:
		(LoadMany VIEW 123 232 433)
		(LoadMany SCRIPT 123 232 433)
		
	Unloading example (performs DisposeScripts):
		(LoadMany FALSE AVOIDER REVERSE TIMER)
		
	
7/13/89	Pablo

	INTRFACE: New method check added to Dialog, fixes bug that kept 
	modelessDialogs from going away upon expiration of seconds.


7/12/89	Pablo

	(class QueuedSound kindof Sound
	
		(properties name "QSnd")

	;;Author: Pablo Ghenis, 7/12/89
	;;
	;;A QueuedSound assumes that the absolute values of the cues it receives
	;;form a sequence, ie. 1,2,3... QueuedSounds eliminate the risk off having 
	;;the animation loop overrun by rapid sound cues since it catches up by 
	;;cueing its client as many times as the latest increment in signal, thus 
	;;faking a "queue of cues" (sorry, I can't resist a pun!)
	
	;;size=160 bytes, should save its own weight in ad-hoc code
	
	)


7/10/89	Pablo

	INTRFACE has been modified to avoid loading TIMER, a 650-byte savings for 
	users of the demo demon or anyone using #time in a Print. Since this 
	involves some new properties it will require a rebuild.
	
	New class TimedCue in script TIMEDCUE. This is a very small substitute 
	for timers that will provide a cue after a specified number of seconds or 
	cycles; it is a subclass of Script and takes 150 bytes or so. What you 
	give up for the 500 bytes is the ability to specify game time, which is 
	more appropriate in many situations. No free lunch, but it may be useful.


6/30/89	Pablo

	DPath = D(yanamic)Path and RelDPath motion classes
	
	This is an alternative to Path, which requires allocation of a static 
	array and specialization of the "at" method.	D(ynamic)PATH uses a 
	dynamically created list to keep path points.
	
	RelDPath interprets its coordinate pairs as relative instead of absolute 
	targets.
	
	Usage is like other motion classes:
	
		(anActor setMotion DPath x1 y1 x2 y2 ...  anOptionalCaller)
		(anActor setMotion RelDPath x1 y1 x2 y2 ...  anOptionalCaller)
		

6/28/89	Pablo

	SCIP Parse tree viewer
	
	To figure out what said spec to write for a sentence you can now run SCIP 
	and type it in. SCIP will display the parse tree in a form that is easily 
	translatable to said-ese.
	
	Example: 
	
		1-	type "get big rock" where get is a noun, big is an adjective and 
			rock is a noun.
		
		2-	SCIP echoes (the indentation is very significant)
			(Root
				(Root
					(Root	.w123))		;get is root of Root
				(DObj
					(<	.w456)			;big is modifier of DObj
					(Root	.w789)))		;rock is root of DObj
					
		3-	Said spec template is 'Root<modifier/DObj<modifier/IObj<modifier'
			so this case is 'get/rock<big'.
			
	Use SCIP next time your favorite author demands the ability to parse 
	"how do squrrels get into trees?"

6/28/89  Corey

	* Added StopWalk class (STOPWALK.SC).  Use in place of Walk if you
			have an alternate view to use when ego is stopped/blocked.
			Behaves just like Walk otherwise.  Should be compatible with
			GROOPER, but not with SMOOPER.
	;;;
	;;; Usage example:
	;;;	(actor setCycle: StopWalk walkingView stoppedView)


6/28/89	Pablo

	* classes Ego, MouseDownHandler and Script updated.
	* new file QSCRIPT
	* new versions of SIGHT, TEXTRA, SMOOPER, GROOPER
	
	Ego: fixed bug that caused ego to respond to mouseDowns even when (User 
	controls) was 0.

	MOUSER: The MouseDownHandler class now has a property name shiftParser 
	which should point to an instance of Code whose doit method will be 
	responsible for putting together a string to be parsed. This opens up the 
	architecture for translating shift-clicks into saidEvents.
	
	;;	Usage:
	;;	
	;;	(instance MyMouseSays of Code
	;;		(method (doit what event)
	;;			(Parse {look} event)	;or (Parse (what name) event)
	;;		)
	;;	)
	;;	(instance MyMouseDownHandler of MouseDownHandler)
	;;	
	;;	(instance FooQuest of Game
	;;		...
	;;		(method (init)
	;;			...
	;;			((= mouseDownHandler MyMouseDownHandler)
	;;				shiftParser: MyMouseSays
	;;				,add: cast features
	;;			)
	;;			...
	;;		);init
	;;		...
	;;	);FooQuest
	
	
	The Script class now has a "next" property which allows chaining of 
	scripts. 
	
	;;	Usage:
	;;	
	;;	(QueScript anObj scriptToChainTo optionalWhoToCallWhenDone optRegister)
	;;	
	;;	this will trigger the following when anObj is done executing its current
	;;	script if any:
	;;	(anObj setScript scriptToChainTo optionalWhoToCallWhenDone optRegister)
	;;	
	;;	scriptToChainTo can be the number of a module which has a real script
	;;	as public entry zero. This mechanism provides an easy route for 
	;;	"overlaying" portions of long or mutually exclusive scripts to save
	;;	memory.
	
	
	
6/22/89	Pablo

	SCPP, the pretty indenter for SCI, now treats comment lines as follows:
	
;;; triple semicolon comments are left-justified
(instance commentExample of FooBar
	;;double semicolon comments are indented just like code
	(properties
		foo	BAR	;this is a comment
						;and this is a single-; continuation
						;which SCPP leaves right where it is
						;hopefully aligned with a previous end-of-line comment
	)
)
			
6/9/89	Bob

	Certain masochists requested the ability to have alternate
	palettes contained within the same picture. I have acceeded
	to their demands.  The palettes are specified in PE version
	6.000 or higher by pressing 'P' at the color selection window.
	All palettes are thereafter saved & loaded with that picture.

	An SCI programmer can request one of those palettes (0 - 3) as
	yet another parameter to the DrawPic kernel routine.  She may
	also access an alternate palette by setting the global variable
	"currentPalette" to the proper value BEFORE drawing the picture
	via the drawPic method of the room. (NOTE  - This method is called
	in the Room's super init: method)  
	The full DrawPic protocol: 

	(DrawPic 
		picNumber	; pic.xxx etc.
		showStyle	; how to show it 
		clearPic 	; TRUE will clear pic, FALSE will overlay
		palette		; 0 - 3 No error if palette not in data.
	)


6/7/89	Bob

	I hate writing in this file, so...
	If you want an Icon to cycle in a Print window, you
	need merely tell Print about it using the same tired old
	#icon: parameter. This time, however, instead of passing
	view, loop, and cel numbers, you pass an objectID of class
	DCicon.  The class DCIcon is in a file called DCICON.SC, and
	should be consulted for any further guidance.  The following
	code snippet will do something.

	(instance myIcon of DCIcon
		(properties
			view: 120
			loop: 5
			cel: 0
			cycleSpeed: 6
		)
		;; the init method for the class
		;; attaches a cycler of Class Forward
		;; to attach a different class, you should
		;; instantiate the init method as shown here
		(method (init)
			((= cycler (EndLoop new:)) init: self)
		)
	)

	;; please note that there is no way currently
	;; to produce a cue from the completion of this cycling.
	;; If it becomes apparent that a need exists, then some
	;; effort will be made in that direction.

	.
	.
	your code goes here
	.
	.
	; to use it
	(Print "This Icon will be cycling forward constantly."
		#icon: myIcon
	)
	; to not use it
	(Print "This Icon will NOT cycle."
		#icon: 125 5 0
	)

	The Chris squared (MURDER) has working examples of cycling icons.
	Please go bother them if this stuff is not clear.

	As always, "Write when you get me to do some work."



6/1/89	Bob

	GReAnimate has been added to KGraph functions.  
	It's used as follows:

		(Graph GReAnimate top left bottom right)

	This will have the same affect as a ShowBits, BUT will re-animate
	the cast members that are inside the shown rectangle.


6/1/89	Pablo

	MORE HEAP!!! The following classes have been taken out of motion.sc and 
	system.sc and  placed in their own files: reverse, chase, follow, wander, 
	timer and timeout. This saves 1700 bytes (!!!) in rooms that don't use  
	these classes.
	
	MODULARITY is the word of the day, if you find other system code that 
	should be in a file of its own please bring it up, everyone may benefit.
	
	------------------
	
	The DEMO DEMON is here! To run a game in demo mode, set global variable 
	demoScripts to some convenient offset, ie. 400. Then for each room to be 
	demo'ed create a script of actions, make it public entry 0 in its file 
	and make the script number equal to the room number plus the value of 
	demoScripts. The following procedures are provided to fake out user 
	interactions: FakeInput, FakeDir, FakeKey and FakeMouseDown. The demo 
	demon locks out the real keyboard and mouse to protect your demo from 
	klutzy showgoers. Overhead is about 380 bytes plus the size of the demo 
	code, which can range from 100 to 500 bytes typically. Did I mention that 
	the point of this is to be able to demo your actual UNMODIFIED game?
	
	For internal details see file DEMO.SC, for examples see 
	\games\ice\source\demo*.sc (especially demo011.sc).
	
	
	------------------
	
	If you need to refer to specific objects in you demo you can use 
	procedure NameFind. Example (NameFind {agent} cast) will return the ID of 
	an object with name property "agent" if it is a member of list cast, 0 
	otherwise. NameFind can also be used as a poor substitute for public 
	objects.
	
	------------------
	
	New and useful procedure added to system.sc: OneOf
	Example:
	(OneOf 23 10 20 23 30) returns TRUE because 23 (the first arg) IS one 
	of 10, 20, 23 or 30
	Also legal is (OneOf client badGuy worseGuy)
	
	------------------
	
	CATS: A Cat is an object that follows the mouse, ie. a mouse-draggable 
	gadget. It can be confined to a rectangle or even to one of a 
	rectangle's diagonals, in which case it can be made to track either the 
	mouse x or y coordinate. Animation can be optionally enabled during 
	dragging, although the default of disabling it provides smoother 
	interaction. A cat can be made to affect other objects or variables by 
	customizing its posn method. For examples see \games\ice\source\rm027.sc.

	------------------
	
	The setLoop method of Actor now also accepts an object as an argument, in 
	which case it will set the actor's looper property and invoke its init 
	just like setMotion does for movers.

	------------------
	
	GROOPERs a.k.a. GradualLoopers are here.
	example: (ego setLoop GradualLooper) will cause ego to go through all 
	intermediate loops when making turns, ie. no more 180 degree "flips". it 
	also works for eight loop views, which can be used for even smoother 
	animation. From system.sh:
			
			;Standard loop order for actors
			(enum
				loopE
				loopW
				loopS
				loopN
	
				loopSE	;new, for 8-loop actors
				loopSW
				loopNE
				loopNW
			)
	

	------------------
	
	SMOOPERs a.k.a. SmoothLoopers are also here
	use same as groopers. Smoopers allow an actor to 'cut away' to a 
	transition view  when performing turns, this is especially nice for long 
	actors. See comments in smooper.sc for details, teleport to Iceman 
	room 56 for live example.

	------------------
	that's all folks!	--Pablo
	------------------
	
		
5/10/89	Corey:

	You can now do room transitions and picture drawing with no special
	effects.  This is the new default option for picture drawing style.
	Simply set your room "style" property to PLAIN (defined in system.sh).
	This is the fastest way to draw a new picture.

5/4/89	Pablo:	VCPP

	The VCPP vocabulary preprocessor has been enhanced so that the following 
	lines are equivalent:
	
	(#synonyms foo bar)
	(#syns foo bar)
	(#syn foo bar)
	(foo bar)
	
	The final form is obviously the most concise and is recommended for 
	foreign language vocabulary extensions.
	
	VCPP's internal stack size has been increased in hopes of eliminating 
	occasional reported crashes.

4/19/89	Pablo
	
	To take advantage of heading, a new script SIGHT has been created to 
	provide procedure (CantBeSeen theSight theSeer theAngle theDepth), which 
	tells use whether theSight is within theAngle from theSeer's heading and 
	within theDepth distance. theSeer defaults to ego, theAngle defaults to 
	the right thing based on egoBlindSpot and theDepth defaults to INFINITY, 
	which is defined in system.sh as a very large number.

	SortedFeatures: said events now go to all members of cast and features, 
	the burden is on the programmer to use procedures IsOffScreen and 
	CantBeSeen to discriminate an objects responses. Doing so provides a lot 
	more flexibility in said event handling.
	
	INTRFACE has a new procedure called MousedOn which tells whether an event 
	took place within an object's rectangle.
	
	New file MOUSER provides a class of EventHandler that on a simple click 
	can move ego towards the click and then pass a copy of the mouse event to 
	the clicked object if any.
	
	New file RFEATURES provides classes RFeature and RPicView that add 
	properties nsLeft, etc to Feature and PicView respectively. A must if 
	using MousedOn.
	
	New file TEXTRA provides a class TalkingExtra of Extra that defers to a 
	surrogate feature or rfeature if addToPic'd, so that the Extra's 
	responses are guaranteed to be around even on a slow machine.
	
	Class Ego has been moved to USER. User has been simplified so that events 
	are handed to the menu bar, then game, then ego; except for saidEvents 
	which go to menu, sortedFeatures, then game. keyDown events no longer go 
	automatically to the cast, which should speed things up. If anyone 
	needs keyDowns to be sent to the cast (?) then they should add a line to 
	their game's handleEvent to do so.
	
	ACTOR setLoop method now accepts a looper as it's argument, in which case 
	it will behave like setMotion, setCycle, etc. If given a number (ie. all 
	past code) it behaves like it always has.



4/4/89	Bob

	Lots of stuff:

	Windows are an object that can be modified/customized to
	let YOU the programmer create that certain look that will
	sell an additional 100,000 copies of your program.
	
	There is so much to tell and so little time to tell it, but
	the one thing that every one must do is add the following line
	as the first statement in your game's init method.

		(= systemWindow (SysWindow new))

	this provides the bare minimum "template" for Print to produce
	windows that are very similar to what you have had for the last
	year or so.

	I will be working with Mark Hood to produce some the proper 
	documentation that this needs.  If you wish, you may read ahead
	by looking in save.sc for SysWindow and see what properties you
	may change.  For the painfully advanced you may read the full
	blown defintion of Window in the file window.sc.

	As always, "Write, when you get it to work!"


3/13/89	Jeff, Bob, and Stuart

	Two new kernel functions allow you to determine something about
	the hardware on which you're operating.:

		(DoSound NumVoices)

	returns the number of voices in the sound hardware.  This lets you
	know when you're on a single voice PC speaker, for example, so you
	can only play a song once.

		(Graph GDetect)

	returns the number of colors supported by the video hardware, so you
	can load a different picture for those mono- and four-color screens.


3/8/89	Bob
	
	The Z property of Actors is now used in Animate to resolve
	priority/drawing order of objects AND will affect the visual
	placement of objects on screen. The Z property is a measure of
	how far UP (above the ground) an Actor is. 
	For any objects that share the same Y the object with the 
	greatest Z will be drawn last. By the same token for any objects 
	that share the same Y the one with the greatest Z will 
	appear HIGHER on the screen. 

	By way of example, consider a car and its door.
	The car is at Y = 100, and to APPEAR properly aligned, the door
	is at y = 90. This will cause a problem in that Animate will
	draw the door and THEN draw the car, erasing the door. Many
	solutions exist for this problem, but the PROPER one is to
	set the door to y = 100 (same as the car), z = 10. Now the door
	will be drawn at the same priority as the car BUT it will be
	draw after, so it shows.

	As always, "Write, when you get work!"

3/8/89	Bob

	All components of a shipping volume based game that USED to reside
	in \GAMES\SCI\SYSTEM\INSTALL have been moved up one level to
	\GAMES\SCI\SYSTEM. The affected files are:
		INSTALL.exe
		space.com
		exists.com
		godir.com
		drvcopy.com

	An additional file has been added to your shipping disk needs.
	This file is called INSTALL.HLP, and contains information on
	drivers in a form useable by INSTALL.EXE.

	Please ensure that all of your "make disk" batch files are
	updated properly.

			
3/2/89	Pablo

	The heading property of Actor has been moved down to Feature, so that now 
	it is also shared by classes PicView, View, Prop and Extra. This reflects 
	the fact that things like chairs have a front and a back side, which does 
	matter when we decide whether to let ego sit down.
	
	*** see 4/19/89 note above ***
	
2/28/89	Jeff

	There are two new motion classes: Path and RelPath.  These allow you
	to move an Actor along a pre-defined path specified as an array of
	points.  Using these classes to follow a path requires less memory
	than creating a script to do it, and is considerable easier to boot.

	You set the motion for an Actor to be a Path or RelPath in the same
	way as for other motion classes, but the parameter to setMotion: must
	be an instance of one of the classes, rather than the class itself
	[for reasons discussed later]:

		(ego setMotion: squarePath self intermediate)

	sets ego's motion to the path 'squarePath' and requests that the caller
	be cue:ed when the path is completed.  The optional 'intermediate'
	parameter specifies an object to be cue:ed at each intermediate endpoint
	along the path.  The intermediate object's cue: method is passed a
	parameter specifying which endpoint caused the cue (first endpoint = 0,
	second = 1, etc.).

	For both classes of path, two things are required: the array of points,
	terminated by PATHEND, and an instance of the class with a redefined
	at: method.  The redefined at: method is called with one parameter, n,
	and returns the nth element of the path array.

	The difference between the classes is the interpretation
	of the points in the array: Path reads them as absolute coordinates to
	which it should move, RelPath reads them as offsets of the next point
	relative to the end point of the previous path segment.
	
	To create a square Path (assuming that ego is positioned at 100,100) we
	do the following:

		(local
			sPath =	[
						100	60
						160	60
						160	100
						100	100
						PATHEND
						]
		)

		(instance squarePath of Path
			(method (at n)
				(return [sPath n])
			)
		)

	The following will make ego walk the path once:

		(ego posn:100 100, setMotion: squarePath)


	The following uses a RelPath to make ego do loop-the-loops across the
	screen:

		(local
			lPath =	[
			 			-10	-10
			 			0		-10
			 			10		-10
			 			10		0
			 			10		10
			 			0		10
			 			-10	10
			 			PATHEND
			 			]
		)

		(instance loopPath of Path
			(method (at n)
				(return [lPath n])
			)
		)


		(instance rm1 of Room
			(properties
				picture 1
			)

			(method (init)
				(ego
					posn: 60 100,
					init:,
					setMotion: aPath self
					)
				(super init:)
			)

			(method (cue)
				(ego setMotion: aPath self)
			)
		)



2/23/89	Bob

	Fixed an obscure bug in menu selection. Bug caused a phantom
	selection of the first item in the menus that did NOT have a
	key equivalent, whenever certain keys (ctrl page-up for one)
	were pressed.
	** this change will take effect with 0.000.434 or higher **


2/18/89	Bob

	The internal modularity of graphics routines has been shuffled
	in order to implement VGA graphics smoothly.  This change is
	of most importance to interpreter programmers, but game programmers
	should be aware that subtle bugs may have been introduced in the
	process.


2/15/89	Bob

	Sounds need not be paused while a menu selection is in process.
	A new OPTIONAL second argument to the handleEvent of MenuBar
	will (if present and FALSE) allow sounds to play during the
	actual selection.  If this argument is not present, then things
	will behave as they have up until now.

	NOTE - This will not affect the various (sound pause:) lines
	that you probably have sprinkled around in your menu code.
	I suggest passing the value of (User blocks?) as the second
	argument to handleEvent AND as the value to all pause: methods.

	** this change will take effect with the next new system **


2/14/89	Pablo

	New class EventHandler of Set, adds a handleEvent method that passes teh 
	event on to its members and returns as soon as the event is claimed. 
	regions, locales, cast and features are now instances of this class. Also,
	system-level  default handleEvent methods now return TRUE if the event is
	claimed so, for example, the following code can now be written for an
	event handler:
	
	(method (handleEvent event)
		(if (not (super handleEvent: event))
			(switch  (event type) 
				(saidEvent
					(cond
						((Said 'look')			(Print "you see"))
						......
					)
				)
			)
		)
	)

2/14/89	Pablo for Bob

	New "mapKeyToDir" property of User controls whether key events get mapped 
	to directions.


2/14/89	Pablo, Bob & Jeff 

	obscure change: on addToPic Views only get init'ed if they are NOT in 
	the cast.
