enum RETVAR
  programmende = -1, ok
end enum
' Konstanten fuer Grafik und zur Berechnung des Feld-Wertes  (fuer den Computerspieler)
const PLANKENBREITE = 40
const FENSTERBREITE = PLANKENBREITE*23
const FENSTERHOEHE  = PLANKENBREITE*12
const WERT_SIEG     = &hffffff     ' Sieg des Spielers
const WERT_MINIMAL  = -&hfffffff
const WERT_BEWEGBARERNAGEL = 20    ' Nagel, der nicht allein auf der Planke steht
const WERT_RND = 5                 ' zufaellige Fluktuation, um die Berechenbarkeit zu verringern
function WERT_FREIERNAGEL(anz as integer) as integer
  select case anz
    case 2 : return 600            ' 2 freie Naegel derselben Farbe
    case 1 : return 400            ' 1 freier Nagel einer Farbe
  end select
  return 0                         ' kein freier Nagel einer Farbe
end function
function WERT_FREIEPLANKE(anz as integer) as integer
  select case anz
    case 1    : return 30          ' 1 freie Planke einer Mittelfarbe
    case 2    : return 50          ' 2 freie Planken derselben Mittelfarbe
    case 3, 4 : return 60          ' 3 oder 4 freie Planken derselben Mittelfarbe
  end select
  return 0                         ' keine freie Planke einer Mittelfarbe
end function

const REDUKTION = 50  ' Bei zu hoher Zahl an Zugmoeglichkeiten wird die Berechnungstiefe heruntergesetzt.

dim shared as integer maxZugtiefe = 3
dim shared as uinteger FARBE(3, 1 to 3)
FARBE(1, 1) = rgb(255,  24,  24)   ' Feldfarbe (Planke)
FARBE(1, 2) = rgb(160,   0,   0)   ' Nagel Hauptfarbe
FARBE(1, 3) = rgb( 95,   0,   0)   ' Nagel Zweitfarbe
FARBE(2, 1) = rgb(  0, 255,   0)
FARBE(2, 2) = rgb(  0, 143,   0)
FARBE(2, 3) = rgb(  0,  95,   0)
FARBE(3, 1) = rgb( 24,  24, 255)
FARBE(3, 2) = rgb(  0,   0, 127)
FARBE(3, 3) = rgb(  0,   0,  31)

#include once "fbgfx.bi"

type TKoordinaten
  as integer x, y
end type

type TPlanke
  as integer farbe(1 to 3), nagel(1 to 3)
  declare constructor
  declare constructor(f1 as integer, f2 as integer, f3 as integer)
  declare constructor(f1 as integer, f2 as integer, f3 as integer, n1 as integer, n2 as integer, n3 as integer)
  declare property anzNaegel as integer
end type
constructor TPlanke
end constructor
constructor TPlanke(f1 as integer, f2 as integer, f3 as integer)
  this.farbe(1) = f1
  this.farbe(2) = f2
  this.farbe(3) = f3
end constructor
constructor TPlanke(f1 as integer, f2 as integer, f3 as integer, n1 as integer, n2 as integer, n3 as integer)
  this.farbe(1) = f1
  this.farbe(2) = f2
  this.farbe(3) = f3
  this.nagel(1) = n1
  this.nagel(2) = n2
  this.nagel(3) = n3
end constructor
property TPlanke.anzNaegel as integer
  return -((nagel(1) > 0) + (nagel(2) > 0) + (nagel(3) > 0))
end property

type TSpieler
  as TPlanke planke(1 to 6)
  as integer anzNagel(1 to 3), anzPlanke(1 to 3), ai
  as FB.Image ptr imgNagel(1 to 3)
  declare property anzNaegel as integer
  declare property anzPlanken as integer
end type
property TSpieler.anzNaegel as integer
  return anzNagel(1) + anzNagel(2) + anzNagel(3)
end property
property TSpieler.anzPlanken as integer
  return anzPlanke(1) + anzPlanke(2) + anzPlanke(3)
end property

type TZug
  as TPlanke planke
  as integer plankenort, steinfarbe, steinort, posStart, posZiel, bewertung, retvar
end type

