两个Python小游戏

废话不说，上代码

import time
import random


class WeGame(object):
    def __init__(self, username, sex, boold_num=2000, money=800, agg=0, pre=0):
        self.username = username
        self.sex = sex
        self.boold_num = boold_num
        self.money = money
        self.agg = agg
        self.pre = pre
        self.room = None
        self.Sword_info = []
        self.Sword()

    # def __new__(cls, *args, **kwargs):
    #     return cls.Come_game(cls)

    # 初始金币
    def Come_game(self):
        print("答题得金币，题号有【1、2、3】")
        _num = input("请输入你想答得题目（谨慎选择！！！）：")
        if _num == '1':
            print("斐波拉契数列的第20位是多少？")
            tmp1 = input("你的答案：")
            if tmp1 == '6765':
                self.money += 600
            else:
                self.money += 0
                print("回答错误，答案是6765")
            print("你的金币为：", self.money)
            return self.Sword()

        elif _num == '2':
            print("英雄联盟中召唤师峡谷的战役中，双方都分有几个位置？")
            tmp2 = input("你的答案：")
            if tmp2 == '5':
                self.money += 600
            else:
                self.money += 0
                print("回答错误，答案是5")
            print("你的金币为：", self.money)
            return self.Sword()

        elif _num == '3':
            print("1+1等于几？")
            tmp3 = input("你的答案：")
            if tmp3 == '2':
                self.money += 600
            else:
                print("你没救了！")
                self.money -= 600
            print("你的金币为：", self.money)
            return self.Sword()

    # 武器装备信息
    def Sword(self):
        print('_' * 50)
        print('*' * 50)
        print("剑铺：2019/1/13剑铺开张！（七剑下天山）\n"
              "武器信息：\n"
              "莫问剑：【功】：100，【守】：100，【价】：1￥\n"
              "游龙剑：【功】：95，【守】：5 ，【价】：75￥\n"
              "青干剑：【功】：70，【守】：20，【价】：60￥\n"
              "竞星剑：【功】：80，【守】：10，【价】：65￥\n"
              "日月剑：【功】：85，【守】：5 ，【价】：55￥\n"
              "舍神剑：【功】：85，【守】：5 ，【价】：50￥\n"
              "天瀑剑：【功】：90，【守】：0 ，【价】：70￥\n")
        print('_' * 50)
        print('*' * 50)

        """
        进入剑铺购买相关的武器，金币足够可以购买多把武器
        按e退出剑铺
        """
        while True:
            print("-"*50)
            print("$_$金币足够可以购买多把武器按e或者exit退出剑铺$_$")
            ret = input("$你$想$购$买$的$武$器$是$：")
            print("-"*50)
            if ret == '莫问剑':
                if self.money >= 1:
                    self.agg += 100
                    self.pre += 100
                    self.money -= 1
                    print(f"背包：攻击力《{self.agg}》|防御力《{self.pre}》|血量《{self.boold_num}》|金币《{self.money}》")
                    self.Sword_info.append(ret)


                else:
                    print("金币不足！！！，可按1进入答题充值")
                    ret2 = input("输入1进入答题，输入exit退出：")
                    if ret2 == '1':
                        self.Come_game()
                    elif ret2 == 'exit' or 'e':
                        exit()


            elif ret == '游龙剑':
                if self.money >= 75:
                    self.agg = 95
                    self.pre = 5
                    self.money -= 75
                    print("背包：攻击力《{}》|防御力《{}》|血量《{}》|金币《{}》".format(self.agg, self.pre, self.boold_num, self.money))
                    self.Sword_info.append(ret)
                else:
                    print("金币不足！！！，可按1进入答题充值")
                    ret2 = input("输入1进入答题，输入exit退出：")
                    if ret2 == '1':
                        self.Come_game()
                    elif ret2 == 'exit' or 'e':
                        print()
                        exit()

            elif ret == '青干剑':
                if self.money >= 60:
                    self.agg += 70
                    self.pre += 20
                    self.money -= 60
                    print(f"背包：攻击力《{self.agg}》|防御力《{self.pre}》|血量《{self.boold_num}》|金币《{self.money}》")
                    self.Sword_info.append(ret)
                else:
                    print("金币不足！！！，可按1进入答题充值")
                    ret2 = input("输入1进入答题，输入exit退出：")
                    if ret2 == '1':
                        self.Come_game()
                    elif ret2 == 'exit':
                        exit()

            elif ret == '竞星剑':
                if self.money >= 65:
                    self.agg += 80
                    self.pre += 10
                    self.money -= 65
                    print(f"背包：攻击力《{self.agg}》|防御力《{self.pre}》|血量《{self.boold_num}》|金币《{self.money}》")
                    self.Sword_info.append(ret)
                else:
                    print("金币不足！！！，可按1进入答题充值")
                    ret2 = input("输入1进入答题，输入exit退出：")
                    if ret2 == '1':
                        self.Come_game()
                    elif ret2 == 'exit':
                        exit()

            elif ret == '日月剑':
                if self.money >= 55:
                    self.agg += 85
                    self.pre += 5
                    self.money -= 55
                    print(f"背包：攻击力《{self.agg}》|防御力《{self.pre}》|血量《{self.boold_num}》|金币《{self.money}》")
                    self.Sword_info.append(ret)
                else:
                    print("金币不足！！！，可按1进入答题充值")
                    ret2 = input("输入1进入答题，输入exit退出：")
                    if ret2 == '1':
                        self.Come_game()
                    elif ret2 == 'exit':
                        exit()

            elif ret == '舍神剑':
                if self.money >= 50:
                    self.agg += 85
                    self.pre += 5
                    self.money -= 50
                    print(f"背包：攻击力《{self.agg}》|防御力《{self.pre}》|血量《{self.boold_num}》|金币《{self.money}》")
                    self.Sword_info.append(ret)
                else:
                    print("金币不足！！！，可按1进入答题充值")
                    ret2 = input("输入1进入答题，输入exit退出：")
                    if ret2 == '1':
                        self.Come_game()
                    elif ret2 == 'exit':
                        exit()

            elif ret == '天瀑剑':
                if self.money >= 70:
                    self.agg = 90
                    self.pre = 5
                    self.money -= 70
                    print(f"背包：攻击力《{self.agg}》|防御力《{self.pre}》|血量《{self.boold_num}》|金币《{self.money}》")
                    self.Sword_info.append(ret)
                else:
                    print("金币不足！！！，可按1进入答题充值")
                    ret2 = input("输入1进入答题，输入exit退出：")
                    if ret2 == '1':
                        self.Come_game()
                    elif ret2 == 'exit':
                        exit()

            elif ret == 'e':
                print("本次购买完毕，退出剑铺！")
                break

            else:
                print("没有这把剑，真j!")
                continue

            all_sword = [i for i in self.Sword_info]
            print("||{}||:你的武器库中有{}把剑：{}".format(self.username, len(self.Sword_info), all_sword))

    # 战斗
    # def Battle(self, obj1):
    def Battle(self, obj):
        if self.room != None and self.room == obj.room:
            obj.boold_num = obj.boold_num - self.agg + obj.pre
            time.sleep(random.randint(1, 2))

            print("++++++++++++++++++++++++++++++++++++++++++++++++++\n")
            print(f"{self.username})-=>{obj.username}|{self.username}血量:{self.boold_num}|{obj.username}血量:{obj.boold_num}\n")
            print("+" * 50)

        else:
            print("两个人不在同一个房间")

