Feature Requests

type baddie
   field strength
end type

global team1.baddie=CreateCollection(baddie)
global team2.baddie=CreateCollection(baddie)
global team3.baddie=CreateCollection(baddie)

type team
   field baddies.baddie=CreateCollection(baddie)
end type

type team
   field name$
   collection baddies.baddie
   field teamColor.aColor
end type

thisBaddie.baddie = New baddie
Add(thisBaddie,team1\baddies)

...

for each someBaddie.baddie in team(i)\baddies
   takeATurn(someBaddie)
next

For n=0 to Size-2
    Most=ReadByte(stream,n)
    Least=ReadByte(stream,n+1)
    Sixteen=Most Shl 4 + Least ; I think?
Next

; WriteInt, Float and String always use the long byte 32-Bit notation.
; However, most Strings contain the standard ASCII set which only requires 8 bits.
; Many Floats or Integers may also be in a small range, that do not require the space of 32-bits.
; However, generally, there's no guarantee of knowing how many bytes worth of information should be attributed to a particular
; value.
; WriteByte, conversely, ONLY writes a single 8-Bit byte. So it cannot alone be used to store values greater than 255.

; Consider the following integer: 42372
; This value requires at least 2 Bytes (16-bits) 

; Bits '3', '7', '8', '10', '13' And '15' are set To 1 (Note: Bit '0' =1 Bit 15 is the 16th Bit)
; 4 + 128 + 256 + 1024 + 8192 + 32768 = 42372

; If taken separately, as 8-Bit Bytes, Byte 1 (Bits '0'-'7') would appear to equal:

;Byte 1
; Bits '3' and '7' set to 1
; 4 + 128 = 132

;Byte 2
; Bits '8', '10', '13' And '15' set to 1 (or, Bits '0', '2', '5' and '7' considering Byte 2 as an 8-Bit Byte)
; 1 + 4 + 32 + 128 = 165

; So there is ambiguity. Are we looking at a 16-Bit value of 42372 
; OR
; a sequence of two 8-Bit values: 132,165

; This ambiguity is the main reason why the standard of 32-Bit notation (64-Bit values and quadwords are beond the scope of this document)
; is used, regardless of the size of the value represented, if it is accepted to always use 32-Bits, then any value in a range of (2^32)-1 (	4294967296   )
; can be represented without risk of confusion.
; so our above example of 42372 will be represented as a 4-Byte value as all 32-Bit values.
; The priority of bytes places the "Most Significant" Byte FIRST. 
; The "Most Significant Byte" will be the Byte with bits representing the HIGHEST values.
; The highest Bit value in 32-Bit notation, is Bit '31' (remember we number Bits from 0....) with a value of 2^31 (  2147483648  )
;Since our number really only utilises two of the 4-Bytes, the first 16-Bits (Bit '31' down to Bit '16') will be 0

; So, contrary to the displayed workings earlier, 42372 is shown by:

;BITS
; 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0
;  0   0   0   0   0   0   0   0  0   0   0   0   0   0  0   0  1   0   0   0   0  1  0  1  1   0  0  0  1  0  0  0

; It is these first two 'wasted space' bytes that this document and the code involved attempts to save.
; However, We still need a means of identifying how many Bytes a particular value needs.
; There is no other way to do this, unless your code ALWAYS knows precisely which range of values to expect and the order
; they appear in. This is impractical for most purposes.
; Therefore, we are going to use an extra Byte to make use of its 8 bits. There is more power available to us with the extra 8-bits
; awarded, besides identifying the number of bytes that follow, Since our 32-Bit processors only cope with numbers of 32-Bits at the most,
; We know that our extra Byte only needs to use Bit '0' and Bit '1', representing the possble number of Bytes to follow from 1 to 4.
; (Since we must use at least 1 Byte, a 0 value  of all Bits set to "0" can show 1 byte to follow, meaning we only need to count 0,1,2,3 for four possible Bytes)
; This then gives us 6 more Bits to 'play with'. But what else can we use them for?
; Well, an obvious first choice would be dealing with negative integers.
; We know we can represent values from 0 to (2^32)-1 but what if we wanted just to show -1 ?
; Traditionally, Byte values are considered "signed" or "unsigned" - "signed" meaning, they contain a Bit that represents a "sign", as in the "minus sign" ( - )
; Since this Bit is used for the "sign", it can no longer be used as part of the number itself.
; Here's an example of an 8-Bit "signed" Byte compared to an  "unisgned" version:

; SIGN 64  32   16   8   4   2   1
; 128   64  32   16   8   4   2   1

;Note how the HIGHEST value (Most Significant) Bit is used for the Sign (in this case, Bit '7'  = 128)

; Despite no longer having access to values Greater Than 127, we still have 255 possible values. How so?
; Well, let's see what happens when we use the "Sign" Bit:

; SIGN 64  32   16   8   4   2   1
;    0     0   1      0   1   0   0   1	=	32 + 8 + 1 		= 41

; If The "Sign" Bit is set to 0, then it is considered Positive. However, the same Byte with the Sign Bit set to 1 gives:

; SIGN 64  32   16   8   4   2   1
;   1     0   1       0   1   0   0   1	=	-	32 + 8 + 1 	= -86

; It doesn't make sense at first sight, how can 32+8+1 = -86 ?
; The answer is that the active Bits are actually added to -127
; Allowing for addition (setting Bits ON to 1)  to Increase, and subtraction (setting Bits OFF to 0) to Decrease the value as mathematically correct.
; The range of values then, for a "Signed" 8-bit Byte, are from -127 to + 127 including 0  to give our 255 possible values.

; So we now know that our special Added Byte will have at least 3 Bits in use:

; 128		64		32		16		8		4		2		1
;										     SIGN	 # BYTES  #BYTES

; What to do with the other 5 Bits?


WaitKey()
End

f=1
While f<65536
Print f+" "+((42372 And f)=f)
f=f*2
Wend


Function WriteEfficientInt(Stream%,Integer%)
	Magnitude%=Abs(Integer%)
	If ((Magnitude%)>255)
		While (Magnitude>255)
			Magnitude%=Magnitude%/256
			WriteByte(Stream%,Magnitude%)
		Wend
	End If
	Magnitude%=Magnitude% Mod 256
	WriteByte(Stream%,Magnitude%)
End Function

Function CalculateBytes%(Magnitude%)
	Magnitude%=Abs(Magnitude%)
	Local nBytes=1
	If ((Magnitude%)>255)
		While (Magnitude>255)
			nBytes=nBytes+1
			Magnitude%=Magnitude%/256
		Wend	
	End If
	Return nBytes%
End Function

Function WriteBools(stream,b1,b2,b3,b4,b5,b6,b7,b8)
WriteByte stream,(b1)And 1 Or (b2)And b2 Or (b3) And 4 Or (b4)And 8 Or (b5)And 16 Or (b6) And 32 Or(b7)And 64 Or (b8)And 128
End Function

Byte=ReadByte(Stream)
Nibble1=Byte And 240 ;Big Endian first
Nibble2=Byte And 31 ; Little Endian

Byte=ReadByte(Stream)
Nibble1$=Hex(Byte And 240) Shl 4;Big Endian first
Nibble2=Hex(Byte And 31); Little Endian

Function DrawACircleOnBuffer(Buffer,H,W)
   SetBuffer Buffer
   Oval W shr 2, H Shr 2,W Shr 1, H Shr 1,1
End Function

Function DrawACircleOnImage(Buffer)
   SetBuffer ImageBuffer(Buffer)
W=ImageWidth(Buffer),H=ImageWidth(Buffer)
   Oval W shr 2, H Shr 2,W Shr 1, H Shr 1,1
End Function

Function DrawACircleOnTexture(Texture)
   SetBuffer TextureBuffer(Texture)
W=TextureWidth(Texture),H=TextureWidth(Texture)
   Oval W shr 2, H Shr 2,W Shr 1, H Shr 1,1
End Function

Function DrawCircleOnBuffer(Buffer)
   SetBuffer Buffer
W=BufferWidth(Buffer),H=BufferWidth(Buffer)
   Oval W shr 2, H Shr 2,W Shr 1, H Shr 1,1
End Function

For i = 1 to 10
  Print "Hello World"
Next

class HelloWorldApp {
   public static void main(String[] args[]) {
      For (i=1;i++;i=10) {
         Console.Writeline("Hello World")
      }
   }
}

class mammal {

   float speed;

   run() {
    ... move mammal forward
   }

}

class cat : mammal {

   float purrVolume;

   purr() {
   ... cat purrs ...
   }

}

fluffy.cat=new cat;

ClsCameraColor(camera)
ClsCameraZBuffer(camera)