General example changes (#2581)

* scaletest.py fixes

* example fixes

* format fix

* format fixes

* liquid example fix

* format fic

* removed time import

* fix 1

* update example

* droid problem fixes

* alien example update

* chimp example

* removed durk from buildconfig

* Revert "removed durk from buildconfig"

This reverts commit d5897be.

* Revert "chimp example"

This reverts commit 5ed783e.

* chimp tutorial update

* format fix

* playmus fix

* Further aliens.py cleanups

* Further scaletest.py cleanups

* Update examples/aliens.py

* formatting

* scaletest fix using irl key access

* clock scaletest

* revert changes resizing_new

---------

Co-authored-by: Dan Lawrence <[email protected]>

Author: bilhox

docs/reST/tutorials/en/chimp-explanation.rst

@@ -65,11 +65,6 @@ It also checks for the availability of some of the optional pygame modules. ::
     import os
     import pygame
 
-    if not pygame.font:
-        print("Warning, fonts disabled")
-    if not pygame.mixer:
-        print("Warning, sound disabled")
-
     main_dir = os.path.split(os.path.abspath(__file__))[0]
     data_dir = os.path.join(main_dir, "data")
 
@@ -79,12 +74,6 @@ us to do things like create platform independent file paths.
 
 In the next line, we import the pygame package. 
 
-Some pygame modules are optional, and if they aren't found,
-they evaluate to ``False``. Because of that, we decide to print
-a nice warning message if the :mod:`font<pygame.font>` or
-:mod:`mixer <pygame.mixer>` modules in pygame are not available.
-(Although they will only be unavailable in very uncommon situations). 
-
 Lastly, we prepare two paths for the rest of the code to use.
 ``main_dir`` uses the `os.path` module and the `__file__` variable provided
 by Python to locate the game's python file, and extract the folder from
@@ -101,12 +90,10 @@ look at each function individually in this section. ::
     def load_image(name, colorkey=None, scale=1):
         fullname = os.path.join(data_dir, name)
         image = pygame.image.load(fullname)
+        image = image.convert()
 
-        size = image.get_size()
-        size = (size[0] * scale, size[1] * scale)
-        image = pygame.transform.scale(image, size)
+        image = pygame.transform.scale_by(image, scale)
 
-        image = image.convert()
         if colorkey is not None:
             if colorkey == -1:
                 colorkey = image.get_at((0, 0))
@@ -130,9 +117,8 @@ call to the `convert()` function. This makes a new copy of a Surface and convert
 its color format and depth to match the display. This means blitting the
 image to the screen will happen as quickly as possible.
 
-We then scale the image, using the :func:`pygame.transform.scale` function.
-This function takes a Surface and the size it should be scaled to. To scale
-by a scalar, we can get the size and scale the x and y by the scalar.
+We then scale the image, using the :func:`pygame.transform.scale_by` function.
+This function takes a Surface and the scale factor it should be scaled of.
 
 Last, we set the colorkey for the image. If the user supplied an argument
 for the colorkey argument we use that value as the colorkey for the image.
@@ -146,7 +132,7 @@ that color for the colorkey. ::
             def play(self):
                 pass
 
-        if not pygame.mixer or not pygame.mixer.get_init():
+        if not pygame.mixer.get_init():
             return NoneSound()
 
         fullname = os.path.join(data_dir, name)
@@ -156,7 +142,7 @@ that color for the colorkey. ::
 
 
 Next is the function to load a sound file. The first thing this function
-does is check to see if the :mod:`pygame.mixer` module was imported correctly.
+does is check to see if the :mod:`pygame.mixer` module was initialized.
 If not, it returns a small class instance that has a placeholder play method.
 This will act enough like a normal Sound object for this game to run without
 any extra error checking.
@@ -367,15 +353,12 @@ input formats. See the :mod:`pygame.Color` for all the color formats.
 Put Text On The Background, Centered
 ------------------------------------
 
-Now that we have a background surface, lets get the text rendered to it. We
-only do this if we see the :mod:`pygame.font` module has imported properly.
-If not, we just skip this section. ::
+Now that we have a background surface, lets get the text rendered to it. ::
 
-    if pygame.font:
-        font = pygame.font.Font(None, 64)
-        text = font.render("Pummel The Chimp, And Win $$$", True, (10, 10, 10))
-        textpos = text.get_rect(centerx=background.get_width() / 2, y=10)
-        background.blit(text, textpos)
+    font = pygame.font.Font(None, 64)
+    text = font.render("Pummel The Chimp, And Win $$$", True, (10, 10, 10))
+    textpos = text.get_rect(centerx=background.get_width() / 2, y=10)
+    background.blit(text, textpos)
 
 As you see, there are a couple steps to getting this done. First we
 must create the font object and render it into a new surface. We then find
@@ -428,19 +411,15 @@ Here we create all the objects that the game is going to need.
     punch_sound = load_sound("punch.wav")
     chimp = Chimp()
     fist = Fist()
-    allsprites = pygame.sprite.RenderPlain((chimp, fist))
-    clock = pygame.time.Clock()
+    all_sprites = pygame.sprite.Group((chimp, fist))
+    clock = pygame.Clock()
 
 First we load two sound effects using the `load_sound` function we defined
 above. Then we create an instance of each of our sprite classes. And lastly
 we create a sprite :class:`Group <pygame.sprite.Group>` which will contain all
 our sprites.
 
-We actually use a special sprite group named :class:`RenderPlain
-<pygame.sprite.RenderPlain>`. This sprite group can draw all the sprites it
-contains to the screen. It is called `RenderPlain` because there are actually
-more advanced Render groups. But for our game, we just need simple drawing. We
-create the group named "allsprites" by passing a list with all the sprites that
+We create the group named "all_sprites" by passing a list with all the sprites that
 should belong in the group. We could later on add or remove sprites from this
 group, but in this game we won't need to.
 
@@ -501,7 +480,7 @@ Update the Sprites
 
 ::
 
-  allsprites.update()
+  all_sprites.update()
 
 Sprite groups have an `update()` method, which simply calls the update method
 for all the sprites it contains. Each of the objects will move around, depending
@@ -515,16 +494,14 @@ Draw The Entire Scene
 Now that all the objects are in the right place, time to draw them. ::
 
   screen.blit(background, (0, 0))
-  allsprites.draw(screen)
+  all_sprites.draw(screen)
   pygame.display.flip()
 
 The first blit call will draw the background onto the entire screen. This
 erases everything we saw from the previous frame (slightly inefficient, but
 good enough for this game). Next we call the `draw()` method of the sprite
-container. Since this sprite container is really an instance of the "RenderPlain"
-sprite group, it knows how to draw our sprites. Lastly, we `flip()` the contents
-of pygame's software double buffer to the screen. This makes everything we've
-drawn visible all at once.
+container. Lastly, we `flip()` the contentsof pygame's software double buffer 
+to the screen. This makes everything we've drawn visible all at once.
 
 
 Game Over
@@ -536,4 +513,4 @@ User has quit, time to clean up. ::
 
 Cleaning up the running game in *pygame* is extremely simple.
 Since all variables are automatically destructed, we don't really have to do
-anything, but calling `pygame.quit()` explicitly cleans up pygame's internals.
+anything, but calling `pygame.quit()` explicitly cleans up pygame's internals.

examples/aacircle.py

@@ -10,7 +10,7 @@ def main():
     pygame.init()
     screen = pygame.display.set_mode((500, 500))
     screen.fill((255, 0, 0))
-    s = pygame.Surface(screen.get_size(), pygame.SRCALPHA, 32)
+    s = pygame.Surface(screen.get_size(), pygame.SRCALPHA)
     pygame.draw.line(s, (0, 0, 0), (250, 250), (250 + 200, 250))
 
     width = 1
@@ -23,18 +23,23 @@ def main():
     pygame.draw.circle(screen, "green", (50, 100), 10)
     pygame.draw.circle(screen, "black", (50, 100), 10, 1)
 
-    pygame.display.flip()
-    try:
-        while True:
-            event = pygame.event.wait()
+    running = True
+
+    clock = pygame.Clock()
+
+    while running:
+        clock.tick(10)
+
+        for event in pygame.event.get():
             if event.type == pygame.QUIT:
-                break
-            if event.type == pygame.KEYDOWN:
-                if event.key == pygame.K_ESCAPE or event.unicode == "q":
-                    break
-            pygame.display.flip()
-    finally:
-        pygame.quit()
+                running = False
+            elif event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_q:
+                    running = False
+
+        pygame.display.flip()
+
+    pygame.quit()
 
 
 if __name__ == "__main__":

examples/aliens.py

@@ -83,9 +83,10 @@ class Player(pygame.sprite.Sprite):
     bounce = 24
     gun_offset = -11
     images = []
+    containers = None
 
     def __init__(self):
-        pygame.sprite.Sprite.__init__(self, self.containers)
+        super().__init__(self.containers)
         self.image = self.images[0]
         self.rect = self.image.get_rect(midbottom=SCREENRECT.midbottom)
         self.reloading = False
@@ -114,6 +115,7 @@ class Alien(pygame.sprite.Sprite):
     speed = 13
     animcycle = 12
     images = []
+    containers = None
 
     def __init__(self):
         pygame.sprite.Sprite.__init__(self, self.containers)
@@ -140,6 +142,7 @@ class Explosion(pygame.sprite.Sprite):
     defaultlife = 12
     animcycle = 3
     images = []
+    containers = None
 
     def __init__(self, actor):
         pygame.sprite.Sprite.__init__(self, self.containers)
@@ -166,6 +169,7 @@ class Shot(pygame.sprite.Sprite):
 
     speed = -11
     images = []
+    containers = None
 
     def __init__(self, pos):
         pygame.sprite.Sprite.__init__(self, self.containers)
@@ -187,6 +191,7 @@ class Bomb(pygame.sprite.Sprite):
 
     speed = 9
     images = []
+    containers = None
 
     def __init__(self, alien):
         pygame.sprite.Sprite.__init__(self, self.containers)
@@ -214,7 +219,7 @@ class Score(pygame.sprite.Sprite):
     def __init__(self):
         pygame.sprite.Sprite.__init__(self)
         self.font = pygame.Font(None, 20)
-        self.font.set_italic(1)
+        self.font.set_italic(True)
         self.color = "white"
         self.lastscore = -1
         self.update()
@@ -225,10 +230,10 @@ def update(self):
         if SCORE != self.lastscore:
             self.lastscore = SCORE
             msg = "Score: %d" % SCORE
-            self.image = self.font.render(msg, 0, self.color)
+            self.image = self.font.render(msg, False, self.color)
 
 
-def main(winstyle=0):
+def main():
     # Initialize pygame
     pygame.mixer.pre_init(44100, 32, 2, 1024)
     pygame.init()
@@ -244,9 +249,9 @@ def main(winstyle=0):
     # Load images, assign to sprite classes
     # (do this before the classes are used, after screen setup)
     img = load_image("player1.gif")
-    Player.images = [img, pygame.transform.flip(img, 1, 0)]
+    Player.images = [img, pygame.transform.flip(img, True, False)]
     img = load_image("explosion1.gif")
-    Explosion.images = [img, pygame.transform.flip(img, 1, 1)]
+    Explosion.images = [img, pygame.transform.flip(img, True, True)]
     Alien.images = [load_image(im) for im in ("alien1.gif", "alien2.gif", "alien3.gif")]
     Bomb.images = [load_image("bomb.gif")]
     Shot.images = [load_image("shot.gif")]
@@ -255,14 +260,13 @@ def main(winstyle=0):
     icon = pygame.transform.scale(Alien.images[0], (32, 32))
     pygame.display.set_icon(icon)
     pygame.display.set_caption("Pygame Aliens")
-    pygame.mouse.set_visible(0)
+    pygame.mouse.set_visible(False)
 
     # create the background, tile the bgd image
     bgdtile = load_image("background.gif")
     background = pygame.Surface(SCREENRECT.size)
     for x in range(0, SCREENRECT.width, bgdtile.get_width()):
         background.blit(bgdtile, (x, 0))
-    screen.blit(background, (0, 0))
     pygame.display.flip()
 
     # load the sound effects
@@ -277,19 +281,18 @@ def main(winstyle=0):
     aliens = pygame.sprite.Group()
     shots = pygame.sprite.Group()
     bombs = pygame.sprite.Group()
-    all = pygame.sprite.RenderUpdates()
+    all_sprites = pygame.sprite.Group()
     lastalien = pygame.sprite.GroupSingle()
 
     # assign default groups to each sprite class
-    Player.containers = all
-    Alien.containers = aliens, all, lastalien
-    Shot.containers = shots, all
-    Bomb.containers = bombs, all
-    Explosion.containers = all
-    Score.containers = all
+    Player.containers = all_sprites
+    Alien.containers = aliens, all_sprites, lastalien
+    Shot.containers = shots, all_sprites
+    Bomb.containers = bombs, all_sprites
+    Explosion.containers = all_sprites
+    Score.containers = all_sprites
 
     # Create Some Starting Values
-    global score
     alienreload = ALIEN_RELOAD
     clock = pygame.Clock()
 
@@ -298,10 +301,13 @@ def main(winstyle=0):
     player = Player()
     Alien()  # note, this 'lives' because it goes into a sprite group
     if pygame.font:
-        all.add(Score())
+        all_sprites.add(Score())
 
     # Run our main loop whilst the player is alive.
     while player.alive():
+        # Erase last frame by blitting the background to the screen
+        screen.blit(background, (0, 0))
+
         # get input
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
@@ -314,7 +320,8 @@ def main(winstyle=0):
                         print("Changing to FULLSCREEN")
                         screen_backup = screen.copy()
                         screen = pygame.display.set_mode(
-                            SCREENRECT.size, winstyle | pygame.FULLSCREEN
+                            SCREENRECT.size,
+                            winstyle | pygame.FULLSCREEN | pygame.SCALED,
                         )
                         screen.blit(screen_backup, (0, 0))
                     else:
@@ -327,11 +334,8 @@ def main(winstyle=0):
 
         keystate = pygame.key.get_pressed()
 
-        # clear/erase the last drawn sprites
-        all.clear(screen, background)
-
         # update all the sprites
-        all.update()
+        all_sprites.update()
 
         # handle player input
         direction = keystate[pygame.K_RIGHT] - keystate[pygame.K_LEFT]
@@ -355,7 +359,7 @@ def main(winstyle=0):
             Bomb(lastalien.sprite)
 
         # Detect collisions between aliens and players.
-        for alien in pygame.sprite.spritecollide(player, aliens, 1):
+        for alien in pygame.sprite.spritecollide(player, aliens, True):
             if pygame.mixer:
                 boom_sound.play()
             Explosion(alien)
@@ -364,23 +368,23 @@ def main(winstyle=0):
             player.kill()
 
         # See if shots hit the aliens.
-        for alien in pygame.sprite.groupcollide(aliens, shots, 1, 1).keys():
+        for alien in pygame.sprite.groupcollide(aliens, shots, True, True).keys():
             if pygame.mixer:
                 boom_sound.play()
             Explosion(alien)
             SCORE = SCORE + 1
 
         # See if alien bombs hit the player.
-        for bomb in pygame.sprite.spritecollide(player, bombs, 1):
+        for bomb in pygame.sprite.spritecollide(player, bombs, True):
             if pygame.mixer:
                 boom_sound.play()
             Explosion(player)
             Explosion(bomb)
             player.kill()
 
         # draw the scene
-        dirty = all.draw(screen)
-        pygame.display.update(dirty)
+        all_sprites.draw(screen)
+        pygame.display.flip()
 
         # cap the framerate at 40fps. Also called 40HZ or 40 times per second.
         clock.tick(40)