From e591d15abc4943a74c39f0fcab065213828a1514 Mon Sep 17 00:00:00 2001
From: Aineopintojen-harjoitustyo-Algoritmit-j <github-hy-tiralabra@v.hix.fi>
Date: Mon, 29 Jan 2024 02:34:32 +0200
Subject: Updating too much. Renewed bots and tui.

---
 bots/bot.py | 133 ++++++++++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 117 insertions(+), 16 deletions(-)

(limited to 'bots/bot.py')

diff --git a/bots/bot.py b/bots/bot.py
index 5ad0bd2..49bd962 100644
--- a/bots/bot.py
+++ b/bots/bot.py
@@ -1,32 +1,133 @@
 """ bots/bot.py - bottien kantaisä """
 from tui import Action
+from board import Tile
 
 class Bot():
     """ Bot - perusluokka perittäväksi """
     def __init__(self, **opts):
         self.uncertain = opts['uncertain'] if 'uncertain' in opts else False
-        self.hints = 0
+        self.safe_tiles = set()
+        self.bomb_tiles = set()
+        self.matrix = []
+        self.w = 0
+        self.h = 0
 
-    def neighbours(self,dx,dy,x,y):
-        """ palauttaa listana viereiset koordinaatit """
+    def search(self):
+        """ search - etsii pommeja tai vapaita ko joukkoihin """
+        return False
+
+    def lucky_guess(self):
+        """ lucky_guess - lisää yhden arvatun vapaan vapaiden joukkoon """
+        return Action.NOOP, 0, 0
+
+    def get_hint_from_list(self):
+        """ palauttaa vihjeen suoraan listalta """
+        if self.safe_tiles:
+            x, y = self.safe_tiles.pop()
+            return Action.SAFE, x, y
+        if self.bomb_tiles:
+            x, y = self.bomb_tiles.pop()
+            return Action.BOMB, x, y
+        return Action.NOOP, 0, 0
+
+    def saved_hints(self):
+        """ onko muuveja varastossa """
+        return self.safe_tiles or self.bomb_tiles
+
+    def hint(self, matrix, cursor_x, cursor_y):
+        """ antaa vinkin. tässä tapauksessa ei mitään """
+        self.matrix = matrix
+        self.w, self.h = self.get_dimensions()
+
+        if self.saved_hints():
+            return self.get_hint_from_list()
+        if self.search():
+            return self.get_hint_from_list()
+        if self.uncertain and self.lucky_guess():
+            return self.get_hint_from_list()
+        return Action.NOOP, cursor_x, cursor_y
+
+    def get_dimensions(self):
+        """ palauttaa matriisin dimensiot """
+        return len(self.matrix), len(self.matrix[0])
+
+    def get_neighbours(self, tile):
+        """ palauttaa viereiset koordinaatit joukkona """
+        x, y = tile
         offsets = (
             (-1, -1), ( 0, -1), ( 1, -1),
             (-1,  0),           ( 1,  0),
             (-1,  1), ( 0,  1), ( 1,  1),
         )
-        coords=[]
+        tiles=set()
         for ox, oy in offsets:
-            if ox+x in range(dx):
-                if oy+y in range(dy):
-                    coords.append((ox+x, oy+y))
-        return coords
+            if ox+x in range(self.w):
+                if oy+y in range(self.h):
+                    tiles.add((ox+x, oy+y))
+        return tiles
 
-    def coordinates_to_tiles(self, matrix, coords):
-        """ lukee koordinaateissa olevien ruutujen arvot listaksi """
-        return [matrix[x][y] for x,y in coords]
+    def get_value(self, tile):
+        """ palauttaa laatan arvon """
+        return self.matrix[tile[0]][tile[1]]
 
-    def hint(self, matrix, cursor_x, cursor_y):
-        """ antaa vinkin. tässä tapauksessa ei mitään """
-        # pylint: disable = unused-argument
-        self.hints += 1
-        return Action.NOOP, cursor_x, cursor_y
+    def remove_number_tiles(self, tiles):
+        """ poistaa vapaat ja vapaaksi merkityt alueet ja numerolaatat """
+        for tile in list(tiles):
+            if self.matrix[tile[0]][tile[1]] < Tile.FLAG_BOMB:
+                tiles.remove(tile)
+
+    def remove_bomb_tiles(self, tiles):
+        """ poistaa pommit ja pommiksi merkityt """
+        count=0
+        for tile in list(tiles):
+            if self.matrix[tile[0]][tile[1]] in (Tile.BOMB, Tile.FLAG_BOMB):
+                tiles.remove(tile)
+                count+=1
+        return count
+
+    def known_tile(self, tile):
+        """ tutkii onko laatta tiedetty """
+        return self.matrix[tile[0]][tile[1]] < Tile.UNOPENED
+
+    def number_tile(self, tile):
+        """ tutkii onko numerolaatta """
+        return 0 < self.matrix[tile[0]][tile[1]] < Tile.BOMB
+
+    def count_unknowns(self, tiles):
+        """ laskee tunnistamattomat laatat """
+        count=0
+        for tile in list(tiles):
+            if not self.known_tile(tile):
+                count+=1
+        return count
+
+    def remove_unknowns(self, tiles):
+        """ poistaa tunnistamattomat laatat """
+        count=0
+        for tile in list(tiles):
+            if not self.known_tile(tile):
+                tiles.remove(tile)
+                count+=1
+            return count
+
+    def get_interesting_tiles(self):
+        """ palauttaa laatat joiden naapureissa on vaihtelua """
+        tiles = set()
+        for x in range(self.w):
+            for y in range(self.h):
+                if self.number_tile((x,y)):
+                    n = self.get_neighbours((x,y))
+                    l = len(n)
+                    r = self.count_unknowns(n)
+                    if r in range(1,l-1):
+                        tiles.add((x,y))
+        return tiles
+
+    def get_unknown_tiles(self):
+        """ palauttaa kaikki tuntemattomat laatat """
+        tiles = set()
+        for x in range(self.w):
+            for y in range(self.h):
+                if not self.known_tile((x,y)):
+                    tiles.add((x,y))
+        return tiles
-- 
cgit v1.2.3