private static bool WszystkiePrzylegleKomorkiSaWyzej(IKomorka komorka)
 {
     return komorka.PrzylegleKomorki.All(
                                      p => p.Dane.Brzeznosc == BrzeznoscKomorki.OtwartyLad
                                           && p.Punkt.Wysokosc > komorka.Punkt.Wysokosc
                                     );
 }
        private void PrzypiszKomorceBrzeznosc(IKomorka komorka)
        {
            switch (komorka.Dane.Typ)
             {
            case TypKomorki.Morze:
               if (komorka.PrzylegleKomorki.Any(
                  k => k.Dane.Typ == TypKomorki.Jezioro || k.Dane.Typ == TypKomorki.Lad
                  ))
                  komorka.Dane.Brzeznosc = BrzeznoscKomorki.MorzePrzybrzezne;
               else komorka.Dane.Brzeznosc = BrzeznoscKomorki.OtwarteMorze;
               break;

            case TypKomorki.Lad:
               if (komorka.PrzylegleKomorki.Any(
                  k => k.Dane.Typ == TypKomorki.Morze
                  ))
                  komorka.Dane.Brzeznosc = BrzeznoscKomorki.BrzegMorza;
               else
                  komorka.Dane.Brzeznosc = BrzeznoscKomorki.OtwartyLad;
               break;

            case TypKomorki.Jezioro:
               if (komorka.PrzylegleKomorki.Any(
                  k => k.Dane.Typ == TypKomorki.Morze)
                  )
                  throw new InvalidOperationException("Komórka jeziorna nie powinna s¹siadowaæ z morsk¹!");
               else
                  komorka.Dane.Brzeznosc = BrzeznoscKomorki.OtwartyLad;
               break;
            default:
               throw new InvalidOperationException("Komórce bez typu nie mo¿na przypisaæ brze¿noœci!");
             }
        }
 private void PrzypiszKomorceTyp(IKomorka komorka)
 {
     if (_zalane.Contains(komorka))
     komorka.Dane.Typ = TypKomorki.Morze;
      else if (komorka.Dane.Podloze == Podloze.Ziemia)
     komorka.Dane.Typ = TypKomorki.Lad;
      else if (komorka.Dane.Podloze == Podloze.Woda)
     komorka.Dane.Typ = TypKomorki.Jezioro;
 }
 private void DodajSasiadow(IKomorka aktualna)
 {
     foreach (IKomorka sasiad in aktualna.PrzylegleKomorki.Where(
     p => !_oczekujace.Contains(p) && !_odwiedzone.Contains(p)
     ))
      {
     UstawGlebokoscIDodajDoOczekujacychJesliTrzeba(sasiad, aktualna);
      }
 }
 private void Rozlewaj(IKomorka komorka)
 {
     _zalane.Add(komorka);
      foreach (var sasiad in komorka.PrzylegleKomorki)
      {
     if (sasiad.Dane.Podloze != Podloze.Woda || _zalane.Contains(sasiad))
        continue;
     Rozlewaj(sasiad);
      }
 }
        private void Odwiedz(IKomorka modyfikowana, IKomorka aktualna, int glebokosc)
        {
            float mnoznik = Mathf.Pow(MnoznikWartosci, glebokosc-1);
             float suma = 0f;
             if (aktualna.Dane.Typ == TypKomorki.Jezioro)
            suma += WartoscJeziora;
             if (aktualna.Dane.Typ == TypKomorki.Morze)
            suma += WartoscMorza;
             if (aktualna.Punkt.ZawieraRzeke || aktualna.Rogi.Any(r => r.Punkt.ZawieraRzeke))
            suma += WartoscRzeki;

             modyfikowana.Dane.Wilgotnosc
            += suma*mnoznik;

             _odwiedzone.Add(aktualna);
        }
        private void Odwiedz(IKomorka odwiedzana, IKomorka reprezentantGrupy)
        {
            _odwiedzone.Add(odwiedzana);

             if (reprezentantGrupy == null)
             {
            reprezentantGrupy = odwiedzana;
            _grupy.Add(reprezentantGrupy, new List<IPunkt>());
             }
            _grupy[reprezentantGrupy].Add(odwiedzana.Punkt);
             foreach (var rog in odwiedzana.Rogi)
             {
            if(!_grupy[reprezentantGrupy].Contains(rog.Punkt)
               && rog.Komorki.All(k=>k.Dane.Typ==TypKomorki.Jezioro))
               _grupy[reprezentantGrupy].Add(rog.Punkt);
             }

             IEnumerable<IKomorka> przylegle = JeziornePrzylegleKomorki(_komorkiJeziorne, odwiedzana).ToList();
             foreach (IKomorka przylegla in przylegle.Where(s => !_odwiedzone.Contains(s)))
             {
               Odwiedz(przylegla, reprezentantGrupy);
             }
        }
 public RozdzielaczMorzIJezior(IKomorka inicjator)
 {
     _inicjatorzyPowodzi = new IKomorka[]{inicjator};
 }
 private static bool LezyWNiecce(IKomorka komorka)
 {
     return komorka.Dane.Brzeznosc == BrzeznoscKomorki.OtwartyLad
                                &&
         ((komorka.Punkt.Nastepnik == null) || WszystkiePrzylegleKomorkiSaWyzej(komorka));
 }
 private void UstawGlebokoscIDodajDoOczekujacychJesliTrzeba(IKomorka sasiad, IKomorka aktualna)
 {
     _glebokosci[sasiad] = _glebokosci[aktualna] + 1;
      if (_glebokosci[sasiad] <= GlebokoscPrzeszukiwania)
      {
     _oczekujace.Add(sasiad);
      }
 }
 private IEnumerable<IKomorka> JeziornePrzylegleKomorki(
  IEnumerable<IKomorka> jeziorne, IKomorka komorka)
 {
     return komorka.PrzylegleKomorki.Where(s => jeziorne.Contains(s));
 }
Exemple #12
0
 public void DodajKomorki(IKomorka lewa, IKomorka prawa)
 {
     if (!Komorki.Contains(lewa))
      {
     Komorki.Add(lewa);
     Punkt.Sasiedzi.Add(lewa.Punkt);
      }
      if (!Komorki.Contains(prawa))
      {
     Komorki.Add(prawa);
     Punkt.Sasiedzi.Add(prawa.Punkt);
      }
 }
 private bool PrzylegaDoKomorkiLezacejNizejNicNiecka(IKomorka komorkaNiecka, IKomorka komorka)
 {
     return komorka.PrzylegleKomorki.Any(p => p.Punkt.Wysokosc < komorkaNiecka.Punkt.Wysokosc);
 }