/// <summary>
    /// Rekursive Suchmethode einer einzelnen Kiste
    /// </summary>
    /// <param name="raum">Raum mit der einzelnen Kiste und Spielerstellung</param>
    /// <returns>Mindestzahl der Schritte zum Ziel (oder 60000 = wenn kein Ziel möglich)</returns>
    int RechneMindestZüge(SokowahnRaum raum)
    {
      List<List<SokowahnStellung>> list = new List<List<SokowahnStellung>>();
      list.Add(new List<SokowahnStellung>(raum.GetStellung().SelfEnumerable()));
      int listTiefe = 0;

      SokowahnHash_Index0 hash = new SokowahnHash_Index0();

      while (listTiefe < list.Count)
      {
        foreach (var stellung in list[listTiefe])
        {
          raum.LadeStellung(stellung);
          if (raumZiele[stellung.kistenZuRaum[0]]) return listTiefe;

          foreach (var variante in raum.GetVarianten())
          {
            int find = hash.Get(variante.crc64);
            if (find < 65535)
            {
              if (find <= variante.zugTiefe) continue;
              hash.Update(variante.crc64, variante.zugTiefe);
            }
            else
            {
              hash.Add(variante.crc64, variante.zugTiefe);
            }
            while (list.Count <= variante.zugTiefe)
            {
              list.Add(new List<SokowahnStellung>());
            }
            list[variante.zugTiefe].Add(variante);
          }
        }
        listTiefe++;
      }

      return 60000;
    }
예제 #2
0
    /// <summary>
    /// initialisiert die ersten Blocker-Kisten für den SammlerStart
    /// </summary>
    /// <param name="zielVariante">gibt an, ob nur Varianten ermittelt werden sollen, wo alle Kisten bereits auf dem Zielfeld stehen</param>
    void SammleKistenInit(bool zielVariante)
    {
      sammlerCheckKisten = Enumerable.Range(0, suchKistenAnzahl).Select(i => i).ToArray();
      sammlerCheckKisten[suchKistenAnzahl - 1]--; // letzte eins zurück setzen, damit beim ersten sammlerNext() auch die erste Variante gesetzt werden kann

      char[] feldData = basisRaum.FeldData;
      int feldBreite = basisRaum.FeldBreite;

      bool[] spielerRaum = SokowahnStaticTools.SpielfeldRaumScan(feldData, feldBreite);
      raumAnzahl = spielerRaum.Count(x => x);
      int[] raumZuFeld = Enumerable.Range(0, spielerRaum.Length).Where(i => spielerRaum[i]).ToArray();
      int[] feldZuRaum = Enumerable.Range(0, feldData.Length).Select(i => spielerRaum[i] ? raumZuFeld.ToList().IndexOf(i) : -1).ToArray();

      if (zielVariante)
      {
        sammlerCheckKistenRaum = raumZuFeld.Select(i => (feldData[i] == '.' || feldData[i] == '*' || feldData[i] == '+') ? feldZuRaum[i] : -1).Where(i => i >= 0).ToArray();
      }
      else
      {
        sammlerCheckKistenRaum = raumZuFeld.Select(i => (feldData[i] == '$' || feldData[i] == '*') ? feldZuRaum[i] : -1).Where(i => i >= 0).ToArray();
      }

      if (!zielVariante) // nur beim ersten mal Initialisieren
      {
        tmpRaum = new SokowahnRaum(feldData, feldBreite);
        tmpRaum.KistenAnzahl = suchKistenAnzahl;
        threadRäume = Enumerable.Range(0, 256).Select(i => new SokowahnRaum(tmpRaum)).ToArray();

        bekannteStellungen = new SokowahnHash_Index24Multi();

        prüfListe = new SokowahnLinearList2(suchKistenAnzahl + 1, Environment.CurrentDirectory + "\\temp\\", listeMax / 32768);
        prüfListeSammler = new SokowahnLinearList2(suchKistenAnzahl + 1, Environment.CurrentDirectory + "\\temp\\", listeMax / 32768);
        prüfListeGut = new SokowahnLinearList2(suchKistenAnzahl + 1, Environment.CurrentDirectory + "\\temp\\", listeMax / 32768);
        prüfListeBöse = new SokowahnLinearList2(suchKistenAnzahl + 1, Environment.CurrentDirectory + "\\temp\\", listeMax / 32768);
      }
    }
    /// <summary>
    /// Konstruktor
    /// </summary>
    /// <param name="spielFeld">Spielfeld als Textzeilen</param>
    public SokoWahn_5th(string spielFeld)
    {
      SokowahnStaticTools.SpielfeldEinlesen(spielFeld, out feldBreite, out feldHöhe, out feldSpielerStartPos, out feldData, out feldDataLeer);

      raumBasis = new SokowahnRaum(feldData, feldBreite);

      Directory.CreateDirectory(TempOrdner);

      // --- Vorwärtssuche initialisieren ---
      bekannteStellungen = new SokowahnHash_Index24Multi();
      bekannteStellungen.Add(raumBasis.Crc, 0);
      vorwärtsTiefe = 0;
      vorwärtsTiefeAktuell = 0;
      vorwärtsSucher = new SokowahnLinearList2[0];
      vorwärtsSucherPunkte = new Dictionary<int, int>[0];
      VorwärtsAdd(raumBasis.GetStellung(), new SokowahnPunkte());

      // --- Zielstellungen und Rückwärtssuche initialisieren ---
      zielStellungen = new SokowahnHash_Index24Multi();
      rückwärtsTiefe = 0;
      rückwärtsSucher = new SokowahnLinearList2[0];

      foreach (SokowahnStellung stellung in SokowahnStaticTools.SucheZielStellungen(raumBasis))
      {
        zielStellungen.Add(stellung.crc64, 60000);
        RückwärtsAdd(stellung);
      }

      ulong spielFeldCrc = Crc64.Start.Crc64Update(raumBasis.FeldBreite, raumBasis.FeldHöhe, raumBasis.FeldData);

      blocker = new SokowahnBlockerB2(Environment.CurrentDirectory + "\\temp\\blocker2_x" + spielFeldCrc.ToString("x").PadLeft(16, '0') + ".gz", raumBasis);
    }
