Das XENO-Video ist wirklich interessant, nicht wahr? Normalerweise schreibe ich Rails, aber ab und zu habe ich auch Python geübt und versucht, das Thema XENO mit Python zu implementieren.
Ich möchte es als Material für maschinelles Lernen verwenden oder auf youtube posten.
Wenn Sie mannual_flag auf True setzen, können Sie den CPU-Kampf von Texto Logic spielen.
Xeno.py
import random
class Xeno():
def __init__(self):
self.winner = "none"
class Player():
def __init__(self,teban):
self.hand = []
self.field = []
self.predict_flag = False
self.defence_flag = False
self.mannual_flag = False
if teban == 0:
self.teban="sente"
elif teban ==1:
self.teban="gote"
def set_deck(self):
card_list=[1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,10]
random.shuffle(card_list)
self.deck = card_list
#Reinkarnierte Rechnungsbearbeitung
self.reincarnation_card = self.deck.pop(-1)
#Ziehe einen vom Deck
def draw_top_card(self):
if len(self.deck) > 0:
self.drawed_card=self.deck.pop(0)
return self.drawed_card
#Sage Execution Sieh dir 3 Karten aus dem Stapel an, ziehe 1 Karte und mische das Deck
def do_predict(self):
if len(self.deck) > 2:
options = self.deck[0:3]
if self.player.mannual_flag ==True:
print("Aktiviere die Wirkung des Weisen")
print(options)
print("Bitte geben Sie die Karte zur Auswahl ein")
ind = options.index(self.inputnumber())
else:
ind = options.index(options[1])
selected_card = self.deck.pop(ind)
random.shuffle(self.deck)
self.drawed_card = selected_card
return self.drawed_card
#Match-Setup
def match_initialize(self):
self.sente = self.Player(0)
self.gote = self.Player(1)
#Erstelle ein Deck und eine wiedergeborene Karte und ziehe eine für jeden Spieler
self.set_deck()
self.sente.hand.append(self.draw_top_card())
self.gote.hand.append(self.draw_top_card())
#Sequenz vom Zeichnen bis zum Ende der Kurve
def play_turn(self,_player):
if _player == self.sente:
self.player = self.sente
self.o_player = self.gote
else:
self.player = self.gote
self.o_player = self.sente
if self.player.predict_flag == True and len(self.deck) > 2:
self.drawed_card = self.do_predict()
self.player.predict_flag = False
else:
self.drawed_card = self.draw_top_card()
#Fügen Sie der Karte eine Ziehkarte hinzu
self.player.hand.append(self.drawed_card)
if self.player.mannual_flag ==True:
print("drawed card:",self.drawed_card)
print(self.player.teban, self.player.hand)
#Lege eine Karte aus deiner Hand ins Spiel
self.play_card = self.decide_play_card()
#Löschen Sie die Karte aus Ihrer Hand
self.player.hand.remove(self.play_card)
#Zum Spielen hinzufügen
self.player.field.append(self.play_card)
# print("player hand:", self.player.hand)
#Spielen Sie den Effekt der ausgegebenen Karte
if self.o_player.defence_flag != True or self.play_card == 7 or self.play_card == 4:
self.play_effect()
#Wenn der Gegner schützt, wird nur die Flagge zurückgesetzt
else:
self.o_player.defence_flag = False
print("player field:", self.player.field)
print("o_player field:", self.o_player.field)
#Wenn das Deck am Ende des Zuges verschwunden ist, Handkampf
print("deck maisuu:", len(self.deck))
if len(self.deck) == 0:
self.battle()
#Endkampf
def battle(self):
print("battle!!!!!!!!!!!!!")
print("sente:", self.sente.hand[0])
print("gote:", self.gote.hand[0])
if self.sente.hand[0] > self.gote.hand[0]:
self.winner = self.sente.teban
elif self.gote.hand[0]>self.sente.hand[0]:
self.winner = self.gote.teban
else:
self.winner = "DRAW"
def decide_play_card(self):
if self.player.mannual_flag== True:
print("Bitte geben Sie die Kartennummer ein, um zu spielen")
return self.inputnumber()
else:
if self.player.hand.count(10) != 1:
# random.shuffle(self.player.hand)
self.player.hand.sort()
return self.player.hand[0]
else:
self.player.hand.sort()
return self.player.hand[0]
def play_effect(self):
pl = self.play_card
if pl == 1:
print("play:", pl)
self.revolution()
elif pl ==2:
print("play:", pl)
self.detect_number()
elif pl == 3:
print("play:", pl)
self.publicate()
elif pl ==4:
print("play:", pl)
self.skip_effect()
elif pl ==5:
print("play:", pl)
self.hide_draw_and_drop()
elif pl == 6:
print("play:", pl)
self.battle_novice()
elif pl == 7:
print("play:", pl)
self.predict()
elif pl == 8:
print("play:", pl)
self.exchange()
elif pl == 9:
print("play:", pl)
self.public_draw_and_drop()
def inputnumber(self):
if self.player.mannual_flag==True:
s = int(input())
return s
else:
return 1
#1 Junge
def revolution(self):
all_field = self.sente.field + self.gote.field
#Öffentliche Ausführung nur, wenn 1 bereits auf dem Feld ist
print(all_field)
if all_field.count(1) > 1:
self.public_draw_and_drop()
#2 Soldaten
def detect_number(self):
detection_number = 3
if self.player.mannual_flag == True:
print("Aktiviere den Effekt des Soldaten")
print("Bitte geben Sie die Handprognose des Gegners ein")
detection_number = self.inputnumber()
else:
detection_number = 5
if self.o_player.hand[0] == detection_number:
self.winner = self.player.teban
#3 Wahrsagerin
def publicate(self):
print(self.o_player.hand)
#4 Wächter
def skip_effect(self):
self.player.defence_flag = True
#5 Shinigami
def hide_draw_and_drop(self):
if len(self.deck)>0:
#Der Gegner zieht 1 Karte und mischt die Hand
self.draw_card = self.draw_top_card()
self.o_player.hand.append(self.draw_card)
random.shuffle(self.o_player.hand)
if self.player.mannual_flag == True:
print("Bitte wählen Sie die Position der Hand, die verworfen werden soll. 0:Links 1:richtig")
inp = self.inputnumber()
else:
inp = 0
#Lass die 0. Karte fallen
drop_target_card = self.o_player.hand.pop(inp)
self.o_player.field.append(drop_target_card)
#Reinkarnationsprozess, wenn das Ziel 10 ist
if drop_target_card == 10:
self.reincarnate()
#6 Aristokraten
def battle_novice(self):
self.battle()
#7 Salbei
def predict(self):
self.player.predict_flag = True
#8 Heiliger Geist
def exchange(self):
tmp = self.player.hand[0]
self.player.hand[0] = self.o_player.hand[0]
self.o_player.hand[0] = tmp
#9 Kaiser
def public_draw_and_drop(self):
if len(self.deck) > 0:
self.o_player.hand.append(self.draw_top_card())
#Handfreigabe
if self.player.mannual_flag ==True:
print("Klicken Sie hier für die Hand des Gegners")
print(self.o_player.hand)
#Zielauswahl
print("select target number:")
drop_target = self.inputnumber()
ind = self.o_player.hand.index(drop_target)
else:
ind = 0
drop_target_card = self.o_player.hand.pop(ind)
self.o_player.field.append(drop_target_card)
#Kaiserkarte(9)Wurde gespielt und die Zielkarte ist ein Held(10)Wenn ja, gewinnt der Spieler
if drop_target_card == 10:
if self.play_card == 9:
self.winner = self.player.teban
elif self.play_card == 1:
self.reincarnate()
#10 Helden
def reincarnate(self):
#Wirf deine Hand weg
self.o_player.field.append(self.o_player.hand.pop(0))
#Zeichne eine wiedergeborene Rechnung
self.o_player.hand.append(self.reincarnation_card)
def main():
winner_list = []
win_process =[]
for i in range(1,1000):
xeno = Xeno()
xeno.match_initialize()
xeno.sente.mannual_flag = False
xeno.gote.mannual_flag = False
while True:
print("=======================")
if xeno.winner == "none":
xeno.play_turn(xeno.sente)
else:
break
print("=======================")
if xeno.winner == "none":
xeno.play_turn(xeno.gote)
else:
break
print("winner :", xeno.winner)
winner_list.append(xeno.winner)
print("gote",winner_list.count("gote"))
print("sente",winner_list.count("sente"))
print("Draw",winner_list.count("DRAW"))
if __name__ == '__main__':
main()
Übrigens ist es Logic Texto, aber das Ergebnis von 10.000 Spielen gote 4543 sente 4967 Draw 489
Da die Möglichkeit besteht, dass die Kombination aus 6 und 10 zuerst gewinnt, ist der erste Zug noch vorteilhafter. Danach ist die Wächterkarte eigentlich gleichbedeutend mit "Lass den Gegner eine Hand wählen und sie ablegen + der Zugsprung des Gegners", also denke ich, dass er ein ziemlich starker Angreifer ist.
Recommended Posts