Python写大富翁代码（两份，共8个不同技能，适合课程设计）

第一份 

import random


# 玩家类
class Player:
    def __init__(self, name):
        self.name = name
        self.money = 6000
        self.position = 0
        self.properties = []
        self.in_jail = False
        self.skill = None
        self.skill_counter = 0
        self.skill_used = False
        self.can_skip_rent=False

    def set_skill(self, skill):
        self.skill = skill

    def use_skill(self):
        used=False
        if   self.skill_counter == 0:
            choice = input("技能可以使用，请问你是否选择使用技能？（y/n）")
            if choice.lower() == 'y':
                used=True
        if used and self.skill==1:
            self.skill_one()
            self.skill_counter = 1
            # self.skill_used = True
        elif used and self.skill==2:
            self.skill_two()
            self.skill_counter = 2
        elif used and self.skill==3:
            self.skill_three()
            self.skill_counter = 1
        elif used and self.skill==4:
            self.skill_four()
            self.skill_counter = 1
        else:
            if self.skill_counter==0:
                print("不使用技能，技能不进入冷却")
            else:
                print(f"{self.name}技能还在冷却中，剩余冷却回合：{self.skill_counter}。")
                self.skill_counter -= 1

    def move(self, steps):
        self.position = (self.position + steps) % len(current_map)
        print(f"{self.name}移动到了位置 {self.position}。")

    def buy_property(self, property):
        if self.money >= property.price:
            self.money -= property.price
            self.properties.append(property)
            property.owner = self #将地产对象的所有者设置为该玩家对象
            print(f"{self.name}购买了 {property.name}。")
        else:
            print(f"{self.name}资金不足，无法购买 {property.name}。")

    def upgrade_property(self, property):
        if self.money >= property.upgrade_cost and property.level < len(property.rent_multiplier):
            self.money -= property.upgrade_cost
            property.level += 1
            property.rent *= property.rent_multiplier[property.level - 1]
            print(f"{self.name}升级了 {property.name}，新租金为 {property.rent}。")
        else:
            print(f"{self.name}资金不足或无法升级 {property.name}。")

    def skill_one(self):
        print(f"{self.name}发动技能一：获得200-1000范围内的钱。")
        money=random.randint(200,1000)
        player.money += money
        print(f"发动技能获得{money}元")

    def skill_two(self):
        global sign_three
        sign_three=True
        print(f"{self.name}发动技能二：移动指定步数。")
        step=eval(input("请输入你要移动的步数"))
        player.move(step)


    def skill_three(self):
        print(f"{self.name}发动技能三：走到别人领地免租金。")
        player.can_skip_rent = True


    def skill_four(self):
        global sign_four
        sign_four=True
        global players
        name_sign=self.name
        print(f"{self.name}发动技能四：摇到1,2,3你给所有玩家200，摇到4,5,6所有玩家给你300。")
        input("按回车键开始掷骰子")
        steps = random.randint(1, 6)
        print(f"你摇到数字{steps}")
        if steps==1 or steps==2 or steps==3:
            for people in players:
                if name_sign==people.name:
                    people.money-=200*(len(players)-1)
                else:
                    people.money+=200
        if steps==4 or steps==5 or steps==6:
            for people in players:
                if name_sign==people.name:
                    people.money+=300*(len(players)-1)
                else:
                    people.money-=300
        player.move(steps)






# 地产类
class Property:
    def __init__(self, name, price, rent):
        self.name = name
        self.price = price
        self.rent = rent
        self.owner = None
        self.level = 1
        self.upgrade_cost = 300
        self.rent_multiplier = [1, 1.5, 2]
        self.mortgaged = False   #是否被抵押

    def is_mortgaged(self):
        return self.mortgaged

    def mortgage(self):
        if not self.mortgaged:
            self.mortgaged = True
            return self.price // 2
        else:
            print("该地产已被抵押。")
            return 0

    def unmortgage(self, player):
        if self.mortgaged:
            if player.money >= self.price // 2:
                player.money -= self.price // 2
                self.mortgaged = False
                print(f"{player.name}解除了 {self.name}的抵押。")
            else:
                print(f"{player.name}资金不足，无法解除抵押。")


