Buchempfehlung
Windows-Programmierung. Das Entwicklerhandbuch zur WIN32-API
Windows-Programmierung. Das Entwicklerhandbuch zur WIN32-API
"Der" Petzold, das über 1000 Seiten starke Standardwerk zum Win32-API - besonders nützlich u. a. bei der GUI-Programmierung in FreeBASIC! [Mehr Infos...]
FreeBASIC-Chat
Es sind Benutzer im FreeBASIC-Chat online.
(Stand:  )
FreeBASIC bei Twitter
Twitter FreeBASIC-Nachrichten jetzt auch über Twitter erhalten. Follow us!

fb:porticula NoPaste

Info
Info / Hilfe
Liste
Übersicht / Liste
Neu
Datei hochladen
Suche
Quellcode suchen
Download
Dateidownload

Statistik.bas

Uploader:MitgliedMuttonhead
Datum/Zeit:03.09.2015 08:04:36

'Spielfeld und Tripletts*******************************************************
'******************************************************************************
'Lage der Positionen
'   0-----------1-----------2
'   |           |           |
'   |   8-------9------10   |
'   |   |       |       |   |
'   |   |  16--17--18   |   |
'   |   |   |       |   |   |
'   7--15--23      19--11---3
'   |   |   |       |   |   |
'   |   |  22--21--20   |   |
'   |   |       |       |   |
'   |  14------13------12   |
'   |           |           |
'   6-----------5-----------4

'Lage der Tripletts (3 in einer Reihe)
'   o----------------0---o-------------------o
'   |                    |                   |
'   |                    |                   |
'   |                    |                   |
'   |     o----------4---o-------------o     |
'   |     |              |             |     |
'   |     |             12             |     |
'   |     |              |             |     |
'   |     |     o----8---o-------o     |     |
'   |     |     |                |     |     |
'   |     |     |                9     5     1
'   |     |     |                |     |     |
'   o-----o--15-o                o-13--o-----o
'   |     |     |                |     |     |
'   3     7    11                |     |     |
'   |     |     |                |     |     |
'   |     |     o--------o--10---o     |     |
'   |     |              |             |     |
'   |     |             14             |     |
'   |     |              |             |     |
'   |     o--------------o---6---------o     |
'   |                    |                   |
'   |                    |                   |
'   |                    |                   |
'   o--------------------o---2---------------o

'alle möglichen Stellungen innerhalb eines Tripletts
'1=weiss 2=schwarz 0=leer
'(im übrigen sieht das hier nach einem 3er Zahlensystem aus :) )
'0  1  2  0  1  2  0  1  2  0  1  2  0  1  2  0  1  2  0  1  2  0  1  2  0  1  2
'0  0  0  1  1  1  2  2  2  0  0  0  1  1  1  2  2  2  0  0  0  1  1  1  2  2  2
'0  0  0  0  0  0  0  0  0  1  1  1  1  1  1  1  1  1  2  2  2  2  2  2  2  2  2

'wenn man die Positionen vernachlässigt und nur die mengenmäßigen Anteile
'innerhalb eines Tripletts betrachtet dann reduziert sich das Ganze dann so:
'0  1  2  1  2  1  1  2  1  2
'0  0  0  1  2  2  1  2  1  2
'0  0  0  0  0  0  2  1  1  2

'letztlich in die Auswertung kamen nun folgende Triplett-Stellungen:

'NEUTRAL
'0-0-0  Triplett ist entweder unbesetzt oder mit je einem Stein beider Spieler besetzt
'1-2-0

'MEHRHEIT EINACH
'1-0-0  mit einem Stein belegt "schön das auch Sie sich in diesem Triplett zeigen wollen, viel Glück"
'2-0-0

'MEHRHEIT ZWEIFACH NEGATIV
'1-1-0  zwei Steine Mehrheit... jedoch der Gegner kann im nächsten Zug die Leerstelle besetzen
'2-2-0

'MEHRHEIT ZWEIFACH NEUTRAL
'1-1-0  zwei Steine Mehrheit... kein Spieler kann im nächsten Zug die Leerstelle besetzen
'2-2-0

