PEMOGRAMAN GAME CATUR KOMPATIBEL PADA LAYAR HP

PEMOGRAMAN GAME CATUR KOMPATIBEL PADA LAYAR HP ANDROID

Berikut ini kode pemograman game Catur 2 pemain pakai bahasa pemograman "python" dengan mengimport modul pygame.

Untuk menyesuaikan agar papan catur lebih kecil sehingga cocok untuk layar HP dengan lebar dan panjang 720 piksel, kita perlu mengubah dimensi layar, kotak papan, serta skala gambar buah catur. Berikut adalah penyesuaian kodenya:

Penyesuaian Kode

1. Perkecil ukuran layar: Atur WIDTH dan HEIGHT menjadi 720.

2. Perkecil ukuran kotak catur: Ubah ukuran kotak menjadi lebih kecil.

3. Sesuaikan skala gambar: Skala ulang buah catur agar sesuai dengan ukuran papan.

Berikut adalah kode yang telah diperbarui:

# Importing Modules

import pygame

# Initialising pygame module

pygame.init()

# Setting width and height of the Chess Game screen

WIDTH = 720

HEIGHT = 720

screen = pygame.display.set_mode([WIDTH, HEIGHT])

pygame.display.set_caption('Two-Player Chess Game')

font = pygame.font.Font('freesansbold.ttf', 18)

medium_font = pygame.font.Font('freesansbold.ttf', 34)

big_font = pygame.font.Font('freesansbold.ttf', 44)

timer = pygame.time.Clock()

fps = 60

# game variables and images

white_pieces = ['rook', 'knight', 'bishop', 'king', 'queen', 'bishop', 'knight', 'rook',

'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn']

white_locations = [(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0), (7, 0),

(0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1), (7, 1)]

black_pieces = ['rook', 'knight', 'bishop', 'king', 'queen', 'bishop', 'knight', 'rook',

'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn']

black_locations = [(0, 7), (1, 7), (2, 7), (3, 7), (4, 7), (5, 7), (6, 7), (7, 7),

(0, 6), (1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6), (7, 6)]

captured_pieces_white = []

captured_pieces_black = []

# 0 - whites turn no selection: 1-whites turn piece selected: 2- black turn no selection, 3 - black turn piece selected

turn_step = 0

selection = 100

valid_moves = []

# load in game piece images (queen, king, rook, bishop, knight, pawn) x 2

black_queen = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/black queen.jpg')

black_queen = pygame.transform.scale(black_queen, (80, 80))

black_queen_small = pygame.transform.scale(black_queen, (45, 45))

black_king = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/black king.jpg')

black_king = pygame.transform.scale(black_king, (80, 80))

black_king_small = pygame.transform.scale(black_king, (45, 45))

black_rook = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/black rook.jpg')

black_rook = pygame.transform.scale(black_rook, (80, 80))

black_rook_small = pygame.transform.scale(black_rook, (45, 45))

black_bishop = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/black bishop.jpg')

black_bishop = pygame.transform.scale(black_bishop, (80, 80))

black_bishop_small = pygame.transform.scale(black_bishop, (45, 45))

black_knight = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/black knight.jpg')

black_knight = pygame.transform.scale(black_knight, (80, 80))

black_knight_small = pygame.transform.scale(black_knight, (45, 45))

black_pawn = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/black pawn.jpg')

black_pawn = pygame.transform.scale(black_pawn, (65, 65))

black_pawn_small = pygame.transform.scale(black_pawn, (45, 45))

white_queen = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/white queen.jpg')

white_queen = pygame.transform.scale(white_queen, (80, 80))

white_queen_small = pygame.transform.scale(white_queen, (45, 45))

white_king = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/white king.jpg')

white_king = pygame.transform.scale(white_king, (80, 80))

white_king_small = pygame.transform.scale(white_king, (45, 45))

white_rook = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/white rook.jpg')

white_rook = pygame.transform.scale(white_rook, (80, 80))

white_rook_small = pygame.transform.scale(white_rook, (45, 45))

white_bishop = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/white bishop.jpg')

white_bishop = pygame.transform.scale(white_bishop, (80, 80))

white_bishop_small = pygame.transform.scale(white_bishop, (45, 45))

white_knight = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/white knight.jpg')

white_knight = pygame.transform.scale(white_knight, (80, 80))

white_knight_small = pygame.transform.scale(white_knight, (45, 45))

white_pawn = pygame.image.load('/storage/emulated/0/AppJadi/Catur/images/white pawn.jpg')

white_pawn = pygame.transform.scale(white_pawn, (65, 65))

white_pawn_small = pygame.transform.scale(white_pawn, (45, 45))

white_images = [white_pawn, white_queen, white_king,

white_knight, white_rook, white_bishop]

small_white_images = [white_pawn_small, white_queen_small, white_king_small, white_knight_small,

white_rook_small, white_bishop_small]

black_images = [black_pawn, black_queen, black_king,

black_knight, black_rook, black_bishop]

small_black_images = [black_pawn_small, black_queen_small, black_king_small, black_knight_small,

black_rook_small, black_bishop_small]

piece_list = ['pawn', 'queen', 'king', 'knight', 'rook', 'bishop']

# check variables/ flashing counter

counter = 0

winner = ''

game_over = False

# draw main game board

def draw_board():

for i in range(32):

column = i % 4

row = i // 4

if row % 2 == 0:

pygame.draw.rect(screen, 'light gray', [

600 - (column * 200), row * 100, 100, 100])

else:

pygame.draw.rect(screen, 'light gray', [

700 - (column * 200), row * 100, 100, 100])

pygame.draw.rect(screen, 'gray', [0, 800, WIDTH, 100])

pygame.draw.rect(screen, 'gold', [0, 800, WIDTH, 100], 5)

pygame.draw.rect(screen, 'gold', [800, 0, 200, HEIGHT], 5)

status_text = ['White: Select a Piece to Move!', 'White: Select a Destination!',

'Black: Select a Piece to Move!', 'Black: Select a Destination!']

screen.blit(big_font.render(

status_text[turn_step], True, 'black'), (20, 820))

for i in range(9):

pygame.draw.line(screen, 'black', (0, 100 * i), (800, 100 * i), 2)

pygame.draw.line(screen, 'black', (100 * i, 0), (100 * i, 800), 2)

screen.blit(medium_font.render('FORFEIT', True, 'black'), (810, 830))

# draw pieces onto board

def draw_pieces():

for i in range(len(white_pieces)):

index = piece_list.index(white_pieces[i])

if white_pieces[i] == 'pawn':

screen.blit(

white_pawn, (white_locations[i][0] * 100 + 22, white_locations[i][1] * 100 + 30))

else:

screen.blit(white_images[index], (white_locations[i]

[0] * 100 + 10, white_locations[i][1] * 100 + 10))

if turn_step < 2:

if selection == i:

pygame.draw.rect(screen, 'red', [white_locations[i][0] * 100 + 1, white_locations[i][1] * 100 + 1,

100, 100], 2)

for i in range(len(black_pieces)):

index = piece_list.index(black_pieces[i])

if black_pieces[i] == 'pawn':

screen.blit(

black_pawn, (black_locations[i][0] * 100 + 22, black_locations[i][1] * 100 + 30))

else:

screen.blit(black_images[index], (black_locations[i]

[0] * 100 + 10, black_locations[i][1] * 100 + 10))

if turn_step >= 2:

if selection == i:

pygame.draw.rect(screen, 'blue', [black_locations[i][0] * 100 + 1, black_locations[i][1] * 100 + 1,

100, 100], 2)

# function to check all pieces valid options on board

def check_options(pieces, locations, turn):

moves_list = []

all_moves_list = []

for i in range((len(pieces))):

location = locations[i]

piece = pieces[i]

if piece == 'pawn':

