Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-flash-lite-preview-06-17-thinking· GoogleHugging Face LMArena Human Preference 140K

tetris oyunu yap

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with DeepSeekdeepseek-r1-0528’s answer.
  1. User

    tetris oyunu yap

  2. Gemini Assistant

    Harika bir fikir! Python ve Pygame kütüphanesini kullanarak temel bir Tetris oyunu oluşturalım.

    Öncelikle bilgisayarınızda Python'un kurulu olduğundan emin olun. Ardından Pygame'i yüklemeniz gerekiyor. Terminali veya komut istemcisini açıp şu komutu çalıştırın:

    pip install pygame
    

    Şimdi Tetris oyununun kodunu yazalım:

    import pygame
    import random
    
    # --- Oyun Ayarları ---
    pygame.font.init() # Font modülünü başlat
    
    # Ekran Boyutları
    SCREEN_WIDTH = 800
    SCREEN_HEIGHT = 700
    PLAY_WIDTH = 300  # Oyun alanının genişliği (10 blok * 30 piksel)
    PLAY_HEIGHT = 600 # Oyun alanının yüksekliği (20 blok * 30 piksel)
    BLOCK_SIZE = 30   # Her bir Tetris bloğunun boyutu
    
    # Oyun Alanı Konumu (Ekranın ortasına yerleştirmek için)
    TOP_LEFT_X = (SCREEN_WIDTH - PLAY_WIDTH) // 2
    TOP_LEFT_Y = SCREEN_HEIGHT - PLAY_HEIGHT - 50 # Biraz aşağıda başlasın
    
    # --- Renkler (RGB) ---
    S = (0, 255, 0)    # Yeşil
    Z = (0, 255, 0)    # Yeşil (S ve Z aynı renk olabilir)
    I = (255, 0, 0)    # Kırmızı
    O = (255, 255, 0)  # Sarı
    J = (0, 0, 255)    # Mavi
    L = (255, 165, 0)  # Turuncu
    T = (128, 0, 128)  # Mor
    BLACK = (0, 0, 0)
    WHITE = (255, 255, 255)
    GRAY = (128, 128, 128)
    DARK_GRAY = (40, 40, 40)
    
    # --- Tetromino Şekilleri ve Formatları ---
    # Her şekil için 4 farklı dönme durumunu temsil eden koordinat listeleri
    # Koordinatlar, şeklin merkezine göre (x, y) şeklinde verilir.
    S_SHAPE = [['.....',
                '.....',
                '..00.',
                '.00..',
                '.....'],
               ['.....',
                '..0..',
                '.00..',
                '.0...',
                '.....']]
    
    Z_SHAPE = [['.....',
                '.....',
                '.00..',
                '..00.',
                '.....'],
               ['.....',
                '.0...',
                '.00..',
                '..0..',
                '.....']]
    
    I_SHAPE = [['..0..',
                '..0..',
                '..0..',
                '..0..',
                '.....'],
               ['.....',
                '0000.',
                '.....',
                '.....',
                '.....']]
    
    O_SHAPE = [['.....',
                '.....',
                '.00..',
                '.00..',
                '.....']]
    
    J_SHAPE = [['.....',
                '.0...',
                '.000.',
                '.....',
                '.....'],
               ['.....',
                '..0..',
                '..0..',
                '.00..',
                '.....'],
               ['.....',
                '.....',
                '000..',
                '...0.' ,
                '.....'],
               ['.....',
                '.00..',
                '..0..',
                '..0..',
                '.....']]
    
    L_SHAPE = [['.....',
                '...0.',
                '.000.',
                '.....',
                '.....'],
               ['.....',
                '.0...',
                '.0...',
                '.00..',
                '.....'],
               ['.....',
                '.000.',
                '0....',
                '.....',
                '.....'],
               ['.....',
                '..00.',
                '..0..',
                '..0..',
                '.....']]
    
    T_SHAPE = [['.....',
                '..0..',
                '.000.',
                '.....',
                '.....'],
               ['.....',
                '..0..',
                '.00..',
                '..0..',
                '.....'],
               ['.....',
                '.....',
                '000..',
                '..0..',
                '.....'],
               ['.....',
                '..0..',
                '..00.',
                '..0..',
                '.....']]
    
    # Şekilleri ve renklerini bir listede toplama
    SHAPES = [S_SHAPE, Z_SHAPE, I_SHAPE, O_SHAPE, J_SHAPE, L_SHAPE, T_SHAPE]
    SHAPE_COLORS = [S, Z, I, O, J, L, T]
    
    # --- Sınıflar ---
    
    # Her bir Tetromino parçasını temsil eden sınıf
    class Piece:
        def __init__(self, x, y, shape):
            self.x = x
            self.y = y
            self.shape = shape
            self.color = SHAPE_COLORS[SHAPES.index(shape)]
            self.rotation = 0  # Mevcut dönme durumu (index)
    
    # --- Yardımcı Fonksiyonlar ---
    
    # Oyun tahtasını (grid) oluşturur
    def create_grid(locked_positions={}):
        # 20 satır, 10 sütunluk boş bir grid oluştur
        grid = [[BLACK for _ in range(10)] for _ in range(20)]
        # Önceden kilitlenmiş pozisyonlardaki blokları grid'e yerleştir
        for r in range(len(grid)):
            for c in range(len(grid[r])):
                if (c, r) in locked_positions:
                    color = locked_positions[(c, r)]
                    grid[r][c] = color
        return grid
    
    # Şeklin formatını (string listesi) oyun tahtasındaki koordinatlara dönüştürür
    def convert_shape_format(piece):
        positions = []
        # Şeklin mevcut dönme formatını al
        shape_format = piece.shape[piece.rotation % len(piece.shape)]
    
        # Şeklin her satırını ve sütununu işle
        for r in range(len(shape_format)):
            row = list(shape_format[r]) # Satırı listeye çevir
            for c in range(len(row)):
                # Eğer şeklin parçasıysa ('0' ile işaretlenmişse)
                if row[c] == '0':
                    # Şeklin pozisyonunu (x, y) grid koordinatlarına ekle
                    # piece.x ve piece.y, şeklin sol üst köşe koordinatlarıdır
                    # c ve r, şeklin kendi içindeki göreceli konumlardır
                    positions.append((piece.x + c, piece.y + r))
    
        # Şeklin başlangıç pozisyonundan 1 birim kaydırma düzeltmesi (bazı şekiller için gerekli)
        # Merkezi (0,0) kabul ettiğimizde, şeklin kendi içindeki formatta
        # genelde ilk birkaç satır boş olabilir. Bu düzeltme,
        # şeklin grid'deki gerçek başlangıç noktasına oturmasını sağlar.
        # Bunu daha temiz yapmak için şekil tanımlarını düzeltebiliriz ama bu da çalışır.
        for i, pos in enumerate(positions):
            positions[i] = (pos[0] - 2, pos[1] - 4) # Örnek bir düzeltme, deneme yanılma ile ayarlanabilir
    
        return positions
    
    # Bir pozisyonun oyun alanı içinde ve boş olup olmadığını kontrol eder
    def valid_space(piece, grid):
        # Kabul edilen pozisyonlar (grid sınırları dışında olmayanlar)
        accepted_positions = [[(c, r) for c in range(10) if grid[r][c] == BLACK] for r in range(20)]
        # Tek bir listede düzleştirilmiş kabul edilen pozisyonlar
        accepted_positions = [pos for sub in accepted_positions for pos in sub]
    
        formatted_shape = convert_shape_format(piece)
    
        for pos in formatted_shape:
            # Blok grid'in dışına mı çıkıyor? (Sol, Sağ, Alt)
            if pos[0] < 0 or pos[0] >= 10 or pos[1] >= 20:
                return False
            # Blok başka bir kilitli bloğun üzerine mi geliyor?
            if pos not in accepted_positions and pos[1] >= 0: # Y>=0 kontrolü, şekil henüz grid'e girmediyse hata vermesin diye
                 return False
    
        return True
    
    # Oyunun kaybedilip kaybedilmediğini kontrol eder (Yeni parça grid'in üstüne mi doğuyor?)
    def check_lost(positions):
        for pos in positions:
            # Eğer kilitlenmiş bir bloğun y pozisyonu 0'dan küçükse (yani en üst satırın üstündeyse)
            if pos[1] < 1:
                return True # Oyun bitti
        return False
    
    # Rastgele bir Tetromino şekli seçer
    def get_shape():
        return Piece(5, 0, random.choice(SHAPES)) # Ortadan başlar (x=5), en üstten (y=0)
    
    # Ekrandaki metni ortalayarak yazdırır
    def draw_text_middle(surface, text, size, color):
        font = pygame.font.SysFont('comicsans', size, bold=True)
        label = font.render(text, 1, color)
    
        surface.blit(label, (TOP_LEFT_X + PLAY_WIDTH / 2 - (label.get_width() / 2),
                             TOP_LEFT_Y + PLAY_HEIGHT / 2 - label.get_height() / 2))
    
    # Oyun alanı (grid) çizgilerini çizer
    def draw_grid_lines(surface, grid):
        # Yatay çizgiler
        for r in range(len(grid)):
            pygame.draw.line(surface, DARK_GRAY, (TOP_LEFT_X, TOP_LEFT_Y + r * BLOCK_SIZE),
                             (TOP_LEFT_X + PLAY_WIDTH, TOP_LEFT_Y + r * BLOCK_SIZE))
        # Dikey çizgiler
        for c in range(len(grid[0])):
             pygame.draw.line(surface, DARK_GRAY, (TOP_LEFT_X + c * BLOCK_SIZE, TOP_LEFT_Y),
                              (TOP_LEFT_X + c * BLOCK_SIZE, TOP_LEFT_Y + PLAY_HEIGHT))
    
    # Tamamlanmış satırları temizler ve yeni satırları ekler
    def clear_rows(grid, locked):
        rows_cleared = 0
        # Alttan başla, yukarı doğru kontrol et
        for r in range(len(grid) - 1, -1, -1):
            row = grid[r]
            # Satırda boş blok (BLACK) yoksa, satır doludur
            if BLACK not in row:
                rows_cleared += 1
                # Dolu satırın indekslerini bul
                indices_to_remove = []
                for c in range(len(row)):
                    try:
                        # Kilitli pozisyonlardaki eşleşen blokları kaldır
                        del locked[(c, r)]
                        indices_to_remove.append((c,r)) # Kaldırılacakları işaretle
                    except:
                        continue # Zaten yoksa hata verme
    
                # Eğer bloklar kaldırıldıysa (yani satır gerçekten doluyduysa)
                if indices_to_remove:
                    # Kilitli pozisyonları güncelle (üstteki blokları aşağı kaydır)
                    # Sıfırdan başla, eski pozisyonları kontrol et
                    new_locked = {}
                    # Kilitli pozisyonları sıralayarak (önce y, sonra x) işlemleri doğru yapmak
                    sorted_keys = sorted(list(locked), key=lambda x: (x[1], x[0]))
    
                    for key in sorted_keys:
                        x, y = key
                        if y < r: # Eğer kaldırılan satırın üstündeyse
                            new_y = y + 1 # Bir aşağı kaydır
                            new_locked[(x, new_y)] = locked[key]
                        elif y > r: # Eğer kaldırılan satırın altındaysa (bu durumu biz eklemedik ama genel olsun)
                             new_locked[(x,y)] = locked[key]
                    locked.clear()
                    locked.update(new_locked)
    
        return rows_cleared
    
    # Bir sonraki şekli ekranda gösterir
    def draw_next_shape(piece, surface):
        font = pygame.font.SysFont('comicsans', 30)
        label = font.render('Sonraki Şekil', 1, WHITE)
    
        # Metnin sol üst koordinatları
        sx = TOP_LEFT_X + PLAY_WIDTH + 50
        sy = TOP_LEFT_Y + PLAY_HEIGHT / 2 - 100
    
        surface.blit(label, (sx + 10, sy - 30)) # Metni biraz yukarı
    
        # Şeklin formatını al (ilk dönme durumu)
        shape_format = piece.shape[piece.rotation % len(piece.shape)]
    
        # Şeklin bloklarını çiz
        for r in range(len(shape_format)):
            row = list(shape_format[r])
            for c in range(len(row)):
                if row[c] == '0':
                    # Blokları çiz (sağ taraftaki boş alana)
                    pygame.draw.rect(surface, piece.color,
                                     (sx + c * BLOCK_SIZE, sy + r * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE), 0)
    
    # Ana pencereyi (ekranı) çizer
    def draw_window(surface, grid, score=0, last_score = 0):
        surface.fill(BLACK) # Arka planı siyaha boya
    
        # Başlık
        pygame.font.init()
        font = pygame.font.SysFont('comicsans', 60)
        label = font.render('TETRIS', 1, WHITE)
        surface.blit(label, (TOP_LEFT_X + PLAY_WIDTH / 2 - (label.get_width() / 2), 30)) # Ortala
    
        # Skor
        font = pygame.font.SysFont('comicsans', 30)
        score_label = font.render(f"Skor: {score}", 1, WHITE)
        sx = TOP_LEFT_X + PLAY_WIDTH + 50
        sy = TOP_LEFT_Y + PLAY_HEIGHT / 2 - 100
        surface.blit(score_label, (sx + 20, sy + 180)) # Biraz aşağı alalım
    
        # Son skor (isteğe bağlı)
        # last_score_label = font.render(f"En Yüksek Skor: {last_score}", 1, WHITE)
        # sx = TOP_LEFT_X - 250
        # sy = TOP_LEFT_Y + 200
        # surface.blit(last_score_label, (sx + 20, sy + 180))
    
        # Oyun alanındaki blokları çiz
        for r in range(len(grid)):
            for c in range(len(grid[r])):
                pygame.draw.rect(surface, grid[r][c],
                                 (TOP_LEFT_X + c * BLOCK_SIZE, TOP_LEFT_Y + r * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE), 0)
    
        # Oyun alanı kenarlığını ve grid çizgilerini çiz
        draw_grid_lines(surface, grid)
        pygame.draw.rect(surface, WHITE, (TOP_LEFT_X, TOP_LEFT_Y, PLAY_WIDTH, PLAY_HEIGHT), 4) # Kenarlık
    
    # Ana oyun döngüsü
    def main(surface):
        locked_positions = {}  # Kilitlenmiş blokların pozisyonlarını (x, y): renk olarak saklar
        grid = create_grid(locked_positions)
    
        change_piece = False # Yeni parça gelmeli mi?
        run = True           # Oyun döngüsü çalışıyor mu?
        current_piece = get_shape() # Başlangıçta rastgele bir parça al
        next_piece = get_shape()    # Bir sonraki parçayı hazırla
        clock = pygame.time.Clock()
        fall_time = 0        # Düşme süresini takip etmek için
        level_time = 0       # Hız artışı için zamanlayıcı
        score = 0
    
        while run:
            grid = create_grid(locked_positions) # Her döngüde grid'i güncelle
    
            # --- Zamanlamalar ve Hız ---
            fall_speed = 0.27 # Saniye cinsinden düşme süresi (daha küçük = daha hızlı)
            # Seviye/Hız artışı (örneğin her 10 saniyede bir hızlansın)
            level_time += clock.get_rawtime()
            if level_time / 1000 > 5: # Her 5 saniyede bir hız artırılabilir
                level_time = 0
                fall_speed -= 0.01 # Hızı biraz artır
                if fall_speed < 0.1: # Minimum hızı ayarla
                    fall_speed = 0.1
    
            fall_time += clock.get_rawtime() # Geçen süreyi ekle
    
            # --- Olay Yönetimi ---
            for event in pygame.event.get():
                if event.type == pygame.QUIT: # Pencere kapatma düğmesine basıldıysa
                    run = False
                    pygame.display.quit() # Pygame'i kapat
                    quit() # Programı sonlandır
    
                if event.type == pygame.KEYDOWN: # Bir tuşa basıldıysa
                    if event.key == pygame.K_LEFT: # Sol ok
                        current_piece.x -= 1
                        if not valid_space(current_piece, grid):
                            current_piece.x += 1 # Geçersizse geri al
                    elif event.key == pygame.K_RIGHT: # Sağ ok
                        current_piece.x += 1
                        if not valid_space(current_piece, grid):
                            current_piece.x -= 1 # Geçersizse geri al
                    elif event.key == pygame.K_DOWN: # Aşağı ok (hızlı düşürme)
                        current_piece.y += 1
                        if not valid_space(current_piece, grid):
                            current_piece.y -= 1 # Geçersizse geri al
                    elif event.key == pygame.K_UP: # Yukarı ok (döndürme)
                        current_piece.rotation += 1
                        if not valid_space(current_piece, grid):
                            current_piece.rotation -= 1 # Geçersizse geri döndür
                    elif event.key == pygame.K_SPACE: # Boşluk (sert düşürme - henüz implemente edilmedi)
                       # İstenirse buraya sert düşürme özelliği eklenebilir
                       # Parçayı en alta kadar indirip kilitlemek gibi
                       pass
    
            # --- Otomatik Düşme ---
            if fall_time / 1000 >= fall_speed: # Ayarlanan düşme süresi dolduysa
                fall_time = 0 # Zamanlayıcıyı sıfırla
                current_piece.y += 1 # Parçayı bir birim aşağı indir
                # Eğer parça yeni pozisyonunda geçersizse (duvara çarptı veya başka bloğa)
                if not valid_space(current_piece, grid) and current_piece.y < 20:
                    current_piece.y -= 1 # Bir önceki geçerli pozisyona geri getir
                    change_piece = True # Parçayı kilitleme zamanı
    
            # --- Çizim ---
            draw_window(surface, grid, score) # Ana pencereyi çiz
            draw_next_shape(next_piece, surface) # Sonraki şekli çiz
    
            # Şeklin parçalarını ve pozisyonlarını hesapla
            shape_pos = convert_shape_format(current_piece)
    
            # Mevcut parçayı ekrana çiz
            for i in range(len(shape_pos)):
                x, y = shape_pos[i]
                # Sadece görünür alandaki blokları çiz
                if y > -1:
                    pygame.draw.rect(surface, current_piece.color,
                                     (TOP_LEFT_X + x * BLOCK_SIZE, TOP_LEFT_Y + y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE), 0)
    
            # --- Parçayı Kilitleme ve Satır Temizleme ---
            if change_piece:
                for pos in shape_pos:
                    # Parçanın grid içindeki koordinatları
                    p = (pos[0], pos[1])
                    # Eğer parça grid'in üstündeyse (y < 0) hata verme
                    if p[1] >= 0:
                       locked_positions[p] = current_piece.color # Kilitle
                # Yeni parçayı ayarla
                current_piece = next_piece
                next_piece = get_shape()
                change_piece = False # Durumu sıfırla
    
                # Satır temizleme işlemini yap
                rows_cleared = clear_rows(grid, locked_positions)
                # Skor hesapla (örneğin 1 satır = 40, 2 = 100, 3 = 300, 4 = 1200)
                if rows_cleared == 1:
                    score += 40
                elif rows_cleared == 2:
                    score += 100
                elif rows_cleared == 3:
                    score += 300
                elif rows_cleared == 4:
                    score += 1200
    
                # Grid'i tekrar oluştur (temizlenen satırlar için)
                grid = create_grid(locked_positions)
    
                # Oyun bitti kontrolü
                if check_lost(locked_positions):
                    run = False
    
            # Ekranı güncelle
            pygame.display.update()
    
        # Oyun Bitti Mesajı
        draw_text_middle(surface, "KAYBETTİN!", 80, WHITE)
        pygame.display.update()
        pygame.time.delay(2000) # 2 saniye bekle
        pygame.quit()
    
    # --- Oyun Başlangıç Ekranı (Menü) ---
    def main_menu(surface):
        run = True
        while run:
            surface.fill(BLACK)
            draw_text_middle(surface, "TETRIS OYNAMAK İÇİN BİR TUŞA BASIN", 40, WHITE)
            pygame.display.update()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    run = False
                if event.type == pygame.KEYDOWN:
                    main(surface) # Oyunu başlat
        pygame.quit()
    
    
    # --- Ana Oyun Başlatma ---
    if __name__ == "__main__":
        win = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        pygame.display.set_caption('Tetris')
        main_menu(win) # Başlangıç menüsünü çalıştır
    

    Kodun Açıklaması:

    1. Ayarlar ve Renkler: Ekran boyutları, oyun alanı boyutları, blok boyutu ve kullanılan renkler tanımlanır.
    2. Tetromino Şekilleri: S_SHAPE, Z_SHAPE vb. listeler, her şeklin 4 farklı dönme durumunu temsil eder. Her durum, '0' karakterleriyle blokların yerini gösteren 5x5'lik bir matristir. SHAPES ve SHAPE_COLORS listeleri bu şekilleri ve renklerini eşleştirir.
    3. Piece Sınıfı: Bir Tetris parçasının (x, y koordinatları, hangi şekil olduğu, rengi ve mevcut dönme durumu) bilgilerini tutar.
    4. create_grid(): Oyun tahtasını temsil eden 2D bir liste oluşturur. locked_positions sözlüğü, daha önce yere oturmuş blokların koordinatlarını ve renklerini içerir. Bu sözlük kullanılarak grid doldurulur.
    5. convert_shape_format(): Bir Piece nesnesinin mevcut dönme durumundaki bloklarının oyun tahtasındaki gerçek (x, y) koordinatlarını hesaplar.
    6. valid_space(): Bir parçanın belirli bir pozisyonda geçerli olup olmadığını kontrol eder (oyun alanı sınırları içinde mi, başka bir bloğa çarpıyor mu?).
    7. check_lost(): Eğer herhangi bir kilitlenmiş blok en üst satırın (y < 1) üzerine çıkmışsa oyunun bittiğini kontrol eder.
    8. get_shape(): Rastgele bir Piece nesnesi oluşturur ve döndürür.
    9. draw_text_middle(), draw_grid_lines(), draw_next_shape(): Ekran çizimi için yardımcı fonksiyonlardır. Metinleri ortalamak, grid çizgilerini çizmek ve bir sonraki şekli göstermek için kullanılırlar.
    10. clear_rows(): Tamamlanmış satırları bulur, grid'den ve locked_positions'dan kaldırır, üzerindeki blokları aşağı kaydırır ve temizlenen satır sayısını döndürür.
    11. draw_window(): Oyunun ana ekranını (skor, grid, kenarlıklar vb.) çizer.
    12. main(): Oyunun ana döngüsünü içerir.
      • Bir parça oluşturulur.
      • Kullanıcı girdileri (ok tuşları, döndürme) işlenir.
      • Parçanın otomatik olarak aşağı düşmesi sağlanır (fall_speed ve fall_time ile).
      • valid_space kontrolü ile hareketler ve dönüşler doğrulanır.
      • Bir parça yere oturduğunda (change_piece = True), locked_positions'a eklenir, satır temizleme kontrolü yapılır, skor güncellenir ve yeni bir parça oluşturulur.
      • check_lost ile oyunun bitip bitmediği kontrol edilir.
      • pygame.display.update() ile ekran sürekli güncellenir.
    13. main_menu(): Oyundan önce basit bir başlangıç ekranı gösterir. Oyuna başlamak için herhangi bir tuşa basılmasını bekler.
    14. Ana Başlatma (if __name__ == "__main__":): Pygame penceresini oluşturur ve main_menu fonksiyonunu çağırarak oyunu başlatır.

    Nasıl Oynanır:

    • Sol Ok: Parçayı sola hareket ettir.
    • Sağ Ok: Parçayı sağa hareket ettir.
    • Aşağı Ok: Parçayı daha hızlı aşağı düşür.
    • Yukarı Ok: Parçayı döndür.
    • Boşluk: (Henüz eklenmedi) Sert düşürme (parçayı anında en alta indirme).
    • Amaç: Yatay sıraları tamamen bloklarla doldurarak satırları temizlemek ve mümkün olduğunca yüksek skor elde etmek.

    Bu kod, Tetris'in temel işlevlerini içeren bir başlangıç noktasıdır. Daha fazla özellik (sesler, zorluk seviyeleri, sert düşürme, yüksek skor tablosu vb.) ekleyerek oyunu geliştirebilirsiniz. İyi eğlenceler!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.