class SpecialProperty(Property):
    def __init__(self, name, price, rent, x):
        super().__init__(name, price, rent)
        x = str(random.randint(1, 2))
        self.special_effect = x

    def trigger_effect(self, player):
        if self.special_effect == "1":
            player.properties = [p for p in player.properties if isinstance(p, Property)]
            for prop in player.properties:
                prop.rent *= 2
        elif self.special_effect == "2":
            player.can_skip_rent = True


# 命运事件类
class FateEvent:
    def trigger(self):
        global players
        for player in players:
            player.money += 200
        print("命运事件触发，所有玩家获得 200 元。")


# 神秘事件类
class MysteryEvent:
    def trigger(self):
        global players
        chosen_player = random.choice(players)
        chosen_player.money += 200
        print(f"神秘事件触发，所有玩家向随机玩家 {chosen_player.name} 支付 200 元。")

    def trigger_extra_dice(self):
        print("神秘事件触发，玩家可多掷一次骰子。")


# 初始化不同的地图
map1 = [Property("韩国 ", 1000, 500), Property("日本", 1400, 600), Property("特殊事件1", 0, 0),
        Property("埃及", 2000, 700), Property("加拿大", 1600, 650), Property("监狱", 0, 0),
        FateEvent(), Property("美国", 2200, 650), Property("墨西哥", 2200, 600),
        Property("巴西", 3200, 700), Property("阿根廷", 1600, 650), MysteryEvent(),
        Property("澳大利亚", 2000, 700), Property("新西兰", 1600, 650), Property("监狱", 0, 0),
        Property("西班牙", 2000, 700), Property("法国", 1600, 650), FateEvent(),
        Property("德国", 2000, 700), Property("希腊", 1600, 650), Property("特殊事件1", 0, 0),
        Property("英国", 2000, 700), Property("乌克兰", 1600, 650), Property("瑞士", 1600, 600),
        Property("意大利", 2000, 700),MysteryEvent(), Property("俄罗斯", 1600, 600),
        Property("中国",600,300),SpecialProperty("神秘之地", 1000, 0, "1")]
map2 = [Property("豪华地产 1", 800, 80), Property("豪华地产 2", 900, 90), FateEvent(),
        Property("超级地产 1", 1000, 100), Property("超级地产 2", 1200, 120), Property("监狱", 0, 0),
        SpecialProperty("幸运之地", 1200, 0, "免租金一回合"), MysteryEvent()]

# 全局变量用于存储当前地图
current_map = None


# 函数用于选择地图
def select_map():
    print("请选择地图：")
    print("1. 地图 1")
    print("2. 地图 2")
    choice = int(input())
    global current_map
    if choice == 1:
        current_map = map1
    else:
        current_map = map2


# 函数用于创建玩家并选择角色
def create_players():
    print("以下是可选角色：")
    print("1. 角色一：获得200-1000范围内的钱，每隔一回合使用一次。")
    print("2. 角色二：移动指定步数，每隔二回合使用一次")
    print("3. 角色三：走到别人领地免租金，每隔一回合使用一次。")
    print("4. 角色四：摇到1,2,3你给所有玩家200，摇到4,5,6所有玩家给你300。")
    num_players = int(input("请输入玩家数量："))
    global players
    players = []

    for i in range(num_players):
        name = input(f"请输入玩家 {i + 1} 的名字：")
        role_choice = int(input(f"玩家 {name} 请选择角色（1/2/3/4）："))
        player = Player(name)
        players.append(player)
        if role_choice == 1:
            player.set_skill(1)
        elif role_choice == 2:
            player.set_skill(2)
        elif role_choice == 3:
            player.set_skill(3)
        elif role_choice == 4:
            player.set_skill(4)
        # players.append(player)

def move():
    steps = random.randint(1, 6)
    print(f"你摇到数字{steps}")
    player.move(steps)