예제 #4
0
    /// <summary>
    /// fügt eine Stellung in die Liste ein
    /// </summary>
    /// <param name="raum">Raum mit den entsprechenden Daten</param>
    public void Add(SokowahnRaum raum)
    {
      if (leseModus) throw new Exception("Fehler beim hinzufügen, Liste befindet siche bereits im Lese-Modus!");

      if (bufferPos == bufferGro)
      {
        if (bufferGro < bufferMax)
        {
          bufferGro = Math.Min(bufferGro * 2, bufferMax);
          Array.Resize(ref buffer, bufferGro * satzGröße);
        }
        else
        {
          TempSpeichern();
        }
      }

      int off = bufferPos * satzGröße;
      buffer[off] = (byte)raum.raumSpielerPos;
      for (int i = 1; i < satzGröße; i++) buffer[off + i] = (byte)raum.kistenZuRaum[i - 1];

      bufferPos++;
    }
예제 #5
0
 /// <summary>
 /// Konstruktor
 /// </summary>
 /// <param name="blockerDatei">Pfad zur Datei, worin sich eventuell archivierte Blocker-Daten befinden</param>
 /// <param name="basisRaum">Raum mit dem originalen Spielfeld</param>
 public SokowahnBlocker(string blockerDatei, SokowahnRaum basisRaum)
 {
   this.basisRaum = basisRaum;
   bekannteBlocker = new BlockerFeld[0];
   status = BlockerStatus.Init;
   suchKistenAnzahl = 0;
   this.blockerDatei = blockerDatei;
   if (File.Exists(blockerDatei))
   {
     LadeAlleBlocker();
   }
 }
예제 #6
0
    /// <summary>
    /// gibt eine bestimmte Stellung direkt als sichtbaren String aus (ohne die eigene Stellung zu beeinflussen)
    /// </summary>
    /// <param name="data">Stellungsdaten, welche ausgelesen werden sollen</param>
    /// <param name="offset">Startposition im Array</param>
    /// <returns>lesbare Stellung</returns>
    public string Debug(ushort[] data, int offset, int zugTiefe)
    {
      SokowahnRaum tmp = new SokowahnRaum(this);

      tmp.LadeStellung(data, offset, zugTiefe);

      return tmp.ToString();
    }
예제 #7
0
 /// <summary>
 /// Konstruktor
 /// </summary>
 /// <param name="blockerDatei">Pfad zur Datei, worin sich eventuell archivierte Blocker-Daten befinden</param>
 /// <param name="basisRaum">Raum mit dem originalen Spielfeld</param>
 public SokowahnBlockerB2(string blockerDatei, SokowahnRaum basisRaum)
 {
   this.basisRaum = basisRaum;
   this.blockerDatei = blockerDatei;
   this.blockerStatus = BlockerStatus.init;
   //if (file.exists(blockerdatei))
   //{
   //  ladealleblocker();
   //}
 }
예제 #8
0
  /// <summary>
  /// ermittelt alle möglichen Zielstellungen
  /// </summary>
  /// <param name="raumBasis">Raumsystem mit Basis-Stellung</param>
  /// <returns>Enumerable aller möglichen Zielstellungen</returns>
  public static IEnumerable<SokowahnStellung> SucheZielStellungen(SokowahnRaum raumBasis)
  {
   int feldBreite = raumBasis.FeldBreite;
   int feldHöhe = raumBasis.FeldHöhe;
   char[] feldData = raumBasis.FeldDataLeer.Select(c => c == '.' ? '*' : c).ToArray();

   for (int spielerY = 1; spielerY < feldHöhe - 1; spielerY++)
   {
    for (int spielerX = 1; spielerX < feldBreite - 1; spielerX++)
    {
     int pos = spielerX + spielerY * feldBreite;
     if (feldData[pos] == ' ' && (feldData[pos - 1] == '*' || feldData[pos + 1] == '*' || feldData[pos - feldBreite] == '*' || feldData[pos + feldBreite] == '*'))
     {
      feldData[pos] = '@';
      SokowahnRaum tmpRaum = new SokowahnRaum(feldData, feldBreite);
      tmpRaum.SpielerZugTiefe = 60000;

      var findStellungen = tmpRaum.GetVariantenRückwärts().ToArray();

      if (findStellungen.Length > 0)
      {
       yield return tmpRaum.GetStellung();
//       foreach (var findStellung in findStellungen) yield return findStellung;
      }

      feldData[pos] = ' ';
     }
    }
   }

   yield break;
  }
예제 #9
0
    /// <summary>
    /// ermittelt alle Zielstellungen, welche mit der entsprechenden Anzahl der Kisten erreichbar sind
    /// </summary>
    /// <returns>Enumerable aller möglichen Zielstellungen</returns>
    IEnumerable<SokowahnStellung> SammlerBerechneZielStellungen()
    {
      SokowahnRaum raum = new SokowahnRaum(basisRaum);
      raum.KistenAnzahl = sammlerKistenAnzahl;

      char[] feldData = basisRaum.FeldData;
      int feldBreite = basisRaum.FeldBreite;

      bool[] spielerRaum = SokowahnStaticTools.SpielfeldRaumScan(feldData, feldBreite);
      int[] raumZuFeld = Enumerable.Range(0, spielerRaum.Length).Where(i => spielerRaum[i]).ToArray();
      int[] feldZuRaum = Enumerable.Range(0, feldData.Length).Select(i => spielerRaum[i] ? raumZuFeld.ToList().IndexOf(i) : -1).ToArray();

      var sammlerKistenRaum = raumZuFeld.Select(i => (feldData[i] == '.' || feldData[i] == '*' || feldData[i] == '+') ? feldZuRaum[i] : -1).Where(i => i >= 0).ToArray();

      foreach (var variante in Tools.BerechneElementeVarianten(basisRaum.KistenAnzahl, sammlerKistenAnzahl, false))
      {
        raum.LadeStellung(variante, sammlerKistenRaum);
        foreach (var stellung in raum.GetVariantenBlockerZiele())
        {
          yield return stellung;
        }
      }
      yield break;
    }
예제 #10
0
 /// <summary>
 /// gibt die eigene Stellung als lesbares Feld zurück
 /// </summary>
 /// <param name="tmpRaum">Sokowahn-Raum mit den jeweiligen Grunddaten</param>
 /// <returns>lesbares Spielfeld</returns>
 public string Debug(SokowahnRaum raum)
 {
   SokowahnRaum temp = new SokowahnRaum(raum);
   temp.KistenAnzahl = kistenZuRaum.Length;
   return temp.Debug(this);
 }
예제 #11
0
 /// <summary>
 /// gibt die eigene Stellung als lesbares Feld zurück
 /// </summary>
 /// <param name="tmpRaum">Sokowahn-Raum mit den jeweiligen Grunddaten</param>
 /// <returns>lesbares Spielfeld</returns>
 public string ToString(SokowahnRaum raum)
 {
   return Debug(raum);
 }
