Telengard notes (note, I fixed a bug when restarting the game from the Y,N menu):

TELNBOOT.BAS:
 So it looks like the PMODE 4 screen gets moved to $E000-$F7FF, and some data and USR routines to $F800-FEFF. So this frees up 6K+ for the BASIC program, which is larger than Disk BASIC would normally allow.

It then CLEARS 420 bytes for variables, I=RND(TIMER) and calls USR4 (which sets the SAM/VDG to show PMODE 4 @ $E000)
It finally launches TELNGARD.BAS.

TGSCREEN.BIN - the intro PMODE 4 page, but also USR 0,2-9 routines and some data tables.
H.BIN - This is the HELP screen graphic, with the identical extra data and USR routines to TGSCREEN.BIN, but it's default start address is $E000 already. Since the part after the graphics is identical... why not cut it down to $1800 in size (rather than reloading it). Or better yet, load the USR routines separate, and cut the graphics to $1800 lengths each. 

Telengard: Disassembly of 64K RAM.BIN:
	org	$7FD0
	orcc    #$50		Shut off interrupts
	ldx	#$8000		Point to start of ROM's
CpyLp	lda	,x		Get byte from ROM
	sta	>$FFDF		map in upper 32K RAM via SAM
	sta	,x+		Save ROM byte to RAM
	sta	>$FFDE		Map ROM back in
	cmpx	#$FF00		Done copying all the way up to I/O page?
	bne	CpyLp		No, keep copying
	sta	>$FFDF		Now that BASIC is copied over, switch to 64K RAM
	andcc	#$AF		Turn interrupts back on
	rts			And exit

USR0 routine is the 64K RAM program above ($7FD0) - Copies ROM to RAM, 64K RAM mode
USR2 routine is $FB1B
USR3 routine is $FB24 (Clear top 16 lines of graphics screen to green)
USR4 routine is $FB37 (set SAM/VDG video to start at $E000 & PMODE 4, SCREEN 1,1)
USR5 routine is $FB6D (Clear map area of screen)
USR6 routine is $FB9C (Scroll bottom text area of screen 1 text/8 pixel line(s))
USR7 routine is $FB8C (Clear bottom text area of screen)
USR8 routine is $FBCC ? Takes BASIC floating point var, converts to 2 byte INTEGER, Saves @$FBD3
USR9 routine is $FBD6

