Schreiben Sie ein 2048-Minispiel ohne Schnittstelle in Python

Als das Spiel 2048 populär wurde, habe ich zufällig eines in einer anderen Sprache geschrieben. Jetzt lerne ich Python und habe mich gerade daran erinnert, also habe ich beschlossen, ein 2048 in Python zu schreiben Python, ich habe ein extrem einfaches No-Interface 2048 geschrieben. Das Prinzip und die Implementierung des Spiels 2048 sind nicht schwierig. Wenn Sie dieses Spiel nicht kennen, können Sie es online überprüfen oder auf Ihr Mobiltelefon herunterladen Prinzip. Ich weiß, wenn Sie kein Bild hochladen, wird es niemanden interessieren. Lassen Sie uns zuerst ein Bild des Spiels hochladen und dann erklären wir Ihnen Schritt für Schritt, wie Sie es mit den grundlegendsten Kenntnissen umsetzen.

1. Erzeugen Sie eine 4*4-Matrix

Der erste Teil des Spiels Der erste Schritt besteht darin, eine 4*4-Matrix als Hauptschnittstelle unseres Spiels zu generieren. Tatsächlich ist es relativ einfach, hier die primitivste Methode zu verwenden, nämlich das direkte Ausdrucken mit

drucken. Zuerst müssen wir eine zweidimensionale 4*4-Liste aller Nullen erstellen und dann einige Zeichen wie „┌ ├└,┤,┘┐│,─,┬,┴“ verwenden, um einen Blick darauf zu werfen. Implementierung des Codes

matix=[[ for i in range()] for i in range()]    # 用列表推导式初始化生成一个*的列表，列表元素全为 
# notzero函数的作用：游戏界面上非零的时候才显示，当为的时候，让其显示空，
def notzero(s):                    
  return s if s!= else ''             # 非零的话返回本身，否则返回 ''
def display():　　　　　　　　　　　　　　　　　　　　　　　　# 显示界面函数，用┌ ├└,┤,┘┐│,─,┬,┴ 等显示边框，中间显示*矩阵里的的元素
  print("\r\
┌──┬──┬──┬──┐\n\
│%s│%s│%s│%s│\n\
├──┬──┬──┬──┤\n\
│%s│%s│%s│%s│\n\
├──┬──┬──┬──┤\n\
│%s│%s│%s│%s│\n\
├──┬──┬──┬──┤\n\
│%s│%s│%s│%s│\n\
└──┴──┴──┴──┘"\
%(notzero(matix[][]),notzero(matix[][]),notzero(matix[][]),notzero(matix[][]),\
 notzero(matix[][]),notzero(matix[][]),notzero(matix[][]),notzero(matix[][]),\
 notzero(matix[][]),notzero(matix[][]),notzero(matix[][]),notzero(matix[][]), \
 notzero(matix[][]),notzero(matix[][]),notzero(matix[][]),notzero(matix[][]),)
     )
display()

Schauen Sie sich die Wirkung des obigen Codes an Aufgrund der Initialisierung sind alle Matrixelemente Null und das Bild unten zeigt nicht 0. Ist es nicht sehr einfach, eine Spieloberfläche einzurichten, aber wir haben die Schnittstelle schließlich nie gelernt? Beschweren Sie sich also nicht über diese Schnittstelle.

generiert zufällig zwei Zufallszahlen 2 oder 4 in der obigen Matrix. Wie generieren wir also eine Zufallszahl 2 oder 4 an einer zufälligen Position in der obigen Matrix? Nachdem wir das Zufallsmodul und pmod() gelernt haben, werfen wir einen Blick darauf, wie man das Zufallsmodul zum Implementieren einer Funktion verwendet.

Schauen wir uns die Wirkung des obigen Codes an, wenn Sie If haben Wenn Sie es im Laufe der Zeit ausprobieren, können Sie feststellen, dass die Position auf der Matrix bei jeder Ausführung unterschiedlich ist und auch die Anzahl der Vorkommen jedes Mal unterschiedlich ist. Weil ich die Wahrscheinlichkeit von 2:4 auf 9:1 eingestellt habe Oben erscheint es meistens 2. Dies ist auch die Notwendigkeit des Spiels. Zu diesem Zeitpunkt kann die Matrix bereits verschoben werden und die Funktionen des Spiels sind bereits zur Hälfte abgeschlossen.

def init():                      # 初始化矩阵
  initNumFlag = 
  while :
    k = if random.randrange(, ) > else  # 当生成随机数大于的时候k=否则k= 生成和的概率为：
    s = pmod(random.randrange(, ), )    # 生成矩阵初始化的下标 比如pmod（，）的话，s为（，）正好可以作为矩阵下标
    if matix[s[]][s[]] == :          # 只有当其值不为的时候才赋值，避免第二个值重复
      matix[s[]][s[]] = k
      initNumFlag += 
      if initNumFlag == :           # 当initNumFlag== 的话表示矩阵里两个随机数都已经生成了，退出循环
        break
