Maison  >  Article  >  développement back-end  >  Écrire un mini-jeu 2048 sans interface en Python

Écrire un mini-jeu 2048 sans interface en Python

高洛峰
高洛峰original
2017-03-02 16:11:431216parcourir

Quand le jeu 2048 est devenu populaire, il m'est arrivé d'en écrire un dans une autre langue. Maintenant, j'apprends le python, et je viens de m'en souvenir, alors j'ai décidé d'écrire un 2048 en python puisque je n'ai jamais appris la programmation d'interface. python, j'ai écrit un no interface 2048 extrêmement simple. Le principe et la mise en œuvre du jeu 2048 ne sont pas difficiles. Il peut être utilisé pour s'entraîner. Si vous ne connaissez pas ce jeu, vous pouvez le consulter en ligne ou le télécharger sur votre téléphone portable pour y jouer. principe. Je sais que si vous ne mettez pas de photo, personne ne sera intéressé. Mettons d’abord une photo du jeu, puis nous expliquerons comment le mettre en œuvre étape par étape en utilisant les connaissances les plus élémentaires.

Écrire un mini-jeu 2048 sans interface en Python

1. Générer une matrice 4*4

La première partie du jeu La première étape consiste à générer une matrice 4*4 comme interface principale de notre jeu. En fait, c'est relativement simple à dire. La méthode la plus primitive est utilisée ici, qui consiste à l'imprimer directement en utilisant

imprimer. Nous devons d'abord générer une liste bidimensionnelle 4*4 de tous les zéros, puis utiliser des caractères comme '┌ ├└,┤,┘┐│,─,┬,┴' pour former notre bordure. Implémentation du code


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()

Jetez un œil à l'effet du code ci-dessus Pensez-vous que le cadre d'un jeu a été. mis en place ?En raison de l'initialisation When , les éléments de la matrice sont tous nuls et l'image ci-dessous ne montre pas 0. N'est-ce pas très simple ? Nous avons mis en place une interface de jeu, mais après tout, nous n'avons jamais appris l'interface, alors ne vous plaignez pas de cette interface.

générera aléatoirement deux nombres aléatoires 2 ou 4 dans la matrice ci-dessus. Alors, comment générer un nombre aléatoire 2 ou 4 à une position aléatoire dans la matrice ci-dessus ? appris avant Le module random et pmod(), voyons comment utiliser le module random pour implémenter une fonction. Écrire un mini-jeu 2048 sans interface en Python

Jetons un coup d'œil à l'effet du code ci-dessus. Avez-vous généré deux nombres à deux positions aléatoires si vous avez Si ? vous l'essayez au fil du temps, vous pouvez voir qu'à chaque fois qu'il est exécuté, la position sur la matrice est différente, et le nombre d'occurrences est également différent à chaque fois Parce que j'ai défini la probabilité de 2:4 à 9:1. , c'est ce qui apparaît la plupart du temps 2. C'est aussi la nécessité du jeu. À ce stade, la matrice peut déjà être déplacée et les fonctions du jeu peuvent être considérées comme à moitié terminées.


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. Mise en place de la partie logique du jeu


Si vous en avez joué à ce jeu Vous saurez que chaque fois que vous montez, descendez, gauche et droite dans le jeu, par exemple, si vous descendez, tous les nombres descendront. Si vous rencontrez le même nombre, il deviendra un nouveau. numéro, par exemple si 2 et 2 se rencontrent, 4 sera généré, puis un 2 ou 4 sera généré aléatoirement à d'autres positions. De même, si 4 et 4 se rencontrent, 8 sera généré. 2048 est synthétisé, ou les nombres dans la matrice ne peuvent pas être déplacés. Bien sûr, si nous jouons à des jeux sur nos téléphones portables, nous pouvons faire glisser tous les chiffres dans une direction d'un simple glissement. Cependant, il n'y a pas d'interface ici et les conditions sont relativement difficiles, donc nous ne pouvons lire que les lettres saisies par le téléphone. l'utilisateur depuis la console, puis entrez un par un. Pour déterminer où l'utilisateur s'est déplacé, nous devons écrire quatre fonctions pour gérer respectivement les mouvements de l'utilisateur vers le haut, le bas, la gauche et la droite, et laisser cette dernière fonction gérer comment ajouter un nombre aléatoire après le déplacement de chaque utilisateur. Écrivons un pseudocode pour expliquer le processus

Écrire un mini-jeu 2048 sans interface en Python

Ce qui précède est un morceau de pseudo-code pour. Compréhension. Voyons comment implémenter la fonction de traitement des mouvements. Voici le code le plus courant dans tout le jeu. La partie difficile à gérer, une fois cette partie terminée, le jeu entier sera essentiellement réalisé. la fonction de traitement du mouvement vers le bas à titre d'exemple. Tout le reste est le même. Lorsque l'entrée de l'utilisateur se déplace vers le bas, tous les nombres seront déplacés vers le bas. Si vous rencontrez le même numéro et souhaitez fusionner, le carré avec le numéro se déplace vers le carré. sans le numéro. Cela doit être implémenté avec une boucle. Il y a 4 colonnes, donc la boucle la plus externe a 4 fois, et chaque colonne doit être bouclée. Voyons comment l'implémenter,

<.>

写完了向下移动的处理函数,那么向其他方向的移动函数也一样,照着写,就可以,到这里游戏中最难的部分就完成,可以说胜利就在眼前了,好了在这之前,我们还需要处理一下其他问题,那就是每次移动后都要检查,游戏是不是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 &#39;&#39;
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(&#39;        \033[33;1m You Score:%s\033[0m&#39; % (score))
    d = input(&#39;\033[33;1m (↑:w) (↓:s) (←:a) (→:d),q(uit) :\033[0m&#39;)  #不断处理用户输入
    if d == &#39;a&#39;:                                  
      moveLeft()
      if not check():                             #检查游戏是否GG
        print(&#39;GG&#39;)
        flag = False                             #GG的话直接退出
    elif d == &#39;s&#39;:
      moveDown()
      if not check():
        print(&#39;GG&#39;)
        flag = False
    elif d == &#39;w&#39;:
      moveUp()
      if not check():
        print(&#39;GG&#39;)
        flag = False
    elif d == &#39;d&#39;:
      moveRight()
      if not check():
        print(&#39;GG&#39;)
        flag = False
    elif d == &#39;q&#39;:                          # 退出
      break
    else:                                # 对用户的其他输入不做处理
      pass
if __name__ == &#39;__main__&#39;:
  main()

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

 Écrire un mini-jeu 2048 sans interface en Python  

以上所述是小编给大家介绍的用Écrire un mini-jeu 2048 sans interface en Python,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对PHP中文网的支持!

更多Écrire un mini-jeu 2048 sans interface en Python相关文章请关注PHP中文网!


Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn