pygame-cookbook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pygame Cookbook - Recipes for Mastering Pygame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hi,\n",
    "\n",
    "in the last years I used **Python** and the module **Pygame** to create some games. I found many information about **Pygame** on many different places in the web. I would prefer one book where I can look for solutions. So I started to write this `Pygame Cookbook`.  \n",
    "\n",
    "**Pygame** (https://www.pygame.org) is a create library for making your own games with python. **Pygame** uses the **SDL** library.\n",
    "\n",
    "This `Pygame Cookbook` tries to explain the building blocks of a game simple and in detail.\n",
    "\n",
    "The official documentation of **Pygame** is available at https://www.pygame.org/docs/.\n",
    "\n",
    "If you like `Pygame Cookbook`, use it. If you have some suggestions, tell me (hebi@python-ninja.com).\n",
    "\n",
    "All game assets that I use in recipes are from https://www.kenney.nl. Thank you.\n",
    "\n",
    "Have fun.\n",
    "\n",
    "Hebi, on the way to Python Ninja"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Edition 0.32, July 2023`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## install pygame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prerequisite for using the `Pygame Cookbook` is that the Python library **Pygame** is installed on your computer."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "$ pip install pygame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More about installing pygame https://www.pygame.org/wiki/GettingStarted#Pygame%20Installation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use **Pygame** with different programming environments. A very convenient way to try the recipes of this Cookbook is to copy the **Jupyter Notebook** version (file *pygame-cookbook.ipynb*) to your computer and evaluate the cells your interested in."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## pygame and jupyter notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Task: Using pygame with Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Open a window that shows the drawing of pygame.  \n",
    "\n",
    "You can "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pygame 2.0.1 (SDL 2.0.14, Python 3.8.8)\n",
      "Hello from the pygame community. https://www.pygame.org/contribute.html\n"
     ]
    }
   ],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    " \n",
    "pygame.init() #start the pygame module\n",
    "\n",
    "screen = pygame.display.set_mode((400, 300)) #get access to the display\n",
    "\n",
    "pygame.display.update() #update the display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can use another jupyter cell to draw a rectangle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.draw.rect(screen, (0, 128, 255), pygame.Rect(30, 30, 60, 60)) #draw a rectangle\n",
    "\n",
    "pygame.display.update() #update display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At least close the pygame window."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.quit() #stop the pygame module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/jupyter_pygame.png\" width=\"280\" align=\"left\"><br><br><br><br><br><br><br><br><br><br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "With the magic command`%gui qt` **Jupyter** can work together with **Pygame**. This enables the use of the Jupyter GUI and the entries in the Pygame window at the same time. Therefore every recipe in this `Pygame Cookbook` has the magic command`%gui qt` in the first line.\n",
    "\n",
    "You don't need that, if you want to try a recipe in a different Python environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**More:**\n",
    "\n",
    "https://ipython.readthedocs.io/en/stable/config/eventloops.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## simple gameloop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Task: simple program structure that works with every game"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Opens a window that shows the drawing of pygame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "# ---- Initialize ----\n",
    "\n",
    "pygame.init()\n",
    "\n",
    "SIZE = WIDTH, HEIGHT = 320, 240\n",
    "BLACK = 0, 0, 0\n",
    "BLUE = 0, 0, 255\n",
    "\n",
    "running = True\n",
    "screen = pygame.display.set_mode(SIZE)\n",
    "\n",
    "# ---- Game loop ----\n",
    "\n",
    "while running:\n",
    "    \n",
    "    # ---- input ----\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "    \n",
    "    # ---- update ---- \n",
    "    \n",
    "    # ---- draw ----\n",
    "    screen.fill(BLACK)\n",
    "    pygame.draw.rect(screen, BLUE, pygame.Rect(30, 30, 60, 60)) #draw a rectangle\n",
    "    pygame.display.flip()\n",
    "\n",
    "# ---- Quit ----\n",
    "\n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/simple_gameloop.png\" width=\"280\" align=\"left\"><br><br><br><br><br><br><br><br><br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "Every game consists of the same building blocks:\n",
    "    \n",
    "* **Input**: Read input from player. Which keys are pressed? Did the  mouse move? Any other input device lika a joystick?\n",
    "* **Update**: Do the changes in the game world\n",
    "* **Draw**: Show the changes on the screen  \n",
    "    \n",
    "* and start all over again\n",
    "\n",
    "This is called **game loop** or **event loop**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`import pygame` .. import the Pygame module  \n",
    "`init() -> (numpass, numfail)` .. initialize all imported Pygame modules. Some Pygame modules needs to be initialized. Return value *numfail* shows how many modules could not be initialized by Pygame."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pygame.display.set_mode()` .. return a *Surface* object on which python can draw. The first parameters define the size. The created display will be the best supported by the system. \n",
    "\n",
    "There are many additional flags:\n",
    "\n",
    "`pygame.FULLSCREEN` .. fullscreen no window  \n",
    "`pygame.HWSURFACE` .. hardware accelerated (only fullscreen). \n",
    "`pygame.OPENGL` .. create an OpenGL-renderable display  \n",
    "`pygame.RESIZABLE` .. resizable window  \n",
    "`pygame.NOFRAME` .. window without border or controls  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pygame.event.get(eventtype=None) -> Eventlist` .. get next event from Pygame.   \n",
    "`if event.type == pygame.QUIT: ` .. user clicked on the close control of the window."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "`screen.fill(BLACK)` .. fill the complete display with color   \n",
    "`pygame.draw.rect` .. draw a rectangle on the display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pygame.display.flip()` .. show changed display on the screen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`pygame.quit() -> None` .. uninitialize all imported Pygame modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This **loop** will be used in the most recipes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**more**  \n",
    "* Pygame documentaion https://www.pygame.org/docs/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## gameloop with timing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Task: integrating time into the game loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "using class **pygame.time.clock** to get a good timing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "# ---- Initialize ----\n",
    "\n",
    "pygame.init()\n",
    "\n",
    "SIZE = WIDTH, HEIGHT = 320, 240\n",
    "BLACK = 0, 0, 0\n",
    "BLUE = 0, 0, 255\n",
    "\n",
    "running = True\n",
    "screen = pygame.display.set_mode(SIZE)\n",
    "\n",
    "clock = pygame.time.Clock() #create clock object\n",
    "\n",
    "FRAMES_PER_SECOND = 30      #who many pictures per second should pygame generate?\n",
    "\n",
    "x_position = 60             #position of the blue rectangel\n",
    "PIXELS_PER_SECOND = 40      #how many pixels per second should the rectangele be moved?\n",
    "\n",
    "# ---- Game loop ----\n",
    "\n",
    "while running:\n",
    "    \n",
    "    # ---- input ----\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "    \n",
    "    # ---- update ---- \n",
    "    delta_time = clock.tick(FRAMES_PER_SECOND)     # time since last frame\n",
    "    \n",
    "    x_position = x_position + delta_time/1000 * PIXELS_PER_SECOND #next position of the rectanel\n",
    " \n",
    "    if x_position > WIDTH: #rectangele vanishes right start from left again\n",
    "        x_position = 0\n",
    "    \n",
    "    # ---- draw ----\n",
    "    screen.fill(BLACK)\n",
    "    pygame.draw.rect(screen, BLUE, pygame.Rect(int(x_position), 30, 60, 60)) #draw a rectangle\n",
    "    pygame.display.flip()\n",
    "\n",
    "# ---- Quit ----\n",
    "\n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "**Pygame** comes with an integrated class for timing: **pygame.time.Clock**\n",
    "\n",
    "**-Initialize-**\n",
    "\n",
    "First you have to create your own **clock** object.  \n",
    "\n",
    "`clock = pygame.time.Clock()`\n",
    "\n",
    "`FRAMES_PER_SECOND = 30` .. you have to define how many frames (pictures) should be maximal drawn by **Pygame** in a second\n",
    "\n",
    "`x_position = 60` .. the blue rectangle will move from left to right. In every frame the script will use the time since the last frame to calculate the new position.  \n",
    "\n",
    "`PIXELS_PER_SECOND = 40` .. the speed (velocity) of the rectangle will be 40 pixels in one second.\n",
    "\n",
    "**-Game loop update()-**\n",
    "\n",
    "`delta_time = clock.tick(FRAMES_PER_SECOND)` .. returns the milliseconds since the last frame.   \n",
    "The parameter *FRAMES_PER_SECOND* defines the maximal number of frames per second. It limits the runtime. **Pygame** will not draw more frames per second.\n",
    "\n",
    "`x_position = x_position + delta_time/1000 * PIXELS_PER_SECOND` .. to get the distance covered since the last frame you have to multiply the elapsed time by the velocity. *delta_time* is in milliseconds but you need the time in seconds. So you have to divide with thousand.\n",
    " \n",
    "`if x_position > WIDTH: x_position = 0`.. before the rectangel is vanishing from the screen you have to start from the left side again"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### coordinates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### colors <a id='colors'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Rect <a id='Rect'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/rect.png\" width=\"320\" align=\"left\"><br><br><br><br><br><br><br><br><br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## draw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### rectangle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Task: drawing a rectangle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "pygame.init()\n",
    "\n",
    "SIZE = WIDTH, HEIGHT = 320, 240\n",
    "running = True\n",
    "screen = pygame.display.set_mode(SIZE)\n",
    "\n",
    "while running:\n",
    "    \n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "            \n",
    "    screen.fill(pygame.Color('black'))\n",
    "    pygame.draw.rect(screen, pygame.Color('blue'), pygame.Rect(30, 30, 60, 60))\n",
    "    pygame.display.flip()\n",
    "\n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "# ---- Initialize ----\n",
    "\n",
    "pygame.init()\n",
    "\n",
    "SIZE = WIDTH, HEIGHT = 320, 120\n",
    "\n",
    "running = True\n",
    "screen = pygame.display.set_mode(SIZE)\n",
    "\n",
    "# ---- Game loop ----\n",
    "\n",
    "while running:\n",
    "    \n",
    "    # ---- input ----\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "    \n",
    "    # ---- update ---- \n",
    "    \n",
    "    # ---- draw ----\n",
    "    screen.fill(BLACK)\n",
    "    \n",
    "    pygame.draw.rect(screen, pygame.Color('blue'), pygame.Rect(30, 30, 60, 60)) #fill area\n",
    "    \n",
    "    pygame.draw.rect(screen, pygame.Color('blue'), pygame.Rect(120, 30, 60, 60), width=1) #border\n",
    "    \n",
    "    pygame.draw.rect(screen, pygame.Color('blue'), pygame.Rect(210, 30, 60, 60), width=2, border_radius=8) #rounded border\n",
    "    \n",
    "    pygame.display.flip()\n",
    "\n",
    "# ---- Quit ----\n",
    "\n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/draw_rectangle.png\" width=\"560\" align=\"left\"><br><br><br><br><br><br><br><br><br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "A rectangle can consist of a fill area and a border.\n",
    "\n",
    "**Drawing the fill area with function rect**\n",
    "\n",
    "`rect(surface, color, rect) -> Rec` .. draws a rectangle to the output surface and returns an object of the class **Rect**  \n",
    "\n",
    "`surface`.. Surface to draw on\n",
    "\n",
    "`color` .. different ways to describe a [color](#colors) in **Pygame**\n",
    "\n",
    "`rec` .. rectangle that describes position, width and height\n",
    "\n",
    "With\n",
    "\n",
    "`Rect(left, top, width, height) -> Rect` .. you can create a new [Rect](#Rect) from position (left, top) and dimension (width, height)\n",
    "\n",
    "**Drawing the border with function rect**\n",
    "\n",
    "`rect(surface, color, rect, width=0, border_radius=0) -> Rect` .. draws the border of a rectangle to the output surface and returns an object of the class **Rect**\n",
    "\n",
    "`width`.. thickness of the border in Pixel. (if is 0, **Pygame** draws a filled rectangle)\n",
    "\n",
    "`border_radius`.. draws border with rounded corners (if is 0, no rounded corners)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**more**  \n",
    "* Pygame documentation http://www.pygame.org/docs/ref/draw.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### polygon, circle, ellipse, arc "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Task: draw text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pygame 2.1.2 (SDL 2.0.18, Python 3.9.16)\n",
      "Hello from the pygame community. https://www.pygame.org/contribute.html\n",
      "freesansbold.ttf\n"
     ]
    }
   ],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "running = True\n",
    "\n",
    "WHITE = (255,255,255)\n",
    "BLUE = (0,0,255)\n",
    "\n",
    "pygame.init()\n",
    "screen = pygame.display.set_mode((640, 340))\n",
    "\n",
    "sysfont = pygame.font.get_default_font()\n",
    "print(sysfont)\n",
    "\n",
    "font = pygame.font.SysFont(None, 24)\n",
    "\n",
    "pygame.display.flip()\n",
    "\n",
    "while running:\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "    \n",
    "    screen.fill(WHITE)\n",
    "    \n",
    "    img = font.render(\"text\", True, BLUE)\n",
    "    rect = img.get_rect()\n",
    "    rect.midtop = (40,40)\n",
    "    screen.blit(img, rect)\n",
    "    \n",
    "    pygame.display.flip()\n",
    "            \n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "`get_default_font() -> str` .. returns the name of the default font\n",
    "\n",
    "\n",
    "`SysFont(name, size) -> Font` .. create a Font object from the system fonts\n",
    "\n",
    "`name`.. name of the font, can be None\n",
    "\n",
    "`size`.. font size\n",
    "\n",
    "\n",
    "`Font(filename, size) -> Font`.. create Font from file\n",
    "\n",
    "`filename`.. file name of the font\n",
    "\n",
    "`size`.. font size\n",
    "\n",
    "\n",
    "`render(text, antialias, color, background=None) -> Surface` .. creates a new surface with text\n",
    "\n",
    "`text`.. as string  \n",
    "`antialias`.. if True than with antialias\n",
    "\n",
    "\n",
    "The text can only be a single line. The Surface will be of the dimensions required to hold the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## transparent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Task: draw a transparent surface"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[5], line 48\u001b[0m\n\u001b[1;32m     44\u001b[0m     surface\u001b[38;5;241m.\u001b[39mfill(BLUE)             \n\u001b[1;32m     46\u001b[0m     screen\u001b[38;5;241m.\u001b[39mblit(surface, (\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m0\u001b[39m))\n\u001b[0;32m---> 48\u001b[0m     \u001b[43mpygame\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdisplay\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflip\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     50\u001b[0m \u001b[38;5;66;03m# ---- Quit ----\u001b[39;00m\n\u001b[1;32m     52\u001b[0m pygame\u001b[38;5;241m.\u001b[39mquit()\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "# ---- Initialize ----\n",
    "\n",
    "pygame.init()\n",
    "\n",
    "SIZE = WIDTH, HEIGHT = 640, 340\n",
    "\n",
    "running = True\n",
    "screen = pygame.display.set_mode(SIZE)\n",
    "\n",
    "WHITE = (255,255,255)\n",
    "BLUE = (0,0,255)\n",
    "GREY_1 = (160, 160, 160)\n",
    "GREY_2 = (192, 192, 192)\n",
    "\n",
    "TILE_SIZE = 24\n",
    "background = pygame.Surface(SIZE) # background image\n",
    "\n",
    "for x in range(0,WIDTH//TILE_SIZE+1):\n",
    "    for y in range(0,HEIGHT//TILE_SIZE+1):\n",
    "        color = GREY_1\n",
    "        if (x+y) % 2 == 0:\n",
    "            color = GREY_2\n",
    "        pygame.draw.rect(background, color, (x*TILE_SIZE, y*TILE_SIZE, TILE_SIZE, TILE_SIZE))\n",
    "\n",
    "# ---- Game loop ----\n",
    "\n",
    "while running:\n",
    "    \n",
    "    # ---- input ----\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "    \n",
    "    # ---- update ---- \n",
    "    \n",
    "    # ---- draw ----\n",
    "    screen.blit(background, (0, 0))\n",
    "    \n",
    "    surface = pygame.Surface((200,200))  # new surface\n",
    "    surface.set_alpha(128)               # set alpha\n",
    "    surface.fill(BLUE)             \n",
    "    \n",
    "    screen.blit(surface, (0,0))\n",
    "    \n",
    "    pygame.display.flip()\n",
    "\n",
    "# ---- Quit ----\n",
    "\n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want a **transparent** image (surface) you have to that the so called **alpha value** of the\n",
    "surface. Use the set_alpha method for this.  \n",
    "\n",
    "If the alpha value is 0 it's totaly transparent. You see nothing.\n",
    "If the value is 255 it's not transpartent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`set_alpha(value) -> None` .. set alpha value of surface"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/transparent_surface.png\" width=\"560\" align=\"left\"><br><br><br><br><br><br><br><br><br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Task: make every pixel of an image transparent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "# ---- Initialize ----\n",
    "\n",
    "pygame.init()\n",
    "\n",
    "SIZE = WIDTH, HEIGHT = 320, 140\n",
    "\n",
    "running = True\n",
    "screen = pygame.display.set_mode(SIZE)\n",
    "\n",
    "WHITE = (255,255,255)\n",
    "BLUE = (0,0,255)\n",
    "GREY_1 = (160, 160, 160)\n",
    "GREY_2 = (192, 192, 192)\n",
    "\n",
    "TILE_SIZE = 24\n",
    "background = pygame.Surface(SIZE) # background image\n",
    "\n",
    "for x in range(0,WIDTH//TILE_SIZE+1):\n",
    "    for y in range(0,HEIGHT//TILE_SIZE+1):\n",
    "        color = GREY_1\n",
    "        if (x+y) % 2 == 0:\n",
    "            color = GREY_2\n",
    "        pygame.draw.rect(background, color, (x*TILE_SIZE, y*TILE_SIZE, TILE_SIZE, TILE_SIZE))\n",
    "\n",
    "# ---- Game loop ----\n",
    "\n",
    "while running:\n",
    "    \n",
    "    # ---- input ----\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "    \n",
    "    # ---- update ---- \n",
    "    \n",
    "    # ---- draw ----\n",
    "    screen.blit(background, (0, 0))\n",
    "    \n",
    "    RADIUS = 50\n",
    "    \n",
    "    surface = pygame.Surface((100,100),pygame.SRCALPHA)  # new surface per pixel alpha\n",
    "    pygame.draw.circle(surface, (0,0,255,128), (RADIUS, RADIUS), RADIUS) # with alpha\n",
    "    screen.blit(surface,(0,0))\n",
    "    \n",
    "    surface = pygame.Surface((100,100),pygame.SRCALPHA)  # new surface per pixel alpha\n",
    "    pygame.draw.circle(surface, (0,0,255,64), (RADIUS, RADIUS), RADIUS) # with alpha\n",
    "    screen.blit(surface,(75,0))\n",
    "    \n",
    "    pygame.display.flip()\n",
    "\n",
    "# ---- Quit ----\n",
    "\n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`surface = pygame.Surface((100,100),pygame.SRCALPHA)`\n",
    "\n",
    "If you want to set an alpha value (transparence) separatly for every pixel to have\n",
    "to use **pygame.SRCALPHA** when creating a surface. Now pygame knows that you wants\n",
    "to use alpha values.\n",
    "\n",
    "`pygame.draw.circle(surface, (0,0,255,128), (RADIUS, RADIUS), RADIUS)`\n",
    "\n",
    "In the color value you can now add the alpha value (128), too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/transparent_pixel.png\" width=\"560\" align=\"left\"><br><br><br><br><br><br><br><br><br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**more** \n",
    "* Draw a transparent rectangle in pygame https://stackoverflow.com/questions/6339057/draw-a-transparent-rectangle-in-pygame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## mouse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Task: drag with the mouse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "# ---- Initialize ----\n",
    "\n",
    "pygame.init()\n",
    "\n",
    "SIZE = WIDTH, HEIGHT = 320, 240\n",
    "BLACK = 0, 0, 0\n",
    "BLUE = 0, 0, 255\n",
    "\n",
    "running = True\n",
    "screen = pygame.display.set_mode(SIZE)\n",
    "\n",
    "rectangle = pygame.rect.Rect(176, 134, 80, 80)\n",
    "draging = False\n",
    "\n",
    "pygame.mouse.set_visible(True)\n",
    "\n",
    "# ---- Game loop ----\n",
    "\n",
    "while running:\n",
    "    \n",
    "    # ---- input ----\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "            \n",
    "        elif event.type == pygame.MOUSEBUTTONDOWN:           \n",
    "            if rectangle.collidepoint(event.pos):\n",
    "                draging = True\n",
    "                mouse_x, mouse_y = event.pos\n",
    "                offset_x = rectangle.x - mouse_x\n",
    "                offset_y = rectangle.y - mouse_y\n",
    "\n",
    "        elif event.type == pygame.MOUSEBUTTONUP:          \n",
    "            draging = False\n",
    "\n",
    "        elif event.type == pygame.MOUSEMOTION:\n",
    "            if draging:\n",
    "                mouse_x, mouse_y = event.pos\n",
    "                rectangle.x = mouse_x + offset_x\n",
    "                rectangle.y = mouse_y + offset_y\n",
    "    \n",
    "    # ---- update ---- \n",
    "    \n",
    "    # ---- draw ----\n",
    "    screen.fill(BLACK)\n",
    "    pygame.draw.rect(screen, BLUE, rectangle) #draw a rectangle\n",
    "    pygame.display.flip()\n",
    "\n",
    "# ---- Quit ----\n",
    "\n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## keyboard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Task: get every pressed key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pygame 2.1.2 (SDL 2.0.18, Python 3.9.16)\n",
      "Hello from the pygame community. https://www.pygame.org/contribute.html\n"
     ]
    }
   ],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "running = True\n",
    "\n",
    "WHITE = (255,255,255)\n",
    "BLUE = (0,0,255)\n",
    "GREEN = (0,255,0)\n",
    "\n",
    "screen = pygame.display.set_mode((640, 340))\n",
    "\n",
    "rectangle = pygame.rect.Rect(200, 150, 40, 40)\n",
    "rect_color = BLUE\n",
    "\n",
    "while running:\n",
    "\n",
    "    right_color = GREEN\n",
    "    left_color = GREEN\n",
    "    up_color = GREEN\n",
    "    down_color = GREEN\n",
    "    \n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "            \n",
    "    keys=pygame.key.get_pressed()\n",
    "    \n",
    "    if keys[pygame.K_RIGHT]:\n",
    "        right_color = BLUE\n",
    "        \n",
    "    if keys[pygame.K_LEFT]:\n",
    "        left_color = BLUE\n",
    "        \n",
    "    if keys[pygame.K_UP]:\n",
    "        up_color = BLUE\n",
    "        \n",
    "    if keys[pygame.K_DOWN]:\n",
    "        down_color = BLUE\n",
    "    \n",
    "    screen.fill(WHITE)\n",
    "    \n",
    "    pygame.draw.rect(screen, right_color, (200, 100, 100, 100))\n",
    "    pygame.draw.rect(screen, left_color, (0, 100, 100, 100))\n",
    "    pygame.draw.rect(screen, up_color, (100, 0, 100, 100))\n",
    "    pygame.draw.rect(screen, down_color, (100, 200, 100, 100))\n",
    "    \n",
    "    pygame.display.flip()\n",
    "\n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`get_pressed() -> bools` .. get a boolean value for every key on the keybaord. Is *True* if key is pressed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## events"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## collision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### point - rectangle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Task: detecting a point in a rectangle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "# ---- Initialize ----\n",
    "\n",
    "pygame.init()\n",
    "\n",
    "SIZE = WIDTH, HEIGHT = 320, 240\n",
    "WHITE =  255, 255 ,255\n",
    "BLUE = 0, 0, 255\n",
    "GREEN = 0, 255, 0\n",
    "\n",
    "running = True\n",
    "screen = pygame.display.set_mode(SIZE)\n",
    "\n",
    "rectangle = pygame.rect.Rect(50, 50, 100, 100)\n",
    "rect_color = BLUE\n",
    "\n",
    "# ---- Game loop ----\n",
    "\n",
    "while running:\n",
    "    \n",
    "    # ---- input ----\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "        elif event.type == pygame.MOUSEMOTION:           \n",
    "            if rectangle.collidepoint(event.pos):\n",
    "                rect_color = GREEN\n",
    "            else:         \n",
    "                rect_color = BLUE\n",
    "    \n",
    "    # ---- update ---- \n",
    "\n",
    "    # ---- draw ----\n",
    "    screen.fill(WHITE)\n",
    "    pygame.draw.rect(screen, rect_color, rectangle)\n",
    "    pygame.display.flip()\n",
    "\n",
    "# ---- Quit ----\n",
    "\n",
    "pygame.quit()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "`rect.collidepoint((x,y)) -> bool` returns True if point is within rect  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**more**  \n",
    "* pygame documentation rect https://www.pygame.org/docs/ref/rect.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### rectangle - rectangle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`rect.colliderect(Rect) -> bool` returns True if rectangles overlap  \n",
    "`rect.collidelist(list) -> index` returns index of the *first* rectangle that overlaps; -1 if nothing is found\n",
    "`rect.collidelistall(list) -> indices` returns indexes of all rectangles that overlap\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### rectangle - line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Task: detecting a line in a rectangle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pygame 2.1.1 (SDL 2.0.18, Python 3.9.7)\n",
      "Hello from the pygame community. https://www.pygame.org/contribute.html\n"
     ]
    }
   ],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "# ---- Initialize ----\n",
    "\n",
    "pygame.init()\n",
    "\n",
    "SIZE = WIDTH, HEIGHT = 320, 240\n",
    "WHITE = 255, 255, 255\n",
    "BLACK = 0, 0, 0\n",
    "BLUE = 0, 0, 255\n",
    "GRAY = 127, 127, 127\n",
    "GREEN = 0, 255, 0\n",
    "\n",
    "running = True\n",
    "screen = pygame.display.set_mode(SIZE)\n",
    "\n",
    "clock = pygame.time.Clock() #create clock object\n",
    "\n",
    "FRAMES_PER_SECOND = 30      #who many pictures per second should pygame generate?\n",
    "\n",
    "x_position = 60             #position of the blue rectangel\n",
    "PIXELS_PER_SECOND = 40      #how many pixels per second should the rectangele be moved?\n",
    "\n",
    "start_pos = (120,0)\n",
    "end_pos = (120,200)\n",
    "\n",
    "# ---- Game loop ----\n",
    "\n",
    "while running:\n",
    "    \n",
    "    # ---- input ----\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "    \n",
    "    # ---- update ---- \n",
    "    delta_time = clock.tick(FRAMES_PER_SECOND)     # time since last frame\n",
    "    \n",
    "    x_position = x_position + delta_time/1000 * PIXELS_PER_SECOND #next position of the rectanel\n",
    " \n",
    "    if x_position > WIDTH: #rectangele vanishes right start from left again\n",
    "        x_position = 0\n",
    "    \n",
    "    # ---- draw ----\n",
    "    screen.fill(BLACK)\n",
    "    rect = pygame.Rect(int(x_position), 30, 60, 60)\n",
    "    \n",
    "    clip = rect.clipline(start_pos,end_pos)\n",
    "    \n",
    "    if len(clip) > 0:\n",
    "        pygame.draw.rect(screen, GRAY, rect)\n",
    "        pygame.draw.line(screen, WHITE, start_pos, end_pos, width=1)\n",
    "        pygame.draw.line(screen, GREEN, clip[0], clip[1])\n",
    "    else:\n",
    "        pygame.draw.rect(screen, BLUE, rect)\n",
    "        pygame.draw.line(screen, WHITE, start_pos, end_pos, width=1)\n",
    "    \n",
    "    \n",
    "    pygame.display.flip()\n",
    "\n",
    "# ---- Quit ----\n",
    "\n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`clipline(x1, y1, x2, y2) -> ((cx1, cy1), (cx2, cy2))` ..\n",
    "returns the coordinates of a line that in rectangle; an empty tuble when line complete out rectangle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### pixel - pixel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "pygame.init()\n",
    "\n",
    "SIZE = WIDTH, HEIGHT = 320, 240\n",
    "BLACK = 0, 0, 0\n",
    "\n",
    "running = True\n",
    "clock = pygame.time.Clock()\n",
    "fps = 30\n",
    "screen = pygame.display.set_mode(SIZE)\n",
    "\n",
    "ball = pygame.image.load(\"Freddy.png\")\n",
    "ballrect = ball.get_rect()\n",
    "ballrect.center = (200,100)\n",
    "ballmask = pygame.mask.from_surface(ball)\n",
    "\n",
    "\n",
    "ball2 = pygame.image.load(\"Freddy.png\")\n",
    "ballrect2 = ball2.get_rect()\n",
    "ballmask2 = pygame.mask.from_surface(ball2)\n",
    "\n",
    "position = pygame.Vector2(100, 100)\n",
    "velocity = pygame.Vector2(10,0)\n",
    "\n",
    "while running:\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "\n",
    "    delta_time = clock.tick(fps) / 1000.0\n",
    "    position = position + velocity * delta_time\n",
    "    ballrect2.center = position\n",
    "    \n",
    "    offset_x = ballrect2.left - ballrect.left\n",
    "    offset_y = ballrect2.top - ballrect.top\n",
    "    \n",
    "    if ballmask.overlap(ballmask2, (offset_x, offset_y)) != None:\n",
    "        print('collision')\n",
    "        \n",
    "    screen.fill(BLACK)\n",
    "    screen.blit(ball, ballrect)\n",
    "    screen.blit(ball2, ballrect2)\n",
    "    pygame.display.flip()\n",
    "\n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`from_surface(Surface) -> Mask`.. Creates a *Mask* object from the *Surface* by setting all the opaque pixels and not setting the transparent pixels  \n",
    "`overlap(othermask, offset) -> (x, y)`.. Returns the first point of intersection encountered between this mask and *othermask*. *None* if there is no overlaping. *offset* is the distance between the two masks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sprite - sprite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**more**  \n",
    "* Collision Detection in PyGame LMU 2017 https://www.medien.ifi.lmu.de/lehre/ss17/mmp/uebung/uebung7/mmp_uebung_7_ss17.pdf\n",
    "* pygame documentation rect https://www.pygame.org/docs/ref/rect.html\n",
    "* pygame documentation sprite https://www.pygame.org/docs/ref/sprite.html\n",
    "* pygame documentation mask https://www.pygame.org/docs/ref/mask.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## opengl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Task: using OpenGl with pygame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solution:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "install Python packages **numpy**,**PyOpenGL** and **PyOpenGL_accelerate**\n",
    "\n",
    "`\n",
    "pip install numpy PyOpenGL PyOpenGL_accelerate\n",
    "`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "%gui qt\n",
    "import pygame\n",
    "\n",
    "from OpenGL.GL import *\n",
    "from OpenGL.GLU import *\n",
    "\n",
    "verticies = ((1, -1, -1),(1, 1, -1),(-1, 1, -1),(-1, -1, -1),\n",
    "             (1, -1, 1),(1, 1, 1),(-1, -1, 1),(-1, 1, 1))\n",
    "\n",
    "edges = ((0,1),(0,3),(0,4),(2,1),\n",
    "         (2,3),(2,7),(6,3),(6,4),\n",
    "         (6,7),(5,1),(5,4),(5,7))\n",
    "\n",
    "# ---- Initialize ----\n",
    "\n",
    "pygame.init()\n",
    "\n",
    "SIZE = WIDTH, HEIGHT = 640, 480\n",
    "BLACK = 0, 0, 0\n",
    "BLUE = 0, 0, 255\n",
    "\n",
    "#pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLEBUFFERS,1) #antialiasing\n",
    "#pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLESAMPLES,4)\n",
    "\n",
    "#pygame.display.gl_set_attribute(pygame.GL_CONTEXT_PROFILE_MASK, #compatibility\n",
    "#                                pygame.GL_CONTEXT_PROFILE_CORE)\n",
    "\n",
    "running = True\n",
    "screen = pygame.display.set_mode(SIZE,pygame.DOUBLEBUF | pygame.OPENGL)\n",
    "\n",
    "gluPerspective(45, (WIDTH/HEIGHT), 0.1, 50)\n",
    "glTranslatef(0.0,0.0,-5)\n",
    "\n",
    "# ---- Game loop ----\n",
    "\n",
    "while running:\n",
    "    \n",
    "    # ---- input ----\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT: \n",
    "            running = False\n",
    "    \n",
    "    # ---- update ---- \n",
    "    \n",
    "    # ---- draw ----\n",
    "    glRotatef(1, 3, 1, 1)\n",
    "    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)\n",
    "    \n",
    "    glBegin(GL_LINES)\n",
    "    for edge in edges:\n",
    "        for vertex in edge:\n",
    "            glVertex3fv(verticies[vertex])\n",
    "    glEnd()\n",
    "    \n",
    "    pygame.display.flip()\n",
    "    pygame.time.wait(10)\n",
    "\n",
    "# ---- Quit ----\n",
    "\n",
    "pygame.quit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}