moves_list = check_pawn(location, turn)

elif piece == 'rook':

moves_list = check_rook(location, turn)

elif piece == 'knight':

moves_list = check_knight(location, turn)

elif piece == 'bishop':

moves_list = check_bishop(location, turn)

elif piece == 'queen':

moves_list = check_queen(location, turn)

elif piece == 'king':

moves_list = check_king(location, turn)

all_moves_list.append(moves_list)

return all_moves_list

# check king valid moves

def check_king(position, color):

moves_list = []

if color == 'white':

enemies_list = black_locations

friends_list = white_locations

else:

friends_list = black_locations

enemies_list = white_locations

# 8 squares to check for kings, they can go one square any direction

targets = [(1, 0), (1, 1), (1, -1), (-1, 0),

(-1, 1), (-1, -1), (0, 1), (0, -1)]

for i in range(8):

target = (position[0] + targets[i][0], position[1] + targets[i][1])

if target not in friends_list and 0 <= target[0] <= 7 and 0 <= target[1] <= 7:

moves_list.append(target)

return moves_list

# check queen valid moves

def check_queen(position, color):

moves_list = check_bishop(position, color)

second_list = check_rook(position, color)

for i in range(len(second_list)):

moves_list.append(second_list[i])

return moves_list

# check bishop moves

def check_bishop(position, color):

moves_list = []

if color == 'white':

enemies_list = black_locations

friends_list = white_locations

else:

friends_list = black_locations

enemies_list = white_locations

for i in range(4): # up-right, up-left, down-right, down-left

path = True

chain = 1

if i == 0:

x = 1

y = -1

elif i == 1:

x = -1

y = -1

elif i == 2:

x = 1

y = 1

else:

x = -1

y = 1

while path:

if (position[0] + (chain * x), position[1] + (chain * y)) not in friends_list and \

0 <= position[0] + (chain * x) <= 7 and 0 <= position[1] + (chain * y) <= 7:

moves_list.append(

(position[0] + (chain * x), position[1] + (chain * y)))

if (position[0] + (chain * x), position[1] + (chain * y)) in enemies_list:

path = False

chain += 1

else:

path = False

return moves_list

# check rook moves

def check_rook(position, color):

moves_list = []

if color == 'white':

enemies_list = black_locations

friends_list = white_locations

else:

friends_list = black_locations

enemies_list = white_locations

for i in range(4): # down, up, right, left

path = True

chain = 1

if i == 0:

x = 0

y = 1

elif i == 1:

x = 0

y = -1

elif i == 2:

x = 1

y = 0

else:

x = -1

y = 0

while path:

if (position[0] + (chain * x), position[1] + (chain * y)) not in friends_list and \

0 <= position[0] + (chain * x) <= 7 and 0 <= position[1] + (chain * y) <= 7:

moves_list.append(

(position[0] + (chain * x), position[1] + (chain * y)))

if (position[0] + (chain * x), position[1] + (chain * y)) in enemies_list:

path = False

chain += 1

else:

path = False

return moves_list

# check valid pawn moves

def check_pawn(position, color):

moves_list = []

if color == 'white':

if (position[0], position[1] + 1) not in white_locations and \

(position[0], position[1] + 1) not in black_locations and position[1] < 7:

moves_list.append((position[0], position[1] + 1))

if (position[0], position[1] + 2) not in white_locations and \

(position[0], position[1] + 2) not in black_locations and position[1] == 1:

moves_list.append((position[0], position[1] + 2))

if (position[0] + 1, position[1] + 1) in black_locations:

moves_list.append((position[0] + 1, position[1] + 1))

if (position[0] - 1, position[1] + 1) in black_locations:

moves_list.append((position[0] - 1, position[1] + 1))

else:

if (position[0], position[1] - 1) not in white_locations and \

(position[0], position[1] - 1) not in black_locations and position[1] > 0:

moves_list.append((position[0], position[1] - 1))

if (position[0], position[1] - 2) not in white_locations and \