declare function bewertung(nr as integer) as integer
declare function innerhalb(kx as integer, ky as integer, x as integer, y as integer, w as integer, h as integer) as integer
declare function koordDrehen(s as integer, nr as integer) as TKoordinaten
declare function koordNagel overload(p as integer, nr as integer) as TKoordinaten
declare function koordNagel(s as integer, f as integer, nr as integer) as TKoordinaten
declare function koordPlanke overload(p as integer) as TKoordinaten
declare function koordPlanke(s as integer, nr as integer) as TKoordinaten
declare function koordStart(s as integer) as TKoordinaten
declare function pruefeSieg as integer
declare sub zeichneFeld
declare sub zeichneNagel(s as integer, x as integer, y as integer, f as integer)
declare sub zeichnePlanke(p as TPlanke, x as integer, y as integer, grau as integer = 0, img as FB.Image ptr = 0)
declare function zugComputer(nr as integer, tiefe as integer) as TZug
declare sub zugComputerNagel(nr as integer, zug() as TZug, byref anz as integer, byval planke as TPlanke, p as integer)
declare sub zugDurchfuehren(nr as integer, zug as TZug, richtung as integer = 1)
declare function zugMensch(nr as integer) as TZug

screenres FENSTERBREITE, FENSTERHOEHE, 32
width FENSTERBREITE\8, FENSTERHOEHE\16
randomize

' Image fuer die Planken und Naegel erstellen
dim shared as FB.Image ptr imgPlanke
imgPlanke = imagecreate(PLANKENBREITE, PLANKENBREITE*3, &hff00ff)
line imgPlanke, (4, 0)-step(PLANKENBREITE-9, 0), &h7f7f7f
line imgPlanke, -step(3, 3), &h7f7f7f
line imgPlanke, -step(0, PLANKENBREITE*3-7), &h7f7f7f
line imgPlanke, -step(-3, 3), &h7f7f7f
line imgPlanke, -step(-PLANKENBREITE+9, 0), &h7f7f7f
line imgPlanke, -step(-3, -3), &h7f7f7f
line imgPlanke, -step(0, -PLANKENBREITE*3+7), &h7f7f7f
line imgPlanke, -step(3, -3), &h7f7f7f
line imgPlanke, (0, PLANKENBREITE-1)-step(PLANKENBREITE-3, 0), &h7f7f7f
line imgPlanke, (0, PLANKENBREITE*2-1)-step(PLANKENBREITE-3, 0), &h7f7f7f

dim shared as Fb.Image ptr imgDrehen
imgDrehen = imagecreate(PLANKENBREITE\2, PLANKENBREITE\2, 0)
line imgDrehen, (PLANKENBREITE\4, 0)-step(-PLANKENBREITE\8, PLANKENBREITE\8)
line imgDrehen, -step(PLANKENBREITE\16, 0)
line imgDrehen, -step(0, PLANKENBREITE\4-1)
line imgDrehen, -step(-PLANKENBREITE\16, 0)
line imgDrehen, -step(PLANKENBREITE\8, PLANKENBREITE\8)
line imgDrehen, -step(PLANKENBREITE\8, -PLANKENBREITE\8)
line imgDrehen, -step(-PLANKENBREITE\16, 0)
line imgDrehen, -step(0, -PLANKENBREITE\4+1)
line imgDrehen, -step(PLANKENBREITE\16, 0)
line imgDrehen, -step(-PLANKENBREITE\8, -PLANKENBREITE\8)

