initial commit

Author: linluk

.gitignore

@@ -0,0 +1 @@
+__pycache__/

COPYING

@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+

DejaVuSansMono.ttf

@@ -0,0 +1,83 @@
+
+import pygame
+
+
+
+
+class Animation(object):
+    __slots__ = ('_count', '_sprite', '_current', '_idx', '_width', '_height', '_duration', '_tick', '_once', '_done')
+    def __init__(self, sprite: pygame.Surface, count: int = 1, fps: int = 8, once: bool = False) -> None:
+        super().__init__()
+        self._count = count
+        self._sprite = sprite
+        self._current = None
+        self._once = once
+        self._done = False
+        self._idx = 0
+        self._width = self._sprite.get_width() // count
+        self._height = self._sprite.get_height()
+        self._duration = 1000 // fps
+        self._tick = 0
+
+    def update(self, delta: int) -> None:
+        if self._done:
+            return
+        self._tick -= delta
+        reclip = False
+        while self._tick <= 0:
+            reclip = True
+            self._idx += 1
+            self._tick += self._duration
+        if reclip:
+            if self._idx >= self._count:
+                self._idx %= self._count
+                self._done = self._once
+            self._current = self._sprite.subsurface((self._width * self._idx, 0, self._width, self._height))
+
+    def render(self, target: pygame.Surface, x: int, y: int) -> None:
+        if self._current is None:
+            return
+        target.blit(self._current, (x, y))
+
+    width = property(lambda s: s._width)
+    height = property(lambda s: s._height)
+    surface = property(lambda s: s._current)
+    done = property(lambda s: s._done)
+
+
+
+
+
+
+
+if __name__ == '__main__':
+    import sys
+    try:
+        fn = sys.argv[1]
+        cnt = int(sys.argv[2])
+    except:
+        fn = 'test.png'
+        cnt = 6
+    def load_image(filename: str) -> pygame.Surface:
+        return pygame.image.load(filename).convert_alpha()
+    pygame.init()
+    screen = pygame.display.set_mode((480, 320))
+    clock = pygame.time.Clock()
+    running = True
+    delta = 0
+    a = Animation(load_image(fn), cnt, 12)
+    while running:
+        # INPUT
+        for e in pygame.event.get():
+            if e.type == pygame.QUIT:
+                running = False
+                continue
+        # UPDATE
+        a.update(delta)
+        # RENDER
+        screen.fill((0,0,0))
+        a.render(screen, 5, 5)
+        #pygame.display.flip()
+        pygame.display.update()
+        # TICK
+        delta = clock.tick(30)

animation.py

