python 6x6游戏加登录、记录系统

Question

import random
import time
def initialize_6x6():#创建一个6行的矩阵，其中第一行有6x5x4x3x2x1=720中结果，其余行数为第一行的结果
    row0=[1,2,3,4,5,6]
    random.shuffle(row0) #随机打乱选择其中一种
    row1=row0[3:6]+row0[0:3]
    row2=[row0[2],row0[0],row0[1],row0[5],row0[3],row0[4]]
    row3=row2[3:6]+row2[0:3]
    row4=row3[5],row3[3],row3[4],row3[2],row3[0],row3[1]
    row5=row4[3:6]+row4[0:3]
    return [row0,row1,row2,row3,row4,row5]

def hanghuanhang(board):
    top=board[:2] #第1、2行
    mid=board[2:4]#第3、4行
    bottom=board[4:]#第5、6行
    random.shuffle(top)#其中第一行与第二行换 见p399图
    random.shuffle(mid)#其中第3行与第4行换 见p399图
    random.shuffle(bottom)#其中第5行与第6行换 见p399图
    return top+mid+bottom
def hengshuhuan(board):#由于行和列不好换 需要创建一个行和列的置换函数 见p388
    size=len(board)
    k=[]
    for _ in range(size):
        k.append([])
    for row in board:
         for g in range(size):
            k[g].append(row[g])
    return k
def shushuhuan(borad):#由于列无法直接置换所以需要把列换到行进行列与列的置换
    shu1_3=borad[0:3]
    shu4_6=borad[3:6]
    random.shuffle(shu1_3)
    random.shuffle(shu4_6)
    return shu1_3+shu4_6
#下面进行与行、列与列的置换，由于第一行出现的情况我们已经知道有720种结果
#但每行与行之间需要换和每列与列之间要换 还存在2**9即2的9次方的结果为512（见图p399）
#所以总可能数为 720x512=368640种
def creation_6x6():
    board=initialize_6x6()
    board=hanghuanhang(board)#行换行 包含 上 中 下三个区域 p399
    board=hengshuhuan(board)#行换列
    board=shushuhuan(board)#由于列无法直接置换所以需要把列换到行进行列与列的置换
    board=hengshuhuan(board)#列在行的方向上换完后回到列
    return board

def copy_board(board):#创建一个复制函数，后面方便对照玩家输入后的答案
    j=[]
    for row in board:
        j.append(row[:])
    return j
def get_messege(messege,a,b):#获取信息函数在总函数里用到
    messeges=input(messege)
    while not(messeges.isdigit() and a<=int(messeges)<=b):
        messeges=input(messege)
    return int(messeges)

def get_level():
    print("游戏规则：等级一为填6个空，等级二为填8个空，等级三为填10个空,等级一在1分钟内完成给一个金币，超过一分钟减一个，等级二在两分钟内完成给一个金币，超过两分钟减一个，等级三在三分钟内完成给一个金币，超过三分钟减一个,等级一在30s内完成多给一个金币，等级二60s内完成多给一个金币，等级二90s内完成多给一个金币")
    level=input("一共1～3个等级 请输入你想进行的等级:")
    while level not in("1","2","3"):
        level=input("一共1～3个等级 请输入你想进行的等级")
    if level=="1":
        return 6
    elif level=="2":
        return 8
    else:
        return 10
def make_holes(copy_board,get_level):#制作"空"函数但空的部分暂且按0来记号
    while get_level >0:
        i=random.randint(0,3)
        j=random.randint(0,3)
        if copy_board[i][j]!=0:
            copy_board[i][j]=0
            get_level-=1
    return copy_board
def show_board(copy_board):#将"0"记号的部分 转化为" . "并且打印出来
    for row in copy_board:
        for entry in row:
            if entry==0:
                print(".",end=" ")
            else:
                print(entry,end=" ")
        print()
