Merge branch 'dev' into staging

Author: intendednull

Pipfile

@@ -13,6 +13,7 @@ pillow = "*"
 pygame = "*"
 aiohttp = "*"
 configparser = "*"
+requests = "*"
 
 [requires]
 python_version = "3.7"

Pipfile.lock

@@ -1,5 +1,5 @@
 [DEFAULT]
-main.title = Cat Tinder
+main.title = App
 main.geometry = 400x500
 main.background = black
 cachesize = 10
@@ -15,5 +15,6 @@ back.background = blue
 bio.text = Bio
 bio.background = blue
 
-[DEV]
-main.title = DEV MODE CAT TINDER
+
+[APP]
+title = App

res/settings.ini

@@ -0,0 +1,7 @@
+[base]
+
+[primary]
+
+
+[secondary]
+

res/widgets.ini

@@ -5,5 +5,6 @@
 RES: Path = ROOT / 'res'
 
 SETTINGS: Path = RES / 'settings.ini'
+THEME: Path = RES / 'widgets.ini'
 IMAGES: Path = RES / 'images'
 SOUNDS: Path = RES / 'sounds'

src/__init__.py

@@ -1,4 +1,4 @@
-from .mainwindow import Tinder
+from .main import App
 
 if __name__ == "__main__":
-    Tinder().start()
+    App().mainloop()

src/__main__.py

@@ -2,9 +2,8 @@
 
 import tkinter as tk
 import operator
-from typing import NamedTuple, Callable, TypeVar, List, Generator, Tuple
-from contextlib import suppress
-from more_itertools import chunked
+import time
+from typing import NamedTuple, Callable, TypeVar, Generator, Tuple
 from enum import Enum
 from dataclasses import dataclass
 from functools import partialmethod, partial
@@ -110,39 +109,51 @@ def __add__(self, other: Direction) -> Coord:
         else:
             return self.value + other
 
+    def flip(self):
+        return Direction(Coord(0, 0) - self.value)
 
-class Animater(tk.Canvas):
+
+class Animater:
     """
-    Inherits Canvas. Manager for executing animation move commands.
-    Currently only event base animations are supported.
+    Manager for executing animations.
 
     example::
 
     ```
     motion = Motion(...)
-    window = Animator(...)
+    window = Animater(...)
     window.add_motion(motion)
-    window.add_event('<Enter>')
     ```
     """
-    motions = []
+    _motions = set()
+    fps = 60
+
+    def __init__(self, canvas: tk.Canvas):
+        self.canvas = canvas
+
+    def start(self):
+        while self._motions:
+            time.sleep(1/self.fps)
+            self.run()
+
+    def run(self):
+        for motion in self._motions:
+            try:
+                next(motion)()
+                self.canvas.update()
+            except StopIteration:
+                self._motions.remove(motion)
+                break
 
-    def add_event(self, event: tk.EventType):
-        self.bind(event, self.run)
+    def add(self, motion: Motion):
+        self._motions.add(iter(motion))
 
-    def run(self, event):
-        active = []
-        for motion in self.motions:
-            with suppress(StopIteration):
-                moves = next(motion)
-                for move in moves:
-                    move()
-                    self.update_idletasks()
-                active.append(motion)
-        self.motions = active
+    def add_motion(self, id: int, end: Coord, **kwargs):
+        motion = Motion(self.canvas, id, (end,), **kwargs)
+        self.add(motion)
 
-    def add_motion(self, motion: Motion):
-        self.motions.append(iter(motion))
+    def clear(self):
+        self._motions.clear()
 
 
 @dataclass
@@ -191,70 +202,36 @@ class Motion:
     id: int
     endpoints: Tuple[Coord]
 
-    steps = 60
     speed: int = 1
 
-    def start(self) -> Generator[Generator[Callable]]:
+    def start(self) -> Generator[Callable]:
         """
         The entry point for generating move commands.
         """
         move = partial(self.canvas.move, self.id)
 
-        def frame(points: List, last: Coord) -> Generator[Callable]:
-            for point in points:
-                offset = point - last
-                yield partial(move, *offset)
-                last = point
+        def frame(increment: Coord, count: int):
+            for _ in range(count):
+                move(*increment)
+                self.canvas.master.update_idletasks()
 
         for end in self.endpoints:
             start = Coord(*self.canvas.coords(self.id)[:2])
-            vec = vector(start, end, self.steps)
+            steps = round(start.distance(end) / self.speed)
+            frames = round(steps / self.speed)
+            increment = (end - start) / steps
 
-            last = vec[0]
-            for points in chunked(vec, self.speed):
-                yield frame(points, last)
-                last = points[-1]
+            for _ in range(frames):
+                yield partial(frame, increment, round(steps / frames))
 
     def __iter__(self):
         return self.start()
 
+    def __key(self):
+        return self.id
 
-def vector(start: Coord, end: Coord, step: int = 60) -> List[Coord]:
-    """
-    Creates a list of all the Coords on a straight line from `start` to `end` (inclusive).
-
-    param:
-        start: Coord -- The starting point.
-        end: Coord -- The end point.
-        step: int (optional) -- The desired number of points to include. Defaults to 60.
-            Actual resulting length may vary.
-
-    return:
-        List[Coord] -- All points that fall on the line from start to end.
+    def __hash__(self):
+        return hash(self.__key())
 
-    example::
-
-    ```
-    start = Coord(0, 5)
-    end = Coord(5, 0)
-    vector(start, end, 5)  # ends up being 8
-    >>> [
-        Coord(x=0, y=5), Coord(x=1, y=4), Coord(x=1, y=4),
-        Coord(x=2, y=2), Coord(x=2, y=2), Coord(x=4, y=1),
-        Coord(x=4, y=1), Coord(x=5, y=0)
-        ]
-    ```
-
-    note:
-
-    The current implementation recursively finds midpoints to build the line.
-    This means the resulting length may vary, due to its eager nature.
-    """
-    mid = start.midpoint(end)
-    instep = round(step / 2)
-    if instep:
-        back = vector(start, mid, step=instep)
-        front = vector(mid, end, step=instep)
-        return back + front
-    else:
-        return [start, end]
+    def __eq__(self):
+        return isinstance(self, type(other)) and self.__key() == other.__key()