dim shared as TPlanke planke(1 to 23)
dim shared as TSpieler spieler(1 to 4)
dim shared as integer aktuellerSpieler
for f as integer = 1 to 3
  for s as integer = 1 to 4
    spieler(s).imgNagel(f) = imagecreate(PLANKENBREITE, PLANKENBREITE, rgb(255, 0, 255))
  next
  ' Spielfiguren Spieler 1
  line spieler(1).imgNagel(f), (8, 8)-step(PLANKENBREITE-17, PLANKENBREITE-17), FARBE(f, 3), b
  line spieler(1).imgNagel(f), (9, 9)-step(PLANKENBREITE-19, PLANKENBREITE-19), FARBE(f, 2), bf
  line spieler(1).imgNagel(f), (12, 12)-step(PLANKENBREITE-25, PLANKENBREITE-25), FARBE(f, 3), b
  ' Spielfiguren Spieler 2
  line spieler(2).imgNagel(f), (PLANKENBREITE\2, 6)-step(PLANKENBREITE\2-5, PLANKENBREITE-15), FARBE(f, 3)
  line spieler(2).imgNagel(f), -step(-PLANKENBREITE+10, 0), FARBE(f, 3)
  line spieler(2).imgNagel(f), -step(PLANKENBREITE\2-5, -PLANKENBREITE+15), FARBE(f, 3)
  paint spieler(2).imgNagel(f), (PLANKENBREITE\2, 8), FARBE(f, 2), FARBE(f, 3)
  line spieler(2).imgNagel(f), (PLANKENBREITE\2, 12)-step(PLANKENBREITE\2-10, PLANKENBREITE-24), FARBE(f, 3)
  line spieler(2).imgNagel(f), -step(-PLANKENBREITE+20, 0), FARBE(f, 3)
  line spieler(2).imgNagel(f), -step(PLANKENBREITE\2-10, -PLANKENBREITE+24), FARBE(f, 3)
  ' Spielfiguren Spieler 3
  circle spieler(3).imgNagel(f), (PLANKENBREITE\2, PLANKENBREITE\2), PLANKENBREITE\3, FARBE(f, 3)
  paint spieler(3).imgNagel(f), (PLANKENBREITE\2, PLANKENBREITE\2), FARBE(f, 2), FARBE(f, 3)
  circle spieler(3).imgNagel(f), (PLANKENBREITE\2, PLANKENBREITE\2), PLANKENBREITE\3-3, FARBE(f, 3)
  ' Spielfiguren Spieler 4
  line spieler(4).imgNagel(f), (PLANKENBREITE\2, 6)-step(PLANKENBREITE\2-6, PLANKENBREITE\2-6), FARBE(f, 3)
  line spieler(4).imgNagel(f), -step(-PLANKENBREITE\2+6, PLANKENBREITE\2-6), FARBE(f, 3)
  line spieler(4).imgNagel(f), -step(-PLANKENBREITE\2+6, -PLANKENBREITE\2+6), FARBE(f, 3)
  line spieler(4).imgNagel(f), -step(PLANKENBREITE\2-6, -PLANKENBREITE\2+6), FARBE(f, 3)
  paint spieler(4).imgNagel(f), (PLANKENBREITE\2, PLANKENBREITE\2), FARBE(f, 2), FARBE(f, 3)
  line spieler(4).imgNagel(f), (PLANKENBREITE\2, 10)-step(PLANKENBREITE\2-10, PLANKENBREITE\2-10), FARBE(f, 3)
  line spieler(4).imgNagel(f), -step(-PLANKENBREITE\2+10, PLANKENBREITE\2-10), FARBE(f, 3)
  line spieler(4).imgNagel(f), -step(-PLANKENBREITE\2+10, -PLANKENBREITE\2+10), FARBE(f, 3)
  line spieler(4).imgNagel(f), -step(PLANKENBREITE\2-10, -PLANKENBREITE\2+10), FARBE(f, 3)
next

' Spielvorbereitung: Planken verteilen
dim shared as integer spielerzahl = 2
'spieler(2).ai = -1
for m as integer = 1 to 3         ' Farbe des mittleren Planken-Feldes
  for i as integer = 1 to 4       ' von jeder Art vier Planken
    do
      dim as integer s = int(rnd*spielerzahl)+1
      if spieler(s).anzPlanken = 12\spielerzahl then continue do
      spieler(s).anzPlanke(m) += 1
      spieler(s).planke(spieler(s).anzPlanken) = TPlanke(((m+1) mod 3)+1, m, (m mod 3)+1)
      exit do
    loop
  next
next
for s as integer = 1 to spielerzahl
  spieler(s).anzNagel(1) = 2      ' zwei Naegel von jeder Sorte
  spieler(s).anzNagel(2) = 2
  spieler(s).anzNagel(3) = 2
next
planke(12) = TPlanke(-1, -1, -1)  ' "Startplanke" auf dem Spielfeld