@@ -0,0 +1,112 @@
+
+import enum
+from enum import auto
+import os
+
+import pygame
+
+import animation
+
+DIRECTORY = '~/Bilder/coder/export'
+
+_surfaces = {}
+class SurfaceType(enum.Enum):
+    VIM = auto()
+    ATOM = auto()
+    EMACS = auto()
+    INTELLIJ = auto()
+    NANO = auto()
+    VSCODE = auto()
+
+    BUG_RED_1 = auto()
+    BUG_RED_2 = auto()
+    BUG_GREEN_1 = auto()
+    BUG_GREEN_2 = auto()
+    BUG_YELLOW_1 = auto()
+    BUG_YELLOW_2 = auto()
+    BUG_GRAY_1 = auto()
+    BUG_GRAY_2 = auto()
+
+    TRY_EXCEPT = auto()
+    CATCH_EXCEPTION = auto()
+
+    FOR_LOOP = auto()
+
+    FLOATINGPOINTERROR = auto()
+    INDEXERROR = auto()
+    KEYERROR = auto()
+    MEMORYERROR = auto()
+    NOTIMPLEMENTEDERROR = auto()
+    OVERFLOWERROR = auto()
+    RECURSIONERROR = auto()
+    RUNTIMEERROR = auto()
+    TYPEERROR = auto()
+
+    def get_filename(self):
+        if self == Surfaces.VIM: fn = 'vim.png'
+        elif self == Surfaces.ATOM: fn = 'atom.png'
+        elif self == Surfaces.EMACS: fn = 'emacs.png'
+        elif self == Surfaces.INTELLIJ: fn = 'intellij.png'
+        elif self == Surfaces.NANO: fn = 'nano.png'
+        elif self == Surfaces.VSCODE: fn = 'vscode.png'
+        elif self == Surfaces.BUG_RED_1: fn = 'bug-red-1.png'
+        elif self == Surfaces.BUG_RED_2: fn = 'bug-red-2.png'
+        elif self == Surfaces.BUG_GREEN_1: fn = 'bug-green-1.png'
+        elif self == Surfaces.BUG_GREEN_2: fn = 'bug-green-2.png'
+        elif self == Surfaces.BUG_YELLOW_1: fn = 'bug-yellow-1.png'
+        elif self == Surfaces.BUG_YELLOW_2: fn = 'bug-yellow-2.png'
+        elif self == Surfaces.BUG_GRAY_1: fn = 'bug-gray-1.png'
+        elif self == Surfaces.BUG_GRAY_2: fn = 'bug-gray-2.png'
+        elif self == Surfaces.TRY_EXCEPT: fn = 'try-except.png'
+        elif self == Surfaces.CATCH_EXCEPTION: fn = 'catch-exception.png'
+        elif self == Surfaces.FOR_LOOP: fn = 'for-loop.png'
+        elif self == Surfaces.FLOATINGPOINTERROR: fn = 'floatingpointerror.png'
+        elif self == Surfaces.INDEXERROR: fn = 'indexerror.png'
+        elif self == Surfaces.KEYERROR: fn = 'keyerror.png'
+        elif self == Surfaces.MEMORYERROR: fn = 'memoryerror.png'
+        elif self == Surfaces.NOTIMPLEMENTEDERROR: fn = 'notimplementederror.png'
+        elif self == Surfaces.OVERFLOWERROR: fn = 'overflowerror.png'
+        elif self == Surfaces.RECURSIONERROR: fn = 'recursionerror.png'
+        elif self == Surfaces.RUNTIMEERROR: fn = 'runtimeerror.png'
+        elif self == Surfaces.TYPEERROR: fn = 'typeerror.png'
+        else raise Exception('Unknown Surface Type: {}'.format(str(self)))
+        return os.path.join(DIRECTORY, fn)
+
+    def get_surface(self):
+        if self in _surfaces:
+            return _surfaces[self]
+        surface = pygame.image.load(self.get_filename()).convert_alpha()
+        _surfaces[self] = surface
+        return surface
+
+
+class Player(animation.Animation):
+    def __init__(self, player_type: SurfaceType):
+        super().__init__(player_type.get_surface(), 1, 1, False)
+
+class Bug(animation.Animation):
+    def __init__(self, bug_type: SurfaceType):
+        super().__init__(bug_type.get_surface(), 3, 12, False)
+
+class TryExcept(animation.Animation):
+    def __init__(self):
+        super().__init__(SurfaceType.TRY_EXCEPT.get_surface(), 1, 1, False)
+
+class CatchException(animation.Animation):
+    def __init__(self, x: int, y: int):
+        super().__init__(SurfaceType.CATCH_EXCEPTION.get_surface(), 8, 20, True)
+        self._x = x
+        self._y = y
+
+    def render(self, target, *args):
+        super().render(target, self._x, self._y)
+
+class Snippet(animation.Animation):
+    def __init__(self, snippet_type: SurfaceType):
+        super().__init__(snippet_type.get_surface(), 1, 1, False)
+
+class Error(animation.Animation):
+    def __init__(self, error_type: SurfaceType):
+        super().__init__(error_type.get_surface(), 1, 1, False)
+
+

animations.py

