add rotation to the tileviewer dialog

Author: AssassinTee

src/backend/tile_connection.py

@@ -1,6 +1,14 @@
 from src.globals import EIGHT_NEIGHBORS, NUM_NEIGHBOR_BITS, NUM_NEIGHBOR_STATES, NEIGHBOR_BIT_COMPARATOR
 from typing import List, Set
 
+# relative (x, y) offsets of the 8-neighborhood, y positive means up (DDNet "Pos" convention)
+NEIGHBOR_OFFSETS = [
+    (-1, 1), (0, 1), (1, 1),
+    (-1, 0), (1, 0),
+    (-1, -1), (0, -1), (1, -1),
+]
+NEIGHBOR_INDEX_BY_OFFSET = {offset: index for index, offset in enumerate(NEIGHBOR_OFFSETS)}
+
 
 class TileConnection:
     def __init__(self, neighbors: list):
@@ -114,11 +122,34 @@ def getEmpty(self) -> "TileConnection":
         neighbors = self._neighbors
         return TileConnection([n % 2 for n in neighbors])
 
+    def getInverseNeighborhood(self, button_id: int, default: int = 2) -> "TileConnection":
+        """
+        Builds the TileConnection a neighbor button sees, given this (center) connection.
+
+        The neighbor at ``button_id`` observes the 8-neighborhood around itself. Each slot is
+        filled with the relationship this center tile stores for the tile sitting there, and the
+        center itself is looked up at the slot facing button_id (its own relation, mirrored).
+        slots that point outside the center's 3x3 grid are set to ``default``.
+        """
+        if button_id < 0 or button_id >= EIGHT_NEIGHBORS:
+            raise ValueError(f"Invalid neighbor ID {button_id}")
+        if default < 0 or default > 2:
+            raise ValueError(f"Invalid default {default}")
+        ret = [default] * EIGHT_NEIGHBORS
+        bx, by = NEIGHBOR_OFFSETS[button_id]
+        for local_index, (lx, ly) in enumerate(NEIGHBOR_OFFSETS):
+            gx, gy = bx + lx, by + ly
+            if gx == 0 and gy == 0:
+                ret[local_index] = self._neighbors[button_id]
+            elif -1 <= gx <= 1 and -1 <= gy <= 1:
+                ret[local_index] = self._neighbors[NEIGHBOR_INDEX_BY_OFFSET[(gx, gy)]]
+        return TileConnection(ret)
+
     def setNeighbor(self, neighbor_id, state):
         if state < 0 or state > 2:
-            return ValueError(f"Invalid state {state}")
-        if neighbor_id < 0 or neighbor_id > EIGHT_NEIGHBORS:
-            return ValueError(f"Invalid neighbor ID {neighbor_id}")
+            raise ValueError(f"Invalid state {state}")
+        if neighbor_id < 0 or neighbor_id >= EIGHT_NEIGHBORS:
+            raise ValueError(f"Invalid neighbor ID {neighbor_id}")
         self._neighbors[neighbor_id] = state
 
 

src/buttons/button_tile_connection.py

@@ -1,11 +1,12 @@
 from typing import TYPE_CHECKING, Any, Optional
 
-from PyQt6.QtCore import QPoint, Qt
-from PyQt6.QtGui import QPainter, QPolygon, QRegion, QPixmap, QColor, QPen
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QPainter, QPixmap, QColor, QPen, QTransform
 from PyQt6.QtWidgets import QAbstractButton
 
 from src.images_helper import ImageHelper
 from src.backend.tile_handler import TileHandler
+from src.backend.tile_status import TileStatus
 from src.signals.signal_emitter import ConfigurationClickedEmitter
 
 if TYPE_CHECKING:
@@ -26,6 +27,7 @@ def __init__(self, button_id, parent=None):
         self._state = 2  # Any
         self._num_states = 3
         self._tile = None
+        self._tile_status = None
         self._main = False
         self.setMinimumSize(128, 128)
         self.setMaximumSize(128, 128)
@@ -47,18 +49,35 @@ def _paintTile(self, qp: QPainter):
         if self._state == 2:
             return
         size = self.size()
-        # clip region for ANY in order to show state between empty and full
-        # if not self._main and self._state == 2:
-        #    polygon = QPolygon()
-        #    polygon << QPoint(0, 0) << QPoint(size.width(), size.height()) << QPoint(0, size.height())
-        #    reg = QRegion(polygon)
-        #    qp.setClipRegion(reg)
 
         # draw tile
         pm = self._findPixmap()
         if pm:
-            qp.drawPixmap(0, 0, size.width(), size.height(), pm)
-        # qp.setClipping(False)
+            transform = QTransform()
+
+            if size.width() != pm.width() or size.height() != pm.height():
+                factor_width = size.width() / pm.width()
+                factor_height = size.height() / pm.height()
+                transform.scale(factor_width, factor_height)
+
+            if self._tile_status:
+                transform.translate(pm.width() // 2, pm.height() // 2)
+
+                # rotate first, because otherwise you might rotate your flip breaking this in the process
+                if self._tile_status.rot:
+                    transform.rotate(90)
+
+                if self._tile_status.y_flip:
+                    transform = transform.scale(1, -1)
+
+                if self._tile_status.x_flip:
+                    transform = transform.scale(-1, 1)
+
+                transform.translate(-pm.width() // 2, -pm.height() // 2)
+
+            qp.setTransform(transform)
+            qp.drawPixmap(0, 0, pm)
+            qp.resetTransform()
 
     # will be overwritten
     def _paintOutline(self, qp: QPainter):
@@ -113,15 +132,20 @@ def leaveEvent(self, e):
         self.update()
         super().leaveEvent(e)
 
-    def setTile(self, tile: Optional["Tile"], update_neighbors=True):
-        if self._tile and tile and \
-                (self._tile.getID() == tile.getID() or self._tile.tile_data == tile.tile_data):
-            return
+    def setTile(self, tile: Optional["Tile"], update_neighbors=True, tile_status: Optional[TileStatus] = None):
+        if self._tile and tile:
+            same_id = self._tile.getID() == tile.getID()
+            same_status = self._tile_status is not None and tile_status is not None \
+                and self._tile_status == tile_status
+            if same_id and same_status:
+                return
 
         if tile is None:
             self._tile = tile
+            self._tile_status = None
         else:
             self._tile = tile.__copy__()
+            self._tile_status = tile_status.__copy__() if tile_status else None
 
         if update_neighbors:
             self._update_neighborhood()

src/dialogs/dialog_tile_settings.py

@@ -103,7 +103,7 @@ def onConnectionButtonClick(self, button_id: int):
         neighbor_buttons = self._getNeighborButtons(button_id)
         for i in range(EIGHT_NEIGHBORS):
             if neighbor_buttons[i] is not None:
-                self._updateTile(i)
+                self._updateTile(neighbor_buttons[i])
 
     def onModificationChange(self, modification: int, value: bool):
         match modification:
@@ -126,22 +126,15 @@ def _updateTileData(self, button_id: int):
         self._tile_data.con.setNeighbor(button_id, state)
 
     def _updateTile(self, button_id: int):
-        neighbors = [1] * EIGHT_NEIGHBORS  # all empty (for now) TODO change view with button
-        neighbor_buttons = self._getNeighborButtons(button_id)
-        for i in range(EIGHT_NEIGHBORS):
-            if neighbor_buttons[i] is not None:
-                neighbors[i] = self._tile_data.con.getNeighbors()[neighbor_buttons[i]]
-        con = TileConnection(neighbors)
-
-        tile_connection = con.getEmpty()
+        tile_connection = self._tile_data.con.getInverseNeighborhood(button_id, default=2)
         tile_id_list = TileHandler.instance().findTiles(tile_connection)
         if len(tile_id_list):
             # yay, I found a tile that connects in this location
             # use a random one, because this shouldn't matter
             rand_tile = random.randint(0, len(tile_id_list) - 1)
-            tile_id, _ = tile_id_list[rand_tile]
+            tile_id, tile_status = tile_id_list[rand_tile]
             tile = TileHandler.instance().getTile(tile_id)
-            self.buttons[button_id].setTile(tile, False)
+            self.buttons[button_id].setTile(tile, False, tile_status)
         else:  # No tile? reset
             self.buttons[button_id].setTile(None, False)
 

tests/logic/test_tile_connection.py

@@ -189,3 +189,74 @@ def test_get_permutations(self, expected, neighbors):
             assert len(expected) == len(perms)
             for exp in expected:
                 assert exp in perms_enc
+
+    # relative offsets of the 8-neighborhood, y positive = up, matching the dialog grid layout:
+    #   0 1 2
+    #   3 . 4
+    #   5 6 7
+    @staticmethod
+    def _offset(index):
+        return [
+            (-1, 1), (0, 1), (1, 1),
+            (-1, 0), (1, 0),
+            (-1, -1), (0, -1), (1, -1),
+        ][index]
+
+    @staticmethod
+    def _expected_inverse(neighbors, button_id, default):
+        offsets = [(-1, 1), (0, 1), (1, 1), (-1, 0), (1, 0), (-1, -1), (0, -1), (1, -1)]
+        index_by_offset = {o: i for i, o in enumerate(offsets)}
+        bx, by = TestTileConnection._offset(button_id)
+        ret = [default] * 8
+        for local_index, (lx, ly) in enumerate(offsets):
+            gx, gy = bx + lx, by + ly
+            if gx == 0 and gy == 0:
+                ret[local_index] = neighbors[button_id]
+            elif -1 <= gx <= 1 and -1 <= gy <= 1:
+                ret[local_index] = neighbors[index_by_offset[(gx, gy)]]
+        return ret
+
+    @pytest.mark.parametrize("neighbors", [
+        [0, 1, 1, 0, 1, 1, 0, 1],
+        [1] * 8,
+        [0] * 8,
+        [2] * 8,
+        [0, 1, 2, 0, 1, 2, 0, 1],
+    ])
+    def test_get_inverse_neighborhood(self, neighbors):
+        center = TileConnection(neighbors)
+        for button_id in range(8):
+            for default in [0, 1, 2]:
+                inv = center.getInverseNeighborhood(button_id, default=default)
+                assert inv.getNeighbors() == self._expected_inverse(neighbors, button_id, default)
+
+    @pytest.mark.parametrize("neighbors", [
+        [0, 1, 1, 0, 1, 1, 0, 1],
+        [2] * 8,
+    ])
+    def test_inverse_neighborhood_contains_center_relation(self, neighbors):
+        # the slot facing the center mirrors the center's own relation to that button
+        center = TileConnection(neighbors)
+        for button_id in range(8):
+            inv = center.getInverseNeighborhood(button_id, default=2)
+            assert inv.getNeighbors()[7 - button_id] == neighbors[button_id]
+
+    def test_get_inverse_neighborhood_invalid(self):
+        center = TileConnection([0] * 8)
+        with pytest.raises(ValueError):
+            center.getInverseNeighborhood(8)
+        with pytest.raises(ValueError):
+            center.getInverseNeighborhood(-1)
+        with pytest.raises(ValueError):
+            center.getInverseNeighborhood(0, default=3)
+
+    @pytest.mark.parametrize("neighbor_id, state", [
+        [8, 0],
+        [-1, 0],
+        [0, 3],
+        [0, -1],
+    ])
+    def test_set_neighbor_invalid(self, neighbor_id, state):
+        t = TileConnection([0] * 8)
+        with pytest.raises(ValueError):
+            t.setNeighbor(neighbor_id, state)

tests/logic/test_tile_connection_button.py

@@ -0,0 +1,105 @@
+import os
+
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+import pytest  # noqa: E402
+from PyQt6.QtGui import QColor, QPainter, QPixmap  # noqa: E402
+
+from src.buttons.button_tile_connection import TileConnectionButton  # noqa: E402
+from src.backend.tile_data import TileData  # noqa: E402
+from src.backend.tile_connection import TileConnection  # noqa: E402
+from src.backend.tile_modificators import TileMods  # noqa: E402
+from src.backend.tile_status import TileStatus  # noqa: E402
+from src.widgets.widget_base_tile import BaseTile  # noqa: E402
+
+
+def _make_tile(tile_id=1, status=None):
+    tile_data = TileData(TileConnection([0] * 8), status or TileStatus(), TileMods(False, False, False))
+    return BaseTile(tile_id, tile_data)
+
+
+def _make_arrow_pixmap():
+    pm = QPixmap(2, 2)
+    pm.fill(QColor(K_EMPTY))
+    p = QPainter(pm)
+    p.fillRect(0, 0, 1, 1, QColor("red"))
+    p.fillRect(1, 0, 1, 1, QColor("green"))
+    p.fillRect(0, 1, 1, 1, QColor("blue"))
+    p.fillRect(1, 1, 1, 1, QColor("yellow"))
+    p.end()
+    return pm
+
+
+K_EMPTY = "#00000000"
+
+
+@pytest.mark.requires_q_app
+def test_set_tile_stores_status_copy(q_app):
+    btn = TileConnectionButton(0)
+    tile = _make_tile(7)
+    base_status = TileStatus()
+    rotated_status = TileStatus()
+    rotated_status.rot = True
+
+    btn.setTile(tile, False, base_status)
+    assert btn._tile_status == base_status
+
+    btn.setTile(tile, False, rotated_status)
+    assert btn._tile_status == rotated_status
+    assert btn._tile_status.rot
+
+
+@pytest.mark.requires_q_app
+def test_set_tile_dedups_only_when_status_is_equal(q_app):
+    btn = TileConnectionButton(0)
+    tile = _make_tile(7)
+    base_status = TileStatus()
+    rotated_status = TileStatus()
+    rotated_status.rot = True
+
+    btn.setTile(tile, False, base_status)
+    stored_before = btn._tile_status
+
+    # same tile + same status -> no re-render required
+    btn.setTile(tile, False, base_status)
+    assert btn._tile_status is stored_before
+
+    # same tile but different orientation -> must be re-rendered
+    btn.setTile(tile, False, rotated_status)
+    assert btn._tile_status is not stored_before
+    assert btn._tile_status.rot
+
+
+@pytest.mark.requires_q_app
+def test_rotated_suggestion_is_drawn_rotated(q_app):
+    btn = TileConnectionButton(0)
+    tile = _make_tile(3)
+    tile.setPixmap(_make_arrow_pixmap())
+    status = TileStatus()
+    status.rot = True
+
+    btn.setState(1)  # FULL: the tile is rendered
+    btn.setTile(tile, False, status)
+
+    img = btn.grab().toImage()
+    assert img.pixelColor(0, 0).name() == "#0000ff"       # BL -> TL
+    assert img.pixelColor(127, 0).name() == "#ff0000"     # TL -> TR
+    assert img.pixelColor(127, 127).name() == "#008000"   # TR -> BR
+    assert img.pixelColor(0, 127).name() == "#ffff00"     # BR -> BL
+
+
+@pytest.mark.requires_q_app
+def test_y_flipped_suggestion_is_drawn_mirrored(q_app):
+    btn = TileConnectionButton(0)
+    tile = _make_tile(3)
+    tile.setPixmap(_make_arrow_pixmap())
+    status = TileStatus()
+    status.y_flip = True
+
+    btn.setState(1)
+    btn.setTile(tile, False, status)
+
+    img = btn.grab().toImage()
+    assert img.pixelColor(0, 0).name() == "#0000ff"       # BL -> TL
+    assert img.pixelColor(0, 127).name() == "#ff0000"     # TL -> BL
+    assert img.pixelColor(127, 0).name() == "#ffff00"     # BR -> TR