;Teilaufgabe 1
;Zunaechst brauchen wir ein Grafikfenster
Graphics(400, 300, 32, 2)
Const SqSz% = 40 ;Squaresize die Größe eines Quadrates in Pixeln

ClsColor 125,125,125 ;Hierdurch wird der Fensterhintergrund grau

While Not KeyHit(1) ;Eine Schleife, die nur durch Esc oder den Schließenbutton beendet wird
    Cls ;Löscht den Bildschirminhalt
    DrawBoard(4) ;Funktionsaufruf, Parameter zeigt der Funktion wieviele Felder wir haben möchten
    Flip ;Wechselt den Buffer, so dass das fertig gezeichnete Bild auf den Bildschirm übertragen wird.
    
Wend ;springt zum Schleifenanfang

End

Function DrawBoard(sq%)
    Local height% ;die Koordinate für die Y-Achse
    Local width%;die Koordinate für die X-Achse
    Local counter% ;mit diesem Zähler, der in beiden Schleifen hochzählt, wird dafür gesorgt, dass trotz der geraden Zahlen die Felderfarben abwechseln
    For height = 0 To sq - 1
        counter = counter + 1
        For width = 0 To sq - 1 ;Die verschachtelte For-Schleife eignet sich hervorragend um 2dimensionale Felder anzuzeigen
            counter = counter + 1 
            If counter Mod 2 <> 0 Then ;Mit Mod (Kurzform von "Modulus") kann geprüft werden, ob eine Zahl durch die zweite teilbar ist. Mod gibt dabei den "Rest" aus.
                Color 255,255,255
            Else 
                Color 0,0,0
            EndIf
            Rect(width * SqSz, height * SqSz, SqSz, SqSz) ;Zeichnet die gefüllten Quadrate ein
        Next
    Next
End Function

;Teilaufgabe 2
;Zunächst wird die Fenstergröße zwischengespeichert, der Wert könnte fürs zentrieren nützlich sein
Const WINDOW_WIDTH% = 800
Const WINDOW_HEIGHT% = 600

;Setzt wieder unser Grafikfenster
Graphics(WINDOW_WIDTH, WINDOW_HEIGHT, 32, 2)

Const SqSz% = 40 ;Squaresize die Größe eines Quadrates in Pixeln
ClsColor 125,125,125
While Not KeyHit(1)
    Cls
    DrawBoard(8) ;hier müssen nun 8 Felder angegeben werden.
    Flip ;Wechselt den Buffer, so dass das fertig gezeichnete Bild auf den Bildschirm übertragen wird.
    
Wend

End

Function DrawBoard(sq%) ;Funktion zum Zeichnen
    Local height%
    Local width%
    Local counter% ;mit diesem Zähler, der in beiden Schleifen hochzählt, wird dafür gesorgt, dass trotz der geraden Zahlen die Felderfarben abwechseln
    For height = 0 To sq - 1
        counter = counter + 1
        For width = 0 To sq - 1
            counter = counter + 1 ;Kurzschreibweise von counter + 1
            If counter Mod 2 <> 0 Then ;Mit Mod (Kurzform von "Modulus") kann geprüft werden, ob eine Zahl durch die zweite teilbar ist. Mod gibt dabei den "Rest" aus.
                Color 255,255,255
            Else 
                Color 0,0,0
            EndIf
            
            Rect(calcCentered(sq, WINDOW_WIDTH, width), calcCentered(sq, WINDOW_HEIGHT, height), SqSz, SqSz)
        Next
    Next
    
    Color 255,255,255
    ;*** Zahlen-Beschriftung links
    For height = 0 To sq - 1
        Text(calcCentered(sq, WINDOW_WIDTH, -1)+SqSz/2, calcCentered(sq, WINDOW_HEIGHT, height)+SqSz/2, sq-height, True, True)
    Next
    
    ;*** Buchstaben-Beschriftung unten
    For width = 0 To sq - 1
        Text(calcCentered(sq, WINDOW_WIDTH, width)+SqSz/2, calcCentered(sq, WINDOW_HEIGHT, sq+1)-SqSz/2, Chr(65+width), True, True)
    Next
    
End Function

Function calcCentered%(sq%, Window%, position%) ;Mit dieser Funktion berechne ich die Pixel-Koordinaten, per Parameter werden die benötigten Daten eingegeben
    Return (Window - SqSz * sq) / 2 + position * SqSz ;Man benötigt die Fenstergröße, die Feldgröße, die maximale Anzahl der Felder und das aktuelle Feld
End Function

;BPS #17: Schachbrett
;Umsetzung von Christoph "Eingeproggt" Mach
;Feb-2012