def judge_property():
    current_property = current_map[player.position]
    if isinstance(current_property, FateEvent):
        current_property.trigger()
    elif isinstance(current_property, MysteryEvent):
        choice = input("神秘事件触发，选择是否多掷一次骰子？（y/n）")
        if choice.lower() == 'y':
            current_property.trigger_extra_dice()
            move()
            judge_property()
    elif current_property.name == "监狱":
        player.in_jail = True
        print(f"{player.name}进入监狱，下回合暂停。")
    elif current_property.name == "特殊事件1":
        print("恭喜你来到了特殊事件1获得500元")
        player.money += 500
    elif current_property.owner is None:
        if current_property.name != "特殊事件1":
            choice = input(f"你来到了 {current_property.name}，租金为{current_property.price}无人拥有，是否购买？（y/n）")
        if choice.lower() == 'y':
            player.buy_property(current_property)
    elif current_property.owner != player:
        if player.can_skip_rent:
            print(f"{player.name}使用技能，免租金。")
            player.can_skip_rent = False
        else:
            player.money -= current_property.rent
            current_property.owner.money += current_property.rent
            print(f"{player.name}向 {current_property.owner.name}支付了 {current_property.rent} 元租金。")
    elif current_property.owner == player:
        choice = input(f"你拥有 {current_property.name}，当前租金为 {current_property.rent}。是否升级？（y/n）")
        if choice.lower() == 'y':
            player.upgrade_property(current_property)
        choice = input(f"是否抵押？（y/n）")
        if choice.lower() == 'y':
            mortgage_money = current_property.mortgage()
            player.money += mortgage_money
            print(f"{player.name}抵押了 {current_property.name}，获得 {mortgage_money} 元。")

def player_turn(player):
    if player.in_jail:
        print(f"{player.name}在监狱中，暂停一回合。")
        player.in_jail = False
        return
    print(f"\n{player.name}的回合。")
    global sign_three
    sign_three=False
    global sign_four
    sign_four=False
    player.use_skill()
    if sign_three==True:
        pass
    elif sign_four==True:
        pass
    else:
        input("按回车键开始掷骰子")
        move()
    judge_property()
    global players
    for people in players:
        print(f"\n{people.name}当前资金：{people.money}元。")
        print(f"{people.name}当前位置为{people.position}")
        properties=list(people.properties)
        print(f"{people.name}拥有的财产为：",end="")
        if len(properties)==0:
            print("无",end="")
        else:
            for field in properties:
                print(f"{field.name}",end=" ")
    print()



def check_game_over():
    active_players = [p for p in players if p.money < 0]
    if len(active_players)>0:
        for player_dead in active_players:
            print(f"{player_dead.name}已经破产,出局 ")
    active_players_alive = [p for p in players if p.money > 0]
    if len(active_players_alive) == 1:
        print(f"游戏结束，获胜者是 {active_players[0].name}！")
        return True
    return False


# 游戏主流程
select_map()
create_players()
while True:
    for player in players:
        if player.money > 0:
            player_turn(player)
    if check_game_over():
        break

第二份

import random