def load_members():
    file=open("/Users/wangzhehan/Desktop/aa.csv","r")
    members={}
    for line in file:
        name,passwd,tries,chips=line.strip("\n").split(",")
        members[name]=(passwd,int(tries),int(chips))
    file.close()
    return members

def login(members):
    user_member=input("输入你的名字：")
    user_passwd=input("输入你的密码：")
    if user_member in members.keys():
        if user_passwd in members[user_member][0]:
            tries=members[user_member][1]
            chips=members[user_member][2]
            print("你已经玩了",tries,"游戏了。")
            if chips >=0:
                print("你现在还有",chips,"chips")
            else:
                print("你欠",chips,"chips")
            return user_member,tries,chips,members
        else:
            return login(members)
    else:
        members[user_member]=(user_passwd,0,0)
        return user_member,0,0,members
def store_members(members):
        file=open("/Users/wangzhehan/Desktop/aa.csv","w")
        names=members.keys()
        for name in  names:
            passwd,tries,chips=members[name]
            line=name+','+passwd+','+str(tries)+','+\
                str(chips)+"\n"
            file.write(line)
        file.close()


def soduk_6x6():#执行总函数
    members= load_members()
    user_name,passwd,tries,chips= login(members)
    more = "y"
    while more == "y":
        solution=creation_6x6()
        puzzle_board=copy_board(solution)
        not_holes=get_level()
        puzzle_board=make_holes(puzzle_board,not_holes)
        start = time.perf_counter()
        show_board(puzzle_board)
        while not_holes>0:
            i = get_messege("行数#", 1, 6) - 1
            j = get_messege("列数#", 1, 6) - 1
            if puzzle_board[i][j]!=0:
                print("这里已经有数了重新输入")
                continue
            n=get_messege("数字#：",1,6)
            if n ==solution[i][j]:
                puzzle_board[i][j]=solution[i][j]
                show_board(puzzle_board)
                not_holes-=1
            else:
                print(n,"数字有误重新输入")

        end=time.perf_counter()
        times= round(end - start, 0)
        print("共用"+str(times)+"秒")
        tries+=1
        if not_holes==6:
            if times <=30:
                chips+=2
            elif 30 < times < 60:
                chips+=1
            elif times >60:
                chips-=1
        elif not_holes==8:
            if times <=60:
                chips+=2
            elif 60< times <120:
                chips+=1
            else:chips-=1
        else:
            if times <= 90:
                chips+=2
            elif 90 < times <180:
                chips+=1
            else:chips-=1
        return chips

        more = input("再来一次的话请输入y，停止输入任意键")
    members[user_name]=(str(passwd),int(tries),int(chips))
    store_members(members)



soduk_6x6()

python 6x6的数独游戏 ， 如要求写的一样 print("游戏规则：等级一为填6个空，等级二为填8个空，等级三为填10个空,等级一在1分钟内完成给一个金币，超过一分钟减一个，等级二在两分钟内完成给一个金币，超过两分钟减一个，等级三在三分钟内完成给一个金币，超过三分钟减一个,等级一在30s内完成多给一个金币，等级二60s内完成多给一个金币，等级二90s内完成多给一个金币")，由于本人太笨 改了这那不行改了那这不行，希望高人来指导一下。要求是不改变我整体框架下 稍稍改动就能使代码跑起来满足我的要求 谢谢！！

Answer 1

。。目前解决了本地文件的问题，

然后发现~

通过修改login()函数的返回值和接受变量如下：

接受变量更改如下：

继续运行结果如下

更改后又遇见问题：

继续更改后：

存储文件变更

Answer 2

增加一个登陆方法实现登陆功能，在游戏开始前调用该登陆方法，如果登陆成功则开始游戏，如果登陆失败则退出游戏。代码如下：