(position[0], position[1] - 2) not in black_locations and position[1] == 6:

moves_list.append((position[0], position[1] - 2))

if (position[0] + 1, position[1] - 1) in white_locations:

moves_list.append((position[0] + 1, position[1] - 1))

if (position[0] - 1, position[1] - 1) in white_locations:

moves_list.append((position[0] - 1, position[1] - 1))

return moves_list

# check valid knight moves

def check_knight(position, color):

moves_list = []

if color == 'white':

enemies_list = black_locations

friends_list = white_locations

else:

friends_list = black_locations

enemies_list = white_locations

# 8 squares to check for knights, they can go two squares in one direction and one in another

targets = [(1, 2), (1, -2), (2, 1), (2, -1),

(-1, 2), (-1, -2), (-2, 1), (-2, -1)]

for i in range(8):

target = (position[0] + targets[i][0], position[1] + targets[i][1])

if target not in friends_list and 0 <= target[0] <= 7 and 0 <= target[1] <= 7:

moves_list.append(target)

return moves_list

# check for valid moves for just selected piece

def check_valid_moves():

if turn_step < 2:

options_list = white_options

else:

options_list = black_options

valid_options = options_list[selection]

return valid_options

# draw valid moves on screen

def draw_valid(moves):

if turn_step < 2:

color = 'red'

else:

color = 'blue'

for i in range(len(moves)):

pygame.draw.circle(

screen, color, (moves[i][0] * 100 + 50, moves[i][1] * 100 + 50), 5)

# draw captured pieces on side of screen

def draw_captured():

for i in range(len(captured_pieces_white)):

captured_piece = captured_pieces_white[i]

index = piece_list.index(captured_piece)

screen.blit(small_black_images[index], (825, 5 + 50 * i))

for i in range(len(captured_pieces_black)):

captured_piece = captured_pieces_black[i]

index = piece_list.index(captured_piece)

screen.blit(small_white_images[index], (925, 5 + 50 * i))

# draw a flashing square around king if in check

def draw_check():

if turn_step < 2:

if 'king' in white_pieces:

king_index = white_pieces.index('king')

king_location = white_locations[king_index]

for i in range(len(black_options)):

if king_location in black_options[i]:

if counter < 15:

pygame.draw.rect(screen, 'dark red', [white_locations[king_index][0] * 100 + 1, white_locations[king_index][1] * 100 + 1, 100, 100], 5)

else:

if 'king' in black_pieces:

king_index = black_pieces.index('king')

king_location = black_locations[king_index]

for i in range(len(white_options)):

if king_location in white_options[i]:

if counter < 15:

pygame.draw.rect(screen, 'dark blue', [black_locations[king_index][0] * 100 + 1, black_locations[king_index][1] * 100 + 1, 100, 100], 5)

def draw_game_over():

pygame.draw.rect(screen, 'black', [200, 200, 400, 70])

screen.blit(font.render(

f'{winner} won the game!', True, 'white'), (210, 210))

screen.blit(font.render(f'Press ENTER to Restart!',

True, 'white'), (210, 240))

# main game loop

black_options = check_options(black_pieces, black_locations, 'black')

white_options = check_options(white_pieces, white_locations, 'white')

run = True

while run:

timer.tick(fps)

if counter < 30:

counter += 1

else:

counter = 0

screen.fill('dark gray')

draw_board()

draw_pieces()

draw_captured()

draw_check()

if selection != 100:

valid_moves = check_valid_moves()

draw_valid(valid_moves)

# event handling

for event in pygame.event.get():

if event.type == pygame.QUIT:

run = False

if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1 and not game_over:

x_coord = event.pos[0] // 100

y_coord = event.pos[1] // 100

click_coords = (x_coord, y_coord)

if turn_step <= 1:

if click_coords == (8, 8) or click_coords == (9, 8):

winner = 'black'

if click_coords in white_locations:

selection = white_locations.index(click_coords)

