Merge pull request #10 from Zer0897/animation

Animation: Project Overhaul

Author: Noah Corona

res/settings.ini

@@ -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/widgets.ini

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

src/__init__.py

@@ -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/__main__.py

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

src/animate.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()

src/cache.py

@@ -23,7 +23,6 @@ def __init__(self, root):
         # get settings
         cp = configparser.ConfigParser()
         cp.read(str(SETTINGS))
-        cp.read('settings.ini')
 
         # for now, let's just look up the DEV settings
         # can change this later
@@ -75,7 +74,7 @@ async def refill(self):
                     image_bytes = await res.read()
                     # open and the image in pillow
                     im = Image.open(io.BytesIO(image_bytes))
-                    im = im.resize((400, 440), Image.NEAREST)
+                    im = im.resize((400, 280), Image.NEAREST)
                     # make the image a tkinter image
                     image = ImageTk.PhotoImage(im)
                     # update the cat data dict

src/front.py

@@ -0,0 +1,114 @@
+import asyncio
+
+from . import widget
+from .animate import Direction
+from .view import Window, View
+from .cache import Cache
+
+
+class Front(widget.PrimaryFrame):
+
+    cachesize = 10
+
+    # Quick fix to keep a reference count on the
+    # last image, making sure the garbage collector
+    # doesn't delete it before the animation ends
+    _last = None
+
+    def __next(self):
+        data: dict = self.cache.pop()
+        data.pop('jumpscare')  # not using it for now
+        if 'name' in data:  # TODO Fix
+            name = data.pop('name')
+        else:
+            name = 'None'
+        image = data.pop('image')
+        self.__load(name, image, data)
+
+    def __load(self, name, image, data):
+        self.title.config(text=name)
+        self.bio.data.load(data)
+        self._last = self.image
+        self.image = View(image, 'image')
+        self.update()
+
+    def __change_image(self, direction: Direction):
+        self.__next()
+        self.window.change_view(self.image, direction)
+
+    def init(self):
+        self.title = widget.PrimaryLabel(self)
+        self.window = Window(self)
+        self.commandbar = widget.SecondaryFrame(self)
+
+        self.bio = View(Bio(self.window), 'widget')
+        self.image = None
+
+        self.btn_dislike = widget.PrimaryButton(
+            self.commandbar, text='Nope', bg='red', command=self.cmd_dislike
+        )
+        self.btn_bio = widget.SecondaryButton(
+            self.commandbar, text='Bio', command=self.cmd_bio
+        )
+        self.btn_like = widget.PrimaryButton(
+            self.commandbar, text='Yep', bg='green', command=self.cmd_like
+        )
+        self.title.pack(fill='x')
+        self.window.pack(fill='both')
+        self.commandbar.pack(side='bottom', fill='x')
+
+        self.btn_bio.pack()
+        self.btn_dislike.pack(side='left')
+        self.btn_like.pack(side='right')
+
+        self._loop = asyncio.get_event_loop()
+        self.cache = Cache(self.window)
+        self.cache
+
+    def cmd_dislike(self):
+        self.__change_image('right')
+
+    def cmd_like(self):
+        self.__change_image('left')
+
+    def cmd_bio(self):
+        if self.window.current != self.bio:
+            self.window.change_view(self.bio, 'up')
+        else:
+            self.window.change_view(self.image, 'down')
+
+    @property
+    def cache(self):
+        if len(self._cache.cats) < self.cachesize:
+            self._loop.run_until_complete(self._cache.refill())
+        return self._cache.cats
+
+    @cache.setter
+    def cache(self, data: list):
+        self._cache = data
+        # Prime the pump
+        self.__next()
+        self.window.set_view(self.image)
+
+
+class Bio(widget.PrimaryFrame):
+
+    # def init(self):
+    #     width = self.master.winfo_width()
+    #     height = self.master.winfo_height()
+    #     self.config(height=height, width=width)
+    #     #self.pack_propagate(0)
+
+    def __make_item(self, name, value):
+        item = widget.SecondaryFrame(self)
+        name = widget.SecondaryLabel(item, text=name)
+        value = widget.SecondaryLabel(item, text=value)
+        name.pack(side='left')
+        value.pack(side='right')
+        return item
+
+    def load(self, data: dict):
+        # print(data)
+        for name, val in data.items():
+            item = self.__make_item(name, val)
+            item.pack()

src/main.py

@@ -0,0 +1,28 @@
+import configparser
+import tkinter as tk
+from pygame import mixer
+
+from .front import Front
+from . import SETTINGS
+
+
+parser = configparser.ConfigParser()
+parser.read(SETTINGS)
+
+
+class App(tk.Tk):
+    appconfig = parser['APP']
+
+    def __init__(self, *args, **kwds):
+        title = self.appconfig.pop('title')
+        super().__init__(*args, **kwds)
+        self.title = title
+        mixer.init()
+
+        self.geometry = '400x500'
+        self.minsize(400, 500)
+        self.maxsize(400, 500)
+
+        self.front = Front(self)
+
+        self.front.pack(fill='both', expand=True)