def login():
    print('您还未登陆！')
    select = 0
    while True:
        select = int(input('1 使用已有账号登陆，2 注册新账号,3 退出:'))
        if select == 1:
            name = input('请输入登陆账号:')
            password = input('请输入登陆密码:')
            check = False
            with open('accounts.txt') as file:
                lines =file.readlines()
                for line in lines:
                    accounts = line.split()
                    if name == accounts[0] and password == accounts[1]:
                        check = True
                        break

            if check:
                print('登陆成功！')
                break
            else:
                print('账号或密码错误！')

        elif select == 2:
            name = input('请输入新的账号:')
            password = input('请输入新账号的密码:')
            check = False
            with open('accounts.txt') as file:
                lines = file.readlines()
                for line in lines:
                    accounts = line.split()
                    if name == accounts[0]:
                        check = True
                        break

            if check:
                print('该账号已存在！')
            else:
                with open('accounts.txt','a') as file:
                    file.write(name+' '+password)
                print('注册成功！')
                break
        else:
            break

    if select!=3:
        return True
    else:
        return False

以上代码包含注册功能，账号密码保存在一个叫account.txt文件中，格式如下：

分别为账号和密码。

其次，实现记录系统，增加一个记录类LogMessage ，将用户的操作记录存放在文件中，代码如下：

import  os

class LogMessage: #记录类
    def __init__(self,user,msg,s_time):
        self.user = user
        self.msg = msg
        self.s_time = s_time

    def log(self):
        if not os.path.exists(self.user):
            os.makedirs(self.user)
        with open(self.user+'\\logs.txt','a+',encoding='utf-8') as file:
            file.write(self.s_time+':'+self.msg+"\n")

logMsg = LogMessage('xxb','登陆游戏','2023-06-01')
logMsg.log()

使用用户的用户名作为一个文件夹，其操作记录存放咋该文件夹下的logs.txt文件中，

Answer 3

下面是修改后的代码，实现了游戏规则的展示和金币的增减：

import random
import time

def initialize_6x6():
row0 = [1, 2, 3, 4, 5, 6]
random.shuffle(row0)
row1 = row0[3:6] + row0[0:3]
row2 = [row0[2], row0[0], row0[1], row0[5], row0[3], row0[4]]
row3 = row2[3:6] + row2[0:3]
row4 = [row3[5], row3[3], row3[4], row3[2], row3[0], row3[1]]
row5 = row4[3:6] + row4[0:3]
return [row0, row1, row2, row3, row4, row5]

def hanghuanhang(board):
top = board[:2]
mid = board[2:4]
bottom = board[4:]
random.shuffle(top)
random.shuffle(mid)
random.shuffle(bottom)
return top + mid + bottom

def hengshuhuan(board):
size = len(board)
k = [[] for _ in range(size)]
for row in board:
for g in range(size):
k[g].append(row[g])
return k

def shushuhuan(board):
shu1_3 = board[0:3]
shu4_6 = board[3:6]
random.shuffle(shu1_3)
random.shuffle(shu4_6)
return shu1_3 + shu4_6

def creation_6x6():
board = initialize_6x6()
board = hanghuanhang(board)
board = hengshuhuan(board)
board = shushuhuan(board)
board = hengshuhuan(board)
return board

def copy_board(board):
copy = []
for row in board:
copy.append(row[:])
return copy

def get_message(message, a, b):
while True:
try:
value = int(input(message))
if a <= value <= b:
return value
except ValueError:
pass

def get_level():
print("游戏规则：等级一为填6个空，等级二为填8个空，等级三为填10个空")
print("等级一在30s内完成多给一个金币，超过30s减一个")
print("等级二在60s内完成多给一个金币，超过60s减一个")
print("等级三在90s内完成多给一个金币，超过90s减一个")
level = get_message("请选择游戏等级（1/2/3）：", 1, 3)
return level

def get_coordinate(board):
while True:
try:
x = int(input("请输入行号（1-6）：")) - 1
y = int(input("请输入列号（1-6）：")) - 1
if 0 <= x <= 5 and 0 <= y <= 5 and board[x][y] == 0:
return x, y
except ValueError:
pass
print("无效的坐标，请重新输入。")