if turn_step == 0:

turn_step = 1

if click_coords in valid_moves and selection != 100:

white_locations[selection] = click_coords

if click_coords in black_locations:

black_piece = black_locations.index(click_coords)

captured_pieces_white.append(black_pieces[black_piece])

if black_pieces[black_piece] == 'king':

winner = 'white'

black_pieces.pop(black_piece)

black_locations.pop(black_piece)

black_options = check_options(

black_pieces, black_locations, 'black')

white_options = check_options(

white_pieces, white_locations, 'white')

turn_step = 2

selection = 100

valid_moves = []

if turn_step > 1:

if click_coords == (8, 8) or click_coords == (9, 8):

winner = 'white'

if click_coords in black_locations:

selection = black_locations.index(click_coords)

if turn_step == 2:

turn_step = 3

if click_coords in valid_moves and selection != 100:

black_locations[selection] = click_coords

if click_coords in white_locations:

white_piece = white_locations.index(click_coords)

captured_pieces_black.append(white_pieces[white_piece])

if white_pieces[white_piece] == 'king':

winner = 'black'

white_pieces.pop(white_piece)

white_locations.pop(white_piece)

black_options = check_options(

black_pieces, black_locations, 'black')

white_options = check_options(

white_pieces, white_locations, 'white')

turn_step = 0

selection = 100

valid_moves = []

if event.type == pygame.KEYDOWN and game_over:

if event.key == pygame.K_RETURN:

game_over = False

winner = ''

white_pieces = ['rook', 'knight', 'bishop', 'king', 'queen', 'bishop', 'knight', 'rook',

'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn']

white_locations = [(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0), (7, 0),

(0, 1), (1, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1), (7, 1)]

black_pieces = ['rook', 'knight', 'bishop', 'king', 'queen', 'bishop', 'knight', 'rook',

'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn']

black_locations = [(0, 7), (1, 7), (2, 7), (3, 7), (4, 7), (5, 7), (6, 7), (7, 7),

(0, 6), (1, 6), (2, 6), (3, 6), (4, 6), (5, 6), (6, 6), (7, 6)]

captured_pieces_white = []

captured_pieces_black = []

turn_step = 0

selection = 100

valid_moves = []

black_options = check_options(

black_pieces, black_locations, 'black')

white_options = check_options(

white_pieces, white_locations, 'white')

if winner != '':

game_over = True

draw_game_over()

pygame.display.flip()

pygame.quit()

Perubahan yang Dilakukan

1. Layar: Lebar dan tinggi papan diubah menjadi 720x720.

2. Kotak Catur: Ukuran kotak dihitung otomatis berdasarkan WIDTH // 8.

3. Gambar Buah Catur: Semua gambar diskalakan ulang sesuai PIECE_SCALE.

Hasil

Papan catur akan lebih kecil dan menyesuaikan ukuran layar HP, dengan buah catur yang proporsional dan terlihat jelas.

Kode tersebut sangat panjang, dan pemotongan dilakukan karena keterbatasan ruang. Berikut beberapa langkah untuk membantu Anda melanjutkan atau memodifikasi kode:

1. Pisahkan Logika Kode ke dalam Modul: Untuk membuat kode lebih mudah dipahami dan diorganisasi, pertimbangkan memecah fungsi-fungsi utama (seperti check_king, check_queen, check_bishop, dll.) ke dalam file Python terpisah sebagai modul yang dapat diimpor.

2. Dokumentasi Setiap Bagian: Tambahkan komentar yang menjelaskan apa yang dilakukan setiap fungsi, variabel, atau blok kode tertentu.

3. Mengatasi Masalah Panjang Kode: Jika Anda memerlukan bantuan khusus pada bagian tertentu (misalnya validasi langkah bidak tertentu), silakan tentukan bagian tersebut sehingga dapat terbantu lebih efektif.