예제 #12
0
 /// <summary>
 /// gibt die eigene Stellung als lesbares Feld zurück
 /// </summary>
 /// <param name="tmpRaum">Sokowahn-Raum mit den jeweiligen Grunddaten</param>
 /// <returns>lesbares Spielfeld</returns>
 public string Debug(SokowahnRaum raum)
 {
   return raum.Debug(this);
 }
예제 #13
0
    /// <summary>
    /// Konstruktor
    /// </summary>
    /// <param name="raum">Basisdaten anhand eines vorhanden Raumes nutzen</param>
    /// <param name="blocker">bekannte Blocker</param>
    /// <param name="startHash">bekannte Einträge in der Start-Hashtable</param>
    /// <param name="zielHash">bekannte Einträge in der Ziel-Hashtable</param>
    public SokowahnRaum(SokowahnRaum raum, ISokowahnBlocker blocker, ISokowahnHash startHash, ISokowahnHash zielHash)
    {
      this.feldData = raum.feldData;
      this.feldBreite = raum.feldBreite;
      this.raumAnzahl = raum.raumAnzahl;
      this.raumLinks = raum.raumLinks;
      this.raumRechts = raum.raumRechts;
      this.raumOben = raum.raumOben;
      this.raumUnten = raum.raumUnten;

      this.raumSpielerPos = raum.raumSpielerPos;
      this.spielerZugTiefe = raum.spielerZugTiefe;
      this.raumZuKisten = raum.raumZuKisten.ToArray(); // Kopie erstellen
      this.kistenAnzahl = raum.kistenAnzahl;
      this.kistenZuRaum = raum.kistenZuRaum.ToArray(); // Kopie erstellen

      this.tmpCheckRaumPosis = new int[raumAnzahl];
      this.tmpCheckRaumTiefe = new int[raumAnzahl];
      this.tmpRaumCheckFertig = new bool[raumAnzahl + 1];
      this.tmpRaumCheckFertig[raumAnzahl] = true; // Ende-Feld schon auf fertig setzen

      this.merkBlocker = blocker;
      this.merkStartHash = startHash;
      this.merkZielHash = zielHash;
    }
예제 #14
0
    /// <summary>
    /// Konstruktor
    /// </summary>
    /// <param name="raum">Basisdaten anhand eines vorhanden Raumes nutzen</param>
    public SokowahnRaum(SokowahnRaum raum)
    {
      this.feldData = raum.feldData;
      this.feldBreite = raum.feldBreite;
      this.raumAnzahl = raum.raumAnzahl;
      this.raumLinks = raum.raumLinks;
      this.raumRechts = raum.raumRechts;
      this.raumOben = raum.raumOben;
      this.raumUnten = raum.raumUnten;

      this.raumSpielerPos = raum.raumSpielerPos;
      this.spielerZugTiefe = raum.spielerZugTiefe;
      this.raumZuKisten = raum.raumZuKisten.ToArray(); // Kopie erstellen
      this.kistenAnzahl = raum.kistenAnzahl;
      this.kistenZuRaum = raum.kistenZuRaum.ToArray(); // Kopie erstellen

      this.tmpCheckRaumPosis = new int[raumAnzahl];
      this.tmpCheckRaumTiefe = new int[raumAnzahl];
      this.tmpRaumCheckFertig = new bool[raumAnzahl + 1];
      this.tmpRaumCheckFertig[raumAnzahl] = true; // Ende-Feld schon auf fertig setzen
    }
    /// <summary>
    /// berechnet die Anzahl der Schritte um eine einzelne Kiste zum Ziel zu bewegen
    /// </summary>
    /// <param name="raum">Raum mit der einzelnen Kiste</param>
    /// <returns>Mindestzahl der Schritte zum Ziel (oder 60000 = wenn kein Ziel möglich)</returns>
    int RechneMinZügeKiste(SokowahnRaum raum)
    {
      var varianten = raum.GetVariantenBlockerZiele().ToArray();

      int mindest = 60000;

      foreach (var variante in varianten)
      {
        raum.LadeStellung(variante);
        raum.spielerZugTiefe = 0;

        int i = RechneMindestZüge(raum);

        if (i < mindest) mindest = i;
      }

      return mindest;
    }
