Galaxy Invaders Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial is aimed at making Galaxian-inspired arcade game that we will call **Galaxy Invaders**. This tutorial draws some ideas from Chapter 5 of Roberto Ulloa's excellent _Kivy: Interactive Applications in Python_. Pick up a copy if you are looking for a nice introduction to making apps or games with Kivy! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.0 Debug Code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we even begin, let's introduce some debugging features that make it easier to lay out an app:\n",
    "\n",
    "* First, put a rectangle around every widget we use.\n",
    "* Next, add a `DebugLabel` class, a randomly-colored button spanning the parent object. Useful for figuring out what your layout looks like as you build it.\n",
    "\n",
    "To make use of this code, add the following to your top-level `.kv` file. \n",
    "```\n",
    "#:include debug.kv\n",
    "```\n",
    "\n",
    "When you are done, you can simply comment it out: \n",
    "\n",
    "```\n",
    "##:include debug.kv\n",
    "```\n",
    "\n",
    "or remove it entirely.\n",
    "\n",
    "Here's the complete `debug.kv`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting debug.kv\n"
     ]
    }
   ],
   "source": [
    "%%file debug.kv\n",
    "#:import random random\n",
    "    \n",
    "<Widget>:\n",
    "    canvas.after:\n",
    "        Color:\n",
    "            rgba: 1,1,1,.5\n",
    "        Line:\n",
    "            rectangle: self.x, self.y, self.width, self.height\n",
    "            width: 2\n",
    "                \n",
    "<DebugLabel@Button>:\n",
    "    size: self.parent.size\n",
    "    pos: self.parent.pos\n",
    "    background_color: random.random(), random.random(), random.random(), 0.6\n",
    "    text: 'debuglabel'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.0 Basic Screen Layout\n",
    "Let's divide the screen into areas.\n",
    "The bottom 30% will be the **player area**. The top 70% will be the **enemy area**. To help visualize what we are laying out, we will add some `DebugLabels` as we go:\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting galaxyinvaders.kv\n"
     ]
    }
   ],
   "source": [
    "%%file galaxyinvaders.kv\n",
    "#:include debug.kv\n",
    "<GalaxyInvaders>:\n",
    "    id: _mainscreen\n",
    "    enemy_area: _enemy_area\n",
    "    player_area: _player_area\n",
    "    BoxLayout:\n",
    "        orientation: 'vertical'\n",
    "        FloatLayout:\n",
    "            id: _enemy_area\n",
    "            size_hint: 1, 0.7\n",
    "            DebugLabel:\n",
    "                text: 'Enemy Area'\n",
    "        FloatLayout:\n",
    "            id: _player_area\n",
    "            size_hint: 1, 0.3\n",
    "            DebugLabel:\n",
    "                text: 'Player Area'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 IDs and References\n",
    "There is a magic property in a `.kv` file called **id**. This assigns a label to the python object that will be created for the specified indentation block. By convention, we will prefix our id labels with an underscore; e.g.\n",
    "\n",
    " `id: _mainscreen`\n",
    " \n",
    "Note this is only a convention. We don't *have* to do this, but sice it helps make our `.kv` file a little clearer, we will pretty much always do so. \n",
    "\n",
    "When this `.kv` file is loaded, it will add several properties to our `GalaxyInvaders` class: `enemy_area`, and `player_area`. These will contain refernces to the two FloatLayout objects we create on lines **9** and **14** of the `.kv` file. \n",
    "\n",
    "### 2.2 The Main Program\n",
    "Now, let's add the basic python code we need to create and display this layout. As usual, we call our main program `main.py`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%file main.py\n",
    "from kivy.app import App\n",
    "from kivy.uix.floatlayout import FloatLayout\n",
    "\n",
    "class GalaxyInvaders(FloatLayout):\n",
    "    pass\n",
    "\n",
    "class GalaxyInvadersApp(App):\n",
    "    def build(self):\n",
    "        return GalaxyInvaders()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    GalaxyInvadersApp().run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can see what this looks like by doing a \n",
    "```\n",
    "python main.py\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-1.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-1.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Adding the Fleet Area\n",
    "\n",
    "Now we need to add a placeholder for the **fleet**. A *fleet* is collection of placeholders (**docks**) for the invaders. In kivy terms, it will be a `GridLayout`. For now, you can think of the fleet is a moving rectangle inside the enemy area.\n",
    "\n",
    "Because we will want to add methods to it later, we will create an object called `Fleet`, which is a kind of `GridLayout`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting galaxyinvaders.kv\n"
     ]
    }
   ],
   "source": [
    "%%file galaxyinvaders.kv\n",
    "#:include debug.kv\n",
    "<GalaxyInvaders>:\n",
    "    id: _mainscreen\n",
    "    enemy_area: _enemy_area\n",
    "    player_area: _player_area\n",
    "    BoxLayout:\n",
    "        orientation: 'vertical'\n",
    "        FloatLayout:\n",
    "            id: _enemy_area\n",
    "            size_hint: 1, 0.7\n",
    "            DebugLabel:\n",
    "                text: 'enemy area'\n",
    "            Fleet:\n",
    "                id: _fleet\n",
    "                size_hint: .5, .4\n",
    "                pos_hint: {'top': .9, 'center_x': 0.5}\n",
    "                DebugLabel:\n",
    "                    text: 'fleet'                    \n",
    "        FloatLayout:\n",
    "            id: _player_area\n",
    "            size_hint: 1, 0.3\n",
    "            DebugLabel:\n",
    "                text: 'player area'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Take notice of the `pos_hint` on line **17**. This will eventually burn us. We have used `center_x` to place the fleet in the middle of the screen, but we will eventually want to move the fleet by setting its `x` property directly. The guiding principle of using Layouts in kivy is that if you want absolute (pixel-level) control, vs relative (`size_hint` and `pos_hint`), you have to set the appropriate hint to `None`.\n",
    "\n",
    "We will leave it for now. But note eventually we will need to set it to something like\n",
    "```\n",
    "pos_hint: {'top': 0.9}\n",
    "x: Window.width/2 - Window.width/4\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we declare `Fleet` to be a `GridLayout` in `main.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%file main.py\n",
    "from kivy.app import App\n",
    "from kivy.uix.floatlayout import FloatLayout\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "\n",
    "class Fleet(GridLayout):\n",
    "    pass\n",
    "\n",
    "class GalaxyInvaders(FloatLayout):\n",
    "    pass\n",
    "\n",
    "class GalaxyInvadersApp(App):\n",
    "    def build(self):\n",
    "        return GalaxyInvaders()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    GalaxyInvadersApp().run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-2.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-2.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.0 Sprites: Images and Atlases\n",
    "Let's create the basic sprites for our game. We will need\n",
    "* The player's ship (`Player`), \n",
    "* An alien ship (`Invader`)\n",
    "* An explosion (`Boom`)\n",
    "* Player and Invader `Projectile` (`Missile` and `Bomb` respectively)\n",
    "\n",
    "However you acquire these images, for efficiency reasons, you should put them inside an **atlas** (also known as a *spritesheet*. We can generate an atlas/spritesheet from a set of files using kivy: `python -m kivy.atlas basename size filelist`; e.g.\n",
    "\n",
    " `python -m kivy.atlas galaxy 100 *.png`\n",
    "\n",
    "Here _size_ is the maximum dimension of the spritesheet.\n",
    "\n",
    "Doing the above, you get an atlas file that looks like this:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting assets/sprites/galaxy.atlas\n"
     ]
    }
   ],
   "source": [
    "%%file assets/sprites/galaxy.atlas\n",
    "{\"galaxy-0.png\": {\"missile\": [42, 35, 10, 13], \n",
    "                  \"player\": [52, 50, 48, 48], \n",
    "                  \"invader\": [2, 50, 48, 48], \n",
    "                  \"boom\": [2, 18, 26, 30], \n",
    "                  \"bomb\": [30, 29, 10, 19]}}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can create image objects from these sprites. (Note, you should obtain the sizes from the generated atlas file, or the original sprites):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting sprites.kv\n"
     ]
    }
   ],
   "source": [
    "%%file sprites.kv\n",
    "<Invader>:\n",
    "    source: 'atlas://assets/sprites/galaxy/invader'\n",
    "    size_hint: None, None\n",
    "    size: 40, 40\n",
    "<Player>:\n",
    "    source: 'atlas://assets/sprites/galaxy/player'\n",
    "    size_hint: None, None\n",
    "    size: 40, 40\n",
    "<Boom>:\n",
    "    source: 'atlas://assets/sprites/galaxy/boom'\n",
    "    size_hint: None, None\n",
    "    size: 26, 30\n",
    "<Missile>:\n",
    "    source: 'atlas://assets/sprites/galaxy/missile'\n",
    "    size_hint: None, None\n",
    "    size: 12, 15\n",
    "<Bomb>:\n",
    "    source: 'atlas://assets/sprites/galaxy/bomb'\n",
    "    size_hint: None, None\n",
    "    size: 12, 27\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a new class for the **Player**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting player.py\n"
     ]
    }
   ],
   "source": [
    "%%file player.py\n",
    "from kivy.uix.image import Image\n",
    "\n",
    "class Player(Image):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's load the `sprites.kv` kivy file manually. We will include our new player object, and then call `kivy.lang.builder.load_file()` to read the associated `.kv` file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%file main.py\n",
    "from kivy.app import App\n",
    "from kivy.uix.floatlayout import FloatLayout\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.lang.builder import Builder\n",
    "from player import Player\n",
    "\n",
    "Builder.load_file('sprites.kv')\n",
    "\n",
    "class Fleet(GridLayout):\n",
    "    pass\n",
    "\n",
    "class GalaxyInvaders(FloatLayout):\n",
    "    pass\n",
    "\n",
    "class GalaxyInvadersApp(App):\n",
    "    def build(self):\n",
    "        return GalaxyInvaders()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    GalaxyInvadersApp().run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only change necessary to the `galaxyinvaders.kv` is to add the `Player` object to the `player_area`. We are not going to use a `pos_hint` to position it, as we want to be able to move it via x coordinate later, so we will use an absolute x coordinate. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting galaxyinvaders.kv\n"
     ]
    }
   ],
   "source": [
    "%%file galaxyinvaders.kv\n",
    "#:include debug.kv\n",
    "<GalaxyInvaders>:\n",
    "    id: _mainscreen\n",
    "    enemy_area: _enemy_area\n",
    "    player_area: _player_area\n",
    "    player: _player\n",
    "    fleet: _fleet\n",
    "    BoxLayout:\n",
    "        orientation: 'vertical'\n",
    "        FloatLayout:\n",
    "            id: _enemy_area\n",
    "            size_hint: 1, 0.7\n",
    "            DebugLabel:\n",
    "                text: 'enemy area'\n",
    "            Fleet:\n",
    "                id: _fleet\n",
    "                size_hint: .5, .4\n",
    "                pos_hint: {'top': .9, 'center_x': 0.5}\n",
    "                DebugLabel:\n",
    "                    text: 'fleet'                    \n",
    "        FloatLayout:\n",
    "            id: _player_area\n",
    "            size_hint: 1, 0.3\n",
    "            Player:\n",
    "                id: _player\n",
    "                mainscreen: _mainscreen\n",
    "                player_area: _player_area\n",
    "                x: self.parent.width / 2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we have starting using the player area, we can safely dropped the `DebugLabel` code that used to identify it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-3.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-3.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.0 Controls\n",
    "Let's make the player move. We can use touches for this, the keyboard, or both. We are obviously going to do both.\n",
    "\n",
    "### 4.1 Using the Keyboard\n",
    "First, let's bind movement to the **left** and **right** arrow keys.\n",
    "\n",
    "In our app initialization, we will get a handle to a keyboard (if present) using the Window object's  `request_keyboard()` method. Then we can set up a handler for keypresses. Since we are mapping keys, we may as well use **Esc** to quit our game. \n",
    "\n",
    "Notice we use `App.get_running_app()` to get a handle to our `GalaxyInvadersApp` instance so that we can shut it down. This technique for accessing the root app is going to be very handy when we get around to adding sound."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%file main.py\n",
    "from kivy.app import App\n",
    "from kivy.uix.floatlayout import FloatLayout\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.lang.builder import Builder\n",
    "from kivy.core.window import Window\n",
    "from kivy.logger import Logger\n",
    "\n",
    "from player import Player\n",
    "\n",
    "Builder.load_file('sprites.kv')\n",
    "\n",
    "class Fleet(GridLayout):\n",
    "    pass\n",
    "\n",
    "class GalaxyInvaders(FloatLayout):\n",
    "    def __init__(self, **kwargs):\n",
    "        super(GalaxyInvaders, self).__init__(**kwargs)\n",
    "        self._keyboard = Window.request_keyboard(self.close, self)\n",
    "        self._keyboard.bind(on_key_down=self.press)\n",
    "        \n",
    "    def close(self):\n",
    "        self._keyboard.unbind(on_key_down=self.press)\n",
    "        self._keyboard = None\n",
    "        # Eventually, we should do an 'Are You Sure?' prompt. For now, just quit\n",
    "        App.get_running_app().stop() \n",
    "        \n",
    "    def press(self, keyboard, keycode, text, modifiers):\n",
    "        if keycode[1] == 'left':\n",
    "            self.player.x -= 30\n",
    "            if self.player.x < self.x:\n",
    "                self.player.x = self.x\n",
    "        elif keycode[1] == 'right':\n",
    "            self.player.x += 30\n",
    "            if self.player.x > self.width - self.player.width:\n",
    "                self.player.x = self.width - self.player.width\n",
    "        elif keycode[1] == 'escape':\n",
    "            self.close()\n",
    "        else:\n",
    "            Logger.debug(\"Unknown key: {}\".format(keycode))\n",
    "        return True\n",
    "\n",
    "class GalaxyInvadersApp(App):\n",
    "    def build(self):\n",
    "        return GalaxyInvaders()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    GalaxyInvadersApp().run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also notice (Lines **7**, **40**) that we are using the kivy `Logger` class to write out debug information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-4a.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-4a.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Using Touches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keyboard is great and all, but touch screens are half the fun of kivy, so let's add those. \n",
    "\n",
    "So, how should we move our object by touch? Our first idea is simply by dragging it. We will start a move by touching **on** our object. Since we can drag off of our object (but we want the ship to continue moving), we will want to **grab** the touch to ensure we get all later messages. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting player.py\n"
     ]
    }
   ],
   "source": [
    "%%file player.py\n",
    "from kivy.uix.image import Image\n",
    "from kivy.logger import Logger\n",
    "\n",
    "class Player(Image):\n",
    "    def on_touch_down(self, touch):\n",
    "        if self.collide_point(*touch.pos):\n",
    "            self.center_x = touch.x\n",
    "            touch.grab(self)\n",
    "            return True\n",
    "            \n",
    "    def on_touch_move(self, touch):\n",
    "        if touch.grab_current is self:\n",
    "            self.center_x = touch.x\n",
    "            return True\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kivy has a funny (but useful) design for messages. All widgets receive all messages, regardless of where the originate. So in this case, every widget will receive an `on_touch_down` event. It's up to the individual widgets to check if this message is destined for them.\n",
    "\n",
    "In our code, we perform this test by checking `if self.collide_point(*touch_pos)` (Line **7**); i.e. if the touch collides with the widget `self`.\n",
    "\n",
    "Similarly, all widgets will receive the `on_touch_move` message. Since we only want to move the ship if the drag started with a touch on the `Player` object, we will use the grab information to do this test for us (Line **13**).\n",
    "\n",
    "Try it out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-4b.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-4b.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.0 Projectiles: Bombs and Missiles\n",
    "There will be 2 kinds of projectiles in the game:\n",
    "* **Missiles**, fired by the player\n",
    "* **Bombs**, fired by the invaders\n",
    "\n",
    "We will use a single class (`Projectile`) for both types, and override as necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting projectile.py\n"
     ]
    }
   ],
   "source": [
    "%%file projectile.py\n",
    "from kivy.animation import Animation\n",
    "from kivy.uix.image import Image\n",
    "\n",
    "class Projectile(Image):\n",
    "    '''Lauch this piece of ammunition towards a target object (`target`),\n",
    "    located at coordinates (`tx`, `ty`).\n",
    "    \n",
    "    When the projectile reaches its target, it disappears. Collision handling is done elsewhere.\n",
    "\n",
    "    The `target` object is used to determine which collide_projectile method to check for collision\n",
    "    in the on_progress method of the projectile.\n",
    "    '''\n",
    "    \n",
    "    def shoot(self, tx, ty, target):\n",
    "        self.target = target\n",
    "        self.animation = Animation(x=tx, y=ty)\n",
    "        self.animation.bind(on_start=self.on_start)\n",
    "        self.animation.bind(on_progress=self.on_progress)\n",
    "        self.animation.bind(on_complete=self.on_stop)\n",
    "        self.animation.start(self)\n",
    "        \n",
    "    def on_start(self, instance, value):\n",
    "        pass\n",
    "    \n",
    "    def on_progress(self, instance, value, progression):\n",
    "        pass\n",
    "            \n",
    "    def on_stop(self, instance, value):\n",
    "        self.parent.remove_widget(self)\n",
    "        \n",
    "\n",
    "class Missile(Projectile):\n",
    "    pass\n",
    "\n",
    "\n",
    "class Bomb(Projectile):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We already saw how to bind events to keypresses, so let's bind \"shoot\" to **Spacebar**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%file main.py\n",
    "from kivy.app import App\n",
    "from kivy.uix.floatlayout import FloatLayout\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.lang.builder import Builder\n",
    "from kivy.core.window import Window\n",
    "from kivy.logger import Logger\n",
    "\n",
    "from player import Player\n",
    "\n",
    "Builder.load_file('sprites.kv')\n",
    "\n",
    "class Fleet(GridLayout):\n",
    "    pass\n",
    "\n",
    "class GalaxyInvaders(FloatLayout):\n",
    "    def __init__(self, **kwargs):\n",
    "        super(GalaxyInvaders, self).__init__(**kwargs)\n",
    "        self._keyboard = Window.request_keyboard(self.close, self)\n",
    "        self._keyboard.bind(on_key_down=self.press)\n",
    "        \n",
    "    def close(self):\n",
    "        self._keyboard.unbind(on_key_down=self.press)\n",
    "        self._keyboard = None\n",
    "        # Eventually, we should do an 'Are You Sure?' prompt. For now, just quit\n",
    "        App.get_running_app().stop() \n",
    "        \n",
    "    def press(self, keyboard, keycode, text, modifiers):\n",
    "        if keycode[1] == 'left':\n",
    "            self.player.x -= 30\n",
    "            if self.player.x < self.x:\n",
    "                self.player.x = self.x\n",
    "        elif keycode[1] == 'right':\n",
    "            self.player.x += 30\n",
    "            if self.player.x > self.width - self.player.width:\n",
    "                self.player.x = self.width - self.player.width\n",
    "        elif keycode[1] == 'escape':\n",
    "            self.close()\n",
    "        elif keycode[1] == 'spacebar':\n",
    "            self.player.shoot()\n",
    "        else:\n",
    "            Logger.debug(\"Unknown key: {} {}\".format(keycode, modifiers))\n",
    "        return True\n",
    "\n",
    "class GalaxyInvadersApp(App):\n",
    "    def build(self):\n",
    "        return GalaxyInvaders()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    GalaxyInvadersApp().run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lines **39-40** handle the keyboard shooing. As for the touch controls, any touch in the player area (that isn't directly on the player) will shoot. This is handled in lines **13-15** below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting player.py\n"
     ]
    }
   ],
   "source": [
    "%%file player.py\n",
    "from kivy.uix.image import Image\n",
    "from kivy.logger import Logger\n",
    "from kivy.graphics import Line, Ellipse\n",
    "from projectile import Missile\n",
    "\n",
    "class Player(Image):\n",
    "    def on_touch_down(self, touch):\n",
    "        if self.collide_point(*touch.pos):\n",
    "            self.center_x = touch.x\n",
    "            touch.grab(self)\n",
    "            return True\n",
    "        elif self.player_area.collide_point(*touch.pos):\n",
    "            self.shoot()\n",
    "            return True\n",
    "            \n",
    "    def on_touch_move(self, touch):\n",
    "        if touch.grab_current is self:\n",
    "            self.center_x = touch.x\n",
    "            return True\n",
    "        \n",
    "    def shoot(self):\n",
    "        '''Shoot straight up.'''\n",
    "        missile = Missile()\n",
    "        missile.center = (self.center_x, self.top)\n",
    "        self.mainscreen.add_widget(missile)\n",
    "        (fx, fy) = self.center_x, self.mainscreen.height\n",
    "        missile.shoot(fx, fy, self.mainscreen.fleet)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally the shot method (starting on line **22**) handles sending the missile on its way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-5b.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-5b.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.0 Explosions and Sound Effects\n",
    "Let's add an explosion when the missile hits something. Since we haven't added enemies yet, the only thing we have to hit is the top of the screen. We can do this by adding an explosion sprite in the projectile's `on_stop` handler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting projectile.py\n"
     ]
    }
   ],
   "source": [
    "%%file projectile.py\n",
    "from kivy.animation import Animation\n",
    "from kivy.uix.image import Image\n",
    "from kivy.logger import Logger\n",
    "from boom import Boom\n",
    "\n",
    "class Projectile(Image):\n",
    "    '''Lauch this piece of ammunition towards a target object (`target`),\n",
    "    located at coordinates (`tx`, `ty`).\n",
    "    \n",
    "    When the projectile reaches its target, it disappears. Collision handling is done elsewhere.\n",
    "\n",
    "    The `target` object is used to determine which collide_projectile method to check for collision\n",
    "    in the on_progress method of the projectile.\n",
    "    '''\n",
    "    \n",
    "    def shoot(self, tx, ty, target):\n",
    "        self.target = target\n",
    "        self.animation = Animation(x=tx, y=ty-40)\n",
    "        self.animation.bind(on_start=self.on_start)\n",
    "        self.animation.bind(on_progress=self.on_progress)\n",
    "        self.animation.bind(on_complete=self.on_stop)\n",
    "        self.animation.start(self)\n",
    "        \n",
    "    def on_start(self, instance, value):\n",
    "        pass\n",
    "    \n",
    "    def on_progress(self, instance, value, progression):\n",
    "        pass\n",
    "            \n",
    "    def on_stop(self, instance, value):\n",
    "        boom = Boom()\n",
    "        boom.pos = self.pos\n",
    "        self.parent.add_widget(boom)\n",
    "        self.parent.remove_widget(self)\n",
    "\n",
    "        \n",
    "class Missile(Projectile):\n",
    "    pass\n",
    "\n",
    "\n",
    "class Bomb(Projectile):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, we have added a gross hack on line **19**, to stop the projectile 30 pixels short of its target. This gives us enough space to draw the explosion. We will fix this hack soon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are obviously two things wrong with this explosion.\n",
    "* It sticks around forever: it should eventually disappear, and\n",
    "* it doesn't go \"boom\". \n",
    "\n",
    "For the former, let's schedule a removal using the `Clock`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting boom.py\n"
     ]
    }
   ],
   "source": [
    "%%file boom.py\n",
    "from kivy.uix.image import Image\n",
    "from kivy.clock import Clock\n",
    "\n",
    "\n",
    "class Boom(Image):\n",
    "    def __init__(self, **kwargs):\n",
    "        super(Boom, self).__init__(**kwargs)\n",
    "        Clock.schedule_once(lambda dt:self.parent.remove_widget(self), 0.2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `lambda` function on line **9** fixes the fact that `schedule_once` wants a function that takes a parameter `dt`. The `lambda` function creates an unnamed function that ignores this argument.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the second problem, we need to add sound. Let's get to it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.1 The wrong way to do sound\n",
    "It seems like we could just play the sound as part of the `boom` constructor, but this runs into a subtle problem: the sound can only be played once. Try firing multiple bombs and listening for the explosions.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting boom.py\n"
     ]
    }
   ],
   "source": [
    "%%file boom.py\n",
    "from kivy.uix.image import Image\n",
    "from kivy.clock import Clock\n",
    "from kivy.core.audio import SoundLoader\n",
    "\n",
    "\n",
    "class Boom(Image):\n",
    "    sound = SoundLoader.load('assets/sound/boom3.wav')\n",
    "    def __init__(self, **kwargs):\n",
    "        super(Boom, self).__init__(**kwargs)\n",
    "        self.play_sound()\n",
    "        Clock.schedule_once(lambda dt:self.parent.remove_widget(self), 0.2)\n",
    "\n",
    "    def play_sound(self):\n",
    "        self.sound.play()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll hear one explosion, and when it finishes, you'll hear the next. This isn't what we want. We want sounds that overlap. To do this, we need to do something a little more drastic.\n",
    "\n",
    "### 6.2 The right way to do sound\n",
    "Here we will create a `Sounds` object with a magic `play_name` method that loads a sound called `name.wav`. Whenver a sound is played, it checks to see if there is a `SoundLoader` with that name that is currently **stopped**. If yes, it plays the sound. If no, it adds a new `SoundLoader` and plays the sound. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting sounds.py\n"
     ]
    }
   ],
   "source": [
    "%%file sounds.py\n",
    "from kivy.core.audio import SoundLoader\n",
    "from kivy.logger import Logger\n",
    "\n",
    "class Sounds(object):\n",
    "\n",
    "    def __init__(self, **kw):\n",
    "        self.sounds = {}\n",
    "        super(Sounds, self).__init__(**kw)\n",
    "    \n",
    "    def __getattr__(self, attr, volume=None):\n",
    "        if not attr.startswith('play_'):\n",
    "            return object.__getattribute__(self, attr)\n",
    "        f = attr.split('play_')[1]\n",
    "        sounds = getattr(self, 'sounds')\n",
    "        loaded = sounds.get(f, [])\n",
    "        ready = None\n",
    "        for l in loaded:\n",
    "            if l.state == 'stop':\n",
    "                ready = l\n",
    "                break\n",
    "        if ready == None:\n",
    "            ready = SoundLoader.load('assets/sound/' + f + '.wav')\n",
    "            sounds[f] = loaded\n",
    "            loaded.append(ready)\n",
    "            Logger.debug(\"Sounds: Loading {}. {} loaded\".format(f, len(sounds[f])))\n",
    "        return ready.play\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%file main.py\n",
    "from kivy.app import App\n",
    "from kivy.uix.floatlayout import FloatLayout\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.lang.builder import Builder\n",
    "from kivy.core.window import Window\n",
    "from kivy.logger import Logger\n",
    "\n",
    "from player import Player\n",
    "from sounds import Sounds\n",
    "\n",
    "Builder.load_file('sprites.kv')\n",
    "\n",
    "\n",
    "class Fleet(GridLayout):\n",
    "    pass\n",
    "\n",
    "\n",
    "class GalaxyInvaders(FloatLayout):\n",
    "    def __init__(self, **kwargs):\n",
    "        super(GalaxyInvaders, self).__init__(**kwargs)\n",
    "        self._keyboard = Window.request_keyboard(self.close, self)\n",
    "        self._keyboard.bind(on_key_down=self.press)\n",
    "        \n",
    "    def close(self):\n",
    "        self._keyboard.unbind(on_key_down=self.press)\n",
    "        self._keyboard = None\n",
    "        # Eventually, we should do an 'Are You Sure?' prompt. For now, just quit\n",
    "        App.get_running_app().stop() \n",
    "        \n",
    "    def press(self, keyboard, keycode, text, modifiers):\n",
    "        if keycode[1] == 'left':\n",
    "            self.player.x -= 30\n",
    "            if self.player.x < self.x:\n",
    "                self.player.x = self.x\n",
    "        elif keycode[1] == 'right':\n",
    "            self.player.x += 30\n",
    "            if self.player.x > self.width - self.player.width:\n",
    "                self.player.x = self.width - self.player.width\n",
    "        elif keycode[1] == 'escape':\n",
    "            self.close()\n",
    "        elif keycode[1] == 'spacebar':\n",
    "            self.player.shoot()\n",
    "        else:\n",
    "            Logger.debug(\"Unknown key: {}\".format(keycode))\n",
    "        return True\n",
    "\n",
    "class GalaxyInvadersApp(App):\n",
    "    sounds = Sounds()\n",
    "    def build(self):\n",
    "        return GalaxyInvaders()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    GalaxyInvadersApp().run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, `App.get_running_app().sounds` seems a bit awkward, but I haven't yet found a better place to put it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting boom.py\n"
     ]
    }
   ],
   "source": [
    "%%file boom.py\n",
    "from kivy.uix.image import Image\n",
    "from kivy.core.audio import SoundLoader\n",
    "from kivy.app import App\n",
    "from kivy.clock import Clock\n",
    "\n",
    "\n",
    "class Boom(Image):\n",
    "    def __init__(self, **kwargs):\n",
    "        super(Boom, self).__init__(**kwargs)\n",
    "        self.play_sound()\n",
    "        Clock.schedule_once(lambda dt:self.parent.remove_widget(self), 0.2)\n",
    "        \n",
    "    def play_sound(self):\n",
    "        App.get_running_app().sounds.play_boom3()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.0 Building the Invasion Fleet\n",
    "\n",
    "Most of the time, enemy invaders fly in formation. In Galaxian, and similar games, enemies sometimes leave this formation to go on a bombing run. We will ignore this behavior for now, and focus on the movement in formation. We call this formation the `Fleet`. The `Fleet` is really a collection of `Dock`s; i.e. places for invaders to sit while they move in formation. We will add these docks using a `GridLayout`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting dock.py\n"
     ]
    }
   ],
   "source": [
    "%%file dock.py\n",
    "from kivy.uix.widget import Widget\n",
    "\n",
    "class Dock(Widget):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to add the right number of rows and columns to the fleet `GridLayout`, and change the pos_hint to not specify the x coordinate, as we will use it directly to do movement. In this case, we will specify 8 columns. We will finally lose our `DebugLabels` while we are at it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting galaxyinvaders.kv\n"
     ]
    }
   ],
   "source": [
    "%%file galaxyinvaders.kv\n",
    "#:include debug.kv\n",
    "<GalaxyInvaders>:\n",
    "    id: _mainscreen\n",
    "    enemy_area: _enemy_area\n",
    "    player_area: _player_area\n",
    "    player: _player\n",
    "    fleet: _fleet\n",
    "    BoxLayout:\n",
    "        orientation: 'vertical'\n",
    "        FloatLayout:\n",
    "            id: _enemy_area\n",
    "            size_hint: 1, 0.7\n",
    "            Fleet:\n",
    "                id: _fleet\n",
    "                mainscreen: _mainscreen\n",
    "                size_hint: .5, .4\n",
    "                pos_hint: {'top': .9}\n",
    "                x: root.width/2 - root.width/4\n",
    "                cols: 8\n",
    "                spacing: 20\n",
    "                    \n",
    "        FloatLayout:\n",
    "            id: _player_area\n",
    "            size_hint: 1, 0.3\n",
    "            Player:\n",
    "                id: _player\n",
    "                mainscreen: _mainscreen\n",
    "                player_area: _player_area\n",
    "                x: self.parent.width / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We initialize the docks in the `Fleet` constructor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting fleet.py\n"
     ]
    }
   ],
   "source": [
    "%%file fleet.py\n",
    "\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.core.window import Window\n",
    "from dock import Dock\n",
    "\n",
    "class Fleet(GridLayout):\n",
    "    \n",
    "    def __init__(self, **kwargs):\n",
    "        super(Fleet, self).__init__(**kwargs)\n",
    "        for x in range (0,32):\n",
    "            dock = Dock()\n",
    "            self.add_widget(dock)\n",
    "        self.center_x = Window.width/4\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We load the new  load the fleet on line **11** of `main.py`, replacing the old empty class declaration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%file main.py\n",
    "from kivy.app import App\n",
    "from kivy.uix.floatlayout import FloatLayout\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.lang.builder import Builder\n",
    "from kivy.core.window import Window\n",
    "from kivy.logger import Logger\n",
    "from kivy.core.audio import SoundLoader\n",
    "\n",
    "from player import Player\n",
    "from fleet import Fleet\n",
    "from sounds import Sounds\n",
    "\n",
    "Builder.load_file('sprites.kv')\n",
    "\n",
    "\n",
    "class GalaxyInvaders(FloatLayout):\n",
    "    def __init__(self, **kwargs):\n",
    "        super(GalaxyInvaders, self).__init__(**kwargs)\n",
    "        self._keyboard = Window.request_keyboard(self.close, self)\n",
    "        self._keyboard.bind(on_key_down=self.press)\n",
    "        \n",
    "    def close(self):\n",
    "        self._keyboard.unbind(on_key_down=self.press)\n",
    "        self._keyboard = None\n",
    "        # Eventually, we should do an 'Are You Sure?' prompt. For now, just quit\n",
    "        App.get_running_app().stop() \n",
    "        \n",
    "    def press(self, keyboard, keycode, text, modifiers):\n",
    "        if keycode[1] == 'left':\n",
    "            self.player.x -= 30\n",
    "            if self.player.x < self.x:\n",
    "                self.player.x = self.x\n",
    "        elif keycode[1] == 'right':\n",
    "            self.player.x += 30\n",
    "            if self.player.x > self.width - self.player.width:\n",
    "                self.player.x = self.width - self.player.width\n",
    "        elif keycode[1] == 'escape':\n",
    "            self.close()\n",
    "        elif keycode[1] == 'spacebar':\n",
    "            self.player.shoot()\n",
    "        else:\n",
    "            Logger.debug(\"Unknown key: {}\".format(keycode))\n",
    "        return True\n",
    "\n",
    "class GalaxyInvadersApp(App):\n",
    "    sounds = Sounds()\n",
    "    def build(self):\n",
    "        return GalaxyInvaders()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    GalaxyInvadersApp().run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-7.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-7.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.1 Animating the Fleet\n",
    "First we used animations to fire projectiles. Now we are going to use them to move the fleet.\n",
    "\n",
    "We set a property, `move_delay` to indicate how long it takes for the fleet to move from side to side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting fleet.py\n"
     ]
    }
   ],
   "source": [
    "%%file fleet.py\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.animation import Animation\n",
    "from kivy.clock import Clock\n",
    "from kivy.core.window import Window\n",
    "from kivy.properties import NumericProperty\n",
    "from kivy.logger import Logger\n",
    "\n",
    "from random import randint, random\n",
    "from dock import Dock\n",
    "\n",
    "class Fleet(GridLayout):\n",
    "    move_delay = NumericProperty(3)\n",
    "    \n",
    "    def __init__(self, **kwargs):\n",
    "        super(Fleet, self).__init__(**kwargs)\n",
    "        for x in range (0,32):\n",
    "            dock = Dock()\n",
    "            self.add_widget(dock)\n",
    "    \n",
    "    def start_fleet(self, instance=None, value=None):\n",
    "        '''Start the fleet march'''\n",
    "        self.x = Window.width/2 - Window.width/4 # why do I need this?\n",
    "        self.go_left(instance, None)\n",
    "        \n",
    "    def go_left(self, instance, value):\n",
    "        '''Move the fleet towards the left edge of the screen. \n",
    "        Normally the fleet moves from the right side of the screen.\n",
    "        If if `value` is None, however, we are calling the animation for the first time,\n",
    "        in which case, the animation starts from the middle of the screen, so we half the\n",
    "        nimation duration'''\n",
    "        if value is None:\n",
    "            animation = Animation(x=0, d=self.move_delay / 2.0)\n",
    "        else:\n",
    "            animation = Animation(x=0, d=self.move_delay)\n",
    "        animation.bind(on_complete = self.go_right)\n",
    "        animation.start(self)\n",
    "    \n",
    "    def go_right(self, instance, value):\n",
    "        '''Move the fleet towards the right edge of the screen.'''\n",
    "        animation = Animation(right=self.parent.width, d=self.move_delay)\n",
    "        animation.bind(on_complete=self.go_left)\n",
    "        animation.start(self)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the way we loop animations. We schedule the next animation as part of the animation's `on_complete` event."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%file main.py\n",
    "from kivy.app import App\n",
    "from kivy.uix.floatlayout import FloatLayout\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.lang.builder import Builder\n",
    "from kivy.core.window import Window\n",
    "from kivy.logger import Logger\n",
    "from kivy.core.audio import SoundLoader\n",
    "from kivy.clock import Clock\n",
    "from kivy.uix.label import Label\n",
    "from kivy.animation import Animation\n",
    "\n",
    "from player import Player\n",
    "from sounds import Sounds\n",
    "from fleet import Fleet\n",
    "\n",
    "Builder.load_file('sprites.kv')\n",
    "\n",
    "\n",
    "class GalaxyInvaders(FloatLayout):\n",
    "    def __init__(self, **kwargs):\n",
    "        super(GalaxyInvaders, self).__init__(**kwargs)\n",
    "        self._keyboard = Window.request_keyboard(self.close, self)\n",
    "        self._keyboard.bind(on_key_down=self.press)\n",
    "        self.start_game()\n",
    "        \n",
    "    def start_game(self):\n",
    "        self.fleet.start_fleet(self.fleet)\n",
    "\n",
    "    def close(self):\n",
    "        self._keyboard.unbind(on_key_down=self.press)\n",
    "        self._keyboard = None\n",
    "        # Eventually, we should do an 'Are You Sure?' prompt. For now, just quit\n",
    "        App.get_running_app().stop() \n",
    "        \n",
    "    def press(self, keyboard, keycode, text, modifiers):\n",
    "        if keycode[1] == 'left':\n",
    "            self.player.x -= 30\n",
    "            if self.player.x < self.x:\n",
    "                self.player.x = self.x\n",
    "        elif keycode[1] == 'right':\n",
    "            self.player.x += 30\n",
    "            if self.player.x > self.width - self.player.width:\n",
    "                self.player.x = self.width - self.player.width\n",
    "        elif keycode[1] == 'escape':\n",
    "            self.close()\n",
    "        elif keycode[1] == 'spacebar':\n",
    "            self.player.shoot()\n",
    "        else:\n",
    "            Logger.debug(\"Unknown key: {}\".format(keycode))\n",
    "        return True\n",
    "\n",
    "class GalaxyInvadersApp(App):\n",
    "    sounds = Sounds()\n",
    "    def build(self):\n",
    "        return GalaxyInvaders()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    GalaxyInvadersApp().run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-8.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-8.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2 A Diversion: Spit and Polish\n",
    "Let's take a moment to add some polish. Let's explain the keys to the user, and add the 's' key to start. Also, prepare the user with an introductory animation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%file main.py\n",
    "from kivy.app import App\n",
    "from kivy.uix.floatlayout import FloatLayout\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.lang.builder import Builder\n",
    "from kivy.core.window import Window\n",
    "from kivy.logger import Logger\n",
    "from kivy.core.audio import SoundLoader\n",
    "from kivy.clock import Clock\n",
    "from kivy.uix.label import Label\n",
    "from kivy.animation import Animation\n",
    "\n",
    "from player import Player\n",
    "from sounds import Sounds\n",
    "from fleet import Fleet\n",
    "\n",
    "Builder.load_file('sprites.kv')\n",
    "\n",
    "\n",
    "class GalaxyInvaders(FloatLayout):\n",
    "    playing = False\n",
    "    unlocked = False\n",
    "    message = None\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(GalaxyInvaders, self).__init__(**kwargs)\n",
    "        self._keyboard = Window.request_keyboard(self.close, self)\n",
    "        self._keyboard.bind(on_key_down=self.press)\n",
    "        label = Label(text=\"Press [b]S[/b] to start\\n[b]<- ->[/b] to move\\n[b]Space[/b] to shoot\\n[b]Esc[/b] to quit\",\n",
    "                     halign='center', markup=True)\n",
    "        self.add_widget(label)\n",
    "        self.help_text = label\n",
    "        \n",
    "    def start_game(self):\n",
    "        '''Display a  'ready' message before a game starts.\n",
    "        When the animation is done, start the game.'''\n",
    "        label = Label(text='Ready!')\n",
    "        animation = Animation(font_size=72, d=2)\n",
    "        animation += Animation(font_size=0, d=2)\n",
    "        self.add_widget(label)\n",
    "        self.message = label\n",
    "        animation.bind(on_complete=self.fleet.start_fleet)\n",
    "        animation.bind(on_complete=self.remove_message)\n",
    "        animation.start(label)\n",
    "        \n",
    "    def remove_message(self, instance, value):\n",
    "        '''Remove the message text when the animation is done'''\n",
    "        self.remove_widget(self.message)\n",
    "        self.message = None\n",
    "\n",
    "    def close(self):\n",
    "        self._keyboard.unbind(on_key_down=self.press)\n",
    "        self._keyboard = None\n",
    "        # Eventually, we should do an 'Are You Sure?' prompt. For now, just quit\n",
    "        App.get_running_app().stop() \n",
    "        \n",
    "    def press(self, keyboard, keycode, text, modifiers):\n",
    "        '''Handle key commands, with different modes for playing, not playing'''\n",
    "        if keycode[1] == 'escape':\n",
    "                self.close()\n",
    "                return True\n",
    "\n",
    "        if not self.playing:\n",
    "            if keycode[1] == 's':\n",
    "                self.remove_widget(self.help_text)\n",
    "                self.playing = True\n",
    "                self.start_game()\n",
    "        else:\n",
    "            if keycode[1] == 'left':\n",
    "                self.player.x -= 30\n",
    "                if self.player.x < self.x:\n",
    "                    self.player.x = self.x\n",
    "            elif keycode[1] == 'right':\n",
    "                self.player.x += 30\n",
    "                if self.player.x > self.width - self.player.width:\n",
    "                    self.player.x = self.width - self.player.width\n",
    "            elif keycode[1] == 'spacebar':\n",
    "                self.player.shoot()\n",
    "            else:\n",
    "                Logger.debug(\"Unknown key: {}\".format(keycode))\n",
    "        return True\n",
    "\n",
    "class GalaxyInvadersApp(App):\n",
    "    sounds = Sounds()\n",
    "    def build(self):\n",
    "        return GalaxyInvaders()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    GalaxyInvadersApp().run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-9.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-9.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 7.3 Adding the Invaders"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's put some invaders in there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting invader.py\n"
     ]
    }
   ],
   "source": [
    "%%file invader.py\n",
    "\n",
    "from kivy.uix.image import Image\n",
    "\n",
    "class Invader(Image):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Invaders can be **docked** or **undocked**. If undocked, they will be following an attacking trajectory. Start with everything docked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting dock.py\n"
     ]
    }
   ],
   "source": [
    "%%file dock.py\n",
    "from kivy.uix.widget import Widget\n",
    "from invader import Invader\n",
    "\n",
    "class Dock(Widget):\n",
    "    def __init__(self, **kwargs):\n",
    "        super(Dock, self).__init__(**kwargs)\n",
    "        self.invader = Invader()\n",
    "        self.add_widget(self.invader)\n",
    "        self.bind_invader()\n",
    "        \n",
    "    def bind_invader(self, instance=None, value=None):\n",
    "        self.invader.formation = True\n",
    "        self.bind(pos = self.on_pos)\n",
    "        \n",
    "    def unbind_invader(self):\n",
    "        self.invader.formation = False\n",
    "        self.unbind(pos = self.on_pos)\n",
    "        \n",
    "    def on_pos(self, instance, value):\n",
    "        self.invader.pos = self.pos\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Line **14** handles the magic task of updating the invader position whenever the dock moves. Binding a function to a kivy property means the function is called whenever that property changes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-10.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-10.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At random intervals, the invaders should drop a bomb. Add this to the fleet code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting fleet.py\n"
     ]
    }
   ],
   "source": [
    "%%file fleet.py\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.animation import Animation\n",
    "from kivy.clock import Clock\n",
    "from kivy.core.window import Window\n",
    "from kivy.properties import NumericProperty, ListProperty\n",
    "from kivy.logger import Logger\n",
    "\n",
    "from random import choice, random\n",
    "from dock import Dock\n",
    "\n",
    "class Fleet(GridLayout):\n",
    "    survivors = ListProperty([])\n",
    "    move_delay = NumericProperty(3)\n",
    "    \n",
    "    def __init__(self, **kwargs):\n",
    "        super(Fleet, self).__init__(**kwargs)\n",
    "        for x in range (0,32):\n",
    "            dock = Dock()\n",
    "            self.survivors.append(dock)\n",
    "            self.add_widget(dock)\n",
    "    \n",
    "    def start_fleet(self, instance=None, value=None):\n",
    "        '''Start the fleet march'''\n",
    "        self.x = Window.width/2 - Window.width/4\n",
    "        self.go_left(instance, None)\n",
    "        self.schedule_events()\n",
    "        \n",
    "    def go_left(self, instance, value):\n",
    "        '''Move the fleet towards the left edge of the screen. \n",
    "        Normally the fleet moves from the right side of the screen.\n",
    "        If if `value` is None, however, we are calling the animation for the first time,\n",
    "        in which case, the animation starts from the middle of the screen, so we half the\n",
    "        nimation duration'''\n",
    "        if value is None:\n",
    "            animation = Animation(x=0, d=self.move_delay / 2.0)\n",
    "        else:\n",
    "            animation = Animation(x=0, d=self.move_delay)\n",
    "        animation.bind(on_complete = self.go_right)\n",
    "        animation.start(self)\n",
    "    \n",
    "    def go_right(self, instance, value):\n",
    "        '''Move the fleet towards the right edge of the screen.'''\n",
    "        animation = Animation(right=self.parent.width, d=self.move_delay)\n",
    "        animation.bind(on_complete=self.go_left)\n",
    "        animation.start(self)\n",
    "    \n",
    "    def schedule_events(self):\n",
    "        '''Start all random events:\n",
    "        * After a random interval, drop a bomb'''\n",
    "        Clock.schedule_once(self.bomb, random()) \n",
    "        \n",
    "    def bomb(self, dt):\n",
    "        '''Randomly choose one of the attackers to drop a bomb, then randomly reschedule'''\n",
    "        if len(self.survivors):\n",
    "            child = choice(self.survivors)\n",
    "            child.invader.drop_bomb()\n",
    "            Clock.schedule_once(self.bomb, random())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting invader.py\n"
     ]
    }
   ],
   "source": [
    "%%file invader.py\n",
    "\n",
    "from kivy.uix.image import Image\n",
    "from kivy.app import App\n",
    "from projectile import Bomb\n",
    "\n",
    "class Invader(Image):\n",
    "    def drop_bomb(self):\n",
    "        bomb = Bomb()\n",
    "        bomb.center = (self.center_x, self.y)\n",
    "        fleet = self.parent.parent\n",
    "        fleet.mainscreen.add_widget(bomb)\n",
    "        bomb.shoot(self.center_x, 0, fleet.mainscreen.player)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-11.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-11.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.4 Missile and Bomb Sounds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add sound to the missiles and bombs. Obviously, they should sound different. We used *cfxr* (a mac port of *sfxr*) to create some quick-and-dirty sound effects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting projectile.py\n"
     ]
    }
   ],
   "source": [
    "%%file projectile.py\n",
    "from kivy.animation import Animation\n",
    "from kivy.uix.image import Image\n",
    "from kivy.logger import Logger\n",
    "from kivy.app import App\n",
    "from boom import Boom\n",
    "\n",
    "class Projectile(Image):\n",
    "    '''Lauch this piece of ammunition towards a target object (`target`),\n",
    "    located at coordinates (`tx`, `ty`)'''\n",
    "    def shoot(self, tx, ty, target):\n",
    "        self.target = target\n",
    "        self.animation = Animation(x=tx, y=ty)\n",
    "        self.animation.bind(on_start=self.on_start)\n",
    "        self.animation.bind(on_progress=self.on_progress)\n",
    "        self.animation.bind(on_complete=self.on_stop)\n",
    "        self.animation.start(self)\n",
    "        \n",
    "    def on_start(self, instance, value):\n",
    "        pass\n",
    "    \n",
    "    def on_progress(self, instance, value, progression):\n",
    "        pass\n",
    "            \n",
    "    def on_stop(self, instance, value):\n",
    "        self.parent.remove_widget(self)\n",
    "        \n",
    "class Missile(Projectile):\n",
    "    def on_start(self, instance, value):\n",
    "        super(Missile, self).on_start(instance, value)\n",
    "        App.get_running_app().sounds.play_shoot()\n",
    "        \n",
    "class Bomb(Projectile):\n",
    "    def on_start(self, instance, value):\n",
    "        super(Bomb, self).on_start(instance, value)\n",
    "        App.get_running_app().sounds.play_bomb()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is satisfying. We no longer use the `Boom` effect, however. We will save that for when we add collision detection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.0 Collision Detection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now make an important change to our projectile class. We will test for **collisions**.\n",
    "To do this, we will overload the `on_progress` event for our projectile animation to check for a target collision. Notice when we shoot, we give a target object, either the player, or the fleet, as that is the only object that needs to check for collision.\n",
    "\n",
    "We will add a collision check by calling the target's collision detection routine (`collide_projectile`) in the projectile's `on_progress` event."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting projectile.py\n"
     ]
    }
   ],
   "source": [
    "%%file projectile.py\n",
    "from kivy.animation import Animation\n",
    "from kivy.uix.image import Image\n",
    "from kivy.logger import Logger\n",
    "from kivy.app import App\n",
    "from boom import Boom\n",
    "\n",
    "class Projectile(Image):\n",
    "    '''Lauch this piece of ammunition towards a target object (`target`),\n",
    "    located at coordinates (`tx`, `ty`)'''\n",
    "    def shoot(self, tx, ty, target):\n",
    "        self.target = target\n",
    "        self.animation = Animation(x=tx, y=ty)\n",
    "        self.animation.bind(on_start=self.on_start)\n",
    "        self.animation.bind(on_progress=self.on_progress)\n",
    "        self.animation.bind(on_complete=self.on_stop)\n",
    "        self.animation.start(self)\n",
    "        \n",
    "    def on_start(self, instance, value):\n",
    "        pass\n",
    "    \n",
    "    def on_progress(self, instance, value, progression):\n",
    "        if self.target.collide_projectile(self):\n",
    "            self.animation.stop(self)\n",
    "            \n",
    "    def on_stop(self, instance, value):\n",
    "        self.parent.remove_widget(self)\n",
    "        \n",
    "class Missile(Projectile):\n",
    "    def on_start(self, instance, value):\n",
    "        super(Missile, self).on_start(instance, value)\n",
    "        App.get_running_app().sounds.play_shoot()\n",
    "        \n",
    "class Bomb(Projectile):\n",
    "    def on_start(self, instance, value):\n",
    "        super(Bomb, self).on_start(instance, value)\n",
    "        App.get_running_app().sounds.play_bomb()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting player.py\n"
     ]
    }
   ],
   "source": [
    "%%file player.py\n",
    "from kivy.uix.image import Image\n",
    "from kivy.logger import Logger\n",
    "from kivy.properties import NumericProperty\n",
    "from kivy.graphics import Line, Ellipse\n",
    "from projectile import Missile\n",
    "\n",
    "from boom import Boom\n",
    "\n",
    "class Player(Image):\n",
    "    lives = NumericProperty(1)\n",
    "    \n",
    "    def on_touch_down(self, touch):\n",
    "        if self.collide_point(*touch.pos):\n",
    "            self.center_x = touch.x\n",
    "            touch.grab(self)\n",
    "            return True\n",
    "        elif self.player_area.collide_point(*touch.pos):\n",
    "            self.shoot()\n",
    "            return True\n",
    "            \n",
    "    def on_touch_move(self, touch):\n",
    "        if touch.grab_current is self:\n",
    "            self.center_x = touch.x\n",
    "            return True\n",
    "        \n",
    "    def shoot(self):\n",
    "        '''Shoot straight up.'''\n",
    "        missile = Missile()\n",
    "        missile.center = (self.center_x, self.top)\n",
    "        self.mainscreen.add_widget(missile)\n",
    "        (fx, fy) = self.center_x, self.mainscreen.height\n",
    "        missile.shoot(fx, fy, self.mainscreen.fleet)\n",
    "        \n",
    "    def collide_projectile(self, projectile):\n",
    "        '''Detect collision with a bomb'''\n",
    "        if self.lives and self.collide_widget(projectile):\n",
    "            boom = Boom()\n",
    "            boom.pos = self.pos\n",
    "            self.parent.add_widget(boom)\n",
    "            self.color = (0,0,0,0)\n",
    "            self.lives -= 1\n",
    "            # Check for end of game\n",
    "            return True\n",
    "        return False\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting fleet.py\n"
     ]
    }
   ],
   "source": [
    "%%file fleet.py\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.animation import Animation\n",
    "from kivy.clock import Clock\n",
    "from kivy.core.window import Window\n",
    "from kivy.properties import NumericProperty, ListProperty\n",
    "from kivy.logger import Logger\n",
    "\n",
    "from random import choice, random\n",
    "from dock import Dock\n",
    "from boom import Boom\n",
    "\n",
    "class Fleet(GridLayout):\n",
    "    survivors = ListProperty([])\n",
    "    move_delay = NumericProperty(3)\n",
    "    \n",
    "    def __init__(self, **kwargs):\n",
    "        super(Fleet, self).__init__(**kwargs)\n",
    "        for x in range (0,32):\n",
    "            dock = Dock()\n",
    "            self.survivors.append(dock)\n",
    "            self.add_widget(dock)\n",
    "    \n",
    "    def start_fleet(self, instance=None, value=None):\n",
    "        '''Start the fleet march'''\n",
    "        self.x = Window.width/2 - Window.width/4\n",
    "        self.go_left(instance, None)\n",
    "        self.schedule_events()\n",
    "        \n",
    "    def go_left(self, instance, value):\n",
    "        '''Move the fleet towards the left edge of the screen. \n",
    "        Normally the fleet moves from the right side of the screen.\n",
    "        If if `value` is None, however, we are calling the animation for the first time,\n",
    "        in which case, the animation starts from the middle of the screen, so we half the\n",
    "        nimation duration'''\n",
    "        if value is None:\n",
    "            animation = Animation(x=0, d=self.move_delay / 2.0)\n",
    "        else:\n",
    "            animation = Animation(x=0, d=self.move_delay)\n",
    "        animation.bind(on_complete = self.go_right)\n",
    "        animation.start(self)\n",
    "    \n",
    "    def go_right(self, instance, value):\n",
    "        '''Move the fleet towards the right edge of the screen.'''\n",
    "        animation = Animation(right=self.parent.width, d=self.move_delay)\n",
    "        animation.bind(on_complete=self.go_left)\n",
    "        animation.start(self)\n",
    "    \n",
    "    def schedule_events(self):\n",
    "        '''Start all random events:\n",
    "        * After a random interval, drop a bomb'''\n",
    "        Clock.schedule_once(self.bomb, random()) \n",
    "        \n",
    "    def bomb(self, dt):\n",
    "        '''Randomly choose one of the attackers to drop a bomb, then randomly reschedule'''\n",
    "        if len(self.survivors):\n",
    "            child = choice(self.survivors)\n",
    "            child.invader.drop_bomb()\n",
    "            Clock.schedule_once(self.bomb, random())\n",
    "            \n",
    "    def collide_projectile(self, projectile):\n",
    "        '''Detect a collision with projectile. Loop through remaining children checking for collision'''\n",
    "        for child in self.survivors:\n",
    "            if child.invader.collide_widget(projectile):\n",
    "                boom = Boom()\n",
    "                boom.pos = child.pos\n",
    "                child.canvas.clear()\n",
    "                child.add_widget(boom)\n",
    "                self.survivors.remove(child)\n",
    "                return True\n",
    "        return False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-13.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-13.png\" width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8.1 Game Over\n",
    "It's starting to feel like an arcade game. Now we need to handle the case when the player dies. There are two things here\n",
    "1. If the player is out of lives, he shouldn't be able to shoot or move\n",
    "2. When the game is over, we need to display a 'Game Over' banner\n",
    "\n",
    "We can handle lives using a kivy property and its associated `on_` handler. The ship is invisible and immobile if lives == 0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How do we keep a player from shooting or moving? For now, we will add an `active` flag, and ignore all events if this attribute is set to `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting player.py\n"
     ]
    }
   ],
   "source": [
    "%%file player.py\n",
    "from kivy.uix.image import Image\n",
    "from kivy.logger import Logger\n",
    "from kivy.properties import NumericProperty\n",
    "from kivy.graphics import Line, Ellipse\n",
    "from projectile import Missile\n",
    "\n",
    "from boom import Boom\n",
    "\n",
    "class Player(Image):\n",
    "    lives = NumericProperty(0)\n",
    "    active = False\n",
    "    \n",
    "    def add_life(self, instance, value):\n",
    "        self.lives += 1\n",
    "        \n",
    "    def on_touch_down(self, touch):\n",
    "        if not self.active:\n",
    "            return False\n",
    "        if self.collide_point(*touch.pos):\n",
    "            self.center_x = touch.x\n",
    "            touch.grab(self)\n",
    "            return True\n",
    "        elif self.player_area.collide_point(*touch.pos):\n",
    "            self.shoot()\n",
    "            return True\n",
    "            \n",
    "    def on_touch_move(self, touch):\n",
    "        if not self.active:\n",
    "            return False\n",
    "        if touch.grab_current is self:\n",
    "            self.center_x = touch.x\n",
    "            return True\n",
    "        \n",
    "    def shoot(self):\n",
    "        '''Shoot straight up.'''\n",
    "        if not self.active:\n",
    "            return\n",
    "        missile = Missile()\n",
    "        missile.center = (self.center_x, self.top)\n",
    "        self.mainscreen.add_widget(missile)\n",
    "        (fx, fy) = self.center_x, self.mainscreen.height\n",
    "        missile.shoot(fx, fy, self.mainscreen.fleet)\n",
    "        \n",
    "    def collide_projectile(self, projectile):\n",
    "        '''Detect collision with a bomb'''\n",
    "        if self.active and self.lives and self.collide_widget(projectile):\n",
    "            boom = Boom()\n",
    "            boom.pos = self.pos\n",
    "            self.parent.add_widget(boom)\n",
    "            self.lives -= 1\n",
    "            return True\n",
    "        return False\n",
    "    \n",
    "    def on_lives(self, instance, value):\n",
    "        '''If lives drops to zero, the player becomes immobile, invisible, and the game ends.'''\n",
    "        if self.lives == 0:\n",
    "            self.active = False\n",
    "            self.color = (0,0,0,0)\n",
    "            self.mainscreen.game_over()\n",
    "        else:\n",
    "            self.active = True\n",
    "            self.color = (1,1,1,1)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In main.py, add a 'Game Over' message. Then check that a player is active before allow key commands. Finally, increase a player's lives to start the game."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%file main.py\n",
    "from kivy.app import App\n",
    "from kivy.uix.floatlayout import FloatLayout\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.lang.builder import Builder\n",
    "from kivy.core.window import Window\n",
    "from kivy.logger import Logger\n",
    "from kivy.core.audio import SoundLoader\n",
    "from kivy.clock import Clock\n",
    "from kivy.uix.label import Label\n",
    "from kivy.animation import Animation\n",
    "\n",
    "from player import Player\n",
    "from sounds import Sounds\n",
    "from fleet import Fleet\n",
    "\n",
    "Builder.load_file('sprites.kv')\n",
    "\n",
    "\n",
    "class GalaxyInvaders(FloatLayout):\n",
    "    playing = False\n",
    "    unlocked = False\n",
    "    message = None\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(GalaxyInvaders, self).__init__(**kwargs)\n",
    "        self._keyboard = Window.request_keyboard(self.close, self)\n",
    "        self._keyboard.bind(on_key_down=self.press)\n",
    "        label = Label(text=\"Press [b]S[/b] to start\\n[b]<- ->[/b] to move\\n[b]Space[/b] to shoot\\n[b]Esc[/b] to quit\",\n",
    "                     halign='center', markup=True)\n",
    "        self.add_widget(label)\n",
    "        self.help_text = label\n",
    "        \n",
    "    def start_game(self):\n",
    "        '''Display a  'ready' message before a game starts.\n",
    "        When the animation is done, start the game.'''\n",
    "        label = Label(text='Ready!')\n",
    "        animation = Animation(font_size=72, d=2)\n",
    "        animation += Animation(font_size=0, d=2)\n",
    "        self.add_widget(label)\n",
    "        self.message = label\n",
    "        animation.bind(on_complete=self.fleet.start_fleet)\n",
    "        animation.bind(on_complete=self.remove_message)\n",
    "        animation.bind(on_complete=self.player.add_life)\n",
    "        animation.start(label)\n",
    "        \n",
    "    def remove_message(self, instance, value):\n",
    "        '''Remove the message text when the animation is done'''\n",
    "        self.remove_widget(self.message)\n",
    "        self.message = None\n",
    "\n",
    "    def close(self):\n",
    "        self._keyboard.unbind(on_key_down=self.press)\n",
    "        self._keyboard = None\n",
    "        # Eventually, we should do an 'Are You Sure?' prompt. For now, just quit\n",
    "        App.get_running_app().stop() \n",
    "        \n",
    "    def press(self, keyboard, keycode, text, modifiers):\n",
    "        '''Handle key commands'''\n",
    "        if keycode[1] == 'escape':\n",
    "                self.close()\n",
    "                return True\n",
    "\n",
    "        if not self.playing:\n",
    "            if keycode[1] == 's':\n",
    "                self.remove_widget(self.help_text)\n",
    "                self.playing = True\n",
    "                self.start_game()\n",
    "        elif self.player.active:\n",
    "            if keycode[1] == 'left':\n",
    "                self.player.x -= 30\n",
    "                if self.player.x < self.x:\n",
    "                    self.player.x = self.x\n",
    "            elif keycode[1] == 'right':\n",
    "                self.player.x += 30\n",
    "                if self.player.x > self.width - self.player.width:\n",
    "                    self.player.x = self.width - self.player.width\n",
    "            elif keycode[1] == 'spacebar':\n",
    "                self.player.shoot()\n",
    "            else:\n",
    "                Logger.debug(\"Unknown key: {}\".format(keycode))\n",
    "        return True\n",
    "    \n",
    "    def game_over(self):\n",
    "        label = Label(text='Game Over!')\n",
    "        animation = Animation(font_size=72, d=2)\n",
    "        animation += Animation(font_size=0, d=1)\n",
    "        self.add_widget(label)\n",
    "        self.message = label\n",
    "        animation.bind(on_complete=self.remove_message)\n",
    "        animation.start(label)\n",
    "\n",
    "\n",
    "class GalaxyInvadersApp(App):\n",
    "    sounds = Sounds()\n",
    "    def build(self):\n",
    "        return GalaxyInvaders()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    GalaxyInvadersApp().run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src='screenshots/galaxyinvaders-12.png' width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src='screenshots/galaxyinvaders-12.png' width=400 />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fun with Properties: Modes and Crawls\n",
    "\n",
    "It would be nice if, when the game was over, everything returned to the demo screen so that the player could play again.\n",
    "\n",
    "We saw the usefulness of properties (and their associated event handlers) when checking for game over. We can use these properties to add modes for demo and gameplay.\n",
    "\n",
    "First, we have to refactor our code to start/stop the gameplay. Let's create a kivy property called `mode`, and use that to change between behaviors.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting main.py\n"
     ]
    }
   ],
   "source": [
    "%%file main.py\n",
    "from kivy.app import App\n",
    "from kivy.uix.floatlayout import FloatLayout\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.lang.builder import Builder\n",
    "from kivy.core.window import Window\n",
    "from kivy.logger import Logger\n",
    "from kivy.core.audio import SoundLoader\n",
    "from kivy.clock import Clock\n",
    "from kivy.uix.label import Label\n",
    "from kivy.animation import Animation\n",
    "from kivy.properties import StringProperty\n",
    "\n",
    "from player import Player\n",
    "from sounds import Sounds\n",
    "from fleet import Fleet\n",
    "\n",
    "Builder.load_file('sprites.kv')\n",
    "\n",
    "\n",
    "class GalaxyInvaders(FloatLayout):\n",
    "    mode = StringProperty('init')\n",
    "    message = None\n",
    "\n",
    "    def __init__(self, **kwargs):\n",
    "        super(GalaxyInvaders, self).__init__(**kwargs)\n",
    "        self._keyboard = Window.request_keyboard(self.close, self)\n",
    "        self._keyboard.bind(on_key_down=self.press)\n",
    "        self.demo_mode()\n",
    "\n",
    "    def on_mode(self, instance, value):\n",
    "        if value == 'demo':\n",
    "            self.fleet.stop_fleet(instance, value)\n",
    "            self.player.lives = 0\n",
    "\n",
    "\n",
    "            label = Label(text=\"Press [b]S[/b] to start\\n\"\n",
    "                          \"[b]<- ->[/b] to move\\n\"\n",
    "                          \"[b]Space[/b] to shoot\\n\"\n",
    "                          \"[b]Esc[/b] to quit\",\n",
    "                         halign='center', markup=True)\n",
    "            self.add_widget(label)\n",
    "            self.help_text = label\n",
    "            self.player.x = Window.width / 2\n",
    "            self.fleet.fill_fleet()\n",
    "        elif value == 'game':\n",
    "            self.remove_widget(self.help_text)\n",
    "            self.player.add_life(instance, value)\n",
    "            self.player.active = True\n",
    "        \n",
    "    def demo_mode(self, instance=None, value=None):\n",
    "        self.mode = 'demo'\n",
    "        \n",
    "    def game_mode(self, instance, value):\n",
    "        self.mode = 'game'\n",
    "        \n",
    "    def start_game(self):\n",
    "        label = Label(text='Ready!')\n",
    "        animation = Animation(font_size=72, d=2)\n",
    "        animation += Animation(font_size=0, d=2)\n",
    "        self.add_widget(label)\n",
    "        self.message = label\n",
    "        animation.bind(on_complete=self.fleet.start_fleet)\n",
    "        animation.bind(on_complete=self.remove_message)\n",
    "        animation.bind(on_complete=self.game_mode)\n",
    "        animation.start(label)\n",
    "        \n",
    "    def remove_message(self, instance, value):\n",
    "        '''Remove the message text when the animation is done'''\n",
    "        self.remove_widget(self.message)\n",
    "        self.message = None\n",
    "\n",
    "    def close(self):\n",
    "        self._keyboard.unbind(on_key_down=self.press)\n",
    "        self._keyboard = None\n",
    "        # Eventually, we should do an 'Are You Sure?' prompt. For now, just quit\n",
    "        App.get_running_app().stop() \n",
    "        \n",
    "    def press(self, keyboard, keycode, text, modifiers):\n",
    "        '''Handle key commands, different, depending on game mode'''\n",
    "        if keycode[1] == 'escape':\n",
    "                self.close()\n",
    "                return True\n",
    "\n",
    "        if self.mode == 'demo':\n",
    "            if keycode[1] == 's':\n",
    "                self.remove_widget(self.help_text)\n",
    "                self.start_game()\n",
    "                self.mode = 'loading' # to prevent multiple starts\n",
    "        elif self.mode == 'game' and self.player.active:\n",
    "            if keycode[1] == 'left':\n",
    "                self.player.x -= 30\n",
    "                if self.player.x < self.x:\n",
    "                    self.player.x = self.x\n",
    "            elif keycode[1] == 'right':\n",
    "                self.player.x += 30\n",
    "                if self.player.x > self.width - self.player.width:\n",
    "                    self.player.x = self.width - self.player.width\n",
    "            elif keycode[1] == 'spacebar':\n",
    "                self.player.shoot()\n",
    "            else:\n",
    "                Logger.debug(\"Unknown key: {}\".format(keycode))\n",
    "        return True\n",
    "    \n",
    "    def game_over(self, message='Game Over!'):\n",
    "        '''Animate a 'Game Over' message (save it as an attribute, `self.message` so we can delete it later).\n",
    "        '''\n",
    "        label = Label(text=message)\n",
    "        animation = Animation(font_size=72, d=2)\n",
    "        animation += Animation(font_size=0, d=1)\n",
    "        self.add_widget(label)\n",
    "        self.message = label\n",
    "        animation.bind(on_complete=self.remove_message)\n",
    "        animation.bind(on_complete=self.demo_mode)\n",
    "        animation.start(label)\n",
    "            \n",
    "\n",
    "class GalaxyInvadersApp(App):\n",
    "    sounds = Sounds()\n",
    "    def build(self):\n",
    "        return GalaxyInvaders()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    GalaxyInvadersApp().run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Replay\n",
    "There are a couple of things left to do to make toggling between game and demo mode work. If we want to be able to play again after a game ends, we will need to reset the fleet and player to their starting states after a game is over. This means:\n",
    "*  The fleet gets a a full set of invaders (and moves back to the center of the screen), and\n",
    "* The player gets a full set of lives\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will start by refilling empty docks with invaders. We can do this by refactoring the fill we do at init time.\n",
    "To handle this refilling, we will have to keep track of docks, and not just survivors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting fleet.py\n"
     ]
    }
   ],
   "source": [
    "%%file fleet.py\n",
    "from kivy.uix.gridlayout import GridLayout\n",
    "from kivy.animation import Animation\n",
    "from kivy.clock import Clock\n",
    "from kivy.core.window import Window\n",
    "from kivy.properties import NumericProperty, ListProperty, BooleanProperty\n",
    "from kivy.logger import Logger\n",
    "\n",
    "from random import choice, random\n",
    "from dock import Dock\n",
    "from boom import Boom\n",
    "\n",
    "\n",
    "class Fleet(GridLayout):\n",
    "    survivors = ListProperty([])\n",
    "    move_delay = NumericProperty(3)\n",
    "    crawl = BooleanProperty(False)\n",
    "    docks = []\n",
    "    \n",
    "    def __init__(self, **kwargs):\n",
    "        super(Fleet, self).__init__(**kwargs)\n",
    "        self.fill_fleet()\n",
    "        \n",
    "    def fill_fleet(self):\n",
    "        '''Fill up missing spots in the dock. This can only be done if the crawl is off'''\n",
    "        if self.crawl:\n",
    "            return\n",
    "        for dock in self.docks:\n",
    "            self.remove_widget(dock)\n",
    "        self.survivors = []    \n",
    "        for x in range(32):\n",
    "            dock = Dock()\n",
    "            self.survivors.append(dock)\n",
    "            self.add_widget(dock)\n",
    "            self.docks.append(dock)\n",
    "            \n",
    "    def start_fleet(self, instance=None, value=None):\n",
    "        '''Start the fleet march'''\n",
    "        self.x = Window.width/2 - Window.width/4\n",
    "        self.crawl = True\n",
    "\n",
    "    def on_crawl(self, instance, value):\n",
    "        '''Transition from doing the fleet crawl and firing (True) \n",
    "        to sitting motionless in the center (False)'''\n",
    "        if value == True:\n",
    "            self.go_left(instance, None)\n",
    "            self.schedule_events()\n",
    "        else:\n",
    "            Animation.cancel_all(self)\n",
    "            # back to center\n",
    "            animation = Animation(x=Window.width/2 - Window.width/4)\n",
    "            animation.start(self)\n",
    "\n",
    "    def stop_fleet(self, instance=None, value=None):\n",
    "        '''stop the fleet march'''\n",
    "        self.crawl = False\n",
    "        \n",
    "    def go_left(self, instance, value):\n",
    "        '''Move the fleet towards the left edge of the screen. \n",
    "        Normally the fleet moves from the right side of the screen.\n",
    "        If if `value` is None, however, we are calling the animation for the first time,\n",
    "        in which case, the animation starts from the middle of the screen, so we half the\n",
    "        animation duration'''\n",
    "        if value is None:\n",
    "            animation = Animation(x=0, d=self.move_delay / 2.0)\n",
    "        else:\n",
    "            animation = Animation(x=0, d=self.move_delay)\n",
    "        animation.bind(on_complete = self.go_right)\n",
    "        animation.start(self)\n",
    "    \n",
    "    def go_right(self, instance, value):\n",
    "        '''Move the fleet towards the right edge of the screen.'''\n",
    "        animation = Animation(right=self.parent.width, d=self.move_delay)\n",
    "        animation.bind(on_complete=self.go_left)\n",
    "        animation.start(self)\n",
    "    \n",
    "    def schedule_events(self):\n",
    "        '''Start all random events:\n",
    "        * After a random interval, drop a bomb'''\n",
    "        Clock.schedule_once(self.bomb, random()) \n",
    "        \n",
    "    def bomb(self, dt):\n",
    "        '''Randomly choose one of the attackers to drop a bomb, then randomly reschedule'''\n",
    "        if len(self.survivors):\n",
    "            child = choice(self.survivors)\n",
    "            child.invader.drop_bomb()\n",
    "            if self.crawl:\n",
    "                Clock.schedule_once(self.bomb, random())\n",
    "            \n",
    "    def collide_projectile(self, projectile):\n",
    "        '''Detect a collision with projectile. Loop through remaining children checking for collision'''\n",
    "        for child in self.survivors:\n",
    "            if child.invader.collide_widget(projectile):\n",
    "                boom = Boom()\n",
    "                boom.pos = child.pos\n",
    "                child.canvas.clear()\n",
    "                child.add_widget(boom)\n",
    "                self.survivors.remove(child)\n",
    "                return True\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's get rid of the debug frames and see what it looks like!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting galaxyinvaders.kv\n"
     ]
    }
   ],
   "source": [
    "%%file galaxyinvaders.kv\n",
    "##:include debug.kv\n",
    "<GalaxyInvaders>:\n",
    "    id: _mainscreen\n",
    "    enemy_area: _enemy_area\n",
    "    player_area: _player_area\n",
    "    player: _player\n",
    "    fleet: _fleet\n",
    "    BoxLayout:\n",
    "        orientation: 'vertical'\n",
    "        FloatLayout:\n",
    "            id: _enemy_area\n",
    "            size_hint: 1, 0.7\n",
    "            Fleet:\n",
    "                id: _fleet\n",
    "                mainscreen: _mainscreen\n",
    "                size_hint: .5, .4\n",
    "                pos_hint: {'top': .9}\n",
    "                x: root.width/2 - root.width/4\n",
    "                cols: 8\n",
    "                spacing: 20\n",
    "                    \n",
    "        FloatLayout:\n",
    "            id: _player_area\n",
    "            size_hint: 1, 0.3\n",
    "            Player:\n",
    "                id: _player\n",
    "                mainscreen: _mainscreen\n",
    "                player_area: _player_area\n",
    "                x: self.parent.width / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"screenshots/galaxyinvaders-14.png\" width=400 />"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<img src=\"screenshots/galaxyinvaders-14.png\" width=400 />\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#!python main.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## What's next?\n",
    "There's lots more we can do with this came. Some features you may want to add:\n",
    "* Score\n",
    "* Additional levels (when all invaders are killed)\n",
    "* increasing difficulty with levels\n",
    "* Multiple player lives\n",
    "* solo attacks for invaders\n",
    "* Smooth player movement\n",
    "* random gameplay in demo mode\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have fun!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "environment": {
   "dependencies": [
    "alabaster=0.7.6=py27_0",
    "appnope=0.1.0=py27_0",
    "babel=2.1.1=py27_0",
    "backports=1.0=py27_0",
    "backports_abc=0.4=py27_0",
    "configparser=3.5.0b2=py27_1",
    "cython=0.23.4=py27_1",
    "decorator=4.0.9=py27_0",
    "docutils=0.12=py27_0",
    "entrypoints=0.2=py27_1",
    "flake8=2.5.1=py27_0",
    "freetype=2.5.5=0",
    "funcsigs=1.0.0=py27_0",
    "ipykernel=4.3.1=py27_0",
    "ipython=4.1.2=py27_2",
    "ipython-notebook=4.0.4=py27_0",
    "ipython_genutils=0.1.0=py27_0",
    "jbig=2.1=0",
    "jedi=0.9.0=py27_0",
    "jinja2=2.8=py27_0",
    "jpeg=8d=1",
    "jsonschema=2.4.0=py27_0",
    "jupyter_client=4.2.2=py27_0",
    "jupyter_core=4.1.0=py27_0",
    "libpng=1.6.17=0",
    "libtiff=4.0.6=1",
    "markupsafe=0.23=py27_0",
    "mccabe=0.3.1=py27_0",
    "mistune=0.7.2=py27_1",
    "mkl=11.3.1=0",
    "mock=2.0.0=py27_0",
    "nbconvert=4.2.0=py27_0",
    "nbformat=4.0.1=py27_0",
    "nose=1.3.7=py27_0",
    "notebook=4.1.0=py27_2",
    "numpy=1.11.0=py27_0",
    "opencv=2.4.8=np17py27_2",
    "openssl=1.0.2h=0",
    "pandas=0.18.1=np111py27_0",
    "path.py=8.2=py27_0",
    "pbr=1.8.0=py27_0",
    "pep8=1.7.0=py27_0",
    "pexpect=4.0.1=py27_0",
    "pickleshare=0.5=py27_0",
    "pillow=3.1.0=py27_0",
    "pip=8.1.1=py27_1",
    "ptyprocess=0.5=py27_0",
    "py=1.4.31=py27_0",
    "pyflakes=1.1.0=py27_0",
    "pygments=2.1.3=py27_0",
    "pytest=2.8.5=py27_0",
    "python=2.7.11=0",
    "python-dateutil=2.5.2=py27_0",
    "python.app=1.2=py27_4",
    "pytz=2016.3=py27_0",
    "pyzmq=15.2.0=py27_0",
    "readline=6.2=2",
    "requests=2.9.1=py27_0",
    "setuptools=20.7.0=py27_0",
    "simplegeneric=0.8.1=py27_0",
    "singledispatch=3.4.0.3=py27_0",
    "six=1.10.0=py27_0",
    "snowballstemmer=1.2.0=py27_0",
    "sphinx=1.3.1=py27_0",
    "sphinx_rtd_theme=0.1.7=py27_0",
    "sqlite=3.9.2=0",
    "ssl_match_hostname=3.4.0.2=py27_1",
    "terminado=0.5=py27_1",
    "tk=8.5.18=0",
    "tornado=4.3=py27_0",
    "traitlets=4.2.1=py27_0",
    "wheel=0.29.0=py27_0",
    "xz=5.0.5=0",
    "zlib=1.2.8=0",
    {
     "pip": [
      "backports-abc==0.4",
      "backports.ssl-match-hostname==3.4.0.2",
      "importmagic==0.1.3",
      "ipython-genutils==0.1.0",
      "jupyter-client==4.2.2",
      "jupyter-core==4.1.0",
      "kivent-core==0.0.0",
      "kivy==1.9.2.dev0",
      "sphinx-rtd-theme==0.1.7"
     ]
    }
   ],
   "name": "kivy2"
  },
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}