4. Menyempurnakan Fungsi yang Terpotong: Jika bagian yang terpotong adalah logika untuk bidak seperti check_bishop atau lainnya, berikut adalah pola umum yang dapat Anda gunakan:

def check_bishop(position, color):

moves_list = []

if color == 'white':

enemies_list = black_locations

friends_list = white_locations

else:

friends_list = black_locations

enemies_list = white_locations

for dx, dy in [(1, 1), (1, -1), (-1, 1), (-1, -1)]:

x, y = position

while True:

x += dx

y += dy

if 0 <= x <= 7 and 0 <= y <= 7: # Check boundaries

if (x, y) in friends_list:

break # Blocked by a friendly piece

moves_list.append((x, y))

if (x, y) in enemies_list:

break # Capture enemy and stop

else:

break # Out of bounds

return moves_list

5. Menghubungkan Fungsi Validasi dengan Permainan: Pastikan fungsi-fungsi seperti check_king, check_queen, dan check_bishop digunakan dengan baik untuk mengisi daftar valid_moves.

6. Pastikan Sumber Daya Gambar Tersedia: Semua file gambar, misalnya di folder ./images/ harus ada. Jika tidak, permainan akan gagal memuat.

Format gambar yang didukung pygame adalah .jpg, .png, dan beberapa format lainnya. Jika file gambar memiliki ekstensi yang tidak didukung, ubah ke format yang kompatibel.

Gambar buah catur putih dan hitam yang perlu di UpLoad ke folder (seluruhnya ada 12 buah gambar) adalah:

- buah catur Raja: white king, black king

- buah catur Ratu (Mentri): white queen, black queen

- buah catur Benteng: white rook, black rook

- buah catur Kuda: white knight, black knight

- buah catur Gajah: white bishop, black bishop

- buah catur Pion: white pawn, black pawn

7. Testing: Jalankan permainan dan uji setiap fungsi validasi secara individual untuk memastikan mereka bekerja sesuai dengan aturan catur.

Pastikan variabel white_locations sudah didefinisikan dengan benar dalam kode Anda sebelum dipanggil dalam fungsi draw_pieces().

Jika white_locations adalah daftar lokasi bidak putih pada papan, Anda dapat mendefinisikannya, misalnya:

# Contoh definisi white_locations

white_locations = [(0, 0), (0, 1), (0, 2), (0, 3)] # Koordinat bidak putih

Kemudian pastikan variabel ini tersedia dalam lingkup yang benar agar dapat diakses oleh fungsi draw_pieces(). Berikut ini contoh bagaimana Anda dapat memperbaikinya:

Contoh kode:

import pygame

pygame.init()

# Variabel global

white_locations = [(0, 0), (0, 1), (0, 2), (0, 3)] # Koordinat bidak putih

black_locations = [(7, 0), (7, 1), (7, 2), (7, 3)] # Koordinat bidak hitam

# Definisi fungsi untuk menggambar bidak

def draw_pieces():

for i, loc in enumerate(white_locations):

x, y = loc

