Python으로 인터페이스 없이 2048 미니 게임 작성

게임 2048이 유명해졌을 때 우연히 다른 언어로 하나 쓰게 됐는데, 이제 파이썬을 배우다 보니 인터페이스 프로그래밍을 파이썬으로 배운 적이 없어서 문득 생각나서 2048을 파이썬으로 작성하게 되었습니다. 매우 단순한 인터페이스 없음 2048을 작성했습니다. 게임 2048의 원리와 구현은 어렵지 않습니다. 이 게임을 모르면 온라인으로 확인하거나 휴대폰에 다운로드하여 플레이할 수 있습니다. 원칙. 그림을 넣지 않으면 아무도 관심을 갖지 않을 것이라는 것을 알고 있습니다. 먼저 게임 그림을 넣은 다음, 가장 기본적인 지식을 활용하여 단계별로 구현하는 방법을 설명하겠습니다.

1. 4*4 행렬 생성

첫 번째 부분 첫 번째 단계는 게임의 메인 인터페이스로 4*4 행렬을 생성하는 것입니다. 사실 여기서는 가장 원시적인 방법을 사용하는데, 이는

인쇄하세요. 먼저 모든 0으로 구성된 4*4 2차원 목록을 생성한 다음 '┌ ├└,┤,┘┐│,─,┬,┴'와 같은 일부 문자를 사용하여 테두리를 살펴보겠습니다. 코드 구현

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

위 코드의 효과를 살펴보면 게임의 프레임워크가 설정된 것이 느껴지시나요? ? 초기화로 인해 행렬 요소가 모두 0이고 아래 그림에는 0이 표시되지 않습니다. 매우 간단하지 않습니까? 게임 인터페이스를 구축했지만 결국 인터페이스를 배운 적이 없으므로 그렇지 않습니다. 이 인터페이스가 얼마나 못생겼는지 불평하지 마세요. 하하.

은 위 행렬에서 두 개의 난수 2 또는 4를 무작위로 생성합니다. 그러면 위 행렬의 임의의 위치에 난수 2 또는 4를 어떻게 생성합니까? 앞서 배웠던 Random 모듈과 pmod(), Random 모듈을 사용하여 함수를 구현하는 방법을 살펴보겠습니다.

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

위 코드의 효과를 살펴보겠습니다. 두 개의 임의의 위치에서 두 개의 숫자가 생성됩니까? , 실행될 때마다 행렬의 위치가 달라지고, 매번 나타나는 숫자도 달라지는 것을 볼 수 있는데, 확률을 2:4로 9:1로 설정했기 때문에 2가 나타납니다. 대부분의 경우 이것은 게임에 필요한 것이기도 합니다. 이쯤 되면 이미 매트릭스는 움직일 수 있고, 게임의 기능은 절반쯤 완성됐다고 할 수 있다.

3. 게임 로직 부분 구현

이 게임을 플레이하시면 게임에서 위, 아래, 왼쪽, 오른쪽으로 움직일 때마다, 예를 들어 아래로 이동하면 모든 숫자가 아래로 이동하고, 같은 숫자를 만나면 새로운 숫자가 된다는 것을 아실 겁니다. 예를 들어 2와 2가 만나면 4가 생성되고 다른 위치에서는 2 또는 4가 무작위로 생성됩니다. 마찬가지로 4와 4가 만나면 8이 생성됩니다. 2048이 합성되었거나 매트릭스의 숫자를 이동할 수 없습니다. 게임 오버입니다. 물론 휴대폰으로 게임을 하면 스와이프만으로 모든 숫자를 한 방향으로 밀어낼 수 있지만, 이곳은 인터페이스도 없고 조건도 까다로워 사용자가 입력한 글자만 읽을 수 있다. 사용자가 어디로 이동했는지 확인하려면 사용자의 위, 아래, 왼쪽, 오른쪽 움직임을 각각 처리하는 4개의 함수를 작성하고 후자의 함수가 추가하는 방법을 처리하도록 해야 합니다. 각 사용자가 이동한 후 의사 코드를 작성하여 프로세스를 설명하겠습니다.

