Python 制作简单的列表网格

大家好，我需要帮助做游戏网格的游戏人不要生气。 我应该做一个函数，生成一个格式为

n*n

一般来说，对于每个奇数，臂的宽度是3，长度是

n

。应该用列表列表来完成，因为我必须画一个数字绕这个网格，所以我需要坐标。 我做了这个游戏网格的周期

def gensachovnicu(n):
    matica='*'' '
    matica1='X '
    matica2='D '
    for j in range(n):
        for i in range(n):
            if i<((n-3)//2) and j<((n-3)//2):
                print('  ',end='')
            elif i<((n-3)//2) and j>(n-((n-3)//2)-1):
                print('  ',end='')
            elif i>(n-((n-3)//2)-1) and j<((n-3)//2):
                print('  ',end='')
            elif i>(n-((n-3)//2)-1) and j>(n-((n-3)//2)-1):
                print('  ',end='')
            elif i==(n//2) and j>0 and j<(n-1) and j!=(n//2):
                print(matica2,end='')
            elif i==(n//2) and j==(n//2):
                print(matica1,end='')
            elif j==(n//2) and i>0 and i<(n-1):
                print(matica2,end="")
            else:
                print(matica,end='')
        print()

def gensachovnicu（n）：
马蒂卡='*''
matica1='X'
马蒂卡2='D'
对于范围（n）内的j：
对于范围（n）中的i：
如果i（n-（（n-3）//2）-1）：
打印（“”，结束=“”）
elif i==（n//2）和j>0以及j0和i责任划分示例：

from random import randint

def dice():
    return randint(1,6)

# true for all fields (including border ones and player) 
def IsField(n, x,y): 
    off = (n-3)//2 # offset to the sides of 3 spaces playing ground

    if (x >= off and x < n-off):
       return True
    if (y >= off and y < n-off):
        return True

    return False


# true only for border 
def IsBorder(n,x,y): 
    off = (n-3)//2
    mid = (n-1)//2 # the middle where player moves

    if (y >= n) or (x >=n) or (y<0) or (x<0):
        return False
    if (y == 0 or y == n-1) and x in [mid-1, mid, mid+1]:
        return True
    if (x == 0 or x == n-1) and y in [mid-1, mid, mid+1]:
        return True
    if (y > 0 or y < n-1) and x == mid:
        return False
    if (x > 0 or x < n-1) and y == mid:
        return False
    if ((x == off or x == off+2) and not x == mid):
       return True
    if ((y == off or y == off+2) and not y == mid):
        return True

    return False


# what to mark field with?
def GetMarker(n,x,y):
    if IsBorder(n,x,y):
        return '*' 
    else:
        return ' '


# repair wrong inputs to odd and minimal 9
def MakeOddMin9(n):
    if n % 2==0:
        n += 1 # make odd
    n = max(9,n) # min 9
    return n


# construct the board, player pos still missing
def MakeBoard(n):
    n = MakeOddMin9(n)
    base = [ [GetMarker(n,x,y) for x in range(n)] for y in range(n)]
    mid = (n-1)//2
    base[0][mid] = 'a' # add player      
    return (base,(mid,0))


# print the boards fields
def PrintBoard(board):
    print("")
    size = len (board) 
    for y in range(size):
        row = ""
        for x in range(size):
            row += board[y][x]

        print (row) 
    print ("")

def Move(b,x,y,nx,ny):
    b[y][x]='*'
    b[ny][nx]='a'


# moves player along 1 tile  
def MoveOne(board,player):
    actX = player[0]
    actY = player[1]
    mid = (len(board)-1)//2
    # right
    if IsBorder(len(board), actX+1, actY) and actY < mid:
        Move(board,actX,actY,actX+1,actY)
        player = (actX+1,actY)
    # down
    elif IsBorder(len(board), actX, actY+1) and actX > mid:
        Move(board,actX,actY,actX,actY+1)
        player = (actX,actY+1)
    #left
    elif IsBorder(len(board), actX-1, actY) and actY > mid:
        Move(board,actX,actY,actX-1,actY)
        player = (actX-1,actY)
    #up
    elif IsBorder(len(board), actX, actY-1) and actX < mid:
        Move(board,actX,actY,actX,actY-1)
        player = (actX,actY-1)

    return (board,player)


b, player = MakeBoard(19)
mid = (len(b)-1)//2

PrintBoard(b)
inputKey= ''
while(inputKey == ''):
    moves = dice()
    b[mid][mid] = str(moves)
    for n in range(0,moves):
        b,player = MoveOne(b,player)

    PrintBoard(b)        
    inputKey = input("\n Hit enter. Enter anything to quit.").lower()
    if (inputKey != ''):
        break

导入操作系统
导入时间
随机输入
doska=[]
n=int（输入（'Zadaj rozmer hracieho pola:'））
def创建_sachovnica（n）：
全球多斯卡
doska=[''表示范围（n）中的i]表示范围（n）中的j]
npol=n//2
对于范围（n）中的i：
doska[npol-1][i]='*'
doska[npol+1][i]='*'
doska[i][npol-1]='*'
doska[i][npol+1]='*'
doska[npol][0]='*'
doska[npol][n-1]='*'
doska[0][npol]='*'
doska[n-1][npol]='*'
对于范围内的i（1，npol）：
doska[npol][i]='D'
doska[npol][n-i-1]='D'
doska[i][npol]=“D”
doska[n-i-1][npol]='D'
doska[npol][npol]='X'
def print_sachovinica（n）：
对于doska中的n：
打印（''.join（n））
打印（）
def gensachovnicu（n）：
创建_sachovinica（n）
萨科夫尼卡印刷厂（n）
def nextpos（doska，x，y）：
尺寸=透镜（多斯卡）
如果x>=大小//2：
如果ysize//2且doska[x][y-1]='*'：
返回x，y-1
elif x>size//2和doska[x][y-1]='*'：
返回x，y-1
返回x，y
def nextpos2（doska，s，r）：
velkost=len（多斯卡）
如果s>=velkost//2：
如果rvelkost//2和doska[s][r-1]=='*'：
返回s，r-1
elif s>velkost//2和doska[s][r-1]=='*'：
返回s，r-1
返回s，r
def pohyb（n、x、y、s、r）：
尽管如此：
创建_sachovinica（n）
doska[x][y]=“A”
多斯卡[s][r]=“B”
hod=random.randint（1,6）
hod1=随机随机随机数（1,6）
如果hod==1：
x、 y=nextpos（doska，x，y）
elif hod==2：
对于范围内的i（hod）：
x、 y=nextpos（doska，x，y）
elif hod==3：
对于范围内的i（hod）：
x、 y=nextpos（doska，x，y）
elif hod==4：
对于范围内的i（hod）：
x、 y=nextpos（doska，x，y）
elif hod==5：
对于范围内的i（hod）：
x、 y=nextpos（doska，x，y）
elif hod==6：
rozhodnutie1=str（输入（'Pohyb（P）/Nova figurka（N）'））
如果rozhodnutie1=='P'：
对于范围内的i（hod）：
x、 y=nextpos（doska，x，y）
其他：
多斯卡[n-1][（（n-3）//2）]='A'
如果hod1==1：
s、 r=nextpos2（多斯卡，s，r）
elif hod1==2：
对于范围内的i（hod1）：
s、 r=nextpos2（多斯卡，s，r）
elif hod1==3：
对于范围内的i（hod1）：
s、 r=nextpos2（多斯卡，s，r）
elif hod1==4：
对于范围内的i（hod1）：
s、 r=nextpos2（多斯卡，s，r）
elif hod1==5：
对于范围内的i（hod1）：
s、 r=nextpos2（多斯卡，s，r）
elif hod1==6：
rozhodnutie=str（输入（'Pohyb（P）/Nova figurka（N）'））
如果rozhodnutie=='P'：
对于范围内的i（hod1）：
s、 r=nextpos2（多斯卡，s，r）
其他：
多斯卡[0][（n-3）//2）+2]=“B”
萨科夫尼卡印刷厂（n）
印刷品（hod）
印刷品（hod1）
时间。睡眠（1）
根萨科夫尼库（北）
pohyb（n，（n-1），（（n-3）//2），0，（（n-3）//2）+2）
印刷品（图（n））
这是一个故事，不是一个问题。不要生气。注意：
不均匀=奇怪
“但时间太长了，我对付不了他。”这意味着什么？从划分责任开始。编写一个def，获取列表列表并打印它们，创建一个数据结构作为您的比赛场地（def创建它），记住playstone的坐标，在更改其位置时，清除IST列表中的数据单元，并将其放置到新的位置。玩家应在中间移动，以便在星星上移动。您可以使用
IsBorder（board，x，y）
-或通过选中
如果board[y][x]来检查字段是否为边框磁贴=='*'
在正确初始化的电路板中。如果在检查
IsBorder（board，newX，newY）
并将
bord[newY][newX]
设置为您的gamepieces representationchar后，用
'*'
替换您的gamepieces位置，您可以沿边缘移动它。如果你需要游戏机制方面的帮助，请在一篇新帖子中说明规则，并将其链接到这篇文章——也许有人会帮你。这个问题是关于制作列表的网格…@Item现在它移动了。我这样做，但我有一个问题。我怎样才能允许这个人物进入？我怎样才能在“房子”中确定这个数字呢？
   *a*
   * *
   * *
**** ****
*       *
**** ****
   * *
   * *
   ***


   ***
   * *
   * *
**** a***
*   4   *
**** ****
   * *
   * *
   ***


 Hit enter. Enter anything to quit.

   ***
   * *
   * *
**** ***a
*   3   *
**** ****
   * *
   * *
   ***


 Hit enter. Enter anything to quit.

   ***
   * *
   * *
**** ****
*   1   a
**** ****
   * *
   * *
   ***


 Hit enter. Enter anything to quit.

   ***
   * *
   * *
**** ****
*   5   *
**** ****
   * a
   * *
   ***


 Hit enter. Enter anything to quit.

   ***
   * *
   * *
**** ****
*   4   *
**** ****
   * *
   * *
   a**


 Hit enter. Enter anything to quit.

   ***
   * *
   * *
**** ****
*   4   *
**a* ****
   * *
   * *
   ***


 Hit enter. Enter anything to quit.

   ***
   * *
   * *
*a** ****
*   5   *
**** ****
   * *
   * *
   ***


 Hit enter. Enter anything to quit.

   *a*
   * *
   * *
**** ****
*   6   *
**** ****
   * *
   * *
   ***


 Hit enter. Enter anything to quit.

import os
import time
import random
doska = []

n=int(input('Zadaj rozmer hracieho pola:'))
def create_sachovnica(n):
    global doska
    doska = [[' ' for i in range(n)] for j in range(n)]
    npol = n // 2
    for i in range(n):
        doska[npol - 1][i] ='*'
        doska[npol + 1][i] ='*'
        doska[i][npol - 1] ='*'
        doska[i][npol + 1] ='*'
    doska[npol][0] ='*'
    doska[npol][n - 1] ='*'                                                 
    doska[0][npol] ='*'
    doska[n - 1][npol] ='*'
    for i in range(1, npol):
        doska[npol][i] ='D'
        doska[npol][n - i - 1] ='D'
        doska[i][npol] ='D'
        doska[n - i - 1][npol] ='D'
    doska[npol][npol] ='X'


def print_sachovnica(n):
    for n in doska:                                                               
        print(' '.join(n))
    print()

def gensachovnicu(n):
    create_sachovnica(n)                                
    print_sachovnica(n)



def nextpos(doska, x, y):
size = len(doska)
if x >= size // 2:
    if y < size // 2 and doska[x - 1][y] == '*':
        return x - 1, y
else:
    if y <= size // 2 and doska[x][y + 1] == '*':
        return x, y + 1
    elif y <= size // 2 and doska[x-1][y] == '*':
        return x-1,y
if y >= size // 2:
    if x <= size // 2 and doska[x + 1][y] == '*':               
        return x + 1, y
    elif x < size // 2 and doska[x][y+1] == '*':
        return x,y+1
    elif x > size // 2 and doska[x][y-1] == '*':
        return x,y-1
    elif x > size // 2 and doska[x+1][y] == '*':
        return x+1,y
else:
    if x > size // 2 and doska[x][y - 1] == '*':
        return x, y - 1
    elif x > size // 2 and doska[x][y - 1] == '*':
        return x, y - 1
return x, y

def nextpos2(doska, s, r):
velkost = len(doska)
if s >= velkost // 2:
    if r < velkost // 2 and doska[s - 1][r] == '*':
        return s - 1, r
else:
    if r <= velkost // 2 and doska[s][r + 1] == '*':
        return s, r + 1
    elif r <= velkost // 2 and doska[s-1][r] == '*':
        return s-1,r
if r >= velkost // 2:
    if s <= velkost // 2 and doska[s + 1][r] == '*':  
        return s + 1, r
    elif s < velkost // 2 and doska[s][r+1] == '*':
        return s,r+1
    elif s > velkost // 2 and doska[s][r-1] == '*':
        return s,r-1
    elif s > velkost // 2 and doska[s+1][r] == '*':
        return s+1,r
else:
    if s > velkost // 2 and doska[s][r - 1] == '*':
        return s, r - 1
    elif s > velkost // 2 and doska[s][r - 1] == '*':
        return s, r - 1
return s, r



def pohyb(n, x, y, s ,r):
while True:
    create_sachovnica(n)
    doska[x][y] = 'A'
    doska[s][r] = 'B'
    hod=random.randint(1,6)
    hod1=random.randint(1,6)
    if hod ==1 :
        x, y = nextpos(doska, x, y)
    elif hod==2:
        for i in range(hod):
            x, y = nextpos(doska, x, y)
    elif hod ==3:
        for i in range(hod):
            x, y = nextpos(doska, x, y)               
    elif hod==4:
        for i in range(hod):
            x, y = nextpos(doska, x, y)
    elif hod == 5:
        for i in range(hod):
            x, y = nextpos(doska, x, y)
    elif hod ==6:
        rozhodnutie1 = str(input('Pohyb(P)/Nova figurka(N)'))
        if rozhodnutie1 == 'P':
            for i in range(hod):
                x, y = nextpos(doska, x, y)
        else:
            doska[n-1][((n - 3) // 2)] = 'A'
    if hod1==1:
        s, r = nextpos2(doska, s, r)
    elif hod1==2:
        for i in range(hod1):
            s, r = nextpos2(doska, s, r)
    elif hod1==3:
        for i in range(hod1):
            s, r = nextpos2(doska, s, r)
    elif hod1==4:
        for i in range(hod1):
            s, r = nextpos2(doska, s, r)
    elif hod1==5:
        for i in range(hod1):
            s, r = nextpos2(doska, s, r)
    elif hod1==6:
        rozhodnutie=str(input('Pohyb(P)/Nova figurka(N)'))
        if rozhodnutie=='P':
            for i in range(hod1):
                s, r = nextpos2(doska, s, r)
        else:
            doska[0][((n-3)//2)+2] = 'B'
    print_sachovnica(n)
    print(hod)
    print(hod1)
    time.sleep(1)

gensachovnicu(n)
pohyb(n,(n-1),((n-3)//2),0,((n-3)//2)+2)
print(figurky(n))