Dim Palette(256)
   Dim Screen(320,200)

// ----------------------------------------------------------------------------		
// ----------------------------------------------------------------------------		
Test_Palette_Mapped_Strips:  // (8bit palette map)
// ----------------------------------------------------------------------------		
// ----------------------------------------------------------------------------		

		rendertoimage screen
		Lockbuffer
		ThisRgb=Point(0,0)
		Ypos=0
		For ypos =0 to 255
				address=GetBankPtr(ScreenBank)+(ypos*320)
				DrawPaletteMappedStrip8(xpos,ypos,Address,320,$ff)
		next
		unLockbuffer

		return
		

		#include "PaletteMapping"

		loadFont "verdana",2,24,0,8


		Dim Palette($10000)
		Dim MasterPalette($10000)
		SetPalette(Palette())

		; set colour zero as RGB(0,0,0), since the images use that
		;   colour as transparent
		Palette(0)	= $00000000
		ColourCount=1


		; create 16bit fX image as the palette mapped screen..
		Screen=CreateScreen(800,600)		
	

		; load some images and remap the RGBS to palette indexes
		Ship,ColourCount= LoadAsPaletteMappedImage("gfx\ship.bmp",_
		     Palette(),ColourCount)
		Bubble,ColourCount= LoadAsPaletteMappedImage("gfx\bubble_64x64.bmp",_
		     Palette(),ColourCount)
		Logo,ColourCount= LoadAsPaletteMappedImage("gfx\uwlogo.bmp",_
		      Palette(),ColourCount)
		
		
		// Make a copy of the original palette
		CopyArray Palette(),MasterPalette()
		
		Do		
	
			cls 255
			frames++
			setcursor 0,0
			t=timer()

			// --------------------------------------------
			// draw to the 16bit screen
			// --------------------------------------------
			
				rendertoimage Screen
				cls 0	
				
				gridimage   Ship,mousex()-250,_
				     mousey()-250,10,10,true
			
				drawrotatedimage Bubble,400,100,_
				       angle#,2,2,-32,-32,true
				angle#=wrapangle(angle#+2)
			
				drawimage logo,100,200,true			
			
				rendertoscreen			
			
				// draw the palette mapped buffer 
				//  to the actual screen
				RenderScreen(Screen,Xpos,Ypos,Palette())
			tt#+=Timer()-t


			// -----------------------------------------------
			// draw what the sprites to 
			// -----------------------------------------------
			drawimage ship,0,500,true
			drawimage bubble,64,500,true


			setfont 2
			lockbuffer
				print "Screen Resolution:"+Str$(GetImageWidth(Screen))_
				+"*"+Str$(GetImageHeight(Screen))
				print "Palette Size:"+str$(ColourCount)
				print "Ticks:"+str$(tt#/frames)
				print "Fps:"+str$(fps())
			unlockbuffer

			// --------------------------------------
			// Fade palette in and out		
			// --------------------------------------
				ScaleLevel=128+Cos(angle#)*128
				ScaleLevel=ClipRange(ScaleLevel,0,255)
				
				For lp=0 to ColourCount	
						ThisRgb=MasterPalette(lp)
						Palette(lp)=RgbScale(ThisRgb,ScaleLevel) 
				next
				
			Sync
		loop
	

Psub CreateScreen(Width,Height)
		; the 
		local ThisIMage=GetFreeImage()
		CreateFXImageEx ThisImage,Width,Height,16
EndPsub ThisImage

	
	
	
Psub RenderScreen(Screen,Xpos,Ypos,Palette())
	if GetImageStatus(Screen) and Screen>0

		if GetImageDepth(Screen)=16

			SetPalette(Palette())

			oldSurface=GetSurface()

			rendertoimage Screen	
			lockbuffer
				thisrgb=point(0,0)
				Width	=GetImageWidth(Screen)
				HEight=GetImageHeight(Screen)
				Ptr	=GetImageptr(Screen)
				Modulo=GetImagePitch(Screen)
			unlockbuffer

			rendertoimage OldSurface

			lockbuffer		
			  thisrgb=point(0,0)
			  For ypos =0 to Height-1
				DrawPaletteMappedStrip16(0,ypos,Ptr,Width,$ffff)
				ptr+=Modulo
			  next
			unLockbuffer
		endif

	endif
		
EndPsub





Psub LoadAsPaletteMappedImage(File$,Palette(),ColourCount)

		local TempImage=LoadNewImage(File$,2)

		local w=GetIMageWidth(TempImage)
		local h=GetIMageHeight(TempImage)

		local ThisImage=GetFreeImage()
		CreatefxImageEx ThisImage,w,h,16

		ColourCount=PaletteMapRGBImage(TempImage,Palette(),ColourCount)

		copyrect TEmpImage,0,0,w,h,ThisImage,0,0

		deleteimage tempimage	
EndPsub ThisImage,COlourCount

      For frame=1 to 10
              LoadIMage "gfx\ship"+str$(frame)+".bmp", 100+frame
      next

	Constant TextFile$="Files/Hello-World.txt"

	#AddResource TextFile$

	; Find this resources index , indexes range between
	;  zero and number of bound resources in the program
	index=FindResourceIndex(TextFile$)
	if index>-1

		; load the text file resource as string	
		s$=LoadResourceAsString$(Index)

		; split the string into this array
		dim rows$(0)
		s$=replace$(s$,chr$(13),"")
		count=splittoarray(S$,chr$(10),Rows$())

		; dump it to the screen
		for lp =0 to Count
			print rows$(lp)
		next
	
	endif

	
	Sync
	WaitKey

	Constant TextFile$="Files/Hello-World.txt"

	#AddResource TextFile$
	#AddResource "Files/Uwlogo.png"
	#AddResource "Files/Arial36.crf"


	; Find this resources index , indexes range between zero
	;  and number of bound resources in the program
	index=FindResourceIndex(TextFile$)
	if index>-1

		; load the text file resource as string	
		s$=LoadResourceAsString$(Index)

		; split the string and remove chr 13's 
		dim rows$(0)
		s$=replace$(s$,chr$(13),"")
		count=splittoarray(S$,chr$(10),Rows$())

		; dump it to the screen
		for lp =0 to Count
			print rows$(lp)
		next
		
		ThisBank=LoadResourceAsBank(Index)
		
		Print ThisBank
		For lp =0 to GetBankSize(ThisBank)-1
				print PeekBankByte(ThisBank,lp)		
				#print chr$(PeekBankByte(ThisBank,lp))		
		next

	endif

	ThisImage=LoadResourceImage("Files/Uwlogo.png")

	drawimage ThisIMage,400,300,false
	
	ThisFont =LoadResourceFont("Files/Arial36.crf")
	
	setfont ThisFont
	
	
	text 200,200,"YEAH"
	
	Sync
	WaitKey

        // This directive imports the file data into memory/exe at compile time
	#AddResource "Files/Arial36.crf"

        // The load statement check if this file is actually a
        // resource, if so it loads it from memory
	Arial36=loadNewFont("Files/Arial36.crf",1)
	setfont Arial36
	text 200,300,"Loading directly from resource:"

        // This directive imports the file data into memory/exe at
        // compile time
	#AddResource "Files/uwlogo.png"

        // The load statement checks if this file is actually a resource,
        // if so, it loads it from memory
	logo=loadNewImage("Files/uwlogo.png",1)

        DrawImage Logo,200,300,true

        Sync
        waitkey

    Dim Stuff(100)

    ; assign Stuff() array to some none existent array
     Stuff() = 2000

	Limbs=10

	Dim Tree(Limbs)
	MakeArray Branch()
	
	; create an array to place them in the tree() array.
	; so each cell is now conceptually a 1D array
	For lp =0 to Limbs
		
		; The MakeBranchfunction exports the 'bank/container' of the array
		; as an integer.  We can assign then anywhere.  There's nothing special
		; about them.  
		
		
		Tree(lp)=MakeBranch(rndrange(5,20))	
	next

	; Display the tree
	
	for lp=0 to limbs
		if Tree(lp)
	
			; Copy the Branch array container into our redirection/pointer array
			; so we now use the redirection arrays to look at the array data
			; When PB writes the right handy value into Branch() array it check
			; if this value does represent a legal array.  if it doesn't it'll error
			Branch()=Tree(lp)

			; Parse the values into a string		
			Row$="Branch["+digits$(lp,2)+"] = "
			For b=0 to getarrayelements(branch())
				row$+=str$(Branch(b))+","				
			next
			
			; print it out
			print trimright$(row$,",")
					
		
		endif
	
	next
	

	
	Sync
	waitkey



Function MakeBranch(Size)
	Dim ThisBranch(size)	
	For lp =0 to size
			ThisBranch(lp)=rnd(1000)
	next
EndFunction ThisBranch()

	size=48
	LoadFont "Verdana",2,size,0,8

	FontBlendColour 2,$00ff00

	; Set output to pre blend pixels with FontBlendColour
	fontdrawmode 2,2

Do
		cls 255

		frames++
		startinterval(0)
		Page_Of_Text(2,$ffff0000)
		tt#+=Endinterval(0)
		
		print tt#/frames
	
	
		Sync
	loop	



Function Page_Of_Text(ThisFont,C)

	oldrgb=getink()
	OldFont =GetCurrentFont()
	SetFont ThisFont

	ink c
	
	For lp=asc("a") to asc("z")
		s$+=chr$(lp)
	next
	s$+=s$	;+s$+s$

	lockbuffer
	For ylp=0 to GetScreenHeight() step 10
		text xpos,ylp,s$
	next
	unlockbuffer

	SetFont OldFont
	ink OldRgb
	
EndFunction

	size=48
	LoadFont "Verdana",2,size,0,8

	FontBlendColour 2,$00ff00
	
	Screen=1	
	CreateFXimageEx Screen,800,600,32

	; Set output to pre blend pixels with FontBlendColour
	fontdrawmode 2,2

	; ------------------------------------------------------------------
	Do
	; ------------------------------------------------------------------
			rendertoimage Screen
			cls 255

			frames++

			startinterval(0)
				Page_Of_Text(2,$ffff0000)
			tt#+=Endinterval(0)
		
			rendertoscreen
			drawimage Screen,0,0,false
			setcursor 0,0
			print tt#/frames
			print GetImageDepth(Screen)
	
			Sync
	loop	



Function Page_Of_Text(ThisFont,C)

	oldrgb=getink()
	OldFont =GetCurrentFont()
	SetFont ThisFont

	ink c
	
	For lp=asc("a") to asc("z")
		s$+=chr$(lp)
	next
	s$+=s$	;+s$+s$

	lockbuffer
	For ylp=0 to GetScreenHeight() step 10
		text xpos,ylp,s$
	next
	unlockbuffer

	SetFont OldFont
	ink OldRgb
	
EndFunction

	Filename$="D:\TestCrf.crf"

	// Load a true type and convert it to CRF
	LoadFont  "verdana",20,75,0,8
	SaveFont Filename$,20
	deletefont 20	
	
	// Load the file into a bank
	fh=ReadNewFile(filename$)
		size=filesize(filename$)
		Thisbank=NewBank(size)
		ptr=GetBankptr(thisBank)
		ReadMemory fh,Ptr,Size
	closefile fh
	

	// Load the front from memory.   Here instead of passing the load command
	// the filename with path, we give it the address of the resource in memory
	// in string form.  
	LoadFont "&"+str$(ptr),30,0	


	// This bank is no longer of any use, so delete it
	DeleteBank ThisBank
	
	
	// set and draw some text with the font loaded from memory
	setfont 30
	Print "Hello World"
	
	Sync
	waitkey

 

	Filename$="D:\PlayBasicSig2.png"
   
   // Load the image file into a bank.  The picture data needs the size (of the image) 
   // appended to the header of the structure for this work.   
   fh=ReadNewFile(filename$)
      size=filesize(filename$)
      Thisbank=NewBank(size+4)
      ptr=GetBankptr(thisBank)
	
		; poke the size into the first 4 bytes
		pokebankint ThisBank,0,size

		; read the data in after the size.  
      ReadMemory fh,Ptr+4,Size
   closefile fh
   

   // Load the image from memory. 
   // Just like the LoadFont tests, here we pass the loadIMage command
   // the address of the buffer in memory.   
   LoadImage "&"+str$(ptr),100,8

   // This bank is no longer of any use, so delete it
   DeleteBank ThisBank
   
	cls 255
	drawimage 100,100,100,true
	   
   Sync
   waitkey
 

  Filename$="D:\PlayBasicSig2.png"
   
   // Load the image file into a bank.  The picture data needs the size (of the image) 
   // appended to the header of the structure for this work.   

   fh=ReadNewFile(filename$)
      size=filesize(filename$)
      Thisbank=NewBank(size+4)
      ptr=GetBankptr(thisBank)
   
      ; poke the size into the first 4 bytes
      pokebankint ThisBank,0,size

      ; read the data in after the size.  
      ReadMemory fh,Ptr+4,Size
   closefile fh



   // Load the image from memory. 
   // Just like the LoadFont tests, here we pass the loadIMage command
   // the address of the buffer in memory.   
		t=timer()
	   LoadafxImage "&"+str$(ptr),100
   

		

		BlockWidth=32
		BlockHeight=32

		Map=NewMap(10)
		Level=NewLevel(Map,20,10)

		LoadMapGFX  "&"+str$(ptr),Map,BlockWidth,BlockHeight,-1,4
	
		Tile=0
		For ylp =0 to GetImageHeight(100) step BlockHeight
			For xlp =0 to GetImageWidth(100) step BlockWidth
					PokeLevelTile Map,Level,xlp/BlockWidth,ylp/BlockHeight,Tile
					Tile++
			next	
		next
			
		leveldrawmode map,level,2
		
	   cls 255
	   drawimage 100,100,100,true
			
		drawmap Map,level,100,300      
		
		
	   DeleteBank ThisBank
		
   Sync
   waitkey