@@ -0,0 +1,95 @@
+
+from typing import List
+
+import pygame
+
+from collections import namedtuple
+import random
+
+class Background(object):
+    __slots__ = ('_chars', '_surfaces', '_tick', '_width', '_height', '_max_idx', '_min_new', '_max_new')
+
+    class Char(object):
+        __slots__ = ('x', 'y', 'v', 'surface')
+        def __init__(self, x, y, velocity, surface) -> None:
+            super().__init__()
+            self.x = int(x)
+            self.y = y
+            self.v = velocity
+            self.surface = surface
+
+    def __init__(self, w: int, h: int) -> None:
+        super().__init__()
+        self._chars = [] # type: List[Char]
+        self._surfaces = [] # type: List[chr, pygame.Surface]
+        self._max_idx = len(self._surfaces)
+        self._tick = 0
+        self._width = w
+        self._height = h
+        self._min_new = max(1, w // 120)
+        self._max_new = max(2, w // 30)
+        self._init_surfaces()
+
+    def _init_surfaces(self):
+        CHARS = '#+!{}[]&%$?' + ''.join(map(chr, range(ord('a'), ord('z')))) + ''.join(map(chr, range(ord('A'), ord('Z'))))
+        font = pygame.font.Font('DejaVuSansMono.ttf', 12)
+        surface = font.render(CHARS, True, (70, 150, 25), None).convert_alpha()
+        width = surface.get_width() // len(CHARS)
+        height = surface.get_height()
+        for i in range(len(CHARS)):
+            subsurface = surface.subsurface((i * width, 0, width, height))
+            self._surfaces.append(subsurface)
+        self._max_idx = len(self._surfaces) - 1
+
+    def update(self, delta: int) -> None:
+        self._tick -= delta
+        if self._tick <= 0:
+            for i in range(random.randint(self._min_new, self._max_new)):
+                c = Background.Char(random.randint(1, self._width), -10, .15 + (random.random() * .2), self._surfaces[random.randint(0, self._max_idx)])
+                self._chars.append(c)
+            self._tick = 125
+            self._chars = [c for c in self._chars if c.y < self._height]
+        for c in self._chars:
+            c.y += (c.v * delta)
+
+    def render(self, target: pygame.Surface, x: int, y: int) -> None:
+        target.fill((30, 30, 30))
+        for c in self._chars:
+            target.blit(c.surface, (c.x, int(c.y)))
+
+
+
+if __name__ == '__main__':
+    SIZE = 600, 600
+    pygame.init()
+    screen = pygame.display.set_mode(SIZE, pygame.DOUBLEBUF)
+    clock = pygame.time.Clock()
+    running = True
+    delta = 0
+    b = Background(*SIZE)
+    fpss = []
+    min_fps = -1000
+    while running:
+        # INPUT
+        for e in pygame.event.get():
+            if e.type == pygame.QUIT:
+                running = False
+                continue
+        # UPDATE
+        b.update(delta)
+        # RENDER
+        b.render(screen, 5, 5)
+        #pygame.display.flip()
+        pygame.display.update()
+        # TICK
+        delta = clock.tick(1000)
+        #fps = 1000 / delta
+        #if len(fpss) > 100:
+        #    print('avg fps {:.1f}    min fps: {:.1f}'.format(sum(fpss) / 100, min(fpss)))
+        #    if min_fps < 0:
+        #        min_fps = 1000 # hack to ignore the first run
+        #    elif min(fpss) < min_fps:
+        #        min_fps = min(fpss)
+        #    fpss = []
+        #fpss.append(fps)
+    #print('MIN: {:.2f}'.format(min_fps))

background.py

@@ -0,0 +1,46 @@
+import pygame
+import consts
+import color
+from typing import List
+
+class Bugs(object):
+    def __init__(self, color, x, y) -> None:
+        self._rect = None # type: pygame.Rect
+        self._textsurface = None
+        self._myfont = None 
+        self._x = x
+        self._y = y
+        self._col = color
+        self._is_killed = False # type: bool        
+
+    def render(self, screen):    
+        self._rect = pygame.Rect(self._x, self._y, consts.BUG_W, consts.BUG_H)
+        pygame.draw.rect(screen, self._col, self._rect, 0)
+
+    def is_collided(self, sprite: pygame.Rect):
+        if self._rect != None:
+            return self._rect.colliderect(sprite)
+        else: return False
+
+
+class BugManager(object):
+    def __init__(self) -> None:
+        self._bugs = []
+        self._snippets = None # type: list
+
+    def add_bug(self, color, x, y):
+        self._bugs.append(Bugs(color, x, y))
+
+    def inject_snippets(self, snippets: List[pygame.Rect]) -> None:
+        self._snippets = snippets
+
+    def render(self, screen):
+        for bug in self._bugs:
+            for snip in self._snippets:
+                if snip._rect != None:
+                    if bug.is_collided(snip._rect):
+                        bug._is_killed = True
+                        snip._is_killed = True
+            bug.render(screen)
+        self._bugs = list(filter(lambda b: not b._is_killed, self._bugs)) # some weird stuff from lukas ask lukas
+