'MEHRHEIT ZWEIFACH POSITIV
'1-1-0  zwei Steine Mehrheit... es besteht die Möglichkeit, wenn mann wieder am Zug ist, eine Mühle zu schliessen
'2-2-0

'MEHRHEIT ZWEIFACH GESCHLOSSEN
'1-1-2  zwei Steine Mehrheit... jedoch der Gegner ist mit an Board
'2-2-1

'GESCHLOSSENE MÜHLE
'1-1-1  die geschlossene Mühle als Stellung bietet in erster Linie "nur" Schutz
'2-2-2

'falls sich bei einer zweifachen Mehrheit die Leerstelle an den Positionen 9,11,13,15 befindet, kann es vorkommen,
'dass beide Spieler die Möglichkeit haben, die Leerstelle zu besetzen
'diese Konstellation wird 2x, gezählt, als MEHRHEIT ZWEIFACH POSITIV und MEHRHEIT ZWEIFACH NEGATIV

'******************************************************************************
'******************************************************************************
type brettposition
  farbe             as integer'0=kein Stein,1=weiss,2=schwarz
  link_pos(3)       as integer'enthält die Nachbar-Indizes für die 4 Zugrichtungen 0=hoch,1=rechts,2=unten,3=links
                              'enthält eine Richtung den Wert -1 ist ein Zug, vom Spielfeldlayout her gesehen, dorthin nicht möglich.
  link_tri(1)       as integer'enthält die Indizes der beiden Tripletts in denen sich diese Position befindet
end type


'ein Triplett ist eine Reihe von drei Brettpositionen die eine Mühle bilden können
type triplett
  link_pos(2)   as integer'enthält die Indizes der drei Brettpositionen, die eine Mühle bilden können
  orientierung  as integer'Orientierung des Tripletts 0=waagerecht,1=senkrecht
end type


type Statistik
  'Brettstruktur und Verknüpfungen
  Brett(23)             as Brettposition  'Spielfeld bestehend aus 24 Positionen
  Tripletts(15)         as Triplett       'alle im Spiel möglichen Tripletts (das sollten 16 sein ???)

  'statistische Erhebung
  'in 0/1  jeweils für weiss/schwarz
  Steine_Brett(1)    as integer'Anzahl Steine auf Brett
  Steine_Geschuetzt(1)as integer'Anzahl Steine in Mühlen geschützt
  Muehle(1)          as integer
  Neutral(1)         as integer
  Einfach(1)         as integer
  Zweifach_Negativ(1)as integer
  Zweifach_Neutral(1)as integer
  Zweifach_Positiv(1)as integer
  Zweifach_Geschl(1) as integer
  'da mitunter Zählen allein nicht reicht gibt es zusätzlich noch die Checkbits:
  'beispielsweise für jede gefundene geschlossene Mühle wird das entsprechende Bit(TriplettIndex=Bitnummer) in CheckBits eingeschaltet
  'Warum? Nun bei einer Zwickmühle bleibt die Anzahl der Mühlen gleich und trotzdem muß irgendwie festgestellt
  'werden DASS eine Mühle geschlossen wurde. Eine Lageveränderung bei den Mühlen schlägt sich in den Checkbits nieder
  'und kann in Kombination der Anzahl ausgewertet werden
  CheckBits_Muehle(1)as integer
  CheckBits_Steine(1) as integer'dient zum Ermitteln der Anzahl der geschützten Steine und vielleicht auch als LockTable mal sehen

  declare constructor
  declare destructor

  declare function GibAnzahlFarbe(TIndex as integer, SteinFarbe as integer) as integer
  declare function GibFreiePosition(TIndex as integer) as integer
  declare function KannLeerfeldBesetzen(PIndex as integer, TIndex as integer, SteinFarbe as integer) as integer

  declare function Pruefe_Auf_Muehle (TIndex as integer, SteinFarbe as integer) as integer
  declare function Pruefe_Auf_Neutral (TIndex as integer) as integer
  declare function Pruefe_Auf_Einfach (TIndex as integer, SteinFarbe as integer) as integer
  declare function Pruefe_Auf_Zweifach (TIndex as integer, SteinFarbe as integer) as integer
  declare function Pruefe_Auf_Zweifach_Negativ (TIndex as integer, SteinFarbe as integer) as integer
  declare function Pruefe_Auf_Zweifach_Neutral (TIndex as integer, SteinFarbe as integer) as integer
  declare function Pruefe_Auf_Zweifach_Positiv (TIndex as integer, SteinFarbe as integer) as integer
  declare function Pruefe_Auf_Zweifach_Geschl (TIndex as integer, SteinFarbe as integer) as integer

  declare sub Erstelle_Statistik
  declare sub Drucke_Statistik

  declare sub Bereinige_Alle_Daten
  declare sub Bereinige_Spielfeld
  declare sub Bereinige_Statistik