aktuellerSpieler = int(rnd*spielerzahl)+1
dim as TZug zug
dim as integer sieger
do
  zeichneFeld
  if spieler(aktuellerSpieler).ai then 
    zug = zugComputer(aktuellerSpieler, maxZugtiefe)
    zugDurchfuehren(aktuellerspieler, zug)
    if zug.planke.farbe(1) then
      for i as integer = 1 to 6
        if spieler(aktuellerSpieler).planke(i).farbe(2) = zug.planke.farbe(2) then
          spieler(aktuellerSpieler).planke(i) = TPlanke(0, 0, 0)
          exit for
        end if
      next
    end if
  else
    zug = zugMensch(aktuellerSpieler)
  end if
  aktuellerSpieler = (aktuellerSpieler mod spielerzahl) + 1
  sieger = pruefeSieg
loop until sieger orelse zug.retvar = RETVAR.programmende
if sieger then
  zeichneFeld
  dim as TKoordinaten koord = koordStart(sieger)
  dim as integer mx, my, mb
  dim as string taste
  line (koord.x, koord.y)-step(PLANKENBREITE*4, PLANKENBREITE*3), 0, b
  line (koord.x+1, koord.y+1)-step(PLANKENBREITE*4-2, PLANKENBREITE*3-2), &hffffff, bf
  line (koord.x+2, koord.y+2)-step(PLANKENBREITE*4-4, PLANKENBREITE*3-4), 0, b
  line (koord.x+3, koord.y+3)-step(PLANKENBREITE*4-6, PLANKENBREITE*3-6), 0, b
  draw string (koord.x+PLANKENBREITE*2-36, koord.y+PLANKENBREITE*1.5-8), "GEWONNEN!", 0
  do
    getmouse mx, my,, mb
    taste = inkey
    sleep 1
  loop until len(taste) orelse (mb > 0 andalso innerhalb(mx, my, koord.x, koord.y, PLANKENBREITE*4, PLANKENBREITE*3))
end if

' Spielende
imagedestroy imgPlanke
for f as integer = 1 to 3
  for s as integer = 1 to 4
    imagedestroy spieler(s).imgNagel(f)
  next
next

function bewegeObjekt(img as FB.Image ptr, startX as integer, startY as integer) as TKoordinaten
  dim as integer mx, my, mb, diffX, diffY
  if getmouse(mx, my,, mb) then return type<TKoordinaten>(-1, -1)
  dim as FB.Image ptr hintergrund = imagecreate(FENSTERBREITE, FENSTERHOEHE)
  get (0, 0)-(FENSTERBREITE-1, FENSTERHOEHE-1), hintergrund
  diffX = mx - startX
  diffY = my - startY
  do
    sleep 1
    if getmouse(mx, my,, mb) then exit do
    screenlock
    put (0, 0), hintergrund, pset
    put (mx-diffX, my-diffY), img, trans
    screenunlock
  loop until mb < 1
  put (0, 0), hintergrund, pset
  imagedestroy hintergrund
  return type<TKoordinaten>(mx, my)
end function

function bewertung(nr as integer) as integer
  dim as integer sieger = pruefeSieg, wert(1 to 4)
  if sieger then return iif(sieger = nr, WERT_SIEG, -WERT_SIEG)
  for i as integer = 1 to spielerzahl
    for f as integer = 1 to 3
      wert(i) += WERT_FREIERNAGEL(spieler(i).anzNagel(f))
      wert(i) += WERT_FREIEPLANKE(spieler(i).anzPlanke(f))
    next
  next
  for p as integer = 1 to 23
    if planke(p).anzNaegel > 1 then
      for f as integer = 1 to 3
        if planke(p).nagel(f) > 0 then wert(planke(p).nagel(f)) += WERT_BEWEGBARERNAGEL
      next
    end if
  next
  if spielerzahl = 4 then
    if nr = 1 or nr = 3 then
      return wert(1)+wert(3)-wert(2)-wert(4)
    else
      return wert(2)+wert(4)-wert(1)-wert(3)
    end if
  else
    return spielerzahl*wert(nr)-wert(1)-wert(2)-wert(3) + rnd*WERT_RND
  end if
end function