예제 #16
0
    /// <summary>
    /// berechnet die nächsten Blocker
    /// </summary>
    /// <param name="limit">maximale Anzahl der Berechnungen, oder 0, wenn die Berechnung beendet werden soll</param>
    /// <returns>true, wenn noch weitere Berechnungen anstehen</returns>
    public bool Next(int limit)
    {
      switch (blockerStatus)
      {
        #region # case BlockerStatus.init:
        case BlockerStatus.init:
        {
          sammlerKistenAnzahl++;
          if (sammlerKistenAnzahl == basisRaum.KistenAnzahl)
          {
            Abbruch();
            return false;
          }

          sammlerAbfrage = SammlerBerechneZielStellungen().GetEnumerator();
          sammlerHash = new SokowahnHash_Index16Multi();
          sammlerStats = new long[60001];
          rückwärtsSucher = Enumerable.Range(0, maxVorschau).Select(x => new SokowahnLinearList2(sammlerKistenAnzahl + 1, Environment.CurrentDirectory + "\\temp\\", multi32k)).ToArray();
          rückwärtsTiefe = 0;

          alleStellungen = new SokowahnLinearList2(sammlerKistenAnzahl + 1, Environment.CurrentDirectory + "\\temp\\", multi32k * 4);
          alleBlockerHash = new HashSet<ulong>();

          char[] feldData = basisRaum.FeldData;
          int feldBreite = basisRaum.FeldBreite;

          bool[] spielerRaum = SokowahnStaticTools.SpielfeldRaumScan(feldData, feldBreite);
          raumAnzahl = spielerRaum.Count(x => x);

          tempBlocker = new SokowahnBlockerB.BlockerFeld[raumAnzahl];
          for (int i = 0; i < tempBlocker.Length; i++) tempBlocker[i].kistenNummerLeer = sammlerKistenAnzahl;

          blockerStatus = BlockerStatus.sammleZiele;
          return true;
        }
        #endregion

        #region # case BlockerStatus.sammleZiele:
        case BlockerStatus.sammleZiele:
        {
          while (limit-- > 0 && sammlerAbfrage.MoveNext())
          {
            var satz = sammlerAbfrage.Current;
            if (sammlerHash.Get(satz.crc64) == 65535)
            {
              sammlerHash.Add(satz.crc64, 60000);
              sammlerStats[60000]++;
              rückwärtsSucher[0].Add(satz.raumSpielerPos, satz.kistenZuRaum);
              alleStellungen.Add(satz.raumSpielerPos, satz.kistenZuRaum);
            }
          }

          if (limit >= 0)
          {
            tempRaum = new SokowahnRaum(basisRaum);
            tempRaum.KistenAnzahl = sammlerKistenAnzahl;
            threadRäume = Enumerable.Range(0, 256).Select(i => new SokowahnRaum(tempRaum)).ToArray();
            blockerStatus = BlockerStatus.suchModus;
          }

          return true;
        }
        #endregion

        #region # case BlockerStatus.suchModus:
        case BlockerStatus.suchModus:
        {
          if (SucheRückwärts(limit)) return true;

          Array.Resize(ref bekannteBlockerHashes, sammlerKistenAnzahl);
          bekannteBlockerHashes[sammlerKistenAnzahl - 1] = sammlerHash;
          Array.Resize(ref bekannteSammlerStats, sammlerKistenAnzahl);
          var tmp = sammlerStats.Reverse().ToList();
          while (tmp[tmp.Count - 1] == 0) tmp.RemoveAt(tmp.Count - 1);
          bekannteSammlerStats[sammlerKistenAnzahl - 1] = tmp.ToArray();
          for (int i = 0; i < rückwärtsSucher.Length; i++) rückwärtsSucher[i].Dispose();
          blockerStatus = BlockerStatus.blockerSuche;

          return true;
        }
        #endregion

        #region # case BlockerStatus.blockerSuche:
        case BlockerStatus.blockerSuche:
        {
          limit = (int)Math.Min((long)limit, alleStellungen.SatzAnzahl);

          if (limit == 0)
          {
            int startPos = bekannteBlocker.Length;
            Array.Resize(ref bekannteBlocker, startPos + raumAnzahl);
            for (int i = 0; i < raumAnzahl; i++) bekannteBlocker[startPos + i] = tempBlocker[i];

            for (int i = 0; i < bekannteBlocker.Length; i++)
            {
              bekannteBlocker[i].geprüfteStellungen = sammlerHash.HashAnzahl;
              bekannteBlocker[i].kistenNummerLeer = sammlerKistenAnzahl + 1;
            }

            long geprüfteStellungenGesamt = 0;
            for (int i = 0; i < bekannteBlocker.Length; i += raumAnzahl) geprüfteStellungenGesamt += bekannteBlocker[i].geprüfteStellungen;
            for (int i = 0; i < bekannteBlocker.Length; i++) bekannteBlocker[i].Sortieren();

            blockerStatus = BlockerStatus.init;
            return true;
          }

          var stellungen = alleStellungen.Pop(limit);
          int satzGröße = alleStellungen.SatzGröße;

          var ergebnisse = Enumerable.Range(0, limit)
#if !parallelDeaktivieren
.AsParallel()
#if parallelGeordnet
.AsOrdered()
#endif
#endif
.SelectMany(stellung =>
          {
            SokowahnRaum raum = threadRäume[Thread.CurrentThread.ManagedThreadId];
            raum.LadeStellung(stellungen, stellung * satzGröße, 0);
            //            return raum.GetVarianten(this).Where(x => sammlerHash.Get(x.crc64) == 65535);
            var ausgabe = raum.GetVarianten(this).Where(x =>
              {
                if (sammlerHash.Get(x.crc64) == 65535) return true;
                x.zugTiefe = 60000 - sammlerHash.Get(x.crc64);
                //string dbg = x.Debug(basisRaum);
                return false;
              }
              );
            return ausgabe;
          }).ToArray();

          foreach (var stellung in ergebnisse)
          {
            if (alleBlockerHash.Contains(stellung.crc64)) continue;
            alleBlockerHash.Add(stellung.crc64);
            tempBlocker[stellung.raumSpielerPos].Add(stellung.kistenZuRaum, sammlerKistenAnzahl);
          }

          return true;
        }
        #endregion

        #region # case BlockerStatus.bereit:
        case BlockerStatus.bereit:
        {
          return false;
        }
        #endregion

        default: throw new NotImplementedException();
      }
    }
    /// <summary>
    /// Normale Suche nach vorne (von der Startstellung aus beginnend)
    /// </summary>
    /// <param name="limit">maximale Anzahl der Rechenschritte</param>
    /// <returns>true, wenn noch weitere Berechnungen anstehen</returns>
    bool SucheVorwärts(int limit)
    {
      if (limit == 0)
      {
        vorwärtsTiefeAktuell = vorwärtsTiefe;
        return true;
      }

      if (vorwärtsTiefe >= vorwärtsSucher.Length) return false;

      if (limit > 1111100000)
      {
        maxZüge = limit - 1111100000 + 1;
        for (int i = maxZüge; i < vorwärtsSucher.Length; i++)
        {
          vorwärtsSucher[i].Dispose();
          vorwärtsSucher[i] = null;
          vorwärtsSucherPunkte[i].Clear();
          vorwärtsSucherPunkte[i] = null;
        }
        Array.Resize(ref vorwärtsSucher, Math.Min(vorwärtsSucher.Length, maxZüge));
        Array.Resize(ref vorwärtsSucherPunkte, vorwärtsSucher.Length);
        MessageBox.Show("Maxzüge gesetzt auf: " + (maxZüge - 1));
        vorwärtsTiefeAktuell = vorwärtsTiefe;
        return true;
      }

      bool schnell = limit >= 100000;

      var liste = vorwärtsSucher[vorwärtsTiefeAktuell];
      var listePunkte = vorwärtsSucherPunkte[vorwärtsTiefeAktuell];

      //if (liste.SatzAnzahl * 2L > (long)limit)
      //{
      //  if (liste.SatzAnzahl < (long)limit * 10L)
      //  {
      //    limit = (int)(liste.SatzAnzahl / 2L);
      //  }
      //}

      limit = (int)Math.Min((long)limit, liste.SatzAnzahl);

      #region # // --- raumPool abfragen bzw. erstellen ---
      if (raumPool == null)
      {
        raumPool = Enumerable.Range(0, 256).Select(x => new SokowahnRaum(raumBasis, blocker, bekannteStellungen, zielStellungen)).ToArray();

        SokowahnRaum r = new SokowahnRaum(raumPool[0]);

        r.KistenAnzahl = 1;

        int[] kistePos = new int[1];
        int[] kisteIndex = new int[1];
        int raumAnzahl = r.RaumAnzahl;
        einzelKistenDauer = new int[raumAnzahl];

        char[] feldLeer = raumPool[0].FeldDataLeer;
        bool[] spielerRaum = SokowahnStaticTools.SpielfeldRaumScan(feldData, feldBreite);
        int[] raumZuFeld = Enumerable.Range(0, spielerRaum.Length).Where(i => spielerRaum[i]).ToArray();
        raumZiele = new bool[raumAnzahl];
        for (int i = 0; i < raumAnzahl; i++) raumZiele[i] = feldLeer[raumZuFeld[i]] == '.';

        for (int k = 0; k < raumAnzahl; k++)
        {
          kistePos[0] = k;
          r.LadeStellung(kisteIndex, kistePos);
          einzelKistenDauer[k] = RechneMinZügeKiste(r);
        }

        laufFelder = new ushort[raumAnzahl * raumAnzahl];

        ushort[] laufPosis = new ushort[raumAnzahl + 1];
        for (int y = 0; y < laufFelder.Length; y += raumAnzahl)
        {
          int pp = 0;
          laufPosis[pp++] = (ushort)(y / raumAnzahl);
          for (int x = 0; x < raumAnzahl; x++)
          {
            if (x > pp) throw new Exception("Fatal!");
            ushort p = laufPosis[x];
            laufFelder[y + x] = p;
            if ((laufPosis[pp] = (ushort)r.raumOben[p]) < raumAnzahl && !laufPosis.Take(pp).Any(i => i == laufPosis[pp])) pp++;
            if ((laufPosis[pp] = (ushort)r.raumRechts[p]) < raumAnzahl && !laufPosis.Take(pp).Any(i => i == laufPosis[pp])) pp++;
            if ((laufPosis[pp] = (ushort)r.raumUnten[p]) < raumAnzahl && !laufPosis.Take(pp).Any(i => i == laufPosis[pp])) pp++;
            if ((laufPosis[pp] = (ushort)r.raumLinks[p]) < raumAnzahl && !laufPosis.Take(pp).Any(i => i == laufPosis[pp])) pp++;
          }
        }

      }

      #endregion

      #region # // --- Teilliste mit den besten Stellungen erzeugen (falls notwendig) ---
      if (liste.SatzAnzahl > limit)
      {
        int punkteOk = 0;
        int findAnzahl = 0;
        int gutDazu = 0;
        foreach (var satz in listePunkte.OrderBy(x => x.Key))
        {
          punkteOk = satz.Key;
          findAnzahl += satz.Value;
          if (findAnzahl >= limit)
          {
            gutDazu = limit - (findAnzahl - satz.Value);
            break;
          }
        }

        var listeOk = new SokowahnLinearList2(raumBasis.KistenAnzahl + 1 + 2, TempOrdner);
        var listeAufheben = new SokowahnLinearList2(raumBasis.KistenAnzahl + 1 + 2, TempOrdner);

        long bis = liste.SatzAnzahl;
        for (long i = 0; i < bis; i++)
        {
          var stellung = liste.Pop();
          SokowahnPunkte punkte = new SokowahnPunkte(stellung);
          if (punkte.tiefeMax <= punkteOk)
          {
            if (punkte.tiefeMax == punkteOk)
            {
              if (gutDazu > 0)
              {
                gutDazu--;
              }
              else
              {
                listeAufheben.Add(stellung);
                continue;
              }
            }
            listeOk.Add(stellung);
            if (listeOk.SatzAnzahl == limit) break;
          }
          else
          {
            listeAufheben.Add(stellung);
          }
        }

        if (liste.SatzAnzahl < listeAufheben.SatzAnzahl)
        {
          bis = liste.SatzAnzahl;
          for (long i = 0; i < bis; i++) listeAufheben.Add(liste.Pop());
          vorwärtsSucher[vorwärtsTiefeAktuell] = listeAufheben;
          liste.Dispose();
        }
        else
        {
          bis = listeAufheben.SatzAnzahl;
          for (long i = 0; i < bis; i++) liste.Add(listeAufheben.Pop());
          listeAufheben.Dispose();
        }

        liste = listeOk;
      }

#if DEBUG
      if (limit != liste.SatzAnzahl) throw new Exception("aua?");
#endif
      #endregion

      SokowahnRaum raum = raumPool[Thread.CurrentThread.ManagedThreadId];

      int mx = maxZüge - rückwärtsTiefe;
      var ergebnisse = Enumerable.Range(0, limit).Select(i => liste.Pop()).SelectMany(stellung =>
      {
        raum.LadeStellung(stellung, vorwärtsTiefeAktuell);
        SokowahnPunkte punkte = new SokowahnPunkte(stellung);

        listePunkte[punkte.tiefeMax]--;
        if (bekannteStellungen.Get(raum.Crc) < vorwärtsTiefeAktuell) return Enumerable.Empty<SokowahnStellungRun>();

        return raum.GetVariantenRun().Where(v => v.zugTiefe <= mx && v.zugTiefe < bekannteStellungen.Get(v.crc64));
      }).ToArray();

#if !parallelDeaktivieren
      var punkteListe = new SokowahnPunkte[ergebnisse.Length];

      if (schnell)
      {
        ParallelEnumerable.Range(0, ergebnisse.Length).Select(v =>
        {
          SokowahnRaum r = raumPool[Thread.CurrentThread.ManagedThreadId];
          r.LadeStellung(ergebnisse[v]);
          punkteListe[v] = r.BerechnePunkte2(einzelKistenDauer, laufFelder);
          //punkteListe[v] = r.BerechnePunkteSchnell(einzelKistenDauer);
          return true;
        }).Count();
      }
      else
      {
        ParallelEnumerable.Range(0, ergebnisse.Length).Select(v =>
        {
          SokowahnRaum r = raumPool[Thread.CurrentThread.ManagedThreadId];
          r.LadeStellung(ergebnisse[v]);
          punkteListe[v] = r.BerechnePunkte(einzelKistenDauer);
          return true;
        }).Count();
      }
#endif

      for (int v = 0; v < ergebnisse.Length; v++)
      {
        var variante = ergebnisse[v];
        int findQuelle = bekannteStellungen.Get(variante.crc64);

#if parallelDeaktivieren
        raum.LadeStellung(variante);
        //        SokowahnPunkte punkte = raum.BerechnePunkte(einzelKistenDauer);
        SokowahnPunkte punkte = raum.BerechnePunkte2(einzelKistenDauer, laufFelder);
        //        SokowahnPunkte punkte = raum.BerechnePunkte3(einzelKistenDauer, laufFelder);
#else
        var punkte = punkteListe[v];
#endif

        if (variante.zugTiefe < findQuelle) // neue Stellung oder bessere Variante gefunden
        {
          int findZiel = zielStellungen.Get(variante.crc64);
          if (findZiel < 65535)
          {
            if (variante.zugTiefe + 60000 - findZiel < maxZüge)
            {
              #region // --- neue (bessere) Variante gefunden ---
              maxZüge = variante.zugTiefe + 60000 - findZiel;
              //gefundenCrc = variante.crc64;

              for (int i = maxZüge; i < vorwärtsSucher.Length; i++)
              {
                vorwärtsSucher[i].Dispose();
                vorwärtsSucher[i] = null;
                vorwärtsSucherPunkte[i].Clear();
                vorwärtsSucherPunkte[i] = null;
              }
              if (maxZüge < vorwärtsSucher.Length)
              {
                Array.Resize(ref vorwärtsSucher, maxZüge);
                Array.Resize(ref vorwärtsSucherPunkte, maxZüge);
              }
              #endregion
            }
            continue;
          }
          //if (punkte.tiefeMin + variante.zugTiefe < maxZüge)
          //if (variante.zugTiefe + rückwärtsTiefe < maxZüge)
          if (variante.zugTiefe + rückwärtsTiefe < maxZüge && punkte.tiefeMin + variante.zugTiefe < maxZüge)
          {
            if (findQuelle < 65535) bekannteStellungen.Update(variante.crc64, variante.zugTiefe); else bekannteStellungen.Add(variante.crc64, variante.zugTiefe);
            VorwärtsAdd(variante, punkte);
          }
        }
      }

      vorwärtsTiefeAktuell++;

      while (vorwärtsTiefe < vorwärtsSucher.Length && vorwärtsSucher[vorwärtsTiefe].SatzAnzahl == 0)
      {
        vorwärtsTiefe++;
        vorwärtsTiefeAktuell = vorwärtsTiefe;
      }

      if (vorwärtsTiefeAktuell == vorwärtsSucher.Length)
      {
        vorwärtsTiefeAktuell = vorwärtsTiefe;
      }

      return true;
    }
예제 #18
0
    /// <summary>
    /// gibt eine bestimmte Stellung direkt als sichtbaren String aus (ohne die eigene Stellung zu beeinflussen)
    /// </summary>
    /// <param name="data">Stellungsdaten, welche ausgelesen werden sollen</param>
    /// <param name="offset">Startposition im Array</param>
    /// <returns>lesbare Stellung</returns>
    public string Debug(byte[] data, int offset)
    {
      SokowahnRaum tmp = new SokowahnRaum(this);

      tmp.LadeStellung(data, offset, 0);

      return tmp.ToString();
    }