end type


constructor Statistik
  restore linkdata
  for i as integer=0 to 23
    read brett(i).link_pos(0)
    read brett(i).link_pos(1)
    read brett(i).link_pos(2)
    read brett(i).link_pos(3)

    read brett(i).link_tri(0)
    read brett(i).link_tri(1)
  next i

  restore triplettdata
  for i as integer=0 to 15
    read tripletts(i).link_pos(0)
    read tripletts(i).link_pos(1)
    read tripletts(i).link_pos(2)
    read tripletts(i).orientierung
  next i
end constructor


destructor Statistik
end destructor

'Grundsuchfunktionen in Tripletts***************
'gibt die Anzahl einer bestimmten Farbe innerhalb eines Tripletts zurück
function Statistik.GibAnzahlFarbe(TIndex as integer, SteinFarbe as integer) as integer
  dim as integer gefunden=0
  for i as integer=0 to 2
    if brett( tripletts(TIndex).link_pos(i) ).farbe=SteinFarbe then gefunden +=1
  next i
  function=gefunden
end function


'liefert den Index der einzigen freien Position eines Tripletts
'diese Funktion setzt voraus, dass im Vorfeld abgeklärt wurde ob und dass ein (und nur ein !!) Leerfeld im Triplett vorhanden ist
function Statistik.GibFreiePosition(TIndex as integer) as integer
  dim as integer gefunden=0
  for i as integer=0 to 2
    if brett( tripletts(TIndex).link_pos(i) ).farbe=0 then gefunden=tripletts(TIndex).link_pos(i)
  next i
  function=gefunden
end function


'liefert eine JA/NEIN Enscheidung ob ein Leerfeld eines Tripletts "von außen" mit der "Wunschfarbe" besetzt werden kann.
'hierzu ist nicht nur die Position des Leefeldes nötig, sondern auch das betreffende Triplett, da dessen
'Orientierung hier wichtig ist. Nur so kann man feststellen was "aussen" ist.
function Statistik.KannLeerfeldBesetzen(PIndex as integer, TIndex as integer, SteinFarbe as integer) as integer
  dim as integer gefunden,Orientierung,extPIndex
  Orientierung=tripletts(TIndex).orientierung
  gefunden=0
  'wenn Orientierung 0 dann Triplett waagerecht, dann werden nur die Nachbarn oben und unten (Index 0,2) überprüft
  'wenn Orientierung 1 dann Triplett senkrecht, dann werden nur die Nachbarn rechts und links (Index 1,3) überprüft
  for i as integer=0 to 2 step 2
    extPIndex=brett(PIndex).link_pos( Orientierung + i)
    if extPIndex<>-1 then'Prüfung nur wenn das Spielfeld in diese Richtung einen Nachbarn zulässt, sonst wäre dort eine -1
      if brett( extPIndex ).farbe = SteinFarbe then gefunden=1
    end if
  next i
  function=gefunden
end function

'folgende Funktionen prüfen ein Triplett auf eine entsprechende Stellung(bzw deren Vorstufe):
'alle Funktion liefern nur eine Ja/Nein
function Statistik.Pruefe_Auf_Muehle (TIndex as integer, SteinFarbe as integer) as integer
  function=0
  if (GibAnzahlFarbe(TIndex,SteinFarbe)=3) then function=1
end function