class Room(object):
    MAX = 2

    def __init__(self, room_name, ):
        # self.room_id = "0"
        self.room_name = room_name
        self.room_users = {}

        # key => username, value => user_object instance

    # 这里是玩家加入，加入房间后记录相关信息，存入字典中
    def join(self, user_obj):
        self.room_users[user_obj.username] = user_obj
        print(self.room_users)
        user_obj.room = self.room_name

        # 当玩家数达到房间上限时，自动启动游戏开始的方法
        if len(self.room_users) == Room.MAX:
            print("房间已满！")
            self.Game_start()

        # 设置满员后，禁止再有玩家加入
        # 在room_users字典中删除，使得长度为2，可调用游戏开始Game_start的方法
        elif len(self.room_users) == Room.MAX + 1:
            print("房间已满！禁止加入")
            self.room_users.pop(user_obj.username)

    # 游戏开始：
    def Game_start(self):
        user1 = list(self.room_users.values())[0]
        user2 = list(self.room_users.values())[1]


        """进入到游戏开始方法时：可在输入框输入【y或者n】来控制是否开始战斗
        y:开始战斗
        n:退出游戏"""
        ret = input("是否开始战斗？y:开始，n:退出").upper()
        if ret == 'Y':
            while True:
                if user1.boold_num > 0 and user2.boold_num > 0:

                    """设置两人对战随机进攻的机制，
                    导入random模块，
                    随机出现单数和双数来决定是谁来攻击谁"""
                    if random.randint(1, 4) % 2 == 0:
                        user1.Battle(user2)
                        # print(f"{p1.username})->{p2.username}---{p2.username}血量剩余{p2.boold_num}")
                    elif random.randint(1, 4) % 2 == 1:
                        user2.Battle(user1)
                        # print(f"{p1.username})->{p2.username}---{p2.username}血量剩余{p2.boold_num}")

                # 当有一方的血量小于等于0时，则游戏结束
                else:
                    if user1.boold_num <= 0:
                        print(f"{user2.username}赢得范闲！")

                    if user2.boold_num <= 0:
                        print(f"{user1.username}赢得范闲！")
                    break

        elif ret == 'N':
            exit()
        else:
            print("输入有误，重新输入！")
            self.Game_start()