init()
display( )

3. Implementierung des Spiellogikteils

Wenn ja Wenn Sie dieses Spiel gespielt haben, werden Sie wissen, dass jedes Mal, wenn Sie sich im Spiel nach oben, unten, links und rechts bewegen, wenn Sie sich beispielsweise nach unten bewegen, alle Zahlen nach unten verschoben werden. Wenn Sie auf dieselbe Zahl stoßen, wird diese zu einer neuen Wenn beispielsweise 2 und 2 zusammentreffen, wird 4 generiert, und dann wird eine 2 oder 4 zufällig an anderen Positionen generiert. Wenn 4 und 4 zusammentreffen, wird 8 generiert 2048 wird synthetisiert, oder die Zahlen in der Matrix können nicht verschoben werden. Das Spiel ist vorbei. Wenn wir auf unseren Mobiltelefonen Spiele spielen, können wir natürlich alle Zahlen mit nur einem Wisch in eine Richtung schieben. Allerdings gibt es hier keine Schnittstelle und die Bedingungen sind schwierig, sodass wir nur die vom Benutzer eingegebenen Buchstaben lesen können Von der Konsole aus und dann nacheinander eingeben, um festzustellen, wohin sich der Benutzer bewegt hat, müssen wir vier Funktionen schreiben, um die Aufwärts-, Abwärts-, Links- und Rechtsbewegungen des Benutzers zu verarbeiten, und die letztere Funktion verarbeiten lassen, wie eine hinzugefügt wird Lassen Sie uns einen Pseudocode schreiben, um den Vorgang zu erklären.

Das Obige ist ein Teil des Pseudocodes zum Verständnis Schauen wir uns an, wie die Bewegungsverarbeitungsfunktion implementiert wird. Der schwierigste Teil ist, sobald dieser Teil abgeschlossen ist, das gesamte Spiel Ein Beispiel für die Abwärtsbewegungsverarbeitung. Alles andere ist gleich. Wenn die Benutzereingabe nach unten geht, werden alle Zahlen nach unten verschoben Zahlen. Dies muss mit einer Schleife implementiert werden, also hat die äußerste Schleife 4 Mal, und jede Spalte muss eine Schleife sein,

写完了向下移动的处理函数，那么向其他方向的移动函数也一样，照着写，就可以，到这里游戏中最难的部分就完成，可以说胜利就在眼前了，好了在这之前，我们还需要处理一下其他问题，那就是每次移动后都要检查，游戏是不是Game Over了，还有就是定义一个变量来纪录分数了，这些实现起来都比较简单。

四、游戏纪录分数和检查游戏是否结束

　　游戏结束的标志是矩阵中所有的数都不为0，而且所有相邻的数都不能合并，根据这个我们就可以来写一个函数来判断游戏是否GG，至于分数纪录，我们只需定义一个变量，然后每次有何并的时候，就加上一定的分数即可。下面我们来看检查函数的实现。

def check():　　　　　　　　　　　　
  for i in range(4):　　　　　　　　#按每一排循环4 次
    for j in range(3):　　　　　 # 如果矩阵中有0存在，或者有相邻的数就表示游戏还可以继续经行，否则就是GG
      if matix[i][j] == 0 or matix[i][j] == matix[i][j + 1] or matix[j][i] == matix[j + 1][i]:
        return True
  else:
    return False

五、完整游戏源码　　

　　完成了上面的部分，整个游戏的过程就实现了，下面附上整个游戏的源码。游戏还有很多不够完善的地方，比如说游戏中如果出现2048的话，就表示玩家胜利，游戏结束，但是我这里没有做处理，所以这个游戏可以一直玩到4096....没有结束，除非你游戏中GG了，要处理也很简单，还可以将矩阵存在文件中，完成一个游戏存档的功能。有兴趣的话大家去实现一下。

import random
score = 0　　　　　　　　　　　　　　　　　　　　　　　　　# 纪录游戏的分数
matix = [[0 for i in range(4)] for i in range(4)] # 初始化生成一个4*4的列表
def notzero(s):
  return s if s != 0 else ''
def display():
  print("\r\
     ┌──┬──┬──┬──┐\n\
     │%4s│%4s│%4s│%4s│\n\
     ├──┬──┬──┬──┤\n\
     │%4s│%4s│%4s│%4s│\n\
     ├──┬──┬──┬──┤\n\
     │%4s│%4s│%4s│%4s│\n\
     ├──┬──┬──┬──┤\n\
     │%4s│%4s│%4s│%4s│\n\
     └──┴──┴──┴──┘" \
     % (notzero(matix[0][0]), notzero(matix[0][1]), notzero(matix[0][2]), notzero(matix[0][3]), \
       notzero(matix[1][0]), notzero(matix[1][1]), notzero(matix[1][2]), notzero(matix[1][3]), \
       notzero(matix[2][0]), notzero(matix[2][1]), notzero(matix[2][2]), notzero(matix[2][3]), \
       notzero(matix[3][0]), notzero(matix[3][1]), notzero(matix[3][2]), notzero(matix[3][3]),)
     )
