pygame_tut.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1><center style=\"color:green;\">GAME DEVELOPMENT USING PYTHON</center></h1>\n",
    "![](https://img.memecdn.com/make-your-own-video-game_o_655941.jpg)\n",
    "\n",
    "![](https://habrastorage.org/getpro/habr/post_images/e38/895/a15/e38895a159ff5bbd8da2f1040b61d219.gif)\n",
    "\n",
    "**pygame** is a Free and Open Source python programming language library for making multimedia applications like games built on top of the excellent **SDL** library. Like SDL, pygame is highly portable and runs on nearly every platform and operating system. \n",
    "\n",
    "\n",
    ">SDL (Simple DirectMedia Layer) is a cross-platform development library designed to provide low level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D. \n",
    "\n",
    "### Why pygame???\n",
    "\n",
    "- Python is a clean programming language that is simple enough to start with. \n",
    "- pygame is simple and well designed for writing basic 2D games.\n",
    "\n",
    "More here: https://www.pygame.org/wiki/about"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## INSTALLATION\n",
    "\n",
    "```\n",
    "$ pip install pygame\n",
    "```\n",
    "\n",
    "### To make sure that installation was successful, let's run an example!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python3 -m pygame.examples.aliens"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many more examples [here](https://www.pygame.org/docs/ref/examples.html)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IMPORTING AND INITIALIZING\n",
    "\n",
    ">The **import pygame** imports the package with all the available pygame modules. \n",
    "\n",
    "![](https://i.imgur.com/xxhlr1l.png)\n",
    "\n",
    ">The call to **pygame.init()** initializes each of these modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pygame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.init()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DISPLAY SCREEN\n",
    ">Initialize a window or screen for display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HEIGHT = 600\n",
    "WIDTH = 600\n",
    "screen = pygame.display.set_mode((HEIGHT, WIDTH))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Set the current window caption"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.display.set_caption(\"My screen!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SET SCREEN BACKGROUND"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "WHITE = (255, 255, 255)\n",
    "GREEN = (0, 255, 0)\n",
    "BLUE = (0, 0, 255)\n",
    "BLACK = (0, 0, 0)\n",
    "FUCHSIA = (255, 0, 255)\n",
    "GRAY = (128, 128, 128)\n",
    "LIME = (0, 128, 0)\n",
    "MAROON = (128, 0, 0)\n",
    "NAVYBLUE = (0, 0, 128)\n",
    "OLIVE = (128, 128, 0)\n",
    "PURPLE = (128, 0, 128)\n",
    "RED = (255, 0, 0)\n",
    "SILVER = (192, 192, 192)\n",
    "TEAL = (0, 128, 128)\n",
    "YELLOW = (255, 255, 0)\n",
    "ORANGE = (255, 128, 0)\n",
    "CYAN = (0, 255, 255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "screen.fill(CYAN)\n",
    "pygame.display.flip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FUN WITH RECTANGLES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = pygame.Rect((3,3), (100,200))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.draw.rect(screen, LIME, r)\n",
    "pygame.display.flip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = r.move((100,100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r.centerx = WIDTH/2\n",
    "r.centery = HEIGHT/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for _ in range(0,100):\n",
    "    r.x += 1\n",
    "    screen.fill(CYAN)\n",
    "    pygame.draw.rect(screen, LIME, r)\n",
    "    pygame.display.flip()\n",
    "    time.sleep(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = pygame.draw.circle(screen, RED, (50,50), 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.display.flip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.colliderect(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**For more info about drawing shapes:** https://www.pygame.org/docs/ref/draw.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LOADING, DISPLAYING AND MOVING IMAGES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shipImg = pygame.image.load(\"ship.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(shipImg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shipRect = shipImg.get_rect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shipRect.center = (300, 550)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "screen.blit(shipImg, shipRect)\n",
    "pygame.display.flip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shipImg = pygame.transform.rotate(shipImg, 90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for _ in range(0,100):\n",
    "    shipRect.y -= 1\n",
    "    screen.fill(CYAN)\n",
    "    screen.blit(shipImg, shipRect)\n",
    "    pygame.display.flip()\n",
    "    time.sleep(0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## READING USER INPUT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while 1:\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT:\n",
    "            print(\"Quit pygame\")\n",
    "            \n",
    "        elif event.type == pygame.KEYDOWN:\n",
    "            print(\"You pressed {}\".format(event.key))\n",
    "            \n",
    "        elif event.type == pygame.KEYUP:\n",
    "            print(\"You released {}\".format(event.key))\n",
    "        \n",
    "        elif event.type == pygame.MOUSEBUTTONDOWN:\n",
    "            print(\"You clicked at {}\".format(event.pos))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The CLOCK!\n",
    "\n",
    "**pygame.time.Clock**\n",
    "creates an object to help track time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clock = pygame.time.Clock()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**clock.tick** method should be called once per frame. It will compute how many milliseconds have passed since the previous call.\n",
    "\n",
    ">If you pass the optional framerate argument the function will delay to keep the game running slower than the given ticks per second. This can be used to help limit the runtime speed of a game. By calling Clock.tick(40) once per frame, the program will never run at more than 40 frames per second."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# update the clock\n",
    "clock.tick(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get time since **pygame.init()** was called, use **pygame.time.get_ticks()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.time.get_ticks()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## WRITING TEXT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def text_objects(text, font):\n",
    "    textSurface = font.render(text, True, BLACK)\n",
    "    return textSurface, textSurface.get_rect()\n",
    "\n",
    "def message_display(text, x, y, size):\n",
    "    font = pygame.font.Font(pygame.font.get_default_font(), size)\n",
    "    textSurface, textRect = text_objects(text, font)\n",
    "    textRect.center  = x, y\n",
    "    screen.blit(textSurface, textRect)\n",
    "    pygame.display.update()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "message_display(\"hello!\", WIDTH/2, HEIGHT/2, 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.font.get_fonts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "font = pygame.font.SysFont(\"comicsans\", 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ADDING SOUND\n",
    "\n",
    "1. initialize the mixer module\n",
    "2. load sound file\n",
    "3. play it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.mixer.init()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "collision_sound = pygame.mixer.Sound(\"./2.PingPong/collision.wav\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.mixer.Sound.play(collision_sound)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CLOSING PYGAME"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "________________\n",
    "\n",
    "## Single player PING-PONG\n",
    "\n",
    "<img src=\"https://media.makeameme.org/created/wanna-play-cnteau.jpg\"  height=400 width=300>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objects required:\n",
    "- ball\n",
    "- paddle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# My ball\n",
    "ball = pygame.image.load(\"ball.png\")\n",
    "ballrect = ball.get_rect()\n",
    "\n",
    "# My paddle rectangle\n",
    "paddle = pygame.Rect((0, HEIGHT/2), (30, 150))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initializations\n",
    "\n",
    "Before start of every game:\n",
    "- Ball is in center of table\n",
    "- Ball speed is given by vector (5, 7)\n",
    "- Paddle is stationery and at center height of table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ballrect.center = WIDTH/2, HEIGHT/2\n",
    "ball_speed = [5,7]\n",
    "paddle.centery = HEIGHT/2\n",
    "paddle_speed = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Controlling paddle\n",
    "\n",
    "- Paddle speed is set to 5 if user presses UP/DOWN key.\n",
    "- Reset it to 0 if key is released."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for event in pygame.event.get():\n",
    "    if event.type == pygame.QUIT: \n",
    "        quit()\n",
    "    elif event.type == pygame.KEYDOWN:\n",
    "        if event.key == pygame.K_UP:\n",
    "            paddle_speed = -5\n",
    "        elif event.key == pygame.K_DOWN:\n",
    "            paddle_speed = 5\n",
    "    elif event.type == pygame.KEYUP:\n",
    "        if event.key in [pygame.K_UP, pygame.K_DOWN]:\n",
    "            paddle_speed = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating paddle position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "paddle.y += paddle_speed\n",
    "paddle.bottom = max(min(paddle.bottom, HEIGHT), paddle.height)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating ball position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ballrect = ballrect.move(ball_speed)\n",
    "\n",
    "if ballrect.right > WIDTH:\n",
    "    ball_speed[0] = -ball_speed[0]\n",
    "\n",
    "elif ballrect.top < 0 or ballrect.bottom > HEIGHT:\n",
    "    ball_speed[1] = -ball_speed[1]\n",
    "\n",
    "elif ballrect.left < 0:\n",
    "    game_over()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ball-paddle collision\n",
    "\n",
    "pygame has in-built function for rectangle to check its collision with another rectangle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "if paddle.colliderect(ballrect):\n",
    "    ball_speed[0] = -ball_speed[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Drawing frame\n",
    "- Set background\n",
    "- Draw ball\n",
    "- Draw paddle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "screen.fill(GREEN)\n",
    "screen.blit(ball, ballrect)\n",
    "pygame.draw.rect(screen, BLACK, paddle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Game Over condition\n",
    "\n",
    "When ball touches left wall."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if ballrect.left < 0:\n",
    "    game_over()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Handling game over condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def game_over():\n",
    "    message_display(\"Game over.\", WIDTH/2, HEIGHT/2, 40)\n",
    "    time.sleep(2)\n",
    "    game_loop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A basic game loop\n",
    "![](https://i.imgur.com/elHOMSA.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenges:\n",
    "- Suggest a score metric for single player game\n",
    "- Display/save highest score\n",
    "- Suggest a metric to change the speed of the ball with increasing time\n",
    "- Try to put paddle on bottom\n",
    "- Make game 2 player"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Managing Objects\n",
    "\n",
    "![](https://www.pygame.org/thumb/ecdcaecfcb0956cc437993cfc37ded21.png)\n",
    "\n",
    "### Sprite\n",
    "\n",
    ">In computer graphics, a sprite is a two-dimensional bitmap that is integrated into a larger scene. Originally sprites referred to independent objects that are composited together, by hardware, with other elements such as a background.\n",
    "\n",
    "In pygame, the **Sprite** class is designed to be a base class for all your game objects. You cannot really use it on its own, as it only has several methods to help it work with the different Group classes. The sprite keeps track of which groups it belongs to. The class constructor (**\\_\\_init\\_\\_** method) takes an argument of a Group (or list of Groups) the Sprite instance should belong to. You can also change the Group membership for the Sprite with the **add()** and **remove()** methods. there is also a **groups()** method, which returns a list of the current groups containing the sprite. The **kill()** method removes the sprite from all groups it belongs to.\n",
    "\n",
    "### Group\n",
    "\n",
    "The **Group** class is just a simple container. Similar to the sprite, it has an **add()** and **remove()** method which can change which sprites belong to the group. You also can pass a sprite or list of sprites to the constructor (**\\_\\_init\\_\\_()** method) to create a **Group** instance that contains some initial sprites."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}