if __name__ == '__main__':
    import random

    p1 = WeGame('林婉儿', 'm')
    room1 = Room("醉仙居")
    room1.join(p1)
    print("所在房间：", p1.room)
    print("&" * 50)

    p2 = WeGame('司理理', 'm')
    room1.join(p2)
    print("所在房间：", p2.room)
    print("&" * 50)
    # p1.attach(p2)
    # p2.attach(p1)


    # print(p1.money)
    # user1 = Role()

双人2048小游戏

import curses
import random
from itertools import chain


class GameField(object):
    def __init__(self, width=4, height=4, win_value=2048):
        self.width = width
        self.height = height
        self.win_value = win_value
        self.score1 = 0
        self.score2 = 0
        self.highscore = 0
        self.moves = {}
        self.moves['Left1'] = self.is_left_move
        self.moves['Right1'] = self.is_right_move
        self.moves['Up1'] = self.is_up_move
        self.moves['Down1'] = self.is_down_move
        self.moves['Left2'] = self.is_left_move
        self.moves['Right2'] = self.is_right_move
        self.moves['Up2'] = self.is_up_move
        self.moves['Down2'] = self.is_down_move
        self.movesDict1 = {}
        self.movesDict2 = {}
        self.movesDict1['Left1'] = self.left_move
        self.movesDict1['Right1'] = self.right_move
        self.movesDict1['Up1'] = self.up_move
        self.movesDict1['Down1'] = self.down_move
        self.movesDict2['Left2'] = self.left_move
        self.movesDict2['Right2'] = self.right_move
        self.movesDict2['Up2'] = self.up_move
        self.movesDict2['Down2'] = self.down_move

    def random_create1(self):
        while True:
            i, j = random.randint(0, self.height - 1), random.randint(0, self.width - 1)
            if self.field1[i][j] == 0:
                self.field1[i][j] = random.choice([2, 2, 2, 4])
                break

    def random_create2(self):
        while True:
            i, j = random.randint(0, self.height - 1), random.randint(0, self.width - 1)
            if self.field2[i][j] == 0:
                self.field2[i][j] = random.choice([2, 2, 2, 4])
                break

    def reset(self):
        self.field1 = [[0 for j in range(self.width)] for i in range(self.height)]
        self.score1 = 0
        self.field2 = [[0 for j in range(self.width)] for i in range(self.height)]
        self.score2 = 0
        self.random_create1()
        self.random_create1()
        self.random_create2()
        self.random_create2()

    def draw(self, stdscr):
        stdscr.clear()
        self.score1 = sum(chain(*self.field1))
        self.score2 = sum(chain(*self.field2))
        if max(self.score1, self.score2) > self.highscore:
            self.highscore = max(self.score1, self.score2)
        stdscr.addstr('最高分：' + str(self.highscore) + ' ')
        stdscr.addstr('玩家1分数：' + str(self.score1) + ' ')
        stdscr.addstr('玩家2分数：' + str(self.score2) + '\n')
        for row in self.field1:
            stdscr.addstr('+' + '-----+' * self.width + '\n')
            stdscr.addstr("".join('|{:^5}'.format(num) if num != 0 else "|     " for num in row) + '|' + '\n')
        stdscr.addstr('+' + '-----+' * self.width + '\n')
        if self.is_win1():
            stdscr.addstr('胜利\n')
        if self.is_gameover1():
            stdscr.addstr('游戏结束\n')
        for row in self.field2:
            stdscr.addstr('+' + '-----+' * self.width + '\n')
            stdscr.addstr("".join('|{:^5}'.format(num) if num != 0 else "|     " for num in row) + '|' + '\n')
        stdscr.addstr('+' + '-----+' * self.width + '\n')
        if self.is_win2():
            stdscr.addstr('胜利\n')
        if self.is_gameover2():
            stdscr.addstr('游戏结束\n')
        stdscr.addstr("玩家1：上下左右键 玩家2：wasd键（R）重置（Q）退出")

    def is_win1(self):
        return max(chain(*self.field1)) >= self.win_value

    def is_win2(self):
        return max(chain(*self.field2)) >= self.win_value

    def is_gameover1(self):
        return not any([self.is_move_possible1(direction) for direction in self.moves])

    def is_gameover2(self):
        return not any([self.is_move_possible2(direction) for direction in self.moves])

    @staticmethod
    def invert(field):
        return [row[::-1] for row in field]

    @staticmethod
    def transpose(field):
        return [list(row) for row in zip(*field)]

    @staticmethod
    def is_row_change(row):
        for i in range(len(row) - 1):
            if row[i] == 0 and row[i + 1] != 0:
                return True
            elif row[i] != 0 and row[i] == row[i + 1]:
                return True
        else:
            return False

    def is_left_move(self, field):
        return any([self.is_row_change(i) for i in field])

    def is_right_move(self, field):
        return any([self.is_row_change(i) for i in self.invert(field)])

    def is_up_move(self, field):
        return any([self.is_row_change(i) for i in self.transpose(field)])

    def is_down_move(self, field):
        return any([self.is_row_change(i) for i in self.invert(self.transpose(field))])

    def is_move_possible1(self, direction):
        if direction in self.moves:
            return self.moves[direction](self.field1)
        else:
            return False

    def is_move_possible2(self, direction):
        if direction in self.moves:
            return self.moves[direction](self.field2)
        else:
            return False

    @staticmethod
    def row_move(row):
        row = sorted(row, key=lambda x: 1 if x == 0 else 0)
        for i in range(len(row) - 1):
            if row[i] == row[i + 1]:
                row[i] *= 2
                row[i + 1] = 0
        return sorted(row, key=lambda x: 1 if x == 0 else 0)

    def left_move(self, field):
        return [self.row_move(i) for i in field]

    def right_move(self, field):
        return self.invert([self.row_move(i) for i in self.invert(field)])

    def up_move(self, field):
        return self.transpose([self.row_move(i) for i in self.transpose(field)])

    def down_move(self, field):
        return self.transpose(self.invert([self.row_move(i) for i in self.invert(self.transpose(field))]))

    def move1(self, direction):
        if direction in self.movesDict1 and self.is_move_possible1(direction):
            self.field1 = self.movesDict1[direction](self.field1)
            self.random_create1()
            return True
        else:
            return False

    def move2(self, direction):
        if direction in self.movesDict2 and self.is_move_possible2(direction):
            self.field2 = self.movesDict2[direction](self.field2)
            self.random_create2()
            return True
        else:
            return False