function innerhalb(kx as integer, ky as integer, x as integer, y as integer, w as integer, h as integer) as integer
  if kx > x and ky > y and kx < x + w and ky < y + h then return -1
  return 0
end function

function koordDrehen(s as integer, nr as integer) as TKoordinaten
  ' Button zum Drehen einer Planke
  dim as TKoordinaten ret = koordPlanke(s, nr)
  ret.x += PLANKENBREITE*.25
  ret.y += iif(ret.y > FENSTERHOEHE\2, -PLANKENBREITE*.7, PLANKENBREITE*3.2)
  return ret
end function

function koordNagel(s as integer, f as integer, nr as integer) as TKoordinaten
  ' Nagel auf der Hand
  dim as TKoordinaten ret = koordStart(s)
  ret.x += PLANKENBREITE*(12\spielerzahl) + PLANKENBREITE*(nr-1)
  ret.y += PLANKENBREITE*(f-1)
  return ret
end function

function koordNagel(p as integer, nr as integer) as TKoordinaten
  ' Nagel auf einer Planke
  dim as TKoordinaten ret = koordPlanke(p)
  ret.y += PLANKENBREITE*(nr-1)
  return ret
end function

function koordPlanke(p as integer) as TKoordinaten
  ' Planke auf dem Feld
  return type<TKoordinaten>(PLANKENBREITE*p, PLANKENBREITE*4.5)
end function

function koordPlanke(s as integer, nr as integer) as TKoordinaten
  ' Planke auf der Hand
  dim as TKoordinaten ret = koordStart(s)
  ret.x += PLANKENBREITE*(nr-1)
  return ret
end function

function koordStart(s as integer) as TKoordinaten
  dim as TKoordinaten ret
  select case s
    case 1
      ret.x = iif(spielerzahl < 4, PLANKENBREITE*7.5, PLANKENBREITE*3)
      if spielerzahl = 3 then ret.x += PLANKENBREITE
      ret.y = PLANKENBREITE*8.5
    case 2
      ret.x = iif(spielerzahl < 3, PLANKENBREITE*7.5, PLANKENBREITE*3)
      ret.y = PLANKENBREITE*0.5
    case 3
      ret.x = PLANKENBREITE*(spielerzahl + 11)
      ret.y = PLANKENBREITE*0.5
    case 4
      ret.x = PLANKENBREITE*15
      ret.y = PLANKENBREITE*8.5
  end select
  return ret
end function

function pruefeSieg as integer
  dim as integer s, lauf
  ' pruefe auf senkrechte Gewinn-Reihen
  for x as integer = 1 to 23
    s = planke(x).nagel(1)
    if s = 0 then continue for
    if planke(x).nagel(2) = s and planke(x).nagel(3) = s then return s
  next
  ' pruefe auf waagrechte Gewinn-Reihen
  for y as integer = 1 to 3
    s = planke(1).nagel(y)
    lauf = iif(s = 0, 0, 1)
    dim as integer x = 2
    do
      if planke(x).nagel(y) = 0 orelse planke(x).nagel(y) <> planke(x-1).nagel(y) _
          orelse planke(x).farbe(y) = planke(x-1).farbe(y) _
          orelse lauf = 3 and planke(x).farbe(y) = planke(x-2).farbe(y) then
        if lauf = 3 then x -= 1
        s = planke(x).nagel(y)
        lauf = iif(s = 0, 0, 1)
      end if
      if lauf = 3 then return planke(x).nagel(y)
      lauf += 1
      x += 1
    loop until x = 23
  next
  return 0
end function

sub zeichneFeld
  ' komplettes Feld zeichnen: Feld-Planken mit Naegeln, Hand aller Spieler
  screenlock
  cls
  dim as integer px, py
  for i as integer = 1 to 23
    let (px, py) = koordPlanke(i)
    zeichnePlanke planke(i), px, py
    for n as integer = 1 to 3
      let (px, py) = koordNagel(i, n)
      zeichneNagel planke(i).nagel(n), px, py, planke(i).farbe(n)
    next
  next
  for s as integer = 1 to spielerzahl
    with spieler(s)
      for i as integer = 1 to 6
        if .planke(i).farbe(1) > 0 then
          let (px, py) = koordPlanke(s, i)
          zeichnePlanke .planke(i), px, py, s <> aktuellerSpieler
          if s = aktuellerSpieler andalso not spieler(s).ai then
            let (px, py) = koordDrehen(s, i)
            put (px, py), imgDrehen, pset
          end if
        end if
      next
      for f as integer = 1 to 3
        for i as integer = 1 to .anzNagel(f)
          let (px, py) = koordNagel(s, f, i)
          zeichneNagel s, px, py, f
        next
      next
    end with
  next
  screenunlock
