Add basic title card.

Author: rchen152

MANIFEST.in

@@ -0,0 +1 @@
+include src/escape/img/*

setup.py

@@ -6,6 +6,7 @@
     name='kitty-escape',
     packages=find_packages(where='src'),
     package_dir={'': 'src'},
+    include_package_data=True,
     entry_points={
         'console_scripts': ['kitty-escape = escape.main:main'],
     },

src/escape/img/title_card.png

@@ -5,12 +5,10 @@
 
 def main():
     pygame.init()
-    pygame.display.set_mode(state.WINSIZE)
+    screen = pygame.display.set_mode(state.WINSIZE)
     pygame.display.set_caption('Kitty Escape')
-    game_state = state.GameState()
-
-    while game_state.active:
-        game_state.handle_events(pygame.event.get())
+    state.TitleCard(screen).run()
+    state.Game(screen).run()
 
 
 if __name__ == '__main__':

src/escape/main.py

@@ -1,20 +1,30 @@
 """Game state."""
 
+import abc
 import pygame
 from pygame.locals import *
+import os
 
 
 WINSIZE = (1024, 576)
+_RED = (200, 25, 25)
+_BLACK = (0, 0, 0)
 
 
 def _keypressed(event, key):
     return event.type == KEYDOWN and event.key == key
 
 
-class GameState:
+class GameState(abc.ABC):
 
-    def __init__(self):
+    def __init__(self, screen):
+        self.screen = screen
         self.active = True
+        self.draw()
+
+    @abc.abstractmethod
+    def draw(self):
+        pass
 
     def handle_events(self, events):
         for event in events:
@@ -28,7 +38,30 @@ def handle_quit(self, event):
     def handle_fullscreen(self, event):
         if not _keypressed(event, K_f):
             return
-        if pygame.display.get_surface().get_flags() & FULLSCREEN:
+        if self.screen.get_flags() & FULLSCREEN:
             pygame.display.set_mode(WINSIZE)
         else:
             pygame.display.set_mode(WINSIZE, FULLSCREEN)
+        self.draw()
+
+    def run(self):
+        while self.active:
+            self.handle_events(pygame.event.get())
+
+
+class TitleCard(GameState):
+
+    def draw(self):
+        path = os.path.join(os.path.dirname(__file__), 'img', 'title_card.png')
+        img = pygame.image.load(path)
+        img = pygame.transform.scale(img.convert_alpha(), WINSIZE)
+        self.screen.fill(_RED)
+        self.screen.blit(img, (0, 0))
+        pygame.display.update()
+
+
+class Game(GameState):
+
+    def draw(self):
+        self.screen.fill(_BLACK)
+        pygame.display.update()

src/escape/state.py

@@ -2,6 +2,7 @@
 
 from escape import state
 
+import pygame
 from pygame.locals import *
 
 import unittest
@@ -15,10 +16,44 @@ def __init__(self, typ, key=None):
         self.key = key
 
 
+class MockGame(state.GameState):
+
+    def __init__(self, screen):
+        self.drawn = 0
+        super().__init__(screen)
+
+    def draw(self):
+        self.drawn += 1
+
+
+class MockScreen:
+
+    def __init__(self):
+        self.fullscreen = False
+
+    def get_flags(self):
+        return FULLSCREEN if self.fullscreen else 0
+
+    def __getattr__(self, name):
+        return unittest.mock.MagicMock()
+
+
 class GameStateTest(unittest.TestCase):
 
     def setUp(self):
-        self.state = state.GameState()
+        self.state = MockGame(MockScreen())
+
+    def mock_set_mode(self, size, fullscreen=False):
+        del size  # unused
+        self.state.screen.fullscreen = fullscreen
+
+    def test_abstract(self):
+        with self.assertRaises(TypeError):
+            state.GameState(MockScreen())  # pytype: disable=not-instantiable
+
+    def test_basic(self):
+        self.assertTrue(self.state.active)
+        self.assertEqual(self.state.drawn, 1)
 
     def test_quit_x(self):
         self.assertTrue(self.state.active)
@@ -30,26 +65,62 @@ def test_quit_q(self):
         self.state.handle_quit(MockEvent(KEYDOWN, K_q))
         self.assertFalse(self.state.active)
 
-    @unittest.mock.patch('pygame.display', autospec=True)
-    def test_fullscreen(self, display_mock):
-        display_mock.get_surface.return_value.get_flags.return_value = 0
-        self.state.handle_fullscreen(MockEvent(KEYDOWN, K_f))
-        display_mock.set_mode.assert_called_once_with(state.WINSIZE, FULLSCREEN)
-
-    @unittest.mock.patch('pygame.display', autospec=True)
-    def test_unfullscreen(self, display_mock):
-        display_mock.get_surface.return_value.get_flags.return_value = (
-            FULLSCREEN)
-        self.state.handle_fullscreen(MockEvent(KEYDOWN, K_f))
-        display_mock.set_mode.assert_called_once_with(state.WINSIZE)
-
-    @unittest.mock.patch('pygame.display', autospec=True)
-    def test_multiple_events(self, display_mock):
-        display_mock.get_surface.return_value.get_flags.return_value = 0
-        self.state.handle_events([MockEvent(KEYDOWN, K_f), MockEvent(QUIT)])
-        display_mock.set_mode.assert_called_once_with(state.WINSIZE, FULLSCREEN)
+    def test_fullscreen(self):
+        self.state.screen.fullscreen = False
+        with unittest.mock.patch.object(
+                pygame.display, 'set_mode', self.mock_set_mode):
+            self.state.handle_fullscreen(MockEvent(KEYDOWN, K_f))
+        self.assertTrue(self.state.screen.fullscreen)
+        self.assertEqual(self.state.drawn, 2)
+
+    def test_unfullscreen(self):
+        self.state.screen.fullscreen = True
+        with unittest.mock.patch.object(
+                pygame.display, 'set_mode', self.mock_set_mode):
+            self.state.handle_fullscreen(MockEvent(KEYDOWN, K_f))
+        self.assertFalse(self.state.screen.fullscreen)
+        self.assertEqual(self.state.drawn, 2)
+
+    def test_multiple_events(self):
+        self.state.screen.fullscreen = False
+        with unittest.mock.patch.object(
+                pygame.display, 'set_mode', self.mock_set_mode):
+            self.state.handle_events([MockEvent(KEYDOWN, K_f), MockEvent(QUIT)])
+        self.assertTrue(self.state.screen.fullscreen)
+        self.assertEqual(self.state.drawn, 2)
         self.assertFalse(self.state.active)
 
+    def test_run(self):
+        self.state.screen.fullscreen = False
+        with unittest.mock.patch.object(
+                pygame.display, 'set_mode', self.mock_set_mode):
+            with unittest.mock.patch.object(pygame.event, 'get') as mock_get:
+                mock_get.return_value = [
+                    MockEvent(KEYDOWN, K_f),
+                    MockEvent(KEYDOWN, K_f),
+                    MockEvent(KEYDOWN, K_q),
+                ]
+                self.state.run()
+        self.assertFalse(self.state.screen.fullscreen)
+        self.assertEqual(self.state.drawn, 3)
+        self.assertFalse(self.state.active)
+
+
+class TitleCardTest(unittest.TestCase):
+
+    def test_init(self):
+        with unittest.mock.patch('pygame.display', autospec=True):
+            with unittest.mock.patch('pygame.image', autospec=True):
+                with unittest.mock.patch('pygame.transform', autospec=True):
+                    state.TitleCard(MockScreen())
+
+
+class GameTest(unittest.TestCase):
+
+    def test_init(self):
+        with unittest.mock.patch('pygame.display', autospec=True):
+            state.Game(MockScreen())
+
 
 if __name__ == '__main__':
     unittest.main()