Breakout.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bqplot import Figure, Axis, LinearScale, Scatter, Lines, CATEGORY10\n",
    "from ipywidgets import HBox, VBox, Button, IntSlider, Play, jslink\n",
    "from random import random, randint\n",
    "#Student Exercise: Import 3 more modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def norm_vector(x, y):\n",
    "    \"\"\"Normalize a vector.\"\"\"\n",
    "    length = math.sqrt(x**2 + y**2)\n",
    "    return x/length, y/length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle(Lines):\n",
    "    \"\"\"Simulate a Rectangle with a Lines mark containing 2 points.\"\"\"\n",
    "    \n",
    "    def __init__(self, x_center, y_center, length=10, **kwargs):\n",
    "        Lines.__init__(self, **kwargs)\n",
    "        self.x_center, self.y_center = x_center, y_center\n",
    "        self.length = length\n",
    "        \n",
    "        self.reset()\n",
    "        \n",
    "    def reset(self):\n",
    "        self.x = [self.x_center - self.length//2, self.x_center + self.length//2 + 1]\n",
    "        self.y = [self.y_center, self.y_center]\n",
    "        \n",
    "        # When a Brick is hit, it's not destroyed but just made visible=False\n",
    "        # Thus resetting this here when the game is reset.\n",
    "        self.visible = True\n",
    "        \n",
    "class Brick(Rectangle):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        ## STUDENT EXERCISE: ENTER THE CODE HERE\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "class Racket(Rectangle):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "       ## STUDENT EXERCISE: ENTER THE CODE HERE\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "        \n",
    "    def move(self, offset):\n",
    "        ## STUDENT EXERCISE: ENTER THE CODE HERE\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ball(Scatter):\n",
    "    def __init__(self, **kwargs):\n",
    "        Scatter.__init__(self, **kwargs)\n",
    "        self.reset()\n",
    "        self.dts = 0.1 #movement amplitude\n",
    "        \n",
    "    def reset(self):\n",
    "        # ball is random placed at the bottom (between racket and bricks)\n",
    "        self.x = np.array([randint(10, 90)]).astype('float64')\n",
    "        self.y = np.array([randint(5, 10)]).astype('float64')\n",
    "        \n",
    "        # You can add a bit of acceleration if you want to spice things up!\n",
    "        self.accel = np.array([0, 0]).astype('float64')\n",
    "        \n",
    "        # Compute a random (but upwward, not toward hte DEAD ZONE) initial speed direction\n",
    "        # And make it speed = 10 in that direction!\n",
    "        speedx, speedy = randint(5, 15), randint(5, 15)\n",
    "        speedx, speedy = norm_vector(speedx, speedy)\n",
    "        #speed up by a multiplier\n",
    "        speedmultiplier = 10\n",
    "        self.speed = np.array([speedmultiplier*speedx, speedmultiplier*speedy]).astype('float64')\n",
    "        \n",
    "    def move(self):\n",
    "        newx, newy = self.x[0], self.y[0]\n",
    "        \n",
    "        self.speed += np.array(self.accel) * self.dts\n",
    "        newx += self.speed[0] * self.dts\n",
    "        newy += self.speed[1] * self.dts\n",
    "\n",
    "        # Update the series\n",
    "        with self.hold_sync():\n",
    "            self.x, self.y = np.array([newx]), np.array([newy])\n",
    "            \n",
    "    def stop(self):\n",
    "        self.x, self.y = 0,0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Game(object):\n",
    "    \n",
    "    MSG_WELCOME = 'Click the Play button to start the game!'\n",
    "\n",
    "    def __init__(self):\n",
    "        self.fig = Figure(title=self.MSG_WELCOME)\n",
    "\n",
    "        # The game area is a 100x100 square Figure\n",
    "        # Only the bottom axis is particular: the DEAD ZONE in read.\n",
    "        gamezone_size = 100\n",
    "        sc = LinearScale(min=0, max=gamezone_size)\n",
    "        self.scales = {\"x\": sc, \"y\": sc}\n",
    "        ax_bottom = Axis(label='DEAD ZONE', scale=sc, num_ticks=0, color='red', label_color='red')\n",
    "        ax_left = Axis(scale=sc, orientation='vertical', side='left', num_ticks=0, color='black')\n",
    "        ax_top = Axis(scale=sc, orientation='horizontal', side='top', num_ticks=0, color='black')\n",
    "        ax_right = Axis(scale=sc, orientation='vertical', side='right', num_ticks=0, color='black')\n",
    "        self.fig.axes = [ax_bottom, ax_left, ax_right, ax_top]\n",
    "        \n",
    "        # Create bricks in a pyramid), a racket and a ball\n",
    "        self.bricks = []\n",
    "        self.bricks.extend([Brick(x, 30, scales=self.scales) for x in range(20, 85, 15)])\n",
    "        self.bricks.extend([Brick(x, 50, scales=self.scales) for x in range(30, 80, 15)])\n",
    "        self.bricks.extend([Brick(x, 70, scales=self.scales) for x in range(40, 75, 15)])\n",
    "        self.bricks.extend([Brick(55, 90, scales=self.scales)])\n",
    "        self.racket = Racket(50, 5, scales=self.scales)\n",
    "        self.ball = Ball(scales=self.scales)\n",
    "\n",
    "        all_marks = [self.racket, self.ball]\n",
    "        all_marks.extend(self.bricks)\n",
    "        self.fig.marks = all_marks\n",
    "        \n",
    "       # Callback called when the Play animation updates the invisible 'time_slider'\n",
    "        def time_passing(change):\n",
    "            newval = change['new']\n",
    "            if newval == 0:\n",
    "                # User clicked the STOP button so we reset the game\n",
    "                self.reset()\n",
    "            else:\n",
    "                if newval == 1:\n",
    "                    # User just started the game, update the label\n",
    "                    self.fig.title = 'Good Luck!'\n",
    "                self.ball.move()\n",
    "                self.check_collisions()\n",
    "                \n",
    "        def create_ui(self):\n",
    "            # To have ascyc updates (i.e. being able to move the ball continuously \n",
    "            # while having the user move the racket) I am leveraing the Play() animation\n",
    "            # from ipywidgets. We link it to a IntSlider (time_slider) that we don't display.\n",
    "            \n",
    "            ### ENTER CODE INTO HERE ###\n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "        create_ui(self)\n",
    "    \n",
    "    def display(self):\n",
    "        IPython.display.display(self.GUI)\n",
    "    \n",
    "    def reset(self):\n",
    "        #self.fig.title = self.MSG_WELCOME\n",
    "        \n",
    "        [m.reset() for m in self.fig.marks]\n",
    "    \n",
    "    def check_collisions(self):\n",
    "        x_min, x_max = self.scales['x'].min, self.scales['x'].max\n",
    "        y_min, y_max = self.scales['y'].min, self.scales['y'].max\n",
    "\n",
    "        newx, newy = self.ball.x[0], self.ball.y[0]\n",
    "\n",
    "        # Collisions with walls (axes)\n",
    "        if newx <= x_min:\n",
    "            newx = x_min\n",
    "            self.ball.speed[0] *= -1\n",
    "            return\n",
    "\n",
    "        if newx >= x_max:\n",
    "            newx = x_max\n",
    "            self.ball.speed[0] *= -1\n",
    "            return\n",
    "        \n",
    "        if newy <= y_min:\n",
    "            newy = y_min\n",
    "            self.ball.speed[1] *= -1\n",
    "            \n",
    "            # Game over\n",
    "            self.fig.title = 'GAME OVER! Play again!'\n",
    "            \n",
    "            #stop the ball\n",
    "            self.but_play.value = self.but_play.max\n",
    "            \n",
    "            #reset the positions of bricks and ball\n",
    "            self.reset()\n",
    "            return\n",
    "        \n",
    "        #Student Execise: Implement the logic when the ball hits the top boundary\n",
    "        \n",
    "        # Collisions with Rectangles\n",
    "        # Ignore those hit already (made visible=False)\n",
    "        rect_list = [r for r in self.bricks+[self.racket] if r.visible]\n",
    "        for rect in rect_list:\n",
    "            # Since the ball position is its center, we account for the ball size\n",
    "            # by adding a bit of offset around our rectangles to look like the\n",
    "            # ball edge hit the obstacles. Below are empirically found.\n",
    "            x_offset, y_offset = 1, 4\n",
    "            \n",
    "            # Collision happens if the ball is within the rectangle (widened with the offsets)\n",
    "            x_check = (rect.x[0]-x_offset <= newx <= rect.x[1]+x_offset)\n",
    "            y_check = (rect.y[0]-y_offset <= newy <= rect.y[1]+y_offset)\n",
    "            if x_check and y_check:\n",
    "                # Collision detected. Remove the Rectangle only if its a brick, not the racket!\n",
    "                # We just make it non-visible so that we can reset it simply by making it visible.\n",
    "                if rect != self.racket:\n",
    "                    rect.visible = False\n",
    "\n",
    "                # Try to best guess if it hit a top/bottom side or a left/right side\n",
    "                # In order to know if we reverse the horizontal or vertical speed.\n",
    "                if rect.x[0] <= newx <= rect.x[1]:\n",
    "                    self.ball.speed[1] *= -1\n",
    "                else:\n",
    "                    self.ball.speed[0] *= -1\n",
    "                    \n",
    "                break\n",
    "            \n",
    "            # Update the ball position in case it was updated\n",
    "            self.ball.x, self.ball.y = np.array([newx]), np.array([newy])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5f736f1a0d8443c2be7b75ed84cd986e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(Play(value=0, interval=40, max=1000000), Button(description='LEFT', style=Button…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "g = Game()\n",
    "g.display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (sandboxed)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}