http___programarcadegames.com_index.php_chapter_introduction_to_sprites_lang_tr_3.xml
1.1 2.1 3.1 3.2 3.3 4.1 4.2 4.3 5.1 5.2 6.1 7.1 8.1 9.1 10.1 11.1 12.1 13.1 14.1 15.1 16.1 16.2 16.3 17.1 17.2 18.1 18.2 18.3 18.4 18.5 19.1 19.2 19.3 20.1 20.2 21.1 21.2 22.1 22.2 22.3 22.4 23.1 23.2 23.3 23.4 24.1 25.1 25.2 25.3 25.4 26.1 26.2 26.3 27.1 27.2 27.3 28.1 28.2 28.3 29.1 30.1 30.2 31.1 31.2 31.3 31.4 31.5 32.1 32.2 33.1 34.1 34.2 35.1 35.2 35.3 35.4 35.5 35.6 35.7 36.1 36.2 36.3 37.1 37.2 37.3 37.4 37.5 37.6 38.1 39.1 39.2 39.3 39.4 39.5 39.6 40.1 41.1 41.2 41.3 42.1 42.2 42.3 43.1 43.2 44.1 44.2 44.3 44.4 45.1 45.2 45.3 46.1 46.2 47.1 47.2 47.3 47.4 47.5 48.1 48.2 49.1 49.2 49.3 49.4 49.5 50.1 51.1 51.2 51.3 52.1 52.2 53.1 54.1 55.1 55.2 55.3 56.1 56.2 56.3 57.1 58.1 59.1 60.1 61.1 61.2 62.1 63.1 64.1 65.1 66.1 66.2 66.3 66.4 67.1 67.2 67.3 67.4 68.1 69.1 70.1 71.1 72.1 73.1 74.1 75.1 75.2 75.3 75.4 75.5 76.1 77.1 78.1 79.1 80.1 81.1 82.1 82.2 83.1 84.1 84.2 85.1 86.1 88.1 88.2 89.1 90.1 91.1 91.2 91.3 92.1 92.2 92.3 93.1 94.1 95.1 96.1 96.2 97.1 98.1 99.1 99.2 100.1 101.1 101.2 102.1 103.1 104.1 104.2 104.3 104.4 105.1 106.1 107.1 108.1 108.2 108.3 108.4 110.1 111.1 111.2 112.1 113.1 114.1 115.1 116.1
Program Arcade GamesWith Python And Pygame Chapter 14: Introduction to Sprites Our games need support for handling objects that collide. Balls bouncing off paddles, laser beams hitting aliens, or our favorite character collecting a coin. All these examples require collision detection. The Pygame library has support for sprites. A sprite is a two dimensional image that is part of the larger graphical scene. Typically a sprite will be some kind of object in the scene that will be interacted with like a car, frog, or little plumber guy. Originally, video game consoles had built-in hardware support for sprites. Now this specialized hardware support is no longer needed, but we still use the term “sprite.” 14.1 Basic Sprites and Collisions Let's step through an example program that uses sprites. This example shows how to create a screen of black blocks, and collect them using a red block controlled by the mouse as shown in Figure 14.1. The program keeps “score” on how many blocks have been collected. The code for this example may be found at: ProgramArcadeGames.com/python_examples/f.php?file=sprite_collect_blocks.py The first few lines of our program start off like other games we've done: # Sample Python/Pygame Programs # Simpson College Computer Science # http://simpson.edu/computer-science import pygame import random # Define some colors black = ( 0, 0, 0) white = ( 255, 255, 255) red = ( 255, 0, 0) The pygame library is imported for sprite support on line 5. The random library is imported for the random placement of blocks on line 6. The definition of colors is standard in lines 9-11; there is nothing new in this example yet. # This class represents the ball # It derives from the "Sprite" class in Pygame class Block(pygame.sprite. Sprite): Lines 13-15 start the definition of the Block class. Note that on line 15 this class is a child class of the Sprite class. The pygame.sprite. specifies the library and package, which will be discussed later in Chapter 15. All the default functionality of the Sprite class will now be a part of the Block class. # Constructor. Pass in the color of the block, # and its size def __init__(self, color, width, height): # Call the parent class (Sprite) constructor pygame.sprite. Sprite.__init__(self) The constructor for the Block class on line 18 takes in a parameter for self just like any other constructor. It also takes in parameters that define the object's color, height, and width. It is important to call the parent class constructor in Sprite to allow sprites to initialize. This is done on line 20. # Create an image of the block, and fill it with a color. # This could also be an image loaded from the disk. self.image = pygame. Surface([width, height]) self.image.fill(color) Lines 25 and 26 create the image that will eventually appear on the screen. Line 25 creates a blank image. Line 26 fills it with black. If the program needs something other than a black square, these are the lines of code to modify. For example, look at the code below: # Ellipse Constructor. Pass in the color of the ellipse, # and its size def __init__(self, color, width, height): # Call the parent class (Sprite) constructor pygame.sprite. Sprite.__init__(self) # Set the background color and set it to be transparent self.image = pygame. Surface([width, height]) self.image.fill(white) self.image.set_colorkey(white) # Draw the ellipse pygame.draw.ellipse(self.image,color,[0,0,width,height]) If the code above was substituted, then everything would be in the form of ellipses. Line 28 draws the ellipse and line 25 makes white a transparent color so the background shows up. This is the same concept used in Chapter 12 for making the white background of a red X transparent. # Graphic Sprite Constructor. def __init__(self): # Call the parent class (Sprite) constructor pygame.sprite. Sprite.__init__(self) # Load the image self.image = pygame.image.load("player.png").convert() # Set our transparent color self.image.set_colorkey(white) If instead a bit-mapped graphic is desired, substituting the lines of code above will load a graphic and set white to the transparent background color. In this case, the dimensions of the sprite will automatically be set to the graphic dimensions, and it would no longer be necessary to pass them in. See how line 17 no longer has those parameters. There is one more important line that we need in our constructor, no matter what kind of sprite we have: # Fetch the rectangle object that has the dimensions of the # image. The position of this object is updated # by setting the values of rect.x and rect.y self.rect = self.image.get_rect() The attribute rect is a variable that is an instance of the Rect class that Pygame provides. The rectangle represents the dimensions of the sprite. This rectangle class has attributes for x and y that may be set. Pygame will draw the sprite where the x and y attributes are. So to move this sprite, a programmer needs to set mySpriteRef.rect.x and mySpriteRef.rect.y where mySpriteRef is the variable that points to the sprite. We are done with the Block class. Time to move on to the initialization code. # Initialize Pygame pygame.init() # Set the height and width of the screen screen_width = 700 screen_height = 400 screen = pygame.display.set_mode([screen_width, screen_height]) The code above initializes Pygame and creates a window for the game. There is nothing new here from other Pygame programs. # This is a list of 'sprites.' Each block in the program is # added to this list. # The list is managed by a class called 'Group.' block_list = pygame.sprite. Group() # This is a list of every sprite. # All blocks and the player block as well. all_sprites_list = pygame.sprite. Group() A major advantage of working with sprites is the ability to work with them in groups. We can draw and move all the sprites with one command if they are in a group. We can also check for sprite collisions against an entire group. The above code creates two lists. The variable all_sprites_list will contain every sprite in the game. This list will be used to draw all the sprites. The variable block_list holds each object that the player can collide with. In this example it will include every object in the game but the player. We don't want the player in this list because when we check for the player colliding with objects in the block_list, Pygame will go ahead and always return the player as colliding if it is part of that list. for i in range(50): # This represents a block block = Block(black, 20, 15) # Set a random location for the block block.rect.x = random.randrange(screen_width) block.rect.y = random.randrange(screen_height) # Add the block to the list of objects block_list.add(block) all_sprites_list.add(block) The loop starting on line 49 adds 50 black sprite blocks to the screen. Line 51 creates a new block, sets the color, the width, and the height. Lines 54 and 55 set the coordinates for where this object will appear. Line 58 adds the block to the list of blocks the player can collide with. Line 59 adds it to the list of all blocks. This should be very similar to the code you wrote back in Lab 13. # Create a red player block player = Block(red, 20, 15) all_sprites_list.add(player) Lines 61-63 set up the player for our game. Line 62 creates a red block that will eventually function as the player. This block is added to the all_sprites_list in line 63 so it can be drawn, but not the block_list. #Loop until the user clicks the close button. done = False # Used to manage how fast the screen updates clock = pygame.time. Clock() score = 0 # -------- Main Program Loop ----------- while done == False: for event in pygame.event.get(): if event.type == pygame.QUIT: done = True # Clear the screen screen.fill(white) The code above is a standard program loop first introduced back in Chapter 5. Line 71 initializes our score variable to 0. # Get the current mouse position. This returns the position # as a list of two numbers. pos = pygame.mouse.get_pos() # Fetch the x and y out of the list, # just like we'd fetch letters out of a string. # Set the player object to the mouse location player.rect.x = pos[0] player.rect.y = pos[1] Line 84 fetches the mouse position similar to other Pygame programs discussed before. The important new part is contained in lines 89-90 where the rectangle containing the sprite is moved to a new location. Remember this rect was created back on line 30 and this code won't work without that line. # See if the player block has collided with anything. blocks_hit_list = pygame.sprite.spritecollide(player,block_list,True) This line of code takes the sprite referenced by player and checks it against all sprites in block_list. The code returns a list of sprites that overlap. If there are no overlapping sprites, it returns an empty list. The boolean True will remove the colliding sprites from the list. If it is set to False the sprites will not be removed. # Check the list of collisions. for block in blocks_hit_list: score +=1 print(score) This loops for each sprite in the collision list created back in line 93. If there are sprites in that list, increase the score for each collision. Then print the score to the screen. Note that the print on line 98 will not print the score to the main window with the sprites, but the console window instead. Figuring out how to make the score display on the main window is part of Lab 14. # Draw all the spites all_sprites_list.draw(screen) The Group class that all_sprites_list is a member of has a method called draw. This method loops through each sprite in the list and calls that sprite's draw method. This means that with only one line of code, a program can cause every sprite in the all_sprites_list to draw. # Limit to 20 frames per second clock.tick(20) # Go ahead and update the screen with what we've drawn. pygame.display.flip() pygame.quit() Lines 103-109 flips the screen, and calls the quit method when the main loop is done. 14.2 Moving Sprites In the example so far, only the player sprite moves. How could a program cause all the sprites to move? This can be done easily; just two steps are required. The first step is to add a new method to the Block class. This new method is called update. The update function will be called automatically when update is called for the entire list. Put this in the sprite: def update(self): # Move the block down one pixel self.rect.y += 1 Put this in the main program loop: # Call the update() method for all blocks in the block_list block_list.update() The code isn't perfect because the blocks fall off the screen and do not reappear. This code will improve the update function so that the blocks will reappear up top. def update(self): # Move the block down one pixel self.rect.y += 1 if self.rect.y > screen_height: self.rect.y = random.randrange(-100, -10) self.rect.x = random.randrange(0, screen_width) If the program should reset blocks that are collected to the top of the screen, the sprite can be changed with the following code: def reset_pos(self): self.rect.y = random.randrange(-100,-10) self.rect.x = random.randrange(0,screen_width) def update(self): # Move the block down one pixel self.rect.y += self.change_y if self.rect.y > screen_height: self.reset_pos() self.game.score -= 1 Rather than destroying the blocks when the collision occurs, the program may instead call the reset_pos function and the block will move to the top of the screen ready to be collected. # See if the player block has collided with anything. blocks_hit_list = pygame.sprite.spritecollide(player,block_list,True) # Check the list of collisions. for block in blocks_hit_list: score +=1 print( score ) # Reset block to the top of the screen to fall again. block.reset_pos() Find the code above. Change the True to a False so the blocks are not destroyed. Change the if statement to a for loop that loops through each block the player has collided with. Call block.reset_pos() on that block. The full code for this example is here: ProgramArcadeGames.com/python_examples/f.php?file=moving_sprites_bounce.py If you'd rather see code for sprites that bounce, look here: ProgramArcadeGames.com/python_examples/f.php?file=moving_sprites.py If you want them to move in circles: ProgramArcadeGames.com/python_examples/f.php?file=sprite_circle_movement.py 14.3 The Game Class Back in Chapter 9 we introduced functions. At the end of the chapter we talked about an option to use a main function. As programs get large this technique helps us avoid problems that can come from having a lot of code to sort through. Our programs aren't quite that large yet. However I know some people like to organize things properly from the start. For those people in that camp, here's another optional technique to organize your code. (If you aren't in that camp, you can skip this section and circle back later when your programs get too large.) Watch the video to get an idea of how the program works. ProgramArcadeGames.com/python_examples/f.php?file=game_class_example.py 14.4 Other Examples Here are several other examples of what you can do with sprites. A few of these also include a linked video that explains how the code works. 14.4.1 Shooting things Interested in a shoot-em-up game? Something like the classic Space Invaders? This example shows how to create sprites to represent bullets: ProgramArcadeGames.com/python_examples/f.php?file=bullets.py Are you looking for more of an adventure games? You don't want your player to wander all over the place? This shows how to add walls that prevent player movement: ProgramArcadeGames.com/python_examples/f.php?file=move_with_walls_example.py Wait? One room isn't enough of an adventure? You want your player to move from screen to screen? We can do that! Look through this example where the player may run through a multi-room maze: ProgramArcadeGames.com/python_examples/f.php?file=maze_runner.py 14.4.3 Platforms Interested in creating a platformer, like Donkey Kong? We need to use the same idea as our example with walls, but add some gravity: ProgramArcadeGames.com/python_examples/f.php?file=platform_jumper.py Good platformers can move side to side. This is a side scrolling platformer: ProgramArcadeGames.com/python_examples/f.php?file=platform_scroller.py Even cooler platform games have platforms that move! See how that is done with this example: ProgramArcadeGames.com/python_examples/f.php?file=platform_moving.py 14.4.4 Snake/Centipede I have occasionally get students that want to make a “snake” or “centipede” type of game. You have a multi-segment snake that you can control. This requires each segment to be held in a list. While it requires learning two new commands, the concept behind how to do this game isn't difficult. Control a snake or centipede going around the screen: ProgramArcadeGames.com/python_examples/f.php?file=snake.py 14.4.5 Using Sprite Sheets This is an extensive example that uses “sprite sheets” to provide the graphics behind a platformer game. It supports multiple levels and moving platforms as well. The game is broken into multiple files. ProgramArcadeGames.com/python_examples/sprite_sheets Complete Lab 14 “Sprite Collecting” to create your first mini-game with sprites. You are not logged in. Log in here and track your progress. English version by Paul Vincent Craven Russian version by Vladimir Slav Turkish version by Güray Yildirim Dutch version by Frank Waegeman Portuguese version by Tati Carvalho
1.1 2.1 3.1 4.1 5.1 6.1 7.1 8.1 9.1 10.1 11.1 12.1 13.1 14.1 15.1 16.1 17.1 18.1 19.1 20.1 21.1 22.1 23.1 24.1 25.1 26.1 27.1 28.1 29.1 30.1 31.1 32.1 33.1 34.1 35.1 36.1 37.1 38.1 39.1 40.1 41.1 42.1 43.1 44.1 45.1 46.1 47.1 48.1 49.1 50.1 51.1 52.1 53.1 54.1 55.1 56.1 57.1 58.1 59.1 60.1 61.1 62.1 63.1 64.1 65.1 66.1 67.1 68.1 69.1 70.1 71.1 72.1 73.1 74.1 75.1 76.1 77.1 78.1 79.1 80.1
Arcade Türü Oyun Programlamayıve Bilgisayar Bilimleri Öğrenin English Dutch - Nederlands French Hungarian - Magyar Portuguese - Português Russian - Pycckий Spanish - Español Turkish - Türkçe Chapter 14: Hareketli Grafiklere(Sprites) Giriş Sprite daha geniş bir sahnenin bir parçası olan iki boyutlu grafiktir. Genel olarak spritelar sahnede etkileşime geçilecek bazı nesne türleridir. Önceden, spritelar eski oyun konsollarının donanımları tarafından özellik olarak destekleniyordu. Bu özelleştirilmiş donanım desteği artık gerekmiyor, fakat bu kelime hala varlığını sürdürüyor. Pygame kütüphanesi spriteları destekliyor. Bu kod animasyon yönetiminde, çarpışma tespitinde ve sprite gruplarının yönetiminde yardımcı oluyor. 14.1 Basit Spritelar and Çarpışmalar Bu örnek siyah bloklar içeren ve fare ile kontrol edilen siyah bir blok yardımıyla onların toplanacağı bir ekranın nasıl oluşturulacağını gösteriyor. Program "skoru" kaç tane bloğun toplandığına göre tutuyor. Bu örneğin kodu şu adreste bulunabilir: http://cs.simpson.edu/index.php?chapter=example_code # Sample Python/Pygame Programları # Simpson College Bilgisayar Bilimi # http: cs.simpson.edu import pygame import random # Bazı renkleri tanımla black = ( 0, 0, 0) white = ( 255, 255, 255) red = ( 255, 0, 0) Pygame kütüphanesi sprite desteği için import edilir. Random kütüphanesi blokların rastgele yerleşebilmesi için import edilir. Renklerin tanımı standarttır; henüz bu örnekte yeni olan hiçbir şey yoktur. # Bu sınıf topu temsil ediyor # Pygame içerisindeki "Sprite" sınıfından türüyor class Block(pygame.sprite.Sprite): Bu kod Block sınıfının tanımını başlatıyor. 15. satırda bu sınıfın Sprite sınıfının bir alt sınıfı olduğuna dikkat edin. pygame.sprite. bu derste daha sonra tartışılacak olan kütüphaneyi ve paketi belirtiyor. Sprite sınıfının tüm varsayılan işlevselliği şu an Block sınıfının bir parçası durumunda. # Yapıcı. Rengi ve onun x ve y konumlarını # bloğa aktar def __init__(self, color, width, height): # Üst sınıfın (Sprite) yapıcı fonksiyonunu çağır super().__init__() Block sınıfı için olan yapıcı fonksiyon self'i tıpkı diğer bütün yapıcı fonksiyonlar gibi bir parametre olarak alıyor. Ayrıca nesnenin rengi(color), yüksekliği(height) ve genişliğini(width) de parametre olarak alıyor. Sprite'ın içerisindeki ebeveyn sınıf yapıcı fonksiyonunu çağırmak spriteları başlatabilmeye imkan sağladığı için önemlidir. Bu satır 21'de yapılmıştır. # Bloğun bir resmini oluştur ve onu bir renkle doldur. # Bu aynı zamanda diskten yüklenen bir resim de olabilir. self.image = pygame.Surface([width, height]) self.image.fill(color) Bu kod aslında sonunda ekranda görünecek olan resmi oluşturuyor. 25. satır boş bir resim oluşturuyor. 26. satır onu siyah renkle boyuyor. Program siyah kareden başka bir şeye ihtiyaç duyarsa, bunlar değiştirilecek kod satırlarıdır. Örneğin, alttaki koda göz atın: self.image = pygame.Surface([width, height]) self.image.fill(white) self.image.set_colorkey(white) pygame.draw.ellipse(self.image,color,[0,0,width,height]) Bu kod bu şekilde değiştirilmiş olsaydı, her şey elips şeklinde olurdu. 25. satır elipsi boyuyor ve 26. satır beyazı saydam bir renk yapıyor. self.image = pygame.image.load("player.png").convert() self.image.set_colorkey(white) Eğer bunların yerine bit eşlemli bir grafik isteniyorsa, yukarıdaki kodları kullanmak bir grafiği yükleyecek ve beyaz rengi saydam arkaplan resmi olarak ayarlayacaktır. Bu durumda, sprite'ın boyutları otomatik olarak grafiğin boyutlarına ayarlanacaktır ve boyutları ona aktarmak artık gerekmeyecektir. # Resmin boyutlarına sahip dikdördgen nesneyi # getir # Bu nesnenin yerini rect.x ve rect.y'yi atayarak # güncelle self.rect = self.image.get_rect() rect niteliği Pygame'in sağladığı Rect sınıfının örneği olan bir değişkendir. Dikdördgen, sprite'ın iki boyutunu temsil eder. Bu dikdördgen sınıfı ayarlanabilir olan x ve y için niteliklere sahiptir. Pygame x ve y niteliklerinin olduğu yere sprite'ı çizecektir.Yani bu sprite'ı değiştirmek için programcının mySpriteRef.rect.x ve mySpriteRef.rect.y değerlerini ayarlaması gerekmektedir. Burada mySpriteRef, sprite'ın olduğu değişkene tekabül etmektedir. # Pygame'i başlat pygame.init() # Ekranın yüksekliğini ve genişliğini ayarla screen_width=700 screen_height=400 screen=pygame.display.set_mode([screen_width,screen_height]) Bu kod pygame'i başlatıyor ve pygame için bir pencere oluşturuyor. Burada diğer pygame programlarından farklı yeni bir şey yok. # Bu 'sprite'ların bir listesi. Programdaki her blok # bu listeye ekleniyor. # Bu liste 'Group' denen bir sınıfla yönetiliyor. block_list = pygame.sprite.Group() # Bu her sprite'ın listesi # Bütün bloklar ve oyuncu bloğu da burada. all_sprites_list = pygame.sprite.Group() Spritelar ile çalışmanın büyük bir avantajı listedeki öğelerle çalışma yeteneği. Tüm nesneleri bir çarpışma olup olmadığı konusunda kontrol etmek yerine, program basitçe listedeki tüm nesneleri çarpışmaya karşı kontrol ediyor. Aynı şekilde, sprite gruplarının tamamı konumlarını güncelleyebilir ve basitçe listeye güncellemesi ve çizmesi söylenerek çizilebilir. Bu otomatik olarak listedeki tüm öğeleri güncelleyecek ve çizecektir. Yukarıdaki kod iki liste oluşturuyor. all_sprites_list değişkeni oyundaki her sprite'ı içeriyor. Bu liste tüm spritelar çizilirken kullanılacak. ball_list değişkeni oyuncunun çarpışabileceği her nesneyi tutuyor. Bu örnekte oyuncununki dışında oyundaki her nesneyi içeriyor. Kesin olduğu üzere oyuncu nesnesi, oyuncu nesnesiyle çarpışamaz, sonuç olarak da program oyuncu nesnesinin olmadığı bir listeye ihtiyaç duyar. for i in range(50): # Bu tek bir bloğu temsil ediyor block = Block(black, 20, 15) # Blok için rastgele konum belirleniyor block.rect.x = random.randrange(screen_width) block.rect.y = random.randrange(screen_height) # Bloğu nesnelerin listesine ekliyor block_list.add(block) all_sprites_list.add(block) Bu döngü 46. satırda başlıyor ve 50 adet siyah sprite bloğunu ekrana ekliyor. 48. satır yeni bir blok oluşturuyor; rengini, genişliğini ve yüksekliğini belirliyor. 51 ve 52. satırlar nesnenin görüneceği yerin koordinatlarını ayarlıyor. 55. satır bloğu oyuncunun çarpışabileceği blokların listesine ekliyor. 56. satırda ise bütün blokların olduğu listeye ekliyor. # Kırmızı bir oyuncu bloğu oluştur player = Block(red, 20, 15) all_sprites_list.add(player) 59. satır sonunda oyuncu görevi görecek bir kırmızı blok oluşturuyor. Bu blok çizilebilmesi için all_sprites_list listesine ekleniyor. # Kullanıcı kapatma düğmesine basana kadar döngü done=False # Ekranın ne hızla güncelleneceğini yönetmek için kullanılır clock=pygame.time.Clock() score = 0 # -------- Ana Program Döngüsü ----------- while done==False: for event in pygame.event.get(): # Kullanıcı bir şey yaptı if event.type == pygame.QUIT: # Kullanıcı kapat butonuna bastıysa done=True # Oyunun bittiğini ve döngüden çıkılmasını söyle # Ekranı temizle screen.fill(white) Bu standart program döngüsüdür. 85. satır skoru 0 olarak başlatmaktadır. # Geçerli fare konumunu al. Bu konumu iki sayıdan oluşan # bir liste olarak döndürecektir. pos = pygame.mouse.get_pos() # x ve y değerlerini listeden al, # tıpkı stringden harfleri alırken yaptığımız gibi. # Oyuncu blok nesnesini fare konumuna ayarla player.rect.x=pos[0] player.rect.y=pos[1] 81. satır daha önce tartışılan diğer Pygame programlarına benzer şekilde fare konumunu alıyor. Önemli olan yeni kısım 86-87 numaralı satırlarda sprite'ı içeren dikdördgen yeni bir konuma hareket ettirilirken görülüyor. Bu dikdördgenin 32. satırda oluşturulduğunu ve bu kodun bu satır olmadan çalışmayacağını unutmayın. # Kullanıcı bloğunun herhangi bir şeyle çarpışıp çarpışmadığını kontrol et blocks_hit_list = pygame.sprite.spritecollide(player, block_list, True) Kodun bu satırı player olarak çağırılan sprite'ı alır ve block_list'in içerisindeki tüm bloklara karşı kontrol eder. Bu kod üst üste binen spriteların bir listesini döndürür. Eğer böyle bir sprite yoksa, boş bir liste döndürür. Mantıksal olan True çarpışan spriteları listeden siler. Eğer bu parametre False olarak ayalanırsa spritelar silinmeyecektir. # Çarpışma listesini kontrol et. if len(blocks_hit_list) > 0: score +=len(blocks_hit_list) print( score ) Bu kod, çarpışma listesinde herhangi bir sprite olup olmadığını kontrol eder. Eğer varsa, skoru çarpışılan sprite kadar arttırır. Ardından skoru ekrana yazdırır. 95. satırdaki yazdırma olayının skoru ana pencereye spritelar ile yazdırmadığına, ekran yerine konsola yazdırdığına dikkat edin. # Tüm spriteları çiz all_sprites_list.draw(screen) Bu all_sprites_list içerisindeki tüm spriteların öizilmesine sebep olur. # Saniyede 20 frame (20 FPS) ile sınırla clock.tick(20) # İlerle ve ekranı çizdirdiğimiz son hali ile güncelle pygame.display.flip() pygame.quit() Bu ekranı günceller, ve döngü bittiğinde quit metodunu çağırır. 14.2 Hareket Eden Spritelar Şu ana kadarki örnekte, sadece oyuncu sprite'ı hareket etti. Program tüm spriteların hareket etmesine nasıl sebep olabilir? Bu kolayca yapılabilir, sadece iki aşama gereklidir. İlk aşama Block sınıfına yeni bir metot eklemektir. Bu yeni metot update olarak adlandırılır. Bu update fonksiyonu update metodu çağırıldığında tüm liste için otomatik olarak çağırılacaktır. Şunu sprite'ın içine koyun: def update(self): # Bloğu 1 piksel aşağı oynat self.rect.y += 1 Şunu ana program döngüsüne koyun: # block_list içerisindeki tüm bloklar için update() metodunu çağır block_list.update() Bu kod mükemmel değildir çünkü bloklar ekrandan düşmekte ve tekrar görünmemektedir. Bu kod update fonksiyonunu blokların üstten tekrar görünebilmesi için geliştirecektir. def update(self): # Bloğu bir piksel oynat self.rect.y += 1 if self.rect.y > screen_height: self.rect.y = random.randrange(-100,-10) self.rect.x = random.randrange(0,screen_width) Programın toplanan blokları ekranın üst kısmından sıfırdan bırakması gerekiyorsa, sprite aşağıdaki kod ile değiştirilebilir: def reset_pos(self): self.rect.y = random.randrange(-100,-10) self.rect.x = random.randrange(0,screen_width) def update(self): # Bloğu bir piksel aşağı kaydır self.rect.y += self.change_y if self.rect.y > screen_height: self.reset_pos() self.game.score -= 1 Çarpışma olduğunda blokları yok etmektense, onun yerine program reset_pos fonksiyonunu çağıracak ve blok toplanmaya hazır bir şekilde ekranın üst kısmına gidecektir. # Oyuncu bloğunun bir şeye çarpıp çarpmadığına bak blocks_hit_list = pygame.sprite.spritecollide(player, block_list, True) # Çarpışma listesini kontrol et. if len(blocks_hit_list) > 0: score +=len(blocks_hit_list) print( score ) Yukarıdaki kodu bulun. Blokların yok olmaması için True ifadesini False olarak değiştirin. if ifadesini oyuncunun çarpıştığı her blok için dönecek bir for döngüsüne çevirin. Bu döngüde her blok için block.reset_pos() metodunu çağırın. ProgramArcadeGames.com/python_examples/en/sprite_sheets You are not logged in. Log in here and track your progress. English version by Paul Vincent Craven Spanish version by Antonio Rodríguez Russian version by Vladimir Slav Turkish version by Güray Yildirim Portuguese version by Armando Marques Sobrinho and Tati Carvalho Dutch version by Frank Waegeman Hungarian version by Nagy Attila French version by Franco Rossi