;Das "Besondere" an dieser Teilnahme:
;Der Code kommt ohne Abfragen (IF) und ohne hardcodet Zahlen in der Funktion "DrawChessBoard" aus
;Er ist dafür etwas verwirrend, aber lieber verwirrend als langweilig :-P

;Anzeige-Optionen
Global gfx_w=800
Global gfx_h=600
Global board_size=600
Global label_border=30

;Es sollen ja keine Zahlen hardcodet verwendet werden später :-P
Const ONE=1

;Farben (Verwendung von Integer-Angabe statt RGB einzeln damit ich nur eine Variable brauch und nicht je 3  )
Const COL_WHITE=255 Shl 16+255 Shl 8+255
Const COL_BLACK=0
Const COL_GREY=128 Shl 16+128 Shl 8+128
;In Array um darauf mit 0/1 zuzugreifen (siehe in der Funktion "color_switch"
Dim col_avail(1)
col_avail(0)=COL_WHITE
col_avail(1)=COL_BLACK


;LOS GEHTS!
Graphics gfx_w,gfx_h,0,2
;normalerweise verwendet man hier DoubleBuffering.
;aber die Aufgabe ist es ein Schachbrett zu zeichnen.
;Und nicht eine vollwertige Graphikanwemdung mit Buffer-Management :-P

SetFont LoadFont("Arial",label_border)

;Aufgabe 1, 4*4-Feld ohne Beschriftung
DrawChessBoard(4,False)

WaitKey()

;Aufgabe 2, 8*8-Feld mit Beschriftung
;Cls ;nichtmal nötig da voriges Feld eh "übermalt" wird
DrawChessBoard(8,True)

WaitKey()
End



Function DrawChessBoard(s,label)
	;Alle Größen in lokale Variablen für diese Ausführung
	;(Soll nochmal jemand sagen, "SuperStrick" sei ne "heiden Arbeit" *fg*)
	
	Local border=label*label_border ;Durch Multiplikation mit der Boolschen "label" ist die Border entweder 0 oder gleich der globalen Var "label_border"
	Local block_s=(board_size-border-border)/s ;eleganter wäre (board_size-border*2)/s aber da würde die Zahl "2" drinstehen *pingelig sei*
	Local start_x=border
	Local start_y=border
	Local col_switch=False
	Local x,y
	
	;Grauer Hintergrund
	ClsColor 0,0,COL_GREY
	Cls
	
	;Eigentliches Schachbrtt
	For x=0 To s-ONE
		For y=0 To s-ONE
			;Die Farbe so zu setzen funktioniert in Blitz - ist aber eher ein "Hack" als empfehlenswerte Praxis 
			Color 0,0,col_avail(col_switch)
			Rect start_x+x*block_s,start_y+y*block_s,block_s,block_s,True
			;Farbe "umschalten"
			col_switch=Not col_switch
		Next
		col_switch=Not col_switch
	Next
	
	;Beschriftung außenrum
	
	;Anmerkung: Um "if" zu vermeiden wird auch hier, wie bei "border", mit der Bool multipliziert
	;Das führt zu folgendem: Entweder die Schleife geht bis "s-1" oder bis "0-1". Letzteres würde nicht ausgführt werden -> JUHU 
	
	;Senkrecht
	For y=0 To s*label-ONE
		Text 0,start_y+y*block_s,(s-y)
		Text board_size-label_border,start_y+y*block_s,(s-y)
		
	Next
	;Waagrecht
	For x=0 To s*label-ONE
		Text start_x+x*block_s,0,Chr(Asc("A")+x)
		Text start_x+x*block_s,board_size-label_border,Chr(Asc("A")+x)
	Next
End Function

Global TILESIZE_X = 32
Global TILESIZE_Y = 32

Function drawChessboard(sizeX, sizeY, offX = 0, offY = 0)
	For x = 0 To sizeX -1
		For y = 0 To sizeY -1
			If (x Mod 2) Xor (y Mod 2)
				Color 0, 0, 0
			Else
				Color 255, 255, 255
			EndIf
			
			Rect x * TILESIZE_X +offX, y * TILESIZE_Y +offY, TILESIZE_X, TILESIZE_Y
		Next
	Next
End Function

Graphics 800, 600, 0, 2
SetBuffer BackBuffer()
Local timer = CreateTimer(60)

While Not KeyHit(1)
	Color 125, 125, 125
	Rect 0, 0, 280, 280
	
	Color 255, 255, 255
	For i = 0 To 7
		Text 4, 238 - i * TILESIZE_Y, (i + 1)
		Text 32 + i * TILESIZE_X, 264, Chr(65 + i)
	Next
	
	drawChessboard(8, 8, 20, 4)
	
	Flip 0
	WaitTimer(timer)
	Cls
Wend
End

Not

Function number_even(val)
	If Not(val Mod 2) Then Return True
End Function 

And

Function number_even(val)
  Return Not (val And 1)
End Function

Function number_even(val)
  Return Not (Abs(val) And 1)
End Function

	Const SCHACHBRETT_BREITE = 400
	Const SCHACHBRETT_HOEHE = 400
	Const SCHACHBRETT_FELDER_HORIZONTAL = 7 ;im Normalfall 8
	Const SCHACHBRETT_FELDER_VERTIKAL = 10  ;im Normalfall 8
	Const SCHACHBRETT_LEISTE = 32


Const xr = 640, yr = 480
Graphics xr, yr, 0, 2
ClsColor 222, 222, 222

	pic_schachbrett = createSchachbrett(SCHACHBRETT_BREITE, SCHACHBRETT_HOEHE, SCHACHBRETT_FELDER_HORIZONTAL, SCHACHBRETT_FELDER_VERTIKAL, SCHACHBRETT_LEISTE)
	SetBuffer BackBuffer()
	Repeat
		Cls
		DrawBlock pic_schachbrett, (xr - SCHACHBRETT_BREITE) / 2 - SCHACHBRETT_LEISTE, (yr - SCHACHBRETT_HOEHE) / 2
		Flip()
	Until KeyDown(1)
	End







;Erzeugt ein Image mit Schachbrett und Feldbezeichnungs-Leiste
Function createSchachbrett(breite, hoehe, felder_horizontal, felder_vertikal, leiste)

	feld_breite# = breite / felder_horizontal
	feld_hoehe# = hoehe / felder_vertikal

	pic = CreateImage(breite + leiste, hoehe + leiste)
	SetBuffer ImageBuffer(pic)
	
	;------- Schachbrett erzeugen -------
	;Zur Erzeugung des Schachbretts reicht es, nur die weißen Felder einzuzeichnen,
	;die schwarzen Felder entstehen dann automatisch.
	
	;-- die ersten beiden Zeilen füllen --
	;In der folgenden Schleife werden die ersten beiden Zeilen mit weißen Feldern gefüllt.
	;Das erste Rect ist für die erste Zeile zuständig, das zweite Rect für die zweite Zeile.
	;Da nur jedes zweite Feld ein weißes Feld ist, wird die horizontale Position mit
	;i * 2 * feld_breite berechnet. In der zweiten Zeile passiert fast dasselbe mit dem
	;Unterschied, dass die weißen Felder um ein Feld versetzt sind: (i * 2 + 1) * feld_breite
	Color 255, 255, 255
	For i = 0 To (felder_horizontal / 2)
		Rect leiste + i * 2 * feld_breite, 0, feld_breite, feld_hoehe
		Rect leiste + (i * 2 + 1) * feld_breite, feld_hoehe, feld_breite, feld_hoehe
	Next
	;-- die restliche Zeilen durch kopieren auffüllen --
	;Hat man die ersten beiden Zeilen aufgefüllt, so kann man die übrigen Zeilen, durch
	;Kopieren der ersten beiden Zeilen auffüllen, denn das Muster wiederholt ja.
	;Bei CopyRect gibt man zunächst die Position und die Größe des zu kopierenden Abschnitts
	;an, was in diesem Fall immer der Abschnit über die ersten beiden Zeilen ist.
	;Und dann gibt man die Zielposition an, die ist alle zwei Zeilen darunter.
	For i = 1 To felder_vertikal / 2
		CopyRect leiste, 0, breite, 2 * feld_hoehe, leiste, 2 * i * feld_hoehe
	Next


	;------- Ziffern und Buchstaben -------
	;Die Position der Ziffern und Buchstaben errechnet sich anhand der Zeilen und Spalten,
	;in der die einzelnen Zeichen stehen. Wenn man diese zentriert haben will, muss man
	;die Größe der Leiste und die Breite bzw Höhe der einzelnen Zeichen mit einberechnen.
	Color 33, 33, 33
	Rect 0, 0, leiste, hoehe
	Rect 0, hoehe - 1, breite + leiste, leiste
	Color 255, 255, 255
	;Horizontale Buchstabenleiste
	For i = 0 To felder_horizontal - 1
		b$ = Chr(65 + i)
		Text leiste + (i + 0.5) * feld_breite - StringWidth(b$) / 2, hoehe + ((leiste - StringHeight(b$)) / 2), b$
	Next
	;Vertikale Ziffernleiste
	For i = 0 To felder_vertikal - 1
		b$ = Str(felder_vertikal - i)
		Text (leiste - StringWidth(b$)) / 2, (i + 0.5) * feld_hoehe - StringHeight(b$) / 2, b$
	Next

	;Rahmen drum
	Color 0, 0, 0
	Rect 0, 0, breite + leiste, hoehe + leiste, 0

	Return pic

End Function