Skapa ett enkelt Luffarschack-spel med Python
Låt oss utforska hur man skapar ett grundläggande Luffarschack-spel med hjälp av Python. Denna övning är ett utmärkt sätt att fördjupa sig i spelutvecklingens logik och att förstå kodens struktur.
Spel är en integrerad del av underhållning för många, tillgängliga på en mängd olika plattformar som webb, mobil och datorer. I det här fallet ska vi dock inte skapa ett avancerat spel. Vårt fokus ligger på att utveckla ett Luffarschack-spel som körs i kommandoraden (CLI) med Python.
Om du inte är bekant med Luffarschack, kan du visualisera det genom att söka på det här. Men det är inget problem om du inte känner till reglerna; vi kommer att gå igenom allt.
Luffarschack – en genomgång
Den här handledningen är uppdelad i tre avsnitt. Först kommer vi att bekanta oss med spelets mekanik. Därefter granskar vi en algoritm som hjälper oss att utforma spellogiken. Slutligen, tittar vi på den faktiska koden och dess detaljerade förklaring.
Om du redan är bekant med hur Luffarschack spelas, kan du hoppa över det första avsnittet.
Låt oss börja med att dyka in i det första avsnittet.
Hur man spelar Luffarschack
I spelet deltar två spelare, där varje spelare representeras av ett specifikt tecken. De vanligaste tecknen som används är X och O. Spelet utspelar sig på en spelplan som består av 9 rutor.
Tänk dig hur spelplanen ser ut.
Spelet spelas på följande sätt:
- En spelare placerar sitt tecken i en valfri ledig ruta.
- Därefter turas den andra spelaren om att göra detsamma.
- Målet är att placera sina tecken på en obruten rad, kolumn eller diagonal.
- Spelet fortsätter tills en spelare vinner, eller tills brädet är fullt utan någon vinnare, vilket resulterar i oavgjort.
Låt oss illustrera några spelscenarier.
I det här exemplet vinner spelaren X, eftersom alla rutor i diagonalen är fyllda med X. Därmed är vinsten ett faktum.
Totalt finns det 8 möjliga kombinationer som leder till seger. Vi ska nu visualisera dessa åtta kombinationer.
Om ingen vinnande kombination uppnås, utan hela brädet fylls, slutar spelet oavgjort. Jag hoppas att du nu har en klar bild av hur Luffarschack fungerar.
Om du vill öva, kan du klicka här för att spela. Du kan hoppa över detta om du redan är bekant med spelet.
Nu är det dags att gå vidare till algoritmdelen.
Algoritmens logik
Vi ska nu utforska den algoritm som styr koden. Denna algoritm kan anpassas till olika programmeringsspråk. Låt oss se hur den fungerar:
- Skapa en spelplan med en tvådimensionell array, och initiera varje position som tom.
- Använd en symbol för att representera en tom ruta, vi använder bindestreck (’-’).
- Skapa en funktion för att avgöra om spelplanen är full.
- Iterera igenom spelplanen och returnera falskt om det finns en tom ruta, annars returnera sant.
- Skapa en funktion för att kontrollera om en spelare har vunnit.
- Kontrollera alla möjliga vinnande kombinationer (rader, kolumner och diagonaler).
- Skapa en funktion för att visa spelplanen vid behov.
- Skapa en funktion för att starta spelet.
- Välj en slumpmässig spelare att börja.
- Skapa en oändlig loop som avslutas när en spelare vinner eller brädet blir fullt.
- Visa spelplanen.
- Låt användaren ange rad och kolumn.
- Uppdatera brädet med spelarens valda tecken.
- Kontrollera om spelaren har vunnit.
- Om en spelare vinner, visa ett grattismeddelande och avsluta loopen.
- Kontrollera om brädet är fullt.
- Om brädet är fullt, visa att det är oavgjort och avsluta loopen.
- Visa den slutgiltiga spelplanen.
Du kanske redan ser hur detta fungerar, men det kommer bli tydligare med koden. Så låt oss gå vidare till koden.
Jag förutsätter att du har Python installerat på din dator för att testa koden.
Koden i detalj
Här är koden vi har skapat:
import random
class TicTacToe:
def __init__(self):
self.board = []
def create_board(self):
for i in range(3):
row = []
for j in range(3):
row.append('-')
self.board.append(row)
def get_random_first_player(self):
return random.randint(0, 1)
def fix_spot(self, row, col, player):
self.board[row][col] = player
def is_player_win(self, player):
win = None
n = len(self.board)
for i in range(n):
win = True
for j in range(n):
if self.board[i][j] != player:
win = False
break
if win:
return win
for i in range(n):
win = True
for j in range(n):
if self.board[j][i] != player:
win = False
break
if win:
return win
win = True
for i in range(n):
if self.board[i][i] != player:
win = False
break
if win:
return win
win = True
for i in range(n):
if self.board[i][n - 1 - i] != player:
win = False
break
if win:
return win
return False
def is_board_filled(self):
for row in self.board:
for item in row:
if item == '-':
return False
return True
def swap_player_turn(self, player):
return 'X' if player == 'O' else 'O'
def show_board(self):
for row in self.board:
for item in row:
print(item, end=" ")
print()
def start(self):
self.create_board()
player="X" if self.get_random_first_player() == 1 else 'O'
while True:
print(f"Spelare {player}s tur")
self.show_board()
row, col = list(
map(int, input("Ange rad och kolumnnummer: ").split()))
print()
self.fix_spot(row - 1, col - 1, player)
if self.is_player_win(player):
print(f"Spelare {player} vinner!")
break
if self.is_board_filled():
print("Oavgjort!")
break
player = self.swap_player_turn(player)
print()
self.show_board()
tic_tac_toe = TicTacToe()
tic_tac_toe.start()
Här är ett exempel på utmatningen av koden:
$ python tic_tac_toe.py Spelare Xs tur - - - - - - - - - Ange rad och kolumnnummer: 1 1 Spelare Os tur X - - - - - - - - Ange rad och kolumnnummer: 2 1 Spelare Xs tur X - - O - - - - - Ange rad och kolumnnummer: 1 2 Spelare Os tur X X - O - - - - - Ange rad och kolumnnummer: 1 3 Spelare Xs tur X X O O - - - - - Ange rad och kolumnnummer: 2 2 Spelare Os tur X X O O X - - - - Ange rad och kolumnnummer: 3 3 Spelare Xs tur X X O O X - - - O Ange rad och kolumnnummer: 3 2 Spelare X vinner! X X O O X - - X O
Viktiga punkter att notera om kodens struktur:
- Vi har använt en klass för att samla alla metoder, vilket gör koden mer återanvändbar.
- Vi har separerat varje uppgift till en funktion, vilket underlättar kodens underhåll.
- Dessa principer hjälper oss att enkelt göra uppdateringar i framtiden.
Anpassa gärna strukturen efter dina egna behov. Strukturen är inte statisk.
Slutsats
Grattis! Du har skapat ett spel från grunden. Det kanske inte är lika avancerat som moderna spel, men det ger värdefull övning i logik och kodstruktur. Använd liknande metoder för att skapa andra spel. Kanske du kan hitta inspiration i spel du spelade som barn.
Lycka till med kodningen! 👩💻
Utmana dig själv genom att utforska hur man skapar ett talgissningsspel eller hur man använder Python unittest.
Tyckte du om den här artikeln? Dela den gärna!