def addRandomNum():　　　　　　　　　 　　#每次移动后随机在矩阵中在生成一个数
  pass  　　　　　　
def moveDown()：　　　　　　　　　　　　　　#向上移动的处理函数
  pass<br>  addRandomNum()　　　　　　　　　　　　 #移动处理完成后，随机生成一个数
def moveLeft():　　　　　　　　　　　　　　 #向左移动的处理函数
  pass
  addRandomNum()
def moveUp():　　　　　　　　　　　　　　  #向上移动的处理函数
  pass
  addRandomNum()
def moveRight():　　　　　　　　　　　　  #向右移动的处理函数
  pass
  addRandomNum()
def main():
  while flag:　　　　　　　　　　　　　　　　　　　　　　　　　　#定义一个死循环，不断读入用户的输入，然后在做判断，看是向哪里移动
    d = input(&#39; (↑:w) (↓:s) (←:a) (→:d),q(uit) :“)
    if d == &#39;a&#39;:
      moveLeft() 
    elif d == &#39;s&#39;:
      moveDown()
    elif d == &#39;w&#39;:
      moveUp()
    elif d == &#39;d&#39;:
      moveRight()
    elif d == &#39;q&#39;:
      break
    else:
      pass

위는 이해를 위한 의사 코드입니다. 이동 처리 기능을 어떻게 구현하는지 살펴보겠습니다. 이 부분이 게임 전체에서 가장 다루기 어려운 부분인데, 이 부분이 완료되면 전체 게임이 기본적으로 구현됩니다. 예를 들어 다른 모든 것은 동일합니다. 사용자 입력이 아래로 이동하면 모든 숫자가 아래로 이동합니다. 이동, 동일한 숫자를 만나 병합하려는 경우 숫자가 있는 사각형이 숫자가 없는 사각형으로 이동합니다. 4개의 열이 있으므로 가장 바깥쪽 루프는 4번씩 반복해야 합니다.

def addRandomNum():　　　　　　　　　　　　　　　　　　　　　　　　# 跟初始化生成随机数一样，只不过这里只是生成一个随机数
  while :
    k = if random.randrange(, ) > else 
    s = pmod(random.randrange(, ), )
    if matix[s[]][s[]] == :
      matix[s[]][s[]] = k
      break
  display()　　　　　　　　　　　　　　　　　　　　　　　　　　　# 随机数添加完成后就直接调用显示函数，直接显示一下游戏界面
def moveDown():　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#处理向下移动的函数
  for i in range():　　　　　　　　　　　　　　　　　　　　　　　　　　　　#外层次循环处理例，内层两个层循环，来处理相邻的两个数
    for j in range(, , -):
      for k in range(j - , -, -):
        if matix[k][i] > :　　　　　　　　　　　　　　　　　　　　# 从最下面的数开始处理相邻的两个数
          if matix[j][i] == :
            matix[j][i] = matix[k][i]　　　　　　　　　　　 # 如果下面的数为空，上面的数字不为空就移动上面的数为下面的数
            matix[k][i] = 
          elif matix[j][i] == matix[k][i]:　　　　　　　　　　# 如果相邻的两个数相等的话，就和并，并把上面的输置零，下面的数变成两倍
            matix[j][i] *= 
            matix[k][i] = 
          break
  addRandomNum()　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　# 移动完成后再随机生成一个数

写完了向下移动的处理函数，那么向其他方向的移动函数也一样，照着写，就可以，到这里游戏中最难的部分就完成，可以说胜利就在眼前了，好了在这之前，我们还需要处理一下其他问题，那就是每次移动后都要检查，游戏是不是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()

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

　　　

以上所述是小编给大家介绍的用Python으로 인터페이스 없이 2048 미니 게임 작성，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对PHP中文网的支持！

更多Python으로 인터페이스 없이 2048 미니 게임 작성相关文章请关注PHP中文网！