end sub

sub zeichneNagel(s as integer, x as integer, y as integer, f as integer)
  if s = 0 then exit sub
  put (x, y), spieler(s).imgNagel(f), trans
end sub

sub zeichnePlanke(p as TPlanke, x as integer, y as integer, grau as integer = 0, img as FB.Image ptr = 0)
  if p.farbe(1) = 0 then exit sub
  put img, (x, y), imgPlanke, trans
  if p.farbe(1) < 0 then exit sub
  paint img, (x+4, y+1),                 FARBE(p.farbe(1), 1) and iif(grau, rgb(63, 63, 63), rgb(255, 255, 255)), &h7f7f7f
  paint img, (x+4, y+1+PLANKENBREITE),   FARBE(p.farbe(2), 1) and iif(grau, rgb(63, 63, 63), rgb(255, 255, 255)), &h7f7f7f
  paint img, (x+4, y+1+PLANKENBREITE*2), FARBE(p.farbe(3), 1) and iif(grau, rgb(63, 63, 63), rgb(255, 255, 255)), &h7f7f7f
end sub

function zugComputer(nr as integer, tiefe as integer) as TZug
  dim as TZug zug(299), besterZug
  dim as TPlanke leerePlanke, merkPlanke
  dim as integer anzahlZuege, wertAktuell, wertMax = WERT_MINIMAL, merkPlankennr
  if tiefe < 1 then
    besterZug.bewertung = bewertung(nr)
    besterZug.retvar = RETVAR.ok
    return besterZug
  end if
  
  ' Liste aller moeglichen Zuege zusammenstellen
  for p as integer = 1 to 23
    if planke(p).farbe(1) = -1 then
      ' neue Planke setzen
      for m as integer = 1 to 3
        if spieler(nr).anzPlanke(m) > 0 then
          zugComputerNagel(nr, zug(), anzahlZuege, TPlanke(((m+1) mod 3)+1, m, (m mod 3)+1), p)
          zugComputerNagel(nr, zug(), anzahlZuege, TPlanke((m mod 3)+1, m, ((m+1) mod 3)+1), p)
        end if
      next
    elseif planke(p).farbe(1) > 0 then
      ' bestehende Planke nutzen
      zugComputerNagel(nr, zug(), anzahlZuege, leerePlanke, p)
    end if
  next
  ' ggf. Reduktion der Berechungstiefe
  if anzahlZuege > REDUKTION then tiefe -= 1
  ' Zuege bewerten
  for i as integer = 0 to anzahlZuege-1
    zugDurchfuehren(nr, zug(i))
    wertAktuell = bewertung(nr)
    if wertAktuell <> WERT_SIEG then wertAktuell = -zugComputer((nr mod spielerzahl)+1, tiefe-1).bewertung
    if wertAktuell > wertMax then
      besterZug = zug(i)
      wertMax = wertAktuell
    end if
    zugDurchfuehren(nr, zug(i), -1)
  next
  besterZug.bewertung = wertMax
  return besterZug
end function

