Improve comments on bots.

2 files changed, 60 insertions, 69 deletions

diff --git a/src/miinaharava/bots/dssp.py b/src/miinaharava/bots/dssp.py
index 1307565..0cea6e7 100644
--- a/src/miinaharava/bots/dssp.py
+++ b/src/miinaharava/bots/dssp.py
@@ -1,21 +1,10 @@
 """ bots/dssp.py - päättelee kahden vierekkäisen laatan perusteella """
-from random import sample
+from random import choice
 
 from .simple import SimpleBot
 
 class DSSPBot(SimpleBot):
-    """ Kahta pistettä tutkiva tekoäly. Käyttää pohjana SipleBot tekoälyä """
-
-    def get_pairs(self):
-        """ Etsii kiinnostavien laattojen joukosta vierekkäiset """
-        tiles = list(self.get_interesting_tiles())
-        pairs = []
-        for i, tile1 in enumerate(tiles):
-            for _, tile2 in enumerate(tiles, i+1):
-                if self.are_neighbours(tile1,tile2):
-                    pairs.append((tile1,tile2))
-                    pairs.append((tile2,tile1))
-        return pairs
+    """ Kahden pisteen naapureita tutkiva tekoäly. Pohjana SipleBot tekoäly."""
 
     def search(self):
         """ Etsitään voiko viereisen numerolaatan osoittamat miinat ja
@@ -25,55 +14,54 @@ class DSSPBot(SimpleBot):
             return True
 
         for tile1, tile2 in self.get_pairs():
-            c1 = self.get_value(tile1)
-            c2 = self.get_value(tile2)
-            n1 = self.get_neighbours(tile1)
-            n2 = self.get_neighbours(tile2)
-            self.remove_known_safe_tiles(n1)
-            self.remove_known_safe_tiles(n2)
-            c1 -= self.remove_mine_tiles(n1)
-            c2 -= self.remove_mine_tiles(n2)
-
-            # otetaan vain alue1:n laatat pois vähennetään se pommeista
-            # näin tiedetään montako pommia on jäätävä yhteiselle alueelle
-            nc = n1 & n2
-            n1 = n1 - nc
-            n2 = n2 - nc
-            cc = c1 - len(n1)
-
-            # jos yhteiselle alueelle ei jääkkään pommeja
-            if cc < 1:
+            unknowns1, minecount1 = self.get_unknowns_and_minecount(tile1)
+            unknowns2, minecount2 = self.get_unknowns_and_minecount(tile2)
+            # Kun 1. alueen miinoista vähennetään vain 1. alueella olevat
+            # tuntemattomat laatat saadaan vähimmäismäärä miinoille yhteisellä
+            # alueella.
+            common_minecount = minecount1 - len(unknowns1-unknowns2)
+            # Turha jatkaa jos yhteiselle alueelle ei tarvitse asettaa miinoja.
+            if common_minecount < 1:
                 continue
-
-            # vähennetään yhteinen alue ja sen pommit alueesta 2
-            # jos jäljelle ei jää miinoja merkataan alueet seiffeiks
-            c2 -= cc
-
-            if c2 == 0:
-                self.safe_tiles |= n2
-
+            # Vähennetään yhteiset tuntemattomat 2. alueen tuntemattomista.
+            unknowns2 = unknowns2 - unknowns1
+            # Vähennetään 2. aluuen miinoista ne jotka on pakko sijoittaa
+            # yhteiselle alueella
+            minecount2 -= common_minecount
+            # Jos 2. alueelle ei jää yhtään miinaa tiedetään kaikki
+            # tuntemattomat siellä vapaiksi
+            if minecount2 == 0:
+                self.safe_tiles |= unknowns2
         return self.saved_hints()
 
+    def get_pairs(self):
+        """ Etsii kiinnostavien laattojen joukosta vierekkäiset """
+        tiles = list(self.get_interesting_tiles())
+        pairs = []
+        for i, tile1 in enumerate(tiles):
+            for _, tile2 in enumerate(tiles, i+1):
+                if self.are_neighbours(tile1,tile2):
+                    pairs.append((tile1,tile2))
+                    pairs.append((tile2,tile1))
+        return pairs
+
     def lucky_guess(self):
+        """ Tehdään arvaus kylmimpien laattojen joukosta """
         heatmap = dict.fromkeys(self.get_unknown_tiles(), float(0))
-        tiles = self.get_border_tiles()
-        for tile in tiles:
-            n = self.get_neighbours(tile)
-            c = self.get_value(tile) - self.remove_mine_tiles(n)
-            self.remove_known_safe_tiles(n)
-            for ntile in n:
-                heatmap[ntile] += c/len(n)
-
+        # Lisätään lämpöä viereisten tuntemattomien ja jäljellä olevien
+        # miinojen suhteen verran.
+        for tile in self.get_border_tiles():
+            unknowns, minecount = self.get_unknowns_and_minecount(tile)
+            for utile in unknowns:
+                heatmap[utile] += minecount/len(unknowns)
+        # Lisätään lämpöä keskimmäisiin laattoihin. Kulmat ei saa lämpöä.
         for tile in heatmap:
             if tile[0] in range(1,self.w-1):
                 heatmap[tile]+=0.005
             if tile[1] in range(1,self.h-1):
                 heatmap[tile]+=0.005
-
-        best = min((x for _, x in heatmap.items()))
-        best_tiles = [x for x,y in heatmap.items() if y == best]
-
-        if best_tiles:
-            self.safe_tiles.add(sample(best_tiles,1)[0])
-            return True
-        return False
+        # Etsitään kylmin arvo ja kylmimmät laatat ja arvotaan niistä yksi.
+        coolest_value = min((x for _, x in heatmap.items()))
+        coolest_tiles = [x for x,y in heatmap.items() if y == coolest_value]
+        self.safe_tiles.add(choice(coolest_tiles))
+        return True
diff --git a/src/miinaharava/bots/simple.py b/src/miinaharava/bots/simple.py
index 07ed954..c321bd9 100644
--- a/src/miinaharava/bots/simple.py
+++ b/src/miinaharava/bots/simple.py
@@ -1,5 +1,5 @@
 """ bots/simple.py - yksinkertainen botti joka etsii vain yhdeltä laatalta """
-from random import sample
+from random import choice
 
 from .bot import Bot
 
@@ -12,20 +12,23 @@ class SimpleBot(Bot):
         joko miinoja tai vapaita. Yhdistetään ne kyseisiin joukkoihin. """
         tiles = self.get_interesting_tiles()
         for tile in tiles:
-            c = self.get_value(tile)
-            nbrs = self.get_neighbours(tile)
-            self.remove_known_safe_tiles(nbrs)
-            c -= self.remove_mine_tiles(nbrs)
-            if c == 0:
-                self.safe_tiles |= nbrs
-            if c == len(nbrs):
-                self.mine_tiles |= nbrs
+            unknowns, minecount = self.get_unknowns_and_minecount(tile)
+            if minecount == 0:
+                self.safe_tiles |= unknowns
+            if minecount == len(unknowns):
+                self.mine_tiles |= unknowns
         return self.saved_hints()
 
+    def get_unknowns_and_minecount(self, tile):
+        """ Palauttaa tuntemattomat naapurit ja niissä olevien miinojen
+        määrän """
+        minecount = self.get_value(tile)
+        unknowns = self.get_neighbours(tile)
+        self.remove_known_safe_tiles(unknowns)
+        minecount -= self.remove_mine_tiles(unknowns)
+        return unknowns, minecount
+
     def lucky_guess(self):
         """ Arvotaan laatta tuntemattomista ja lisätään vapaiden joukkoon """
-        tiles = list(self.get_unknown_tiles())
-        if tiles:
-            self.safe_tiles.add(sample(tiles,1)[0])
-            return True
-        return False
+        self.safe_tiles.add(choice(list(self.get_unknown_tiles())))
+        return True