# 玩家类，定义玩家的相关属性
class Player:
    def __init__(self, name):
        self.name = name
        self.money = 7000
        self.position = 0
        self.properties = []
        self.in_jail = False
        self.skill = None
        self.skill_counter = 0
        self.skill_used = False
        self.can_skip_rent=False

    def set_skill(self, skill):
        self.skill = skill

    def use_skill(self):
        used=False
        if   self.skill_counter == 0:
            choice = input("技能可以使用，请问你是否选择使用技能？（y/n）")
            if choice.lower() == 'y':
                used=True
        if used and self.skill==1:
            self.skill_one()
            self.skill_counter = 1
            # self.skill_used = True
        elif used and self.skill==2:
            self.skill_two()
            self.skill_counter = 2
        elif used and self.skill==3:
            self.skill_three()
            self.skill_counter = 1
        elif used and self.skill==4:
            self.skill_four()
            self.skill_counter = 1
        else:
            if self.skill_counter==0:
                print("不使用技能，技能不进入冷却")
            else:
                print(f"{self.name}技能还在冷却中，剩余冷却回合：{self.skill_counter}。")
                self.skill_counter -= 1

    def move(self, steps):
        self.position = (self.position + steps) % len(current_map)
        print(f"{self.name}移动到了位置 {self.position}。")

    def buy_property(self, property):
        if self.money >= property.price:
            self.money -= property.price
            self.properties.append(property)
            property.owner = self #将地产对象的所有者设置为该玩家对象
            print(f"{self.name}购买了 {property.name}。")
        else:
            print(f"{self.name}资金不足，无法购买 {property.name}。")

    def upgrade_property(self, property):
        global sign_lucky
        if self.money >= property.upgrade_cost and property.level < len(property.rent_multiplier):
            self.money -= property.upgrade_cost
            property.level += 1
            property.rent *= property.rent_multiplier[property.level - 1]
            print(f"{self.name}升级了 {property.name}，新租金为 {property.rent}。")
        elif sign_lucky==True:
            print("你的技能发动成功，免费升级一次")
            property.level += 1
            property.rent *= property.rent_multiplier[property.level - 1]
            print(f"{self.name}升级了 {property.name}，新租金为 {property.rent}。")
            if not property.level < len(property.rent_multiplier):
                self.money+=500
                print("你的房子已经满级，已经给你500元")
        else:
            print(f"{self.name}资金不足或无法升级 {property.name}。")

    def skill_one(self):
        print(f"{self.name}发动技能：空间传送：摇到5或者6可以进行空间跳跃，即可以直接传送到地图的任意位置。")
        number = random.randint(1, 6)
        print(f"你摇的数字是{number}")
        if number==5 or number==6:
            print("判断成功。可以进行空间跳跃")
            select_position = eval(input("请输入你想要到达的位置"))
            self.position = select_position
            print(f"{self.name}移动到了位置 {self.position}。")
            global sign_transfer
            sign_transfer = True
        else:
            print("判断失败")


    def skill_two(self):
        global sign_two
        sign_two=True
        print(f"{self.name}发动技能：幸运抽奖：花200元进行抽奖，摇到4,5,6可以免罚监狱或者免去租金，不是判定")
        input("按回车键开始掷骰子")
        steps=5
        player.move(steps)
        print(f"你摇到数字{steps}")
        if steps==5 or steps==6 or steps==4:
            global is_in_jail
            is_in_jail=True
            player.can_skip_rent = True
        else:
            print("谢谢惠顾，你没有中奖哦")



    def skill_three(self):
        global sign_lucky
        sign_lucky= True
        print(f"{self.name}发动技能三：好运连连：走到自己的地产上时，摇骰子判定，数字为5,6时，升级免费，若房子已经满级，获得500元")



    def skill_four(self):
        global sign_four
        sign_four=True
        global players
        name_sign=self.name
        print(f"{self.name}发动技能四：双摇惊喜：多摇一次骰子，如果两次之和相加10(不包含)以上每位玩家给你500元。。")
        input("按回车键开始掷骰子")
        number_1 = random.randint(1, 6)
        print(f"你摇到数字{number_1}")
        input("按回车键开始掷骰子")
        number_2 = random.randint(1, 6)
        print(f"你摇到数字{number_2}")
        steps=number_1+number_2
        if number_1+number_2>10:
            for people in players:
                if name_sign==people.name:
                    people.money+=500*(len(players)-1)
                else:
                    people.money-=200
        else:
            player.move(steps)




# 地产类，定义关于每一个土地的相关属性
class Property:
    def __init__(self, name, price, rent):
        self.name = name
        self.price = price
        self.rent = rent
        self.owner = None
        self.level = 1
        self.upgrade_cost = 300
        self.rent_multiplier = [1, 1.5, 2]
        self.mortgaged = False   #是否被抵押

    def is_mortgaged(self):
        return self.mortgaged

    def mortgage(self):
        if not self.mortgaged:
            self.mortgaged = True
            return self.price // 2
        else:
            print("该地产已被抵押。")
            return 0

    def unmortgage(self, player):
        if self.mortgaged:
            if player.money >= self.price // 2:
                player.money -= self.price // 2
                self.mortgaged = False
                print(f"{player.name}解除了 {self.name}的抵押。")
            else:
                print(f"{player.name}资金不足，无法解除抵押。")

