三消游戏逻辑 - 编程之家

如何解决三消游戏逻辑

我正在开发一款三消游戏（例如宝石迷阵或糖果粉碎游戏）。到目前为止，我可以创建一个以 2D 数组表示的网格 (w*h)，我在其中放入代表不同类型宝石的字母。相同的字母可以是小写（普通宝石）或大写（相同颜色的特殊宝石，会在 9 格区域内爆炸周围的宝石）。

我的第一个功能是创建一个网格，其中没有 3 个相邻的宝石（水平或垂直）。为此，我设法构建了一个不错的函数：

def __create_grid(self):
    ''' this will create a grid 8x8 filled with random jewels
        so that we have something like:
        [['o','c','o','r','p','g','r'],['r','b','b'],['o','y','c'],['b','v','y'],['v',['g',['p','g']]
    '''

    JEWELS = list("gbrpyvoc")
    grid = []

    for i in range(8):
        
        last_letter = ""
        equals_letter_count = 0
        row = []
        
        for j in range(8):
            new_l = random.choice(JEWELS)
            
            if new_l == last_letter:
                equals_letter_count += 1
                if equals_letter_count >= 2:
                    new_l = JEWELS[(JEWELS.index(new_l)+1)%8]
                    equals_letter_count = 0
            
            if i >= 2:
                if new_l == grid[i-2][j] and new_l == grid[i-1][j]:
                    new_l = JEWELS[(JEWELS.index(new_l)+1)%8]
            
            last_letter = new_l
            row.append(new_l)
        
        grid.append(row)
    return grid

在该功能之后，我必须检查网格是否有可用的移动。这是我需要优化的功能，因为对我来说它似乎不是最佳的，即使它可以工作，即使最坏的情况（通过所有网格控制）仅在没有移动时才发生（实际上当它找到第一个可用的有效的移动返回 True 和要移动的棋子的位置）。这是可怕的代码：

def have_moves(self):
    ''' a valid move is when we can have 3 or more adjacent piece of same type
        by moving a piece,so I check for:
        
        HORIZONTAL CONTROLS: these perform each cycle,inner from 0 to len -4
        XX.X    X.XX   
        
        HORIZONTAL MULTILINE CONTROLS: these perform from 0 to len -2,inner from 0 to len -3
        X..    ..X   .XX  XX.   .X.  X.X 
        .XX    XX.   X..  ..X   X.X  .X.
        
        VERTICAL CONTROLS: these perform from 0 to len -4
        X  X   
        X  .
        .  X
        X  X
        
        VERTICAL multicolUMS CONTROLS: these perform  from 0 to len -3,inner from 0 to len -2
        X    .X   X.  .X   .X   X.   
        X    .X   .X  X.   X.   .X
        .X   X.   X.  .X   X.   .X
    '''
    vsize = len(self.grid)
    hsize = len(self.grid[0])
    for i in range(hsize):
        
        for j in range(vsize):
            
            if j <= vsize-4:
                # horizontal controls
                if self.is_valid((i,j),(i,j+1),j+3)):
                    return True,j+3)
                elif self.is_valid((i,j+2),j)
            
            if j <= vsize-3 and i <= hsize -2: 
                # horizontal multiline controls
                if self.is_valid((i,(i+1,j+2)):
                    return True,j)
                elif self.is_valid((i+1,j+2)
                elif self.is_valid((i+1,j)
                elif self.is_valid((i,j+1)
                elif self.is_valid((i,j+1)
            
            if i <= hsize-4:
                # vertical controls
                if self.is_valid((i,(i+3,j)):
                    return True,(i+2,j)
                        
            if i <= hsize-3 and j <= vsize-2:
                # vertical multicolumns control
                if self.is_valid((i,j+1)):
                    return True,j+1)
                if self.is_valid((i,j)
                if self.is_valid((i,j)
            
    return False

 def is_valid(self,a,b,c):
    if self.grid[a[0]][a[1]].lower() == self.grid[b[0]][b[1]].lower() == self.grid[c[0]][c[1]].lower():
        return True
    else:
        return False

如您所见，它看起来不太好...我确信可以使用更好的方法来检查棋盘上的可用动作，但是经过两天的思考，我找不到更好的方法。也许我可以将元组存储在像 [ [ [(x,y)(x,y),(x,y)],... ] ] 这样的数组中，以便我可以在控制流中执行 for 循环，但只是缩短代码，不改变性能，它也会使用额外的空间来存储元组。

我想我说得够多了，我希望有人能给我一个很好的建议，让这个控件比这个更好。

提前致谢。