Getting Started

Well it kind of makes sense since the screen size on ratina is huge. The problem is that python overall is pretty slow on mac. Where i run our app on linux and windows 250fps easily my friends pretty new macbook runs it at 60fps max. Also python will use 100% of his cpu while on my windows it is only 10%. Install Pygame in Mac OS X # pygame # game # pip # install. Darkside haguremetal Apr 10, 2019 ・1 min read. Environment Mac OS X 10.14 Mojave; Anaconda3-5.3.1.

You must do the following to get started with Pygame:

Strictly speaking, import sys is not needed for PyGame, but as we'll see later, to be able to use the 'close window' button on Windows or Mac, we'll need to use sys.exit(), so it is helpful.

Opening a Window

To open a window of size 640,480, use the statement below.

This opens a window of size 640,480, and stores it in a variable called screen
Substitute other numbers for other sizes of screeen.
You have to pass this variable anytime you want to do something to the screen

The screen

If your screen is of size 640,480:

The point (0,0) is at the upper left hand corner of the screen.
x coordinates increase from left to right, y coordinates increase from top to bottom
So:
- Upper right is (640,0)
- Lower left is (0,480)
- Lower right is (640,480)

Updating the Screen

Changes you make to the screen—e.g. filling it with color, or drawing on it—do not show up immediately!

Instead, you have to call this function

pygame.display.update() shows you all the drawing you did since the last call to pygame.display.update()
if this is the first call to pygame.display.update(), it is all changes since the screen was created

Why do you have to do this?

This implements a features called double buffering
Double buffering is a feature of PyGame (and many other game programming packages) that lets you make lots of changes to the screen, and then have them all show up together as a single frame.
Otherwise, when there is fast animation, the screen would 'flicker' and it would be annoying to people playing the game

Colors

name the color anything you like.
(r,g,b) is a tuple with values for red, green, and blue
all three should be integers between 0 and 255, with 255 being brightest, and 0 being darkest

Examples:

Drawing

Remember that after you draw, you have to call pygame.display.update() before your changes show up.

fills the entire screen with the given color
e.g. screen.fill(white)

draws a series of lines, connecting the points specified in pointlist
pointlist is a list of tuples, specifying a series of points, e.g. to draw a V you might use [(100,100), (150,200), (200,100)], with closed = False
closed should be either True or False, indicating whether to connect the last point back to the first
thickness is the thickness of the line (in pixels).
Example: pygame.draw.lines(screen, black, False, [(100,100), (150,200), (200,100)], 1)

draws a rectangle
(x,y,width,height) is a Python tuple
x,y are the coordinates of the upper left hand corner
width, height are the width and height of the rectangle
thickness is the thickness of the line. If it is zero, the rectangle is filled

draws a circle
(x,y) is a Python tuple for the center, radius is the radius
thickness is the thickness of the line. If it is zero, the rectangle is filled

draws an arc (portion of an ellipse)
(x,y,height,width) are the coordinates of a rectangle that the arc would fit inside if it were drawn all the way around
if height and width are equal, then the rectangle is a square, and the arc will be a portion of a circle
start_angle and stop_angle are the angle on the unit circle in radians (not degrees) where the arc stops and starts
An example is shown in this Python file: drawCircleArcExample.py

Writing your own drawing functions

You can use functions to help you draw in PyGame in two different ways:

Create your own specialized drawing functions
Create functions that return lists of points

Specialized Drawing Functions (as in ex06)

The first way is illustrated below. This function actually draws a house. First it forms a list of points, and then it uses them to draw the house by calling pygame.draw.lines()

Functions that return lists of points (as in ex09)

The second way is illustrated below. First, we have a function that creates the list of points:

Then, we can just use those points to draw a house like this.

Note that we have a function call to makeHouseFrame() as the fourth argument to the pygame.draw.lines() function call.

The call to makeHouseFrame() returns a list of points
That list of points is what we draw whenever drawHouse() is called
So, a call to drawHouse() results in a call to makeHouseFrame() to return a list of points, which is then passed in to pygame.draw.lines()

Comparing the two techniques

At first, it may seem like this is not progress. We've turned a simple five line function into two functions, and fourteen lines of code—that do the very same thing.T

This seems to go against the idea that 'simple is better than complex'.

However, the second version has several advantages:

We list the points one at a time in the makeHouseFrame() function.
- That gives us a chance to put a comment next to each point.
- That can help a lot when we are having trouble figuring out what is going on.
We can use check_expect() to write test cases for makeHouseFrame() to see if the list of points returned is correct or not
- For an example of this, see the file ex09DrawHousesWithTests.py
When we add additional features to the house, like doors, windows, etc. we can put each of these in its own function.
- That keeps the drawHouse function shorter and easier to understand
- We might also be able to reuse some things—for example, we might find a way to draw multiple windows on a single house if we define our makeWindowPoints function in the correct way.

Restructuring our code like this is an example of 'refactoring' (discussed in section 4.7 of the textbook)

Enabling the quit button (red X on Windows, red circle on Mac)

To make the quit button work, we need two things:

An infinite loop, that goes around and around looking for events
Some code that looks for a QUIT event, and handles that event

The infinite loop part is easy. Here is an infinite loop in Python:

Whatever we have in place of # do something will be done over and over again, until we exit the program.

What is it that we want to do over and over? Each time through the loop, we need to look for quit events and if we find one, we need to quit the program:

This code says the following:

The call to pygame.event.get() returns a list of every event that has happened since we called pygame.init(), or since the last call to pygame.event.get().
One by one, the variable event is set to each of those events.
For each one of those, we use an if test to see if that event is equal to pygame.QUIT which is a value that means that the user clicked the red X (or red Circle) to close the window
If the user did that, then do two things:
- Call pygame.quit() to shut down pygame (this includes closing the window)
- Call sys.exit() to shut down the program (this exits the infinite loop)

We put this code inside a while (True): infinite loop so that we can do it over and over again—we have to keep doing it, because we don't know when the user will click the red X.

Animation (making drawings move)

To make a drawing move, you just put code inside your infinite loop that

erases the old drawing (e.g. screen.fill(white) or screen.fill(black))
draws the new drawing (e.g. using function calls starting with pygame.draw) in a different place than it was before!
calls pygame.display.

Pygame To Mac App