#黄金地带
class Golden_Property(Property):
    def __init__(self, name, price, rent, x):
        super().__init__(name, price, rent)
        x = str(random.randint(1, 2))
        self.special_effect = x

    def trigger_effect(self, player):
        if self.special_effect == "1":
            player.properties = [p for p in player.properties if isinstance(p, Property)]
            for prop in player.properties:
                prop.rent *= 2
        elif self.special_effect == "2":
            player.can_skip_rent = True


# 命运事件类
class FateEvent:
    def trigger(self):
        global players
        for player in players:
            player.money += 300
        print("命运事件触发，所有玩家获得 300 元。")


# 神秘事件类
class MysteryEvent:
    def trigger_extra_dice(self):
        print("神秘事件触发，玩家可多掷一次骰子。")




class MysteryEvent_second:
    def trigger(self):
        global players
        chosen_player = random.choice(players)
        chosen_player.money += 200
        print(f"神秘事件触发，所有玩家向随机玩家 {chosen_player.name} 支付 200 元。")


# 初始化不同的地图
map1 = [Property("河北 ", 1000, 500), Property("山西", 1200, 600), Property("天降财运", 0, 0),
        Property("吉林", 1100, 550), Property("辽宁", 1000, 500), Property("监狱", 0, 0),
        FateEvent(), Property("江苏", 1200, 600), Property("浙江", 900, 500),
        Property("安徽",1000, 500), Property("福建", 1200, 600), MysteryEvent(),
        Property("江西", 1300, 700), Property("山东", 1100, 550), Property("监狱", 0, 0),
        Property("河南", 1300, 700), Property("湖北", 1200, 650), FateEvent(),
        Property("湖南", 1100, 550), Property("广东", 1200, 600), Property("天降财运", 0, 0),
        Property("海南", 1300, 700), Property("四川", 1200, 600), Property("贵州", 1250, 600),
        Property("云南", 1300, 700),MysteryEvent_second(), Property("陕西", 1100, 550),
        Property("甘肃",900,500),Golden_Property("黄金地带", 1400, 600, "1")]
map2 = [Property("中国", 1300, 800), Property("美国", 1200, 600), FateEvent(),
        Property("俄罗斯", 1000, 500), Property("加拿大", 1100, 550), Property("监狱", 0, 0),
        Golden_Property("黄金地带", 1400, 400, "1"), MysteryEvent(),Property("英国", 1300, 700),
        Property("法国", 1250, 650), Property("德国", 1100, 550),Property("意大利", 1300, 700),
        Property("日本", 900, 400), FateEvent(),Property("韩国", 1100, 550), Property("澳大利亚", 1200, 600),
        Property("新西兰", 1100, 550),Property("巴西", 1200, 600), Property("阿根廷", 1100, 550), FateEvent(),
        Property("墨西哥", 1300, 700), Property("南非", 1000, 500),Property("埃及", 1200, 650)]

# 全局变量用于存储当前地图
current_map = None


# 函数用于选择地图
def select_map():
    print("欢迎使用大富翁游戏")
    print("请选择你想要的地图地图：")
    print("~"*40)
    print("1. 地图 1")
    print("2. 地图 2")
    choice = int(input())
    global current_map
    if choice == 1:
        current_map = map1
    else:
        current_map = map2
    print("~" * 40)



# 函数用于创建玩家并选择角色
def create_players():
    print("以下是可选角色，以下角色技能都隔一回合使用一次，不使用不计入冷却：")
    print("1. 小红：空间传送：摇到5或者6可以进行空间跳跃，即可以直接传送到地图的任意位置。")
    print("2. 小芽：幸运抽奖：花200元进行抽奖，摇到4,5,6可以免罚监狱或者免去租金")
    print("3. 小音：好运连连：走到自己的地产上时，摇骰子判定，数字为5,6时，升级免费，若房子已经满级，获得500元")
    print("4. 小涂：双摇惊喜：多摇一次骰子，如果两次之和相加10(不包含)以上每位玩家给你500元。")
    num_players = int(input("请输入玩家数量："))
    global players
    players = []

    for i in range(num_players):
        name = input(f"请输入玩家 {i + 1} 的名字：")
        role_choice = int(input(f"玩家 {name} 请选择角色（1-2-3-4）："))
        player = Player(name)
        players.append(player)
        if role_choice == 1:
            player.set_skill(1)
        elif role_choice == 2:
            player.set_skill(2)
        elif role_choice == 3:
            player.set_skill(3)
        elif role_choice == 4:
            player.set_skill(4)