function Statistik.Pruefe_Auf_Neutral (TIndex as integer) as integer
  function=0
  if GibAnzahlFarbe(TIndex,0)=3 then function=1
  if (GibAnzahlFarbe(TIndex,0)=1) and (GibAnzahlFarbe(TIndex,1)=1) and (GibAnzahlFarbe(TIndex,2)=1) then function=1
end function


function Statistik.Pruefe_Auf_Einfach (TIndex as integer, SteinFarbe as integer) as integer
  function=0
  if (GibAnzahlFarbe(TIndex,0)=2) and (GibAnzahlFarbe(TIndex,SteinFarbe)=1) then function=1
end function

'Vorstufe für alle Zweifach Varianten... hier fehlt der Qualifier
function Statistik.Pruefe_Auf_Zweifach (TIndex as integer, SteinFarbe as integer) as integer
  function=0
  if (GibAnzahlFarbe(TIndex,0)=1) and (GibAnzahlFarbe(TIndex,SteinFarbe)=2) then function=1
end function


function Statistik.Pruefe_Auf_Zweifach_Negativ (TIndex as integer, SteinFarbe as integer) as integer
  function=0
  dim as integer FPIndex, GegnerFarbe
  if Pruefe_Auf_Zweifach(TIndex,SteinFarbe) then
    FPIndex=GibFreiePosition(TIndex)
    GegnerFarbe= iif(Steinfarbe=1,2,1)
    if (KannLeerfeldBesetzen(FPIndex,TIndex,GegnerFarbe)) then function=1
  end if
end function


function Statistik.Pruefe_Auf_Zweifach_Neutral (TIndex as integer, SteinFarbe as integer) as integer
  function=0
  dim as integer FPIndex
  if Pruefe_Auf_Zweifach(TIndex,SteinFarbe) then
    FPIndex=GibFreiePosition(TIndex)
    if (KannLeerfeldBesetzen(FPIndex,TIndex,1)=0) and (KannLeerfeldBesetzen(FPIndex,TIndex,2)=0) then function=1
  end if
end function


function Statistik.Pruefe_Auf_Zweifach_Positiv (TIndex as integer, SteinFarbe as integer) as integer
  function=0
  dim as integer FPIndex
  if Pruefe_Auf_Zweifach(TIndex,SteinFarbe) then
    FPIndex=GibFreiePosition(TIndex)
    if KannLeerfeldBesetzen(FPIndex,TIndex,SteinFarbe) then function=1
  end if
end function


function Statistik.Pruefe_Auf_Zweifach_Geschl (TIndex as integer, SteinFarbe as integer) as integer
  function=0
  dim as integer GegnerFarbe
  GegnerFarbe= iif(Steinfarbe=1,2,1)
  if (GibAnzahlFarbe(TIndex,Steinfarbe)=2) and (GibAnzahlFarbe(TIndex,GegnerFarbe)=1) then function=1
end function


sub Statistik.Erstelle_Statistik
  dim as integer farbe
  Bereinige_Statistik

  for fi as integer=0 to 1'beide Farben
    farbe=fi+1
    for ti as integer =0 to 15'alle Tripletts

      if Pruefe_Auf_Muehle(ti, farbe ) then
        'wenn ein Triplett eine geschlossene Mühle ist
        'dann alle Positionen des Tripletts im CheckBits_Steine entsprechend setzen
        for li as integer=0 to 2
          CheckBits_Steine(fi)= bitset( CheckBits_Steine(fi), Tripletts(ti).link_pos(li))
        next li

        Muehle(fi) +=1
        CheckBits_Muehle(fi)= bitset(CheckBits_Muehle(fi),ti)
      end if

      if Pruefe_Auf_Neutral (ti)                      then Neutral(fi) +=1
      if Pruefe_Auf_Einfach (ti, farbe)               then Einfach(fi) +=1
      if Pruefe_Auf_Zweifach_Negativ (ti, farbe )     then Zweifach_Negativ(fi) +=1
      if Pruefe_Auf_Zweifach_Neutral (ti, farbe )     then Zweifach_Neutral(fi) +=1
      if Pruefe_Auf_Zweifach_Positiv (ti, farbe )     then Zweifach_Positiv(fi) +=1
      if Pruefe_Auf_Zweifach_Geschl (ti, farbe ) then Zweifach_Geschl(fi) +=1
    next ti
  next fi

  for pi as integer=0 to 23
    'alle auf dem Brett befindlichen Steine zählen
    if brett(pi).farbe=1 then Steine_Brett(0) +=1'für weiss
    if brett(pi).farbe=2 then Steine_Brett(1) +=1'für schwarz
    'in Checkbits_Steine alle geschützte Steine zählen
    if bit(CheckBits_Steine(0),pi) then Steine_Geschuetzt(0) +=1'für weiss
    if bit(CheckBits_Steine(1),pi) then Steine_Geschuetzt(1) +=1'für schwarz
  next pi
end sub

sub Statistik.Drucke_Statistik
  locate (1,1)
  for i as integer=0 to 1
    print "auf Brett       :",Steine_Brett(i)
    print "geschuetzt      :",Steine_Geschuetzt(i)
    print
    print "zweifach positiv:",Zweifach_Positiv(i)
    print "zweifach neutral:",Zweifach_Neutral(i)
    print "Muehle          :",Muehle(i)
    print "zweifach negativ:",Zweifach_Negativ(i)
    print "zweifach geschl.:",Zweifach_Geschl(i)
    print "einfach         :",Einfach(i)
    print "neutral         :",Neutral(i)
    print:print
  next i
end sub


sub Statistik.Bereinige_Alle_Daten
  Bereinige_Spielfeld
  Bereinige_Statistik
end sub


sub Statistik.Bereinige_Spielfeld
  for pi as integer=0 to 23
    brett(pi).farbe=0
  next pi
end sub


sub Statistik.Bereinige_Statistik
  for fi as integer=0 to 1'beide Farben
    Steine_Brett(fi)        =0
    Steine_Geschuetzt(fi)   =0
    Muehle(fi)              =0
    Neutral(fi)             =0
    Einfach(fi)             =0
    Zweifach_Negativ(fi)    =0
    Zweifach_Neutral(fi)    =0
    Zweifach_Positiv(fi)    =0
    Zweifach_Geschl(fi)=0
    CheckBits_Muehle(fi)    =0
    CheckBits_Steine(fi)    =0
  next fi
end sub

'******************************************************************************
'******************************************************************************

linkdata:
'4xRichtungsIndex 2xTriplettIndex
'äusseres Viereck 0-7
data -1,1,7,-1     ,0,3
data -1,2,9,0      ,0,12
data -1,-1,3,1     ,1,0
data 2,-1,4,11     ,1,13
data 3,-1,-1,5     ,2,1
data 13,4,-1,6     ,2,14
data 7,5,-1,-1     ,3,2
data 0,15,6,-1     ,3,15
'mittleres Viereck 8-15
data -1,9,15,-1    ,4,7
data 1,10,17,8     ,4,12
data -1,-1,11,9    ,5,4
data 10,3,12,19    ,5,13
data 11,-1,-1,13   ,6,5
data 21,12,5,14    ,6,14
data 15,13,-1,-1   ,7,6
data 8,23,14,7     ,7,15
'inneres Viereck 16-23
data -1,17,23,-1   ,8,11
data 9,18,-1,16    ,8,12
data -1,-1,19,17   ,9,8
data 18,11,20,-1   ,9,13
data 19,-1,-1,21   ,10,9
data -1,20,13,22   ,10,14
data 23,21,-1,-1   ,11,10
data 16,-1,22,15   ,11,15

triplettdata:
'Positionen aller 16 Tripletts und deren Orientierungen
'äusseres Viereck
data 0,1,2       ,0
data 2,3,4       ,1
data 4,5,6       ,0
data 6,7,0       ,1
'mittleres Viereck
data 8,9,10      ,0
data 10,11,12    ,1
data 12,13,14    ,0
data 14,15,8     ,1
'inneres Viereck
data 16,17,18    ,0
data 18,19,20    ,1
data 20,21,22    ,0
data 22,23,16    ,1
'nach innen zeigende
data 1,9,17      ,1
data 3,11,19     ,0
data 5,13,21     ,1
data 7,15,23     ,0
'******************************************************************************
'******************************************************************************