def get_user_action(stdscr):
    action = stdscr.getch()
    if action == curses.KEY_UP:
        return 'Up1'
    elif action == curses.KEY_DOWN:
        return 'Down1'
    elif action == curses.KEY_LEFT:
        return 'Left1'
    elif action == curses.KEY_RIGHT:
        return 'Right1'
    elif action == ord('r'):
        return 'Restart'
    elif action == ord('q'):
        return 'Exit'
    elif action == ord('w'):
        return 'Up2'
    elif action == ord('s'):
        return 'Down2'
    elif action == ord('a'):
        return 'Left2'
    elif action == ord('d'):
        return 'Right2'


def main(stdscr):
    def init():
        game_field.reset()
        game_field.draw(stdscr)
        return 'Game'

    def game():
        game_field.draw(stdscr)
        action = get_user_action(stdscr)
        if action == 'Restart':
            return 'Init'
        if action == 'Exit':
            return 'Exit'
        if action in ('Up1', 'Down1', 'Left1', 'Right1'):
            if game_field.move1(action):
                if game_field.is_win1():
                    return 'Win'
                if game_field.is_gameover1():
                    return 'GameOver'
        if action in ('Up2', 'Down2', 'Left2', 'Right2'):
            if game_field.move2(action):
                if game_field.is_win2():
                    return 'Win'
                if game_field.is_gameover2():
                    return 'GameOver'
        return 'Game'

    def not_game():
        game_field.draw(stdscr)
        while True:
            action = get_user_action(stdscr)
            if action == 'Restart':
                return 'Init'
            if action == 'Exit':
                return 'Exit'

    game_field = GameField()
    state = 'Init'
    state_actions = {
        'Init': init,
        'Game': game,
        'Win': not_game,
        'GameOver': not_game
    }
    while state != 'Exit':
        state = state_actions[state]()


curses.wrapper(main)