def init(): 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　# 初始化矩阵
  initNumFlag = 0
  while 1:
    k = 2 if random.randrange(0, 10) > 1 else 4 　　　　　　# 随机生成 2 或 4
    s = pmod(random.randrange(0, 16), 4) 　　　　　　　　　# 生成矩阵初始化的下标
    if matix[s[0]][s[1]] == 0: 　　　　　　　　　　　　　　　　 # 只有当其值不为0的时候才赋值，避免第二个值重复
      matix[s[0]][s[1]] = k
      initNumFlag += 1
      if initNumFlag == 2:
        break
  display()
def addRandomNum():　　　　　　　　　　　　　　　　　　　　　　　　#处理完移动后添加一个新的随机数
  while 1:
    k = 2 if random.randrange(0, 10) > 1 else 4
    s = pmod(random.randrange(0, 16), 4)
    if matix[s[0]][s[1]] == 0:
      matix[s[0]][s[1]] = k
      break
  display()
def check():　　　　　　　　　　　　　　　　　　　　　　　　　　　　#检查游戏是否GG
  for i in range(4):
    for j in range(3):
      if matix[i][j] == 0 or matix[i][j] == matix[i][j + 1] or matix[j][i] == matix[j + 1][i]:
        return True
  else:
    return False
def moveRight():　　　　　　　　　　　　　　　　　　　　　　　　 # 向右移动处理函数
  global score
  for i in range(4):
    for j in range(3, 0, -1):
      for k in range(j - 1, -1, -1):
        if matix[i][k] > 0:
          if matix[i][j] == 0:
            matix[i][j] = matix[i][k]
            matix[i][k] = 0
          elif matix[i][j] == matix[i][k]:
            matix[i][j] *= 2
            score += matix[i][j]　　　　　　　#将当前数作为score加上
            matix[i][k] = 0
          break
  addRandomNum()
def moveUp():
  global score
  for i in range(4):
    for j in range(3):
      for k in range(j + 1, 4):
        if matix[k][i] > 0:
          if matix[j][i] == 0:
            matix[j][i] = matix[k][i]
            matix[k][i] = 0
          elif matix[k][i] == matix[j][i]:
            matix[j][i] *= 2
            score += matix[j][i]
            matix[k][i] = 0
          break
  addRandomNum()
def moveDown():
  global score
  for i in range(4):
    for j in range(3, 0, -1):
      for k in range(j - 1, -1, -1):
        if matix[k][i] > 0:
          if matix[j][i] == 0:
            matix[j][i] = matix[k][i]
            matix[k][i] = 0
          elif matix[j][i] == matix[k][i]:
            matix[j][i] *= 2
            score += matix[j][i]
            matix[k][i] = 0
          break
  addRandomNum()
def moveLeft():
  global score
  for i in range(4):
    for j in range(3):
      for k in range(1 + j, 4):
        if matix[i][k] > 0:
          if matix[i][j] == 0:
            matix[i][j] = matix[i][k]
            matix[i][k] = 0
          elif matix[i][j] == matix[i][k]:
            matix[i][j] *= 2
            score += matix[i][j]
            matix[i][k] = 0
          break
  addRandomNum()
def main():
  print("    \033[33;1mWelcome to the Game of 2048!\033[0m")
  flag = True
  init()
  while flag:　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#循环的标志
    print('        \033[33;1m You Score:%s\033[0m' % (score))
    d = input('\033[33;1m (↑:w) (↓:s) (←:a) (→:d),q(uit) :\033[0m')  #不断处理用户输入
    if d == 'a':　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
      moveLeft()
      if not check():　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#检查游戏是否GG
        print('GG')
        flag = False　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #GG的话直接退出
    elif d == 's':
      moveDown()
      if not check():
        print('GG')
        flag = False
    elif d == 'w':
      moveUp()
      if not check():
        print('GG')
        flag = False
    elif d == 'd':
      moveRight()
      if not check():
        print('GG')
        flag = False
    elif d == 'q':　　　　　　　　　　　　　　　　　　　　　　　　　　# 退出
      break
    else:　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 # 对用户的其他输入不做处理
      pass
if __name__ == '__main__':
  main()

最后在附上一张图片最为结束

　　　

以上所述是小编给大家介绍的用Schreiben Sie ein 2048-Minispiel ohne Schnittstelle in Python，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对PHP中文网的支持！

更多Schreiben Sie ein 2048-Minispiel ohne Schnittstelle in Python相关文章请关注PHP中文网！