sub zugComputerNagel(nr as integer, zug() as TZug, byref anz as integer, byval planke_ as TPlanke, p as integer)
  dim as TPlanke tempPlanke
  if planke_.farbe(1) < 1 then tempPlanke = planke(p) else tempPlanke = planke_
  dim as TZug hilfszug
  hilfszug.planke = planke_
  hilfszug.plankenort = p
  if spieler(nr).anzNaegel = 0 then
    ' Nagel verschieben
    for i as integer = 1 to 23
      if planke(i).anzNaegel < 2 orelse i = p then continue for
      for j as integer = 1 to 3
        if planke(i).nagel(j) <> nr then continue for
        for k as integer = 1 to 3
          if tempPlanke.farbe(k) = planke(i).farbe(j) then
            if tempPlanke.nagel(k) <> 0 then continue for, for
            zug(anz).posStart = j
            zug(anz).posZiel  = k
            exit for
          end if
        next
        zug(anz).planke = planke_
        zug(anz).plankenort = p
        zug(anz).steinfarbe = planke(i).farbe(j)
        zug(anz).steinort = j
        anz += 1
      next
    next
  else
    ' neuen Nagel setzen
    for f as integer = 1 to 3
      if tempPlanke.nagel(f) <> 0 orelse spieler(nr).anzNagel(tempPlanke.farbe(f)) = 0 then continue for
      zug(anz) = hilfszug
      zug(anz).steinfarbe = tempPlanke.farbe(f)
      zug(anz).posZiel = f
      anz += 1
    next
  end if
end sub

sub zugDurchfuehren(nr as integer, zug as TZug, richtung as integer = 1)
  dim as TPlanke leerePlanke
  with zug
    if .plankenort = 0 or .posZiel = 0 then exit sub
    if richtung > 0 then
      ' Zug durchfuehren
      if .planke.farbe(1) > 0 then
        planke(.plankenort) = .planke
        spieler(nr).anzPlanke(.planke.farbe(2)) -= 1
        if .plankenort > 1 andalso planke(.plankenort-1).farbe(1) = 0 then
          planke(.plankenort-1).farbe(1) = -1
          planke(.plankenort-1).farbe(2) = -1
          planke(.plankenort-1).farbe(3) = -1
        end if
        if .plankenort < 23 andalso planke(.plankenort+1).farbe(1) = 0 then
          planke(.plankenort+1).farbe(1) = -1
          planke(.plankenort+1).farbe(2) = -1
          planke(.plankenort+1).farbe(3) = -1
        end if
      end if
      planke(.plankenort).nagel(.posZiel) = nr
      if .steinort = 0 then
        spieler(nr).anzNagel(.steinfarbe) -= 1
      else
        planke(.plankenort).nagel(.posStart) = 0
      end if
    else
      ' rueckgaengig machen
      if .planke.farbe(1) > 0 then
        planke(.plankenort).farbe(1) = -1
        planke(.plankenort).farbe(2) = -1
        planke(.plankenort).farbe(3) = -1
        spieler(nr).anzPlanke(.planke.farbe(2)) += 1
        if .plankenort > 1 andalso planke(.plankenort-1).farbe(1) = -1 then
          planke(.plankenort-1).farbe(1) = 0
          planke(.plankenort-1).farbe(2) = 0
          planke(.plankenort-1).farbe(3) = 0
        end if
        if .plankenort < 23 andalso planke(.plankenort+1).farbe(1) = -1 then
          planke(.plankenort+1).farbe(1) = 0
          planke(.plankenort+1).farbe(2) = 0
          planke(.plankenort+1).farbe(3) = 0
        end if
      end if
      planke(.plankenort).nagel(.posZiel) = 0
      if .steinort = 0 then
        spieler(nr).anzNagel(.steinfarbe) += 1
      else
        planke(.plankenort).nagel(.posStart) = nr
      end if
    end if
  end with
end sub