TELNBOOT: Sets up the USR routines, loads 64K RAM program and runs it (moves ROM's to RAM).
CLR >$D00
Then resets the following BASIC pointers to all point to $DXX (leaving XX as is):
$0019 (Start of BASIC program ptr)
$001B (Start of BASIC variables)
$001D (Start of BASIC arrays)
$001F (End of BASIC arrays)
Then loads TGSCREEN.BIN (file header: starts at $6100 for $1F00 bytes, so it would load from $6100-$7FFF). BUT, it loads with an offset of $7F00, so it actually loads in at $E000-$FEFF.
Layout of TGSCREEN.BIN / H.BIN:
RAM Addr	Offset in file	Description
--------	--------------	-----------------------------------------------
$E000		$0005		PMODE 4 title screen graphic or HELP screen graphic
$F800		$1805		Series of 8 char text strings, left justified/padded with spaces:
$F800		$1805		'GNOLL   ' (monster list - all 8 chars, space padded)
$F808		$180D		'KOBOLD  '
$F810		$1815		'SKELETON'
$F818		$181D		'HOBBIT  '
$F820		$1825		'ZOMBIE  '
$F828		$182D		'ORC     '
$F830		$1835		'FIGHTER '
$F838		$183D		'MUMMY   '
$F840		$1845		'ELF     '
$F848		$184D		'GHOUL   '
$F850		$1855		'DWARF   '
$F858		$185D		'TROLL   '
$F860		$1865		'WRAITH  '
$F868		$186D		'OGRE    '
$F870		$1875		'MINOTAUR'
$F878		$187D		'GIANT   '
$F880		$1885		'SPECTRE '
$F888		$188D		'VAMPIRE '
$F890		$1895		'DEMON   '
$F898		$189D		'DRAGON  '
$F8A0		$18A5		'SALTY    ' (adjective list, all 9 chars, space padded)
$F8A9		$18AE		'BOLD     '
$F8B2		$18B7		'LOAD     '
$F8BB		$18C0		'OLD      '
$F8C4		$18C9		'GOODLY   '
$F8CD		$18D2		'WORTHY   '
$F8D6		$18DB		'LOFTY    '
$F8DF		$18E4		'FINE     '
$F8E8		$18ED		'ROCKY    '
$F8F1		$18F6		'AGED     '
$F8FA		$18FF		'ROAD	  '
$F903		$1908		'EYE      ' (noun list?, all 9 chars, space padded)
$F90C		$1911		'TOOTH    '
$F915		$191A		'DRAGON   '
$F91E		$1923		'MUG      '
$F927		$192C		'DEMON    '
$F930		$1935		'WHARF    '
$F939		$193E		'BRIDGE   '
$F942		$1947		'MEADE    '
$F94B		$1950		'ALE      '
$F954		$1959		'TAVERN   '
$F95D		$1962		'ALEHOUSE '
$F966		$196B		'CELLAR   '
$F96F		$1974		'CLUB     '
$F978		$197D		'INN      '
$F981		$1986		'LODGE    '
$F98A		$198F		'MEADHALL '
$F993		$1998		'RESTHOUSE'
$F99C		$19A1		'RED     ' (Color list, all 8 chars, space padded)
$F9A4		$19A9		'YELLOW  '
$F9AC		$19B2		'GREEN   '
$F9B4		$19BA		'BLUE    '
$F9BC		$19C2		Now it repeats a $FF00 word pattern (with one $FF41 in the middle)
...
USR2 ROUTINE:
-------------
$FB1B		$1B20

	org	$FB1B
	ldd	#$FFFF
	ldx	#$E610		Point into PMODE 4 screen (48 lines down, halfway across)
	jmp	>$FB73

USR3 ROUTINE: (clear top 16 lines to green)
-------------
$FB24		$1B29

	org	$FB24
	ldd	#$FFFF		Load up 16 pixels of green
Clr16Lp	ldx	#$E000		Point to start of PMODE 4 screen
	std	,x++		Put on screen
	cmpx	#$E1FF		Fill top 16 lines with green
	blo	Clr16Lp
	ldx	#$E210		Point to midpoint of 17th line
	jmp	>$FB73

USR4 ROUTINE: (set video to $E000 & PMODE 4, SCREEN 1,1)
-------------
$FB37		$1B3C

	org	$FB24
	lda	#4
	sta	>$FFD3		Set SAM to point video RAM to $E000 (%1110100 * 512=$E800?)
	sta	>$FFD1
	sta	>$FFCF
	sta	>$FFCC
	sta	>$FFCA
	sta	>$FFC8
	sta	>$FFC6
	sta	>$FFC5		Set SAM graphics mode %110 (256x192x2)
	sta	>$FFC3
	sta	>$FFC0
	sta	<u00B6		Save 4 for PMODE value for BASIC
	lda	#$F0		Screen 1,0 on VDG (black/green)
	sta	>$FF22
	lda	#$20		# bytes/line to 32 for BASIC
	sta	<u00B9
	lda	#$F8
	sta	<u00B7		Set end of current graphics page to $F800
	lda	#$E0		Set start of current graphics page to $E000
	sta	<u00BA
	sta	<u00BC		And set alternate high byte start of current graphics page as well
	rts

USR5 ROUTINE: (Clear map area - 128 pixels on left side, rows 16-143)
-------------
$FB6D		$1B72

	org	$FB6D
	ldd	#$FFFF		16 pixels of green
	ldx	#$E200		Point 16 lines down the screen
HlfClLp	std	,x++		clear 16 bytes (128 pixels)
	std	,x++
	std	,x++
	std	,x++
	std	,x++
	std	,x++
	std	,x++
	std	,x++
	leax	<$10,x		Skip to next line on screen
	cmpx	#$EFFF		Done 128 lines? (lines 16-143)
	blo	HlfClLp		No, keep clearing left half of screen until done.
	rts

USR7 ROUTINE: (Clear bottom text area of screen)
-------------
$FB8C		$1B91

	org	$FB8C
	ldd	#$FFFF		16 pixels of green
	ldx	#$F000		Point 128 lines down on screen (2/3 way down)
ClBotLp	std	,x++		Clear bottom of screen with green (64 lines) 
	std	,x++
	cmpx	#$F7FE
	bls	ClBotLp
	rts

USR6 ROUTINE: (scroll bottom text area of screen)
-------------
$FB9C		$1BA1

	org	$FB9C
	ldx	#$F000		Point 128 lines down on screen (top of text area on bottom)
	ldy	#$F100		Point 8 lines down from that (to scroll from)
ScrlLp	ldd	,y++		Copy 32 pixels up 1 text line
	std	,x++
	ldd	,y++
	std	,x++
	cmpx	#$F6FE		Smooth scroll up 56 pixels lines (7 text lines)
	bls	ScrlLp
	ldd	#$FFFF		16 green pixels
	bra	ClrBotLp	And clear next text line (8 pixel lines) & exit from there
-------------
$FBB5		$1BBA
This appears to be a data table, not code. 23 ($17) bytes
-------------
                fdb		$FF00,$FF00,$FF00,$FF00,$FF00,$FF00,$FF00,$FF00,$FF00,$FF00,$FF00
		fcb		$FF

USR8 ROUTINE: (I think this one actually uses the parameter passed)
Guessing, but I think it is start position to start printing text. In the 16 bit number it saves, I think the Y position is upper 11 bits, X position is lower 5 bits. Y will be limited to lowest 2 bits of A and highest 3 bits of B (which is enough to allow 0-23 Y position)
-------------
$FBCC		$1BD1
	org	$FBCC
	jsr	>$B3ED		Convert FPA0 to signed 2 byte integer (returns in D)
	std	<LFBD3,PCR	Save that X,Y text coord to print at
	rts			%000000yy yyyxxxxx  (5 bits each for Y (0-23) and X (0-31)

LFBD3	fdb	$02E0		X/Y coord (see above). Initializes to X=0, Y=23
LFBD5	fcb	$00		Might be string length?

USR9 ROUTINE: (? Font drawing, maybe?). Gets called with a string (and possibly returns one?)
Guessing that X points to string to print on entry?
-------------
$FBD6		$1BDB

	org	$FBD6
LFBD6	lda	,x		?Get length of string to print
	sta 	<LFBD5,pcr      Save working copy
	ldy	2,x		Get ptr to string to print
	ldd	<LFBD3,pcr	Get Y,X coord to print at (0-23,0-31) last 10 bits (5 each). Saved from USR8 call (passed parameter)
	ldx	#$e070		Point to middle of 4th line on screen
* For every 32 of parameter passed to us, move gfx ptr down 8 graphics lines/1 text line
L000E	cmpd	#$0020		Subtract Y positions (moving 8 gfx lines each) for Y position
	blo	L001D		Done Y position, go add X position
	subd	#$0020		More Y, subtract 1 from Y
	leax	>$100,x		Move gfx screen ptr down 8 lines (8 lines/char)
	bra	L000E		Keep going until Y position determined

L001D	leax	d,x		Add the leftover (X offset) to current screen Y
	cmpx	#$F79F		Screen position above bottom 3 lines on screen?
	blo	L0025		Yes, continue
	rts			No, ignore printing and just return

* Entry: X=Screen ptr we are printing at
*        Y=Ptr to string to print
L0025	lda	,y+		Get char to print
	cmpa	#$21		Control char or space?
	blo	L0033		Yes, replace with CHR$($3F) '?'
	cmpa	#'z		No, is it lowercase z or below?
	bhi	L0033		No, replace with CHR$($3F) '?'
	suba	#$21		Yes, subtract 33 to adjust for font table entry #
	bra	L0035		And go print it

L0033	lda	#$3F		Override illegal character with '?'
L0035	ldb	#$08		8 rows per character
	mul			Calc offset to character data in table
	tfr	pc,u		
	leau	d,u
	leau    <$20,u		Point to 8 byte character in font table
	ldb	#$80
L0041	lda	,u+		Draw 8 byte tall character from font data
	deca
	sta	b,x
	addb	#$20
	cmpb	#$80
	bne	L0041
	tfr	x,d
	cmpb	#$9F
	beq	L0059
	leax	1,x
	dec	<-1,pcr
	bne	L0025
L0059	rts

-------------
$FC30		$1C35
This appears to be a data table, not code. Maybe the graphics font?
LFC30	fcb	$20		CHR$($21) normally '!', appears to be underscore here
	fcb	$20
	fcb	$20
	fcb	$20
	fcb	$20
	fcb	$20
	fcb	$20
	fcb	$00

LFC38	fcb	$48		CHR$($22) "
	fcb	$48
	fcb	$48
	fcb	$00
	fcb	$00
	fcb	$00
	fcb	$00
	fcb	$00

etc.

========================