Python 战争卡游戏模拟器中的无限循环

我在试着模拟一个（微小的）战争游戏！作为OOP中的练习。我有一个循环，两副牌相互对打，但它似乎永远循环，一次又一次重复相同的序列。输出到达一个卡片组中有4个卡片对象的点，然后循环重复。仅当两个Drawpile对象都大于零时，循环才应运行

ranks = [2,3,4,5,6,7,8,9,10,11,12,13,14] #for use of value comparison via index
suits =['Diamonds','Hearts','Clubs','Spades']
rounds = 0

class Card:
    def __init__(self, rank, suit): 
        self.rank = rank
        assert rank in ranks
        assert suit in suits
        self.suit = suit
    def __repr_(self):
        return '{} of {}'.format(self.rank,self.suit)
    def __str__(self):
        return '{} of {}'.format(self.rank,self.suit)
    def __eq__(self, other): 
        if self.rank == other.rank:
            return True
        else:
            return False
    def __gt__(self, other): #gt compared via ordering of ranks index
        if self.rank > other.rank:
            return True
        else:
            return False
    def __lt__(self, other):
        if self.rank < other.rank:
            return True
        else:
            return False

class Drawpile:
    def __init__(self, pile =[]):
        self.pile = pile
    def __len__(self):
        return len(self.pile)
    def __getitem__(self, n):
        return self.pile[n]
    def add(self, n):
        self.pile.append(n)
    def draw(self):
        if len(self) <= 0:
            return None
        return self.pile.pop(0)

dp1 = Drawpile([Card(2,'Diamonds'),Card(13,'Hearts'),Card(7,'Clubs')])
dp2 = Drawpile([Card(4,'Hearts'),Card(3,'Hearts'),Card(8,'Spades')])

while len(dp1) > 0 and len(dp2) > 0:

    rounds += 1
    c1 = dp1.draw()
    c2 = dp2.draw()

    print('Round ',rounds)
    print('c1',c1, len(dp1))
    print('c2',c2, len(dp2))

    if c1 > c2:
        dp1.add(c1)
        dp1.add(c2)
    else:
        dp2.add(c1)
        dp2.add(c2)

if len(dp1) > len(dp2):
    print('Pile 1 Won!')
else:
    print('Pile 2 Won!')

ranks=[2,3,4,5,6,7,8,9,10,11,12,13,14]#用于通过索引进行值比较
西服=[“钻石”、“红心”、“梅花”、“黑桃”]
轮数=0
班级卡：
定义初始（自我、等级、套装）：
self.rank=等级
名列前茅
在诉讼中主张诉讼
西服
定义报告（自我）：
返回{}格式的{}（self.rank，self.suit）
定义（自我）：
返回{}格式的{}（self.rank，self.suit）
定义（自身、其他）：
如果self.rank==other.rank：
返回真值
其他：
返回错误
def _gt__（自我、其他）：#gt通过等级索引排序进行比较
如果self.rank>other.rank：
返回真值
其他：
返回错误
定义（自身、其他）：
如果self.rank0：
回合数+=1
c1=dp1.draw（）
c2=dp2.draw（）
打印（'圆形'，圆形）
打印（'c1'，c1，透镜（dp1））
打印（'c2'，c2，透镜（dp2））
如果c1>c2：
dp1.添加（c1）
dp1.添加（c2）
其他：
dp2.添加（c1）
dp2.添加（c2）
如果len（dp1）>len（dp2）：
打印（'1号桩赢！'）
其他：
打印（'2号桩赢！'）

---

有人能告诉我这个回路到底在哪里卡住了吗？我试着画出图表，这是我第二次重写。有什么想法吗？

这是一个真正的无限循环：这就是游戏的本质。没有保证的结局。这是您提供的一段跟踪（做得好！），显示了循环。列出的第一轮和最后一轮是相同的；在这两种情况下，它们后面的甲板也是相同的。如果你想要一个有限的游戏，你需要对这种情况实施某种解决方案

Round  64274
c1 13 of Hearts 3
c2 4 of Hearts 1
Round  64275
c1 2 of Diamonds 4
c2 8 of Spades 0
Round  64276
c1 7 of Clubs 3
c2 2 of Diamonds 1
Round  64277
c1 3 of Hearts 4
c2 8 of Spades 0
Round  64278
c1 13 of Hearts 3
c2 3 of Hearts 1
Round  64279
c1 4 of Hearts 4
c2 8 of Spades 0
Round  64280
c1 7 of Clubs 3
c2 4 of Hearts 1
Round  64281
c1 2 of Diamonds 4
c2 8 of Spades 0
Round  64282
c1 13 of Hearts 3
c2 2 of Diamonds 1
Round  64283
c1 3 of Hearts 4
c2 8 of Spades 0
Round  64284
c1 7 of Clubs 3
c2 3 of Hearts 1
Round  64285
c1 4 of Hearts 4
c2 8 of Spades 0
Round  64286
c1 13 of Hearts 3
c2 4 of Hearts 1

---

DP2的最后一张牌总是黑桃8张，所以它总是赢下另外2张牌。你需要洗牌吗？我认为这不是算法，只是牌的顺序和选择的巧合。试着用所选的牌手动玩游戏，看看游戏是否结束或无限期地继续（注意赢的牌被附加到现有牌组中的顺序）。当你得到一个解决方案时，请记住向上投票有用的东西并接受你最喜欢的答案（即使你必须自己写），因此，堆栈溢出可以正确地存档问题。感谢您的回答！我在while循环中添加了一个条件，当其中一个组命中len（0）时退出。卡交换的逻辑都是在没有点击I gather中while循环的检查的情况下进行的。代码现在可以正常工作：）