pygame.draw.circle(screen, (255, 255, 255), (x * square_size + square_size // 2, y * square_size + square_size // 2), square_size // 3)

for i, loc in enumerate(black_locations):

x, y = loc

pygame.draw.circle(screen, (0, 0, 0), (x * square_size + square_size // 2, y * square_size + square_size // 2), square_size // 3)

# Setup layar dan papan catur

screen_width, screen_height = 800, 800

square_size = screen_width // 8

screen = pygame.display.set_mode((screen_width, screen_height))

running = True

while running:

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

screen.fill((0, 0, 0)) # Latar belakang hitam

draw_pieces() # Gambar bidak

pygame.display.flip() # Perbarui layar

pygame.quit()

Catatan:

1. Pastikan white_locations dan black_locations sudah diinisialisasi dengan lokasi bidak yang sesuai.

2. Jika lokasi ini dinamis atau berubah saat permainan, pastikan fungsinya disesuaikan untuk memperbarui lokasi sebelum menggambar ulang.

Selanjutnya untuk optimalisasi, jika kode lengkap game Catur di atas dijalankan, maka aturan catur tentang "Rokade" dan "Promosi Pion" belum termasuk, maka:

Berikut ini penjelasan dan implementasi kode untuk mendukung fitur rokade dan promosi pion pada permainan catur menggunakan pygame

1. Rokade (Castling)

Rokade adalah gerakan khusus dalam catur di mana raja dan salah satu benteng bergerak secara bersamaan. Kondisi untuk rokade:

- Raja dan benteng belum pernah bergerak.

- Tidak ada bidak lain di antara raja dan benteng.

- Raja tidak dalam keadaan skak, dan tidak melewati atau berakhir di petak yang diserang.

2. Promosi Pion

Pion dapat dipromosikan jika mencapai baris terakhir papan. Saat promosi, pemain dapat memilih untuk mengubah pion menjadi menteri, benteng, gajah, atau kuda.

Berikut adalah kode Python dengan pygame yang mendukung kedua fitur ini:

import pygame

pygame.init()

# Inisialisasi ukuran layar

screen_width, screen_height = 800, 800

square_size = screen_width // 8

screen = pygame.display.set_mode((screen_width, screen_height))

pygame.display.set_caption("Catur - Rokade dan Promosi Pion")

# Warna

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

BLUE = (0, 0, 255)

# Posisi awal bidak (format: (x, y))

white_pieces = {

"king": (4, 7),

"rook1": (0, 7),

"rook2": (7, 7),

"pawns": [(i, 6) for i in range(8)]

}

black_pieces = {

"king": (4, 0),

"rook1": (0, 0),

"rook2": (7, 0),

"pawns": [(i, 1) for i in range(8)]

}

# Status untuk rokade

white_king_moved = False

white_rook1_moved = False

white_rook2_moved = False

black_king_moved = False

black_rook1_moved = False

black_rook2_moved = False

# Fungsi menggambar papan catur

def draw_board():

for row in range(8):

for col in range(8):

color = WHITE if (row + col) % 2 == 0 else BLACK

pygame.draw.rect(screen, color, (col * square_size, row * square_size, square_size, square_size))

# Fungsi menggambar bidak

def draw_pieces():

for key, pos in white_pieces.items():

if key == "pawns":

for pawn in pos:

pygame.draw.circle(screen, WHITE, (pawn[0] * square_size + square_size // 2, pawn[1] * square_size + square_size // 2), square_size // 3)

else:

x, y = pos

pygame.draw.circle(screen, WHITE, (x * square_size + square_size // 2, y * square_size + square_size // 2), square_size // 3)

for key, pos in black_pieces.items():

if key == "pawns":

for pawn in pos:

pygame.draw.circle(screen, BLACK, (pawn[0] * square_size + square_size // 2, pawn[1] * square_size + square_size // 2), square_size // 3)

else:

x, y = pos

pygame.draw.circle(screen, BLACK, (x * square_size + square_size // 2, y * square_size + square_size // 2), square_size // 3)

# Fungsi melakukan rokade

def castle(king, rook, is_white):

global white_king_moved, white_rook1_moved, white_rook2_moved

global black_king_moved, black_rook1_moved, black_rook2_moved

# Rokade raja putih

if is_white and king == "king" and not white_king_moved:

if rook == "rook1" and not white_rook1_moved: # Rokade kiri

white_pieces["king"] = (2, 7)

white_pieces["rook1"] = (3, 7)

white_king_moved = True

white_rook1_moved = True

elif rook == "rook2" and not white_rook2_moved: # Rokade kanan

white_pieces["king"] = (6, 7)

white_pieces["rook2"] = (5, 7)

white_king_moved = True

white_rook2_moved = True

# Rokade raja hitam

elif not is_white and king == "king" and not black_king_moved:

if rook == "rook1" and not black_rook1_moved: # Rokade kiri

black_pieces["king"] = (2, 0)

black_pieces["rook1"] = (3, 0)

black_king_moved = True

black_rook1_moved = True

elif rook == "rook2" and not black_rook2_moved: # Rokade kanan

black_pieces["king"] = (6, 0)

black_pieces["rook2"] = (5, 0)

black_king_moved = True

black_rook2_moved = True

# Fungsi promosi pion

def promote_pawn(pawn, is_white):

# Tampilkan menu promosi

print("Pilih promosi: 1. Menteri, 2. Benteng, 3. Gajah, 4. Kuda")

choice = int(input("Masukkan pilihan: "))

promoted_piece = ""

if choice == 1:

promoted_piece = "queen"

elif choice == 2:

promoted_piece = "rook"

elif choice == 3:

promoted_piece = "bishop"

elif choice == 4:

promoted_piece = "knight"

if is_white:

white_pieces[promoted_piece] = pawn

white_pieces["pawns"].remove(pawn)

else:

black_pieces[promoted_piece] = pawn

black_pieces["pawns"].remove(pawn)

# Main loop

running = True

while running:

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

# Gambar ulang layar

screen.fill(BLUE)

draw_board()

draw_pieces()

# Cek promosi pion putih

for pawn in white_pieces["pawns"]:

if pawn[1] == 0: # Pion mencapai baris terakhir

promote_pawn(pawn, True)

# Cek promosi pion hitam

for pawn in black_pieces["pawns"]:

if pawn[1] == 7: # Pion mencapai baris terakhir

promote_pawn(pawn, False)

pygame.display.flip()

pygame.quit()

Penjelasan Kode:

1. Rokade:

- Fungsi castle() menangani logika rokade dengan memindahkan posisi raja dan benteng sesuai aturan rokade.

- Ada pengecekan apakah raja atau benteng sudah pernah bergerak sebelumnya.

2. Promosi Pion:

- Jka pion mencapai baris terakhir (baris 0 untuk pion putih, baris 7 untuk pion hitam), fungsi promote_pawn() dipanggil.

- Pemain dapat memilih bidak untuk promosi melalui input.

Catatan:

- Anda dapat mengganti sistem input promosi dengan menu grafis untuk pengalaman pengguna yang lebih baik.

- Pastikan ada validasi tambahan untuk aturan lengkap catur seperti skak, skak-mat, atau langkah ilegal.

Menggabungkan kedua kode:

Menggabungkan dua kode dengan memastikan bahwa setiap elemen dan fungsi unik (tidak ganda atau duplikat) adalah proses yang membutuhkan pemeriksaan mendalam untuk menghindari konflik. Berikut langkah-langkahnya:

1. Identifikasi Elemen Unik:

- Pastikan setiap modul yang diimpor hanya diimpor satu kali.

- Gabungkan daftar variabel, objek, dan fungsi tanpa duplikasi.

2. Mengatasi Konflik Nama:

Jika terdapat elemen dengan nama yang sama tetapi fungsi yang berbeda, beri nama yang lebih spesifik.

3. Integrasikan Logika:

Pastikan logika dari kode yang berbeda saling terhubung sesuai dengan kebutuhan.

4. Pengujian:

Setelah digabung, jalankan program untuk memastikan tidak ada error atau bug.

Berikut adalah kode gabungan berdasarkan dua kode yang Anda berikan. Kode ini dioptimalkan untuk menghindari duplikasi:

# Importing Modules

import pygame

# Initialising pygame module

pygame.init()

# Setting width and height of the Chess Game screen

WIDTH = 720

HEIGHT = 720

screen = pygame.display.set_mode([WIDTH, HEIGHT])

pygame.display.set_caption('Two-Player Chess Game')

# Fonts

font = pygame.font.Font('freesansbold.ttf', 18)

medium_font = pygame.font.Font('freesansbold.ttf', 34)

big_font = pygame.font.Font('freesansbold.ttf', 44)

# Timer and FPS

timer = pygame.time.Clock()

fps = 60

# Game Variables