def play_6x6():
board = creation_6x6()
copy = copy_board(board)
start_time = time.time()
level = get_level()
if level == 1:
blanks = 6
time_limit = 30
elif level == 2:
blanks = 8
time_limit = 60
else:
blanks = 10
time_limit = 90
gold = 0
while blanks > 0:
print("当前金币数：", gold)
print("剩余空格数：", blanks)
在最后一行代码下添加以下代码，实现了填数字和金币的增减：
print("当前数独：")
        print_board(board)
        x, y = get_coordinate(board)
        value = get_message("请输入该位置的数字（1-6）：", 1, 6)
        board[x][y] = value
        blanks -= 1
        if blanks == 0:
            if board == copy:
                print("恭喜你，完成数独！")
                if time.time() - start_time <= time_limit:
                    gold += 1
                    print("时间内完成，获得一枚金币！")
                else:
                    gold -= 1
                    print("超时完成，扣除一枚金币。")
            else:
                print("很遗憾，填写错误。")
                gold -= 1
                print("扣除一枚金币。")

Answer 4

不知道你这个问题是否已经解决, 如果还没有解决的话:

• 帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/7641969
• 除此之外, 这篇博客: python小白自学基础知识（二）附加(人狗大战游戏)中的 根据函数和面向对象（类）的知识，概括为一个总的例子（该例子我在其他的文章中见过），作为上课的内容，老师要求实现人狗大战游戏代码编写，内容中包含：人初始化的金钱额度，金钱用于买枪，枪对狗的伤害，以及狗的血量，最后是人在多少次把狗打死（其中没有涉及到人打狗的同时，狗也在咬人，但是却定义了狗对人的伤害，有兴趣的朋友可以继续把游戏做下去） 部分也许能够解决你的问题, 你可以仔细阅读以下内容或者直接跳转源博客中阅读:
  

  人狗大战游戏

  #创建一个类（该类的属性会为后面的类继承调用）
  class lable:
      def __init__(self, name, aggr, hp):  #类属性
          self.name = name
          self.aggr = aggr
          self.hp = hp
  
  class dog(lable):  #创建狗的类,并且继承lable(父类)的属性
      def __init__(self, name, aggr, hp, kind):
          lable.__init__(self, name, aggr, hp)
          self.kind = kind
  	#定义狗的攻击方法
      def attack(self, person):
      	#人的血等于人当前的血量减去狗的攻击力
          person.hp -= self.aggr
  
  class person(lable): #创建人的类,同样继承lable(父类)的属性
      def __init__(self, name, aggr, hp, sex):
          lable.__init__(self, name, aggr, hp)
          self.sex = sex
          #初始化人的钱为0
          self.money = 0
  	#定义人的攻击方法，参数对象是狗
      def person_attack(self, dog):
      	#狗的血量等于狗当前的血量减去人的攻击力
          dog.hp -= self.aggr
  	#定义人买枪的方法
      def person_gun(self, gun):  
          if self.money >= gun.g_price:
          	#如果钱够就买枪
              self.money -= gun.g_price
              self.gun = gun
              #枪的攻击力赋值与人的攻击力
              self.aggr = gun.g_aggr
          else:
              print('余额不足,请充值金额打狗!')
  
  class gun:  #创建gun枪的类
  	#类属性 记录子弹数量，初始化为0
      num_bullet = 0
      def __init__(self, name, aggr, zds, price):
          self.g_name = name
          self.g_aggr = aggr
          self.g_zds = zds
          self.g_price = price
   	def hand_w(self,dog):
   	#定义人开枪的方法
   		while self.g_zds > 0:#保证子弹数一直是正数
   			if dog.hp > 0:
   				#人用枪打狗，伤害为枪伤害的二倍
   				dog.hp -= self.g_aggr * 2
       			self.g_zds -= 1
                  gun.num_bullet += 1
                  print('正在使用武器攻击(伤害为{}的二倍)!'.format(self.g_aggr))
                  print('当前{}的血条为{}'.format(dog.name,dog.hp))
              else:  # 防止程序陷入死循环
                  break
  #创建实例对象
  zangao = dog('zangao', 100, 200, '咬人')
  tom = person('tom', 50, 10, '打狗')
  m4a1 = gun('m4-a1', 20, 3, 500)
  tom.money += 1000
  #假想藏獒不攻击人类,只有人类用枪打狗的过程
  # 构造一个循环体,当[zangao]的hp<=0时,退出循环
  # 固定子弹数量
  bullet_full = m4a1.g_zds
  while zangao.hp > 0:
      # 使用gun攻击
      # 判断tom是否还有钱购买枪攻击zangao,如果没有终止循环
      while tom.money >= m4a1.g_price:
          # 购买武器
          tom.person_gun(m4a1)
          # 我们需要重置一下子弹的数量
          m4a1.g_zds = 3
          # 使用武器攻击(hand_w方法自带判断,这里不用加判断了)
          m4a1.hand_w(zangao)
          
  #输出消耗打狗的总子弹数
  print('使用子弹数量为[%d]' % gun.num_bullet)
  

  (这个小例子重点在掌握面向对象的继承，还有定义函数的方法，以及一些逻辑关系，程序里没有实现让狗攻击人，然后人在攻击狗，完全就是单纯的人打狗。至于函数内定义的狗的攻击力，可以作为是为了学习面相对象的继承。一起加油呀！）

• 以下回答来自chatgpt:

  我可以给出一些优化建议和代码示例：

  1. 使用面向对象的思想，封装游戏的相关信息和操作，方便可维护性和扩展性。

  class Sudoku:
      def __init__(self, level):
          # 初始化游戏信息
          self.level = level
          self.size = 6
          self.grid_size = 2
          self.max_time = 60  # 单位秒
          self.gold_reward = 1
          self.silver_reward = 0
          self.bronze_reward = -1
  
          # 生成一个完整的数独
          self.grid = generate_full_sudoku(self.size, self.grid_size)
  
          # 根据难度等级随机隐藏一些数
          cnt = get_hidden_cnt(self.level, self.size)
          self.puzzle = generate_puzzle(self.grid, cnt)
  
      def start_game(self):
          # 开始游戏，计时并记录成绩
          start_time = time.time()
          answer = input('请输入{}x{}数独的解：'.format(self.size, self.size))
          end_time = time.time()
          duration = end_time - start_time
          score, reward = self.calculate_score(duration)
          self.save_game(score, reward)
          return score, reward
  
      def calculate_score(self, duration):
          # 根据完成时间和难度等级计算得分和奖励金币数量
          if duration <= self.max_time * 0.5:
              score = 3
              reward = self.gold_reward
          elif duration <= self.max_time * 0.8:
              score = 2
              reward = self.silver_reward
          elif duration <= self.max_time:
              score = 1
              reward = self.bronze_reward
          else:
              score = 0
              reward = self.bronze_reward
          return score, reward
  
      def save_game(self, score, reward):
          # 记录游戏成绩和奖励
          # 可以使用数据库、文件、网络等方式保存
          pass
  
  def generate_full_sudoku(size, grid_size):
      # 生成一个完整的数独
      pass
  
  def get_hidden_cnt(level, size):
      # 根据难度级别和数独大小计算需要隐藏的数的数量
      pass
  
  def generate_puzzle(grid, cnt):
      # 根据需要隐藏的数的数量随机隐藏一些数
      pass
  

  1. 使用模块化的方法，将不同的功能封装成不同的模块，方便重用和维护。比如可以将登录和游戏记录系统分别封装成两个独立的模块。

  import login
  import game_record
  
  # 用户登录
  user = login.login()
  
  # 开始游戏
  game = Sudoku(level)
  score, reward = game.start_game()
  
  # 记录游戏成绩和奖励
  game_record.save(user, score, reward)
  

  1. 使用异常处理机制，增加程序的健壮性。比如可以处理输入错误、时间超时、保存错误等异常。

  try:
      # 开始游戏
      game = Sudoku(level)
      score, reward = game.start_game()
  except TimeoutError:
      print('时间超时，请重新开始游戏！')
      # 记录游戏成绩和奖励
      game_record.save(user, 0, 0)
  except ValueError:
      print('输入错误，请重新开始游戏！')
      # 记录游戏成绩和奖励
      game_record.save(user, 0, 0)
  except Exception as e:
      print('未知错误：', e)
      # 记录游戏成绩和奖励
      game_record.save(user, 0, 0)
  else:
      print('游戏结束，得分：{}，奖励：{}'.format(score, reward))
      # 记录游戏成绩和奖励
      game_record.save(user, score, reward)
  finally:
      # 释放资源
      login.logout(user)
  

  以上是一些优化建议和代码示例，但是具体的实现还需要根据你目前的代码和需要继续修改。如果具体实现过程中遇到问题，欢迎继续咨询。

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^

Answer 5

可以像下面这样对你的代码进行一些修改，以满足你的要求。这里只给出修改的部分代码，请结合你的完整代码进行修改。

# 添加等级、计时器和得分变量
level = 0
timer = 0
score = 0

# 在主函数中添加参数 level
def main(level):
  # 选择数独中需要填入空格的数量
  if level == 1:
    blanks = 6
    time_limit = 60
    bonus_time = 30 # 完成时间加分的时间阈值
    bonus_coin = 1 # 完成任务得到的金币个数
    penalty = 1 # 超时扣除的金币个数
  elif level == 2:
    blanks = 8
    time_limit = 120
    bonus_time = 60
    bonus_coin = 1
    penalty = 1
  elif level == 3:
    blanks = 10
    time_limit = 180
    bonus_time = 90
    bonus_coin = 1
    penalty = 1
  else:
    print("无效的等级选择")
    return

  # 根据等级和空格数量生成数独谜题
  puzzle = generate_sudoku_puzzle(6, blanks)

  # 开始计时
  start_time = time.time()

  # 输出游戏规则和等级
  print("游戏规则：等级一为填6个空，等级二为填8个空，等级三为填10个空,等级一在1分钟内完成给一个金币，超过一分钟减一个，等级二在两分钟内完成给一个金币，超过两分钟减一个，等级三在三分钟内完成给一个金币，超过三分钟减一个,等级一在30s内完成多给一个金币，等级二60s内完成多给一个金币，等级二90s内完成多给一个金币")
  print("当前等级：", level)

  # 输出数独谜题
  print(puzzle)

  # 填写数独谜题
  filled_puzzle = fill_puzzle(puzzle)

  # 停止计时
  elapsed_time = time.time() - start_time

  # 输出填写的数独和用时
  print(filled_puzzle)
  print("用时：", elapsed_time, "秒")

  # 根据用时和任务完成情况获得得分和金币奖励
  if elapsed_time <= time_limit:
    score = blanks
    if elapsed_time <= bonus_time:
      score += 1
    print("任务完成，得分：", score)
    print("获得金币奖励：", bonus_coin)
  else:
    print("任务失败，扣除金币：", penalty)

# 在游戏开始前让用户选择等级
level = int(input("请选择等级（1-3）："))

# 开始游戏
main(level)

在这个修改后的代码中，我们添加了三个变量 level, timer 和 score 来跟踪游戏等级、计时器和得分。同时，我们在 main 函数之前让用户选择等级，之后将等级作为参数传递给 main 函数。

在 main 函数内部，我们根据不同等级设置不同的任务：空格数量、时间限制、加分时间阈值、得到金币奖励的数量和超时的罚款数量。之后，我们生成新的数独题目并开始计时。根据输出的规则，我们向用户说明了当前的等级。

在数独游戏结束后，我们计算用时并根据任务完成情况判断得分和金币奖励。如果用时小于等于时间限制，并且在加分时间阈值内完成，则可以获得额外的金币奖励。如果用时超过时间限制，则会被扣除金币罚款。

希望这个修改后的代码可以满