// sucht mögliche Züge und legt sie in possibilities[] ab
function checkPossibilities(color)
{
  var Reihe, Spalte;
  var i, j, k;

  // Möglichkeiten resetten
  for (i = 0; i < 64; i++)
  {
    possibilities[i]['anzahl'] = 0;
    possibilities[i]['flips'] = '';
  }
  var flips = '';
  var anzahl = 0;

  // Farbe des Gegners
  var opponent = (color == 1) ? 2 : 1;

  // für jeden Chip derselben Farbe wird geprüft
  for (i = 0; i < 64; i++)
  {
    if (Spielfeld[i] == color)
    {
      Reihe = Math.floor(i/8);
      Spalte = i%8;

      // in derselben Reihe
      for (j = 0; j < 8; j++)
      {
        // dasselbe Feld und angrenzende Felder werden übersprungen
        if (j == Spalte || j == Spalte-1 || j == Spalte+1) continue;

        // wenn ein leeres Feld gefunden wurde
        if (Spielfeld[(Reihe*8+j)] == 0)
        {
          // für die Felder zwischen dem Stein und dem gefundenen leeren Feld
          if (Spalte > j)
          {
            for (k = 1; k < Spalte-j; k++)
            {
              if (Spielfeld[i-k] == opponent)
              {
                anzahl++;
                flips = flips.concat((i-k) + '|');
              }
              else
              {
                anzahl = 0;
                flips = '';
                break;
              }
            }
            possibilities[(Reihe*8+j)]['anzahl'] += anzahl;
            possibilities[(Reihe*8+j)]['flips'] = possibilities[(Reihe*8+j)]['flips'].concat(flips);
            anzahl = 0;
            flips = '';
          }
          else
          {
            for (k = 1; k < j-Spalte; k++)
            {
              if (Spielfeld[i+k] == opponent)
              {
                anzahl++;
                flips = flips.concat((i+k) + '|');
              }
              else
              {
                anzahl = 0;
                flips = '';
                break;
              }
            }
            possibilities[(Reihe*8+j)]['anzahl'] += anzahl;
            possibilities[(Reihe*8+j)]['flips'] = possibilities[(Reihe*8+j)]['flips'].concat(flips);
            anzahl = 0;
            flips = '';
          }
        }
      }
      
      // für jeden Chip derselben Spalte
      for (j = 0; j < 8; j++)
      {
        // dasselbe Feld und angrenzende Felder werden übersprungen
        if (j == Reihe || j == Reihe-1 || j == Reihe+1) continue;

        // wenn ein leeres Feld gefunden wurde
        if (Spielfeld[(j*8+Spalte)] == 0)
        {
          // für die Felder zwischen dem Stein und dem gefundenen leeren Feld
          if (Reihe > j)
          {
            for (k = 1; k < Reihe-j; k++)
            {
              if (Spielfeld[(i-k*8)] == opponent)
              {
                anzahl++;
                flips = flips.concat((i-k*8) + '|');
              }
              else
              {
                anzahl = 0;
                flips = '';
                break;
              }
            }
            possibilities[(j*8+Spalte)]['anzahl'] += anzahl;
            possibilities[(j*8+Spalte)]['flips'] = possibilities[(j*8+Spalte)]['flips'].concat(flips);
            anzahl = 0;
            flips = '';
          }
          else
          {
            for (k = 1; k < j-Reihe; k++)
            {
              if (Spielfeld[(i+k*8)] == opponent)
              {
                anzahl++;
                flips = flips.concat((i+k*8) + '|');
              }
              else
              {
                anzahl = 0;
                flips = '';
                break;
              }
            }
            possibilities[(j*8+Spalte)]['anzahl'] += anzahl;
            possibilities[(j*8+Spalte)]['flips'] = possibilities[(j*8+Spalte)]['flips'].concat(flips);
            anzahl = 0;
            flips = '';
          }
        }
      }

      
      for (j = 2; j < 8; j++)
      {
        // diagonal NW
        if (j <= Reihe && j <= Spalte && Spielfeld[(i-j*9)] == 0)
        {
          // für die Felder zwischen dem Stein und dem gefundenen leeren Feld
          for (k = 1; k < j; k++)
          {
            if (Spielfeld[(i-k*9)] == opponent)
            {
              anzahl++;
              flips = flips.concat((i-k*9) + '|');
            }
            else
            {
              anzahl = 0;
              flips = '';
              break;
            }
          }
          possibilities[(i-j*9)]['anzahl'] += anzahl;
          possibilities[(i-j*9)]['flips'] = possibilities[(i-j*9)]['flips'].concat(flips);
          anzahl = 0;
          flips = '';
        }

        // diagonal NO
        if (j <= Reihe && j < 8-Spalte && Spielfeld[(i-j*7)] == 0)
        {
          // für die Felder zwischen dem Stein und dem gefundenen leeren Feld
          for (k = 1; k < j; k++)
          {
            if (Spielfeld[i-k*7] == opponent)
            {
              anzahl++;
              flips = flips.concat((i-k*7) + '|');
            }
            else
            {
              anzahl = 0;
              flips = '';
              break;
            }
          }
          possibilities[(i-j*7)]['anzahl'] += anzahl;
          possibilities[(i-j*7)]['flips'] = possibilities[(i-j*7)]['flips'].concat(flips);
          anzahl = 0;
          flips = '';
        }

        // diagonal SW
        if ( j < 8-Reihe && j <= Spalte && Spielfeld[(i+j*7)] == 0)
        {
          // für die Felder zwischen dem Stein und dem gefundenen leeren Feld
          for (k = 1; k < j; k++)
          {
            if (Spielfeld[i+k*7] == opponent)
            {
              anzahl++;
              flips = flips.concat((i+k*7) + '|');
            }
            else
            {
              anzahl = 0;
              flips = '';
              break;
            }
          }
          possibilities[(i+j*7)]['anzahl'] += anzahl;
          possibilities[(i+j*7)]['flips'] = possibilities[(i+j*7)]['flips'].concat(flips);
          anzahl = 0;
          flips = '';
        }

        // diagonal SO
        if (j < 8-Reihe && j < 8-Spalte && Spielfeld[(i+j*9)] == 0)
        {
          // für die Felder zwischen dem Stein und dem gefundenen leeren Feld
          for (k = 1; k < j; k++)
          {
            if (Spielfeld[i+k*9] == opponent)
            {
              anzahl++;
              flips = flips.concat((i+k*9) + '|');
            }
            else
            {
              anzahl = 0;
              flips = '';
              break;
            }
          }
          possibilities[(i+j*9)]['anzahl'] += anzahl;
          possibilities[(i+j*9)]['flips'] = possibilities[(i+j*9)]['flips'].concat(flips);
          anzahl = 0;
          flips = '';
        }
      }
    }
  }
}