#一般进程的角色移动
def move():
    steps = random.randint(1, 6)
    print(f"你摇到数字{steps}")
    player.move(steps)
#到达位置后进行判断


def judge_property():
    current_property = current_map[player.position]
    if isinstance(current_property, FateEvent):
        current_property.trigger()
    elif isinstance(current_property, MysteryEvent):
        choice = input("神秘事件触发，你可以选择是否多丢一次骰子？（y/n）")
        if choice.lower() == 'y':
            current_property.trigger_extra_dice()
            move()
            judge_property()
    elif current_property.name == "监狱":
        if is_in_jail==True:
            player.in_jail=False
            print("发动技能，免监狱或免租金")
        else:
            player.in_jail = True
            print(f"{player.name}进入监狱，下回合暂停。")
    elif current_property.name == "天降财运":
        print("你今天天降财运，获得500元")
        player.money += 500
    elif current_property.owner is None:
        if current_property.name != "天降财运":
            choice = input(f"你来到了 {current_property.name}，租金为{current_property.price}无人拥有，是否购买？（y/n）")
        if choice.lower() == 'y':
            player.buy_property(current_property)
    elif current_property.owner != player:
        if player.can_skip_rent:
            print(f"{player.name}使用技能，免监狱或免租金。")
            player.can_skip_rent = False
        else:
            player.money -= current_property.rent
            current_property.owner.money += current_property.rent
            print(f"{player.name}向 {current_property.owner.name}支付了 {current_property.rent} 元租金。")
    elif current_property.owner == player:
        choice = input(f"你拥有 {current_property.name}，当前租金为 {current_property.rent}。是否升级？（y/n）")
        if choice.lower() == 'y':
            player.upgrade_property(current_property)
        choice = input(f"是否抵押？（y/n）")
        if choice.lower() == 'y':
            mortgage_money = current_property.mortgage()
            player.money += mortgage_money
            print(f"{player.name}抵押了 {current_property.name}，获得 {mortgage_money} 元。")

#每一回合最开始的判断
def player_turn(player):
    global sign_lucky
    sign_lucky = False
    global is_in_jail
    is_in_jail = False
    global sign_four
    sign_four=False
    if player.in_jail:
        print(f"{player.name}在监狱中，暂停一回合。")
        player.in_jail = False
        return
    print(f"\n{player.name}的回合。")
    global sign_transfer
    sign_transfer=False
    global sign_two
    sign_two = False
    player.use_skill()
    if sign_transfer==True:
        pass
    elif sign_two==True:
        pass
    elif sign_four==True:
        pass
    else:
        input("按回车键开始掷骰子")
        move()
    judge_property()
    print("~" * 40)
    global players
    for people in players:
        print(f"\n{people.name}当前资金：{people.money}元。")
        print(f"{people.name}当前位置为{people.position}")
        properties=list(people.properties)
        print(f"{people.name}拥有的财产为：",end="")
        if len(properties)==0:
            print("无",end="")
        else:
            for field in properties:
                print(f"{field.name}",end=" ")
    print()
    print("~"*40)


#检查是否有玩家破产，是否游戏结束
def check_game_over():
    active_players = [p for p in players if p.money < 0]
    if len(active_players)>0:
        for player_dead in active_players:
            print(f"{player_dead.name}已经破产,出局 ")
    active_players_alive = [p for p in players if p.money > 0]
    if len(active_players_alive) == 1:
        print(f"游戏结束，获胜者是 {active_players[0].name}！")
        return True
    return False


# 游戏进程，这里是代码运行的地方
select_map()
create_players()
while True:
    for player in players:
        if player.money > 0:
            player_turn(player)
    if check_game_over():
        break