function zugMensch(nr as integer) as TZug
  dim as string taste
  dim as integer mx, my, mb, gezogen = 0
  dim as TZug zug
  dim as TKoordinaten drehKoord, plankKoord, nagelKoord
  do
    getmouse mx, my,, mb
    sleep 1
  loop until mb < 1
  do
    taste = inkey
    if taste = chr(255, 107) then
      zug.retvar = RETVAR.programmende
      return zug
    end if
    getmouse mx, my,, mb
    if mb = 1 then
      for i as integer = 1 to 6
        if spieler(nr).planke(i).farbe(1) <> 0 then
          drehKoord  = koordDrehen(nr, i)
          plankKoord = koordPlanke(nr, i)
          ' Hand-Planke drehen
          if innerhalb(mx, my, drehKoord.x, drehKoord.y, PLANKENBREITE\2, PLANKENBREITE\2) then
            swap spieler(nr).planke(i).farbe(1), spieler(nr).planke(i).farbe(3)
            zeichnePlanke spieler(nr).planke(i), plankKoord.x, plankKoord.y
            do
              getmouse mx, my,, mb
              sleep 1
            loop until mb < 1
            continue do
          end if
          ' Planke legen
          if gezogen = 0 andalso innerhalb(mx, my, plankKoord.x, plankKoord.y, PLANKENBREITE, PLANKENBREITE*3) then
            dim as FB.Image ptr img = imagecreate(PLANKENBREITE, PLANKENBREITE*3, &hff00ff)
            zeichnePlanke spieler(nr).planke(i), 0, 0,, img
            let (mx, my) = bewegeObjekt(img, plankKoord.x, plankKoord.y)
            imagedestroy img
            for k as integer = 1 to 23
              plankKoord = koordPlanke(k)
              if planke(k).farbe(1) = -1 andalso innerhalb(mx, my, _
                   plankKoord.x, plankKoord.y, PLANKENBREITE, PLANKENBREITE*3) then
                for f as integer = 1 to 3
                  planke(k).farbe(f) = spieler(nr).planke(i).farbe(f)
                  spieler(nr).planke(i).farbe(f) = 0
                  if k > 0  andalso planke(k-1).farbe(f) = 0 then planke(k-1).farbe(f) = -1
                  if k < 22 andalso planke(k+1).farbe(f) = 0 then planke(k+1).farbe(f) = -1
                next
                spieler(nr).anzPlanke(planke(k).farbe(2)) -= 1
                zeichneFeld
                gezogen = k
              end if 
            next
          end if
        end if
      next
      ' Nagel setzen
      for f as integer = 1 to 3
        for n as integer = 1 to 4
          if n > spieler(nr).anzNagel(f) then exit for
          nagelKoord = koordNagel(nr, f, n)
          if innerhalb(mx, my, nagelKoord.x, nagelKoord.y, PLANKENBREITE, PLANKENBREITE) then
            let (mx, my) = bewegeObjekt(spieler(nr).imgNagel(f), nagelKoord.x, nagelKoord.y)
            for k as integer = 1 to 23
              if gezogen > 0 andalso k <> gezogen then continue for
              plankKoord = koordPlanke(k)
              for i as integer = 1 to 3
                if planke(k).farbe(i) = f andalso planke(k).nagel(i) = 0 andalso _
                    innerhalb(mx, my, plankKoord.x, plankKoord.y, PLANKENBREITE, PLANKENBREITE) then
                  spieler(nr).anzNagel(f) -= 1
                  planke(k).nagel(i) = nr
                  gezogen = 99
                  zeichneFeld
                end if
                plankKoord.y += PLANKENBREITE
              next
            next
          end if
        next
      next
      ' Nagel verschieben
      if spieler(nr).anzNaegel = 0 then
        for p as integer = 1 to 23
          if planke(p).anzNaegel < 2 then continue for
          for f as integer = 1 to 3
            if planke(p).nagel(f) <> nr then continue for
            nagelKoord = koordNagel(p, f)
            if innerhalb(mx, my, nagelKoord.x, nagelKoord.y, PLANKENBREITE, PLANKENBREITE) then
              let (mx, my) = bewegeObjekt(spieler(nr).imgNagel(planke(p).farbe(f)), nagelKoord.x, nagelKoord.y)
              for k as integer = 1 to 23
                if gezogen > 0 andalso k <> gezogen then continue for
                plankKoord = koordPlanke(k)
                for i as integer = 1 to 3
                  if planke(k).farbe(i) = planke(p).farbe(f) andalso planke(k).nagel(i) = 0 andalso _
                      innerhalb(mx, my, plankKoord.x, plankKoord.y, PLANKENBREITE, PLANKENBREITE) then
                    planke(k).nagel(i) = planke(p).nagel(f)
                    planke(p).nagel(f) = 0
                    gezogen = 99
                    zeichneFeld
                  end if
                  plankKoord.y += PLANKENBREITE
                next
              next
            end if
          next
        next
      end if
    end if
    sleep 1
    if taste = chr(255, 107) then
      zug.retvar = RETVAR.programmende
      return zug
    end if
  loop until gezogen = 99
  zug.retvar = RETVAR.ok
  return zug
end function