http___programarcadegames.com_index.php_chapter_introduction_to_sprites_lang_tr_3.xml
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 13.2 14.1 15.1 15.2 16.1 16.2 17.1 18.1 18.2 18.3 19.1 20.1 20.2 20.3 21.1 21.2 21.3 21.4 21.5 22.1 22.2 22.3 23.1 24.1 24.2 25.1 26.1 26.2 26.3 27.1 27.2 28.1 29.1 30.1 31.1 32.1 32.2 32.3 33.1 34.1 34.2 34.3 34.4 34.5 35.1 36.1 36.2 36.3 36.4 36.5 37.1 38.1 40.1 41.1 42.1 42.2 42.3 42.4 42.5 42.6 43.1 44.1 45.1 45.2 45.3 45.4 46.1 47.1 48.1 48.2 49.1 50.1 50.2 50.3 51.1 52.1 52.2 52.3 53.1 53.2 53.3 53.4 53.5 54.1 55.1 55.2 56.1 57.1 57.2 57.3 57.4 57.5 59.1 59.2 60.1 61.1 62.1 63.1 63.2 64.1 65.1 65.2 66.1 67.1 68.1 69.1 70.1 70.2 71.1 72.1 72.2 72.3 73.1 74.1 74.2 74.3 74.4 74.5 74.6 74.7 75.1 75.2 75.3 75.4 76.1 77.1 77.2 78.1 78.2 79.1 79.2 79.3 79.4 79.5 80.1 80.2 80.3 80.4 81.1 81.2 81.3 82.1 83.1 84.1 85.1 86.1 87.1 87.2 87.3 88.1 88.2 88.3 88.4 88.5 88.6 89.1 90.1 91.1 92.1 93.1 94.1 95.1 96.1 97.1 99.1 100.1 100.2 101.1 102.1 103.1 104.1 105.1 106.1 107.1
Program Arcade GamesWith Python And Pygame English Dutch - Nederlands French Hungarian - Magyar Portuguese - Português Russian - Pycckий Spanish - Español Turkish - Türkçe Chapter 8: Introduction to Animation 8.1 The Bouncing Rectangle To begin our first animation, let's start with the base pygame program from Chapter 5 that opens up a blank screen. Source for pygame_base_template.py can be found here: ProgramArcadeGames.com/python_examples/f.php?file=pygame_base_template.py We will put together a program to bounce a white rectangle around a screen with a black background. Feel free to pick your own colors, just make sure the background color is different than the rectangle color! First step, start with the base template and flip the background color from white to black. This code should be around line 46. screen.fill(BLACK) Next up, draw the rectangle we plan to animate. A simple rectangle will suffice. This code should be placed after clearing the screen, and before flipping it. pygame.draw.rect(screen, WHITE, [50, 50, 50, 50]) Each time through the loop the rectangle will be drawn at an (x,y) location of exactly (50,50). This is controlled by the first two 50s in the list. Until those numbers change, the square will not move. The rectangle will be 50 pixels wide and 50 pixels tall. The dimensions are controlled by the last two numbers in the list. We could also call this rectangle a square, since it has the same width and height. I'll stick with calling it a rectangle because all squares are also rectangles, and depending on the monitor and resolution used, pixels aren't always square. Look up Pixel Aspect Ratio if you are really interested in this subject. How do we keep changing the location rather than have it stuck at (50, 50)? Use a variable, of course! The code below is a first step towards that: rect_x = 50 pygame.draw.rect(screen, WHITE, [rect_x, 50, 50, 50]) To move the rectangle to the right, x can be increased by one each frame. This code is close, but it does not quite do it: rect_x = 50 pygame.draw.rect(screen, WHITE, [rect_x, 50, 50, 50]) rect_x += 1 The problem with the above code is that rect_x is reset back to 50 each time through the loop. To fix this problem, move the initialization of rect_x up outside of the loop. This next section of code will successfully slide the rectangle to the right. # Starting x position of the rectangle # Note how this is outside the main while loop. rect_x = 50 # -------- Main Program Loop ----------- while not done: for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user clicked close done = True # Flag that we are done so we exit this loop # Set the screen background screen.fill(BLACK) pygame.draw.rect(screen, WHITE, [rect_x, 50, 50, 50]) rect_x += 1 To move the box faster, rather than increasing rect_x by 1, increase it by 5: rect_x += 5 We can expand this code and increase both x and y, causing the square to move both down and right: # Starting position of the rectangle rect_x = 50 rect_y = 50 # -------- Main Program Loop ----------- while not done: for event in pygame.event.get(): if event.type == pygame.QUIT: done = True # Set the screen background screen.fill(BLACK) # Draw the rectangle pygame.draw.rect(screen, WHITE, [rect_x, rect_y, 50, 50]) # Move the rectangle starting point rect_x += 5 rect_y += 5 The direction and speed of the box's movement can be stored in a vector. This makes it easy for the direction and speed of a moving object to be changed. The next bit of code shows using variables to store the x and y change of (5, 5). # Starting position of the rectangle rect_x = 50 rect_y = 50 # Speed and direction of rectangle rect_change_x = 5 rect_change_y = 5 # -------- Main Program Loop ----------- while done == False: for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user clicked close done = True # Flag that we are done so we exit this loop # Set the screen background screen.fill(BLACK) # Draw the rectangle pygame.draw.rect(screen, WHITE, [rect_x, rect_y, 50, 50]) # Move the rectangle starting point rect_x += rect_change_x rect_y += rect_change_y Once the box hits the edge of the screen it will keep going. Nothing makes the rectangle bounce off the edge of the screen. To reverse the direction so the rectangle travels towards the right, rect_change_y needs to change from 5 to -5 once the rectangle gets to the bottom side of the screen. The rectangle is at the bottom when rect_y is greater than the height of the screen. The code below can do the check and reverse the direction: # Bounce the rectangle if needed if rect_y > 450: rect_change_y = rect_change_y * -1 Why check rect_y against 450? If the screen is 500 pixels high, then checking against 500 would be a logical first guess. But remember the rectangle is drawn starting from the top left corner of the rectangle. If the rectangle was drawn starting at 500, it would draw from 500 to 550, totally off screen before it bounced. See Figure 8.1. Taking into account that the rectangle is 50 pixels high the correct bounce location is: The code below will bounce the rectangle off all four sides of a 700x400 window: # Bounce the rectangle if needed if rect_y > 450 or rect_y   650 or rect_x < 0: rect_change_x = rect_change_x * -1 Interested in a more complex shape than a rectangle? Several drawing commands can be used based off the rect_x and rect_y. The code below draws a red rectangle inside the white rectangle. The red rectangle is offset 10 pixels in the x,y directions from the upper left corner of the white rectangle. It also is 20 pixels smaller in both dimensions, resulting in 10 pixels of white surrounding the red rectangle. See Figure 8.2. # Draw a red rectangle inside the white one pygame.draw.rect(screen, WHITE, [rect_x, rect_y, 50, 50]) pygame.draw.rect(screen, RED, [rect_x + 10, rect_y + 10 ,30, 30]) 8.2 Animating Snow Animating only one item isn't enough? Need to animate more? How about being able to animate hundreds of objects at once? This shows how to use techniques from Section 8.1 to animate many snowflakes falling. 8.2.1 Code Explanation To start this program, begin with the base pygame template that opens up a blank screen. Again, source for pygame_base_template.py can be found here: ProgramArcadeGames.com/python_examples/show_file.php?file=pygame_base_template.py It is possible to create x, y locations for things like stars, snow, or rain by using random numbers. The simplest way to attempt this is using a for loop to draw circles in random x, y positions. Try the following code inside of the main while loop. for i in range(50): x = random.randrange(0, 400) y = random.randrange(0, 400) pygame.draw.circle(screen, WHITE, [x, y], 2) Try it, this program has an odd problem! Twenty times per second, each time through the loop, it draws the show in new random locations. Try adjusting the show flake count and see how it changes the image. Obviously, we need to randomly position the snow flakes and keep them in the same spot. We don't want to generate new positions twenty times per second. We need to to keep a list of where they are. The program can use a python list to do this. This should be done before the main loop, otherwise the program will add 50 new snow flakes to the list every 1/20th of a second. for i in range(50): x = random.randrange(0, 400) y = random.randrange(0, 400) snow_list.append([x, y]) Once the snow flake locations have been added, they can be accessed like a normal list. The following code would print both the x and y coordinates of the first location, stored in position zero: print(snow_list[0]) What if we wanted just the x or y coordinate? We have lists inside lists. The main list has all the coordinates. Inside of that list, each coordinate is a list of an x (position 0), and a y coordinate (position 1). For example, here are three coordinates: To print the y coordinate at position 0, first select coordinate 0, and then the y value at position 1. The code will look like: print(snow_list[0][1]) To print the x value of the 21st coordinate (position 20), first select coordinate 20, and then the x value at position 0: print(snow_list[20][0]) Inside of the main while loop, a program may use a for loop to draw each of the items in the snow list. Remember, len(snow_list) will return the number of elements in the snow flake list. # Process each snow flake in the list for i in range(len(snow_list)): # Draw the snow flake pygame.draw.circle(screen, WHITE, snow_list[i], 2) Remember, there are two types of for loops. The other type of loop can be used, and it would look like: # Process A COPY of each snow flake's location in the list for xy_coord in snow_list: # Draw the snow flake pygame.draw.circle(screen, WHITE, xy_coord, 2) However, because we plan on modifying the snow flake's location we can't use this type of for loop because we'd be modifying the location of a copy of the snow flake's location rather than the actual snow flake's location. If the program is to have all the objects in the array move down, like snow, then expanding the for loop created above will cause the y coordinate to increase: # Process each snow flake in the list for i in range(len(snow_list)): # Draw the snow flake pygame.draw.circle(screen, WHITE, snow_list[i], 2) # Move the snow flake down one pixel snow_list[i][1] += 1 This moves the snow downwards, but once off the screen nothing new appears. By adding the code below, the snow will reset to the top of the screen in a random location: # If the snow flake has moved off the bottom of the screen if snow_list[i][1] > 400: # Reset it just above the top y = random.randrange(-50, -10) snow_list[i][1] = y # Give it a new x position x = random.randrange(0, 400) snow_list[i][0] = x It is also possible to add things to the list and have different sizes, shapes, colors, speeds and directions for each item on the screen. This gets complex however because of the multiple types of data that need to be kept in the list. We will keep it simple for now, but once we learn about “classes” in Chapter 13 it will be easy to manage many different attributes for multiple objects. 8.2.2 Full Program Listing """ Animating multiple objects using a list. Sample Python/Pygame Programs Simpson College Computer Science http://programarcadegames.com/ http://simpson.edu/computer-science/ Explanation video: http://youtu.be/Gkhz3FuhGoI """ # Import a library of functions called 'pygame' import pygame import random # Initialize the game engine pygame.init() BLACK = [ 0, 0, 0] WHITE = [255, 255, 255] # Set the height and width of the screen SIZE = [400, 400] screen = pygame.display.set_mode(SIZE) pygame.display.set_caption("Snow Animation") # Create an empty array snow_list = [] # Loop 50 times and add a snow flake in a random x,y position for i in range(50): x = random.randrange(0, 400) y = random.randrange(0, 400) snow_list.append([x, y]) clock = pygame.time. Clock() #Loop until the user clicks the close button. done = False while done == False: for event in pygame.event.get(): # User did something if event.type == pygame.QUIT: # If user clicked close done = True # Flag that we are done so we exit this loop # Set the screen background screen.fill(BLACK) # Process each snow flake in the list for i in range(len(snow_list)): # Draw the snow flake pygame.draw.circle(screen, WHITE, snow_list[i], 2) # Move the snow flake down one pixel snow_list[i][1] += 1 # If the snow flake has moved off the bottom of the screen if snow_list[i][1] > 400: # Reset it just above the top y = random.randrange(-50, -10) snow_list[i][1] = y # Give it a new x position x = random.randrange(0, 400) snow_list[i][0] = x # Go ahead and update the screen with what we've drawn. pygame.display.flip() clock.tick(20) # Be IDLE friendly. If you forget this line, the program will 'hang' # on exit. pygame.quit () This example shows each snowflake moving the same direction. What if each item needs to be animated separately, with its own direction? If you need this for your game, see Chapter 13 on how to use classes. Lab 8 steps you through how to have hundreds of different items animated, each with their own direction. 8.3 3D Animation Extending from a 2D environment into a 3D environment complete with game physics isn't as hard as it would seem. While it is beyond the scope of this class, it is worth while to see how it is done. There is a freely available 3D program called Blender which has a “game engine” that allows programmers to create 3D games. The 3D objects in the game can have Python code attached to them that controls their actions in the game. Look at Figure 8.3. This shows a green tray with several objects in it. The blue object is controlled by a Python script that moves it around the tray bumping into the other objects. The script, shown below, has many of the same features that the 2D programs have. There is a main loop, there is a list for x,y locations, and there are variables controlling the vector. The main program loop is controlled by Blender. The python code shown in the listing is called by Blender for each “frame” the game renders. This is why the Python code does not show a main program loop. It does exist however. The blue object has a location held in x,y,z format. It can be accessed and changed by using the blueobject.position variable. Array position 0 holds x, position 1 holds y, and position 2 holds the z location. Rather than the change_x and change_y variables used in the 2D examples in this changer, this Blender example uses the associative array locations: blueObject["x_change"] blueObject["y_change"] The if statements check to see if the blue object has reached the borders of the screen and the direction needs to reverse. Unlike pixels used in the 2D games, locations of objects may be a floating point number type. To position an item between 5 and 6, setting its location to 5.5 is permissable. # Import Blender Game Engine import bge # Get a reference to the blue object cont = bge.logic.getCurrentController() blueObject = cont.owner # Print the x,y coordinates where the blue object is print(blueObject.position[0], blueObject.position[1] ) # Change x,y coordinates according to x_change and # y_change. x_change and y_change are game properties # associated with the blue object. blueObject.position[0] += blueObject["x_change"] blueObject.position[1] += blueObject["y_change"] # Check to see of the object has gone to the edge. # If so reverse direction. Do so with all 4 edges. if blueObject.position[0] > 6 and blueObject["x_change"] > 0: blueObject["x_change"] *= -1 if blueObject.position[0]   6 and blueObject["y_change"] > 0: blueObject["y_change"] *= -1 if blueObject.position[1] < -6 and blueObject["y_change"] < 0: blueObject["y_change"] *= -1 Blender may be downloaded from: http://www.blender.org/ A full blender example file is available at: ProgramArcadeGames.com/chapters/08_intro_to_animation/simple_block_move.blend. 8.4 Review 8.4.1 Multiple Choice Quiz Click here for a multiple-choice quiz. 8.4.2 Short Answer Worksheet Click here for the chapter worksheet. Click here for the chapter lab. 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
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