from abc import ABC, abstractmethod
from random import randint
from itertools import cycle
from functools import total_ordering


class DiceGame:
    def set(self, dealer, *users):
        self._dealer, self._users = dealer, users
        return self

    def run(self):
        assert self._dealer and self._users, 'set a dealer and users before running a game'
        print()
        self._dealer.join()
        for user in cycle(self._users):
            if not user.bankrupt():
                user.join()
                self._play(self._dealer, user)
                user.leave()
                print()

            if sum(user.bankrupt() for user in self._users) >= 2:
                return self._finish()

    def _play(self, dealer, user):
        bet = user.bet()
        dr, ur = dealer.roll(), user.roll()

        if  ur >= dr:
            user.calc(bet, ur.dbl and not dr.dbl)
        else:
            user.calc(-bet, dr.dbl and not ur.dbl)

    def _finish(self):
        winner = max(self._users, key=lambda user: user.money)
        print('winner:', winner.name, winner.money)


@total_ordering
class DiceRoll:
    def __init__(self):
        self._d1, self._d2 = randint(1, 6), randint(1, 6)

    @property
    def d1(self):
        return self._d1

    @property
    def d2(self):
        return self._d2

    @property
    def sum(self):
        return self._d1 + self._d2

    @property
    def dbl(self):
        return self._d1 == self._d2

    def __eq__(self, other):
        return self.sum == other.sum and self.dbl == other.dbl

    def __lt__(self, other):
        return self.sum + self.dbl * 10 < other.sum + self.dbl * 10


class Player(ABC):
    def __init__(self, name=None):
        self._name = name if name else self.__class__.__name__

    @property
    def name(self):
        return self._name # readonly

    def join(self):
        print(self._name, 'joined the game')

    def roll(self):
        roll = DiceRoll()
        print('{} rolls dices: {}, {} {}'.format(self._name, roll.d1, roll.d2, 'double!' if roll.dbl else ''))
        return roll

    @abstractmethod
    def calc(self, bet=0, dbl=False):
        "specify player's action at the end of turn"
        pass

    def leave(self):
        print(self._name, 'leaves the game')


class Dealer(Player):
    def calc(self, bet=0, dbl=False):
        pass


class User(Player):
    SEEDMAX = 100000
    BETMAX = 10000

    def __init__(self, name=None):
        super().__init__(name)
        self._money = self._seed()

    @property
    def money(self):
        return self._money # readonly

    def _seed(self):
        s = int(input(self.name +f"''s seed(1~{self.SEEDMAX}): "))
        return s if 1 <= s <= self.SEEDMAX else self._seed()

    def join(self):
        assert not self.bankrupt(), 'bankrupted user cannot join a game'
        print('{} joined the game, money={}'.format(self.name, self._money))

    def bet(self):
        maxbet = min(self._money, self.BETMAX)
        b = int(input('{} bet(1~{}):'.format(self.name, maxbet)))
        return b if 1 <= b <= maxbet else self.bet()

    def calc(self, bet=0, dbl=False):
        diff = bet * (1 + dbl)
        fmt = '{} win, {}+{}={}' if diff >= 0 else '{} lose, {}{}={}'
        print(fmt.format(self.name, self._money, diff, self._money + diff))
        self._money += diff
        if self._money <= 0:
            print(self.name, 'bankrupted')

    def bankrupt(self):
        return self._money <= 0


Player.register(Dealer)
Player.register(User)
DiceGame().set(Dealer(), User('User1'), User('User2'), User('User3')).run()

.

조금 다르게:

from random import randint

SEEDMAX = 100000
BETMAX = 10000


def seed(name):
    s = int(input(f"{name} seed(1~{SEEDMAX}): "))
    return s if 1<=s<=SEEDMAX else seed(name)


def bet(usr):
    lmt = min(usr['money'], BETMAX)
    b = int(input(f"{usr['name']} bet(1~{lmt}): "))
    return b if 1<=b<=lmt else bet(usr)


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


def dbl(d):
    return d[0] == d[1]


def score(d):
    return d[0] + d[1] + dbl(d) * 10


def play(usr, bet):
    rd, ru = roll(), roll()
    if score(ru) >= score(rd):
        winner, loser = (usr['name'], ru), ('dealer', rd)
    else:
        winner, loser = ('dealer', rd), (usr['name'], ru)

    return calc(usr, bet, winner, loser)


def calc(usr, bet, winner, loser):
    doubled = dbl(winner[1]) and not dbl(loser[1])
    stake =  bet * (1 + doubled)
    if usr['name'] in winner:
        usr['money'] += stake
    else:
        usr['money'] -= stake

    print("{}{} win{}, {}{} lose, {}'s money={}".format(*winner, '(x2)'*doubled, *loser, *usr.values()))
    return usr['money'] > 0


usrs = [{'name':n, 'money':seed(n)} for n in ('User1', 'User2', 'User3')]
while len(usrs) > 1:
    usr = usrs.pop(0)
    usrs += [usr] if play(usr, bet(usr)) else []
    print()

last_usr = max(usrs, key=lambda u: u['money'])
print('Finally {} win, money={}'.format(*last_usr.values()))

#----------------------------------------------
import random as r
pm=False
def dice_bettle(p1,p2) :
    global pm
    pm=False
    p1_int=''.join(p1); p2_int=''.join(p2)
    if int(p1_int)%11==0 :
        p1_int=int(p1_int)+100
        pm=not(pm)
    else:p1_int=eval("+".join(p1))
    if int(p2_int)%11==0 :
        p2_int=int(p2_int)+100
        pm=not(pm)
    else:p2_int=eval("+".join(p2))
    if p1_int>=p2_int : return True
    else: return False
#-----------------------------------------------
def dice():return str(r.randint(1,6))
#-----------------------------------------------
a,b,c=map(int,input("3명의 소지금을 각각 입력하시오.").split())
player_list=[a,b,c]
break_=True
while break_:
    for i in range(3):
        double=1
        user=[dice(),dice()];dealer=[dice(),dice()]
        if not(dice_bettle(user,dealer)):
            double*=-1
        if pm:double*=2
        betting=int(input("betting! :")) if player_list[i]>0 else 0
        while betting>100000 or betting<0 or betting>player_list[i]:
            betting=int(input("betting! :")) if player_list[i]>0 else 0
        player_list[i]+=(double*betting)
        print(user,dealer)
        print(player_list)

        for j in range(3):
            for k in range(j):
                if player_list[j]<=0 and player_list[k]<=0:
                    print("player가 일정이상 파산했습니다 게임을종료합니다.")
                    break_=False
                    break
                if not(break_):break
            if not(break_):break

이태리에서 스파게티집열면 잘팔릴거같네요;;; 가독성;;;

n중루프문 한번에탈출하는방법있나요? cpp처럼 goto 문쓰고싶다 ㅋ;

import java.util.Random;
import java.util.Scanner;


public class DiceGambling {

    static int user_m[] = {100000, 100000, 100000};

    public static void main(String[] args) {

        while(true)
        {
            Batting();

            if(user_m[0] <= 0 || user_m[1] <= 0 || user_m[2] <= 0)
                break;
        }


        for(int i=0 ; i<3 ; i++)
            System.out.println(user_m[i]);

    }

    public static void Batting()
    {
        Scanner sc = new Scanner(System.in);
        int bat_m;

        for(int i=0 ; i<3 ; i++)
        {
            while(true)
            {
                System.out.print("배팅액 (1~10000) : ");
                bat_m = sc.nextInt();

                if(bat_m > 0 && bat_m < 10000 && bat_m < user_m[i])
                    break;

                System.out.println("배팅액이 잘못되었습니다. 다시입력해주십시오.");
            }


            user_m[i] += Gambling(bat_m);

            if(user_m[i] == 0)
                break;

            System.out.println((i+1) + "번째 유저 잔액 : " + user_m[i]);

        }
    }

    public static int RandomDice()
    {
        Random r = new Random();

        int dice1, dice2, sum;

        dice1 = r.nextInt(6)+1;
        dice2 = r.nextInt(6)+1;

        if(dice1 == dice2)
            sum = dice1 + 11;
        else 
            sum = dice1 + dice2;

        return sum;
    }

    public static int Gambling(int bat)
    {
        int d1 = RandomDice();
        int d2 = RandomDice();

        System.out.println(d1 + " , " + d2);

        if(d1 > 11 || d2 > 11 && d1 != d2) 
            bat *= 2;

        if(d1 < d2)
            return bat;
        else
            return -bat;

    }

}

코딩 초보라 많이 허접한듯 ㅠ 무한루프가 두개나.. 자바 고수님들 코드좀 올려주세요 ~~

import java.util.Random;
import java.util.Scanner;

public class RollingDiceGame {
    private Random inputR = new Random();
    private Scanner inputS = new Scanner(System.in);
    private int[][] playData = { { 0, 0, 0 }, { 1, 1, 0 }, { 2, 2, 0 }, { 3, 3, 0 } };
    private boolean gameswitch = true;

    public RollingDiceGame() {
        while (true) {
            System.out.print("게임을 하시겠습니까?\n1.예      2.아니오\n=>");
            switch (inputS.nextInt()) {
            case 1:
                mainstart();
                break;
            case 2:
                System.out.println("안녕히 가세요.");
                return;
            default:
                System.out.println("제대로 입력하시오");
            }
        }
    }

    private void mainstart() {
        System.out.println("\n유저3명의 시작금액을 입력하세요");
        for (int i = 1; i < playData.length; i++) {
            System.out.printf("유저 %d :", i);
            playData[i][1] = inputS.nextInt();
            if (playData[i][1] > 100000 || playData[i][1] < 1) {
                System.out.println("자본금은 10만원 이내에서 양수만 입력 가능합니다.");
                i--;
            }
        }
        gameStart();
    }

    private void gameStart() {
        System.out.println("게임을 시작하겠습니다.");
        while (gameswitch) {
            UserCheck();
            System.out.println("1.현재 금액 보기");
            System.out.println("2.계속 게임하기");
            System.out.println("3.게임 종료하기");
            switch (inputS.nextInt()) {
            case 1:
                showMoney();
                break;
            case 2:
                game();
                break;
            case 3:
                System.exit(0);
                break;

            default:
                System.out.println("제대로 입력해주세요.");
                break;
            }
        }
    }

    private void game() {
        betting();
        for (int i = 1; i < playData.length; i++) {
            if (playData[i][1] < 0) {
                System.out.printf("유저 %d님은 자본금이 부족하여 참여할 수 없습니다", i);
                continue;
            }
            System.out.printf("유저 %d의 차례입니다%n", i);
            int[] dealerDice = rollingDice();
            System.out.printf("딜러의 주사위는 %d, %d입니다\n", dealerDice[0], dealerDice[1]);
            int[] playerDice = rollingDice();
            System.out.printf("유저 %d 님의 주사위는 %d, %d입니다 %n", i, playerDice[0], playerDice[1]);
            String determin = "" + i;
            determin += scoreDetermin(dealerDice, playerDice);
            scoreCal(determin);
            //determin은 두자리의 정수로 십의 자리 숫자는 플레이어의 수, 일의 자리 숫자는 판정수가 붙는다.
        }

    }

    private void UserCheck() {
        //최소 두 명이 모두잃음
        int checknum = 0;
        for (int i = 0; i < playData.length; i++) {
            if (playData[i][1] <= 0) {
                checknum++;
            }
        }
        if (checknum >= 2) {
            gameOver();
        }
    }

    private void gameOver() {
        System.out.println("게임을 종료합니다.");
        showMoney();
        System.out.println("수고하셨습니다.");
        gameswitch = false;
    }

    private void showMoney() {
        for (int i = 1; i < playData.length; i++) {
            System.out.printf("유저 %d님 : %d 원%n", i, playData[i][2]);
        }
    }

    private void betting() {
        System.out.println("유저3명의 배팅할 금액을 입력하시오 ");
        for (int i = 1; i < playData.length; i++) {
            System.out.printf("유저 %d :", i);
            playData[i][2] = inputS.nextInt();

            if (playData[i][2] > 10000 || playData[i][2] < 1) {
                System.out.println("1회 배팅은 1~10,000원 내에서 가능합니다.");
                i--;
            }

            if (playData[i][2] > playData[i][1]) {
                System.out.println("자본금이 부족합니다. 자본금 이내의 수로 변경해주세요.");
                i--;
            }

        }
    }

    private void scoreCal(String determin) {

        switch (determin.charAt(1)) {
        //1이면 유저의 승리
        //2이면 딜러의 승리
        //3이면 유저의 더블 승리
        //4이면 딜러의 더블 승리
        case 49:
            playData[(int) determin.charAt(0) - 48][1] += playData[(int) determin.charAt(0) - 48][2];
            System.out.printf("유저 %d가 승리하였습니다.", (int) determin.charAt(0) - 48);
        case 50:
            playData[(int) determin.charAt(0) - 48][1] -= playData[(int) determin.charAt(0) - 48][2];
            System.out.printf("유저 %d가 더블로 승리하였습니다.", (int) determin.charAt(0) - 48);
            break;
        case 51:
            playData[(int) determin.charAt(0) - 48][1] += playData[(int) determin.charAt(0) - 48][2] * 2;
            System.out.printf("딜러가 승리하였습니다.");
            break;
        case 52:
            playData[(int) determin.charAt(0) - 48][1] -= playData[(int) determin.charAt(0) - 48][2] * 2;
            System.out.printf("딜러에게 더블로 패배하였습니다.");
            break;
        }

    }

    private int[] rollingDice() {
        int[] result = { inputR.nextInt(6) + 1, inputR.nextInt(6) + 1 };
        return result;
    }

    private int scoreDetermin(int[] dealerDice, int[] playerDice) {
        int result = 0;
        //1이면 유저의 승리
        //2이면 딜러의 승리
        //3이면 유저의 더블 승리
        //4이면 딜러의 더블 승리
        int dealerscore = dealerDice[0] + dealerDice[1];
        int playerscore = playerDice[0] + playerDice[1];
        if (dealerscore > playerscore) {
            if (dealerDice[0] == dealerDice[1]) {
                result = 4;
            } else {
                result = 2;
            }
        } else {
            if (playerDice[0] == playerDice[1]) {
                result = 3;
            } else {
                result = 1;
            }
        }

        return result;
    }

    public static void main(String[] args) {
        new RollingDiceGame();
    }
}

파이썬에 발들인지 2달채 안되서 그런지 코드가 길고 정리가 안된거 같습니다. 수정 필요한 부분 있으면 지적 부탁드립니다!

from random import randint as ran


def capital():  # 자본 입력 함수
    c = int(input("자본을 입력하세요(최대자본은 100000원 입니다)"))
    if c > 100000:
        print("금액은 100000까지라했는데?")
        exit()
    return c


def insert_money():  # user별로 자본 입력
    user_mon = []
    for i in range(3):
        print("user%d " % int(i + 1), end='')
        m = capital()
        user_mon.append(m)
    print()
    return user_mon


def roll_dice():  # 주사위 굴리기 함수(딜러, user1, user2, user3순)
    di = [[], [], [], []]
    for i in range(4):
        for l in range(2):
            di[i].append(ran(1, 6))
    print()
    return di


def bet(user_mon):  # 배팅금액 입력
    global all_in
    all_in = 0  # 올인한 유저의 수를 0으로 초기화
    bet_mon = []
    for l in range(3):
        a = user_mon[l]
        print("user%d money : %d" % (int(l+1), a),end='    ')
    print()
    for i in range(3):
        print("user%d의" %int(i+1), end=' ')
        m = int(input("배팅금액(자금보다 높은 금액입력시 자동으로 올인) : "))
        if m > user_mon[i] or m == user_mon[i]:
            bet_mon.append(user_mon[i])
            print("user%d 올인"%int(i+1))
            all_in_user()  #all-in한 유저의 수
        else:
            bet_mon.append(m)
    return bet_mon


def check_dice(di):  # 주사위 비교하기
    d_sum = []
    s = 0
    dealer = di[0]
    dealer_sum = di[0][0]+di[0][1]
    res = []  # 0은 딜러 승,1은 딜러 2배승,2는 무승부 ,3은 유저 승, 4는 배팅 2배승
    for k in di[1:4]:
        for l in k:
            s += l
        d_sum.append(s)
        s = 0

    for b in range(3):
        a = d_sum[b]
        if dealer_sum > a:
            if dealer[0] == dealer[1]:
                res.append(1)
            else:
                res.append(0)
        elif dealer_sum == a:
            if dealer[0] == dealer[1]:
                if di[b+1][0] == di[b+1][1]:
                    res.append(2)
                else:
                    res.append(1)
            else:
                if di[b+1][0] == di[b+1][1]:
                    res.append(4)
                else:
                    res.append(2)
        else:
            if di[b+1][0] == di[b+1][1]:
                res.append(4)
            else:
                res.append(3)
    return res


def fin_money(mon, betm, res):  # 주사위 비교 결과에 따른 돈 계산
    result_money = []
    for x in range(3):
        if res[x] == 0:
            if mon[x] - betm[x] > 0:
                result_money.append(mon[x] - betm[x])
            else:
                result_money.append(0)
                end_user()
        if res[x] == 1:
            if mon[x] < betm[x]*2 or mon[x] == betm[x]*2:
                result_money.append(0)
                end_user()
            else:
                result_money.append(mon[x] - betm[x]*2)
        if res[x] == 2:
            result_money.append(mon[x])
        if res[x] == 3:
            result_money.append(mon[x] + betm[x])
        if res[x] == 4:
            result_money.append(mon[x] + betm[x]*2)
    return result_money


def all_in_user():  # all_in한 유저의 수 저장
    global all_in
    all_in += 1
    return all_in


def end_user():  # 탕진한 유저의 수 저장
    global zero_user
    zero_user += 1
    return zero_user


def end_game(resu):  # 게임 끝내고 결과 출력
    global all_in, zero_user
    if all_in == 3 or zero_user == 2:
        ma = max(resu[0], resu[1], resu[2])
        for i in range(3):
            if ma == resu[i]:
                print("user%d가 최대금액 %d를 남김" %(int(i+1), ma))
        exit()

# 변수 지정
all_in = 0
zero_user = 0
user_money = insert_money() # 돈 입력


while 1: # 주사위 도박 시작
    dice = roll_dice()  # 주사위 굴리기
    bet_money = bet(user_money)  # 배팅머니 입력
    dice_result = check_dice(dice)  # 주사위별로 결과 확인
    result = fin_money(user_money, bet_money, dice_result)  # 결과에 따른 돈 정산

    for i in range(3):  # 보유금액 수정
        user_money[i] = result[i]

    end_game(result)

import random

# User 생성
def create_user(x,y):
    u_base = [['dealer',y]]
    for u_cnt in range(0,users):
        u_cnt = u_cnt + 1
        u_nm = input('Input User Name : ')
        u_all = int(input('User money : '))
        u_base.insert(u_cnt,[u_nm,u_all])
    return u_base

# 주사위 함수
def rand_dice(n):
    dice = []
    for i in range(n):        
        x = random.randint(1,6)
        y = random.randint(1,6)
        dice.insert(n,[x+y,x,y])
    return dice

# 금액 배팅
def bat_mon(n):
    bat_m = []
    for i in (range(n)):
        if cu[i+1][1]:
            print('소지 금액을 모두 소진하여 배팅할 수 없습니다.')
            x = 0
        else:    
            x = int(input('Bat_money : '))

        if x > cu[i+1][1]:
            print('소지 금액보다 배팅 금액이 많으므로 올인으로 간주합니다.')
            x = cu[i+1][1]
        bat_m.insert(i,x)
    return bat_m

users = int(input('Select User Count : '))
deal_m = int(input('Dealer Money : '))
# 사용자 생성 및 딜러 자본 금액 생성
cu = create_user(users,deal_m)



while True:
    # 2명이상이 0보다 밑금액 이므로
    end_cnt = 0
    for i in range(0,len(cu)):
        if cu[i][1] <= 0:
            end_cnt += 1

    # 게임 종료
    if end_cnt >= 2:
        print('2명이상이 돈을 모두 잃었으므로 게임을 종료합니다.')
        break

    # 배팅
    bat = bat_mon(users)
    # 배팅시 올인에 대한 게임 종료
    end_b = 0
    for i in range(len(cu) - 1):
        if bat[i] == cu[i+1][1]:
            end_b += 1

    if end_b == (len(cu) - 1):
        print('모두 올인 하였으므로 게임을 종료합니다.')
        break


    # 주사위 돌리기
    dice = rand_dice(len(cu))

    for i in range(1,len(cu)):      
        if dice[0][0] > dice[i][0]: # 유저가 지면 돈을 얻음
            cu[i][1] = cu[i][1] + bat[i-1]
            cu[0][1] = cu[0][1] - bat[i-1]
        elif dice[0][0] < dice[i][0]: # 유저가 이기면 돈을 잃음
            cu[i][1] = cu[i][1] - bat[i-1]
            cu[0][1] = cu[0][1] + bat[i-1]
        elif dice[0][0] == dice[i][0]: # 주사위 합이 동일한 경우
            if dice[0][1] == dice[0][2] and dice[i][1] == dice[i][2]:
                pass
            elif dice[0][1] == dice[0][2]: # 딜러의 주사위가 똑같은 경우
                cu[i][1] = cu[i][1] + (bat[i-1] * 2)
                cu[0][1] = cu[0][1] - (bat[i-1] * 2)
            elif dice[i][1] == dice[i][2]: # 유저 주사위가 똑같은 경우
                cu[i][1] = cu[i][1] - (bat[i-1] * 2)
                cu[0][1] = cu[0][1] + (bat[i-1] * 2)
    print(dice)
    print(bat)
    print(cu)   

import random

def get_dice_score(first, second):
    print(first, second)
    res = 0
    is_double = False
    if first == second:
        res = first + 11
        is_double = True
    else:
        res = first + second
    return res, is_double

def get_dice_value():
    first  = random.randint(1, 6)
    second = random.randint(1, 6)
    return first, second

def is_empty_user_money(moneys):
    zero_cnt = 0
    for money in moneys:
        if money == 0:
            zero_cnt += 1
    return True if zero_cnt >= 2 else False

total_money = 100000
users_money = [total_money, total_money, total_money]

while False == is_empty_user_money(users_money):
    dealer_score, is_double  = get_dice_score(*list(get_dice_value()))
    for user in range(3):
        if users_money[user] == 0:
            continue
        beting_money = random.randint(1, 10000)
        if users_money[user] < beting_money:
            beting_money = users_money[user]

        user_score, is_double = get_dice_score(*list(get_dice_value()))
        if dealer_score <= user_score:
            users_money[user] += beting_money*2 if is_double == True else beting_money
        else:
            users_money[user] -= beting_money

# 주사위 도박

import random

class User:
  def __init__(self):
    self.seed_money = int(input("SEED <= 100000:"))
  def betting(self):
    self.betting_money = int(input("Betting:"))
    self.remaining_money = self.seed_money - self.betting_money

  def dice(self):
     self.a = random.randint(1,6)
     self.b = random.randint(1,6)
     d = self.a+self.b
     print("User's Dice=:", self.a,self.b)
     if self.a==self.b:
      d += 12
     return d

  def playable(self):
     if self.seed_money>0:
      return True
     else:
      return False

class Dealer:
  def dice(self):
    self.a = random.randint(1,6)
    self.b = random.randint(1,6)
    d = self.a+self.b
    print("Dealer's Dice=:", self.a,self.b)
    if self.a==self.b:
      d += 12
    return d

user1 = User()
user2 = User()
user3 = User()
dealer =Dealer()
Number_of_Players = 3

while True:

  if user1.playable():
    print("------------user1------------")
    print("user1's seed_money=",user1.seed_money)

    dealer_dice = dealer.dice()
    user1.betting()
    user1_dice = user1.dice()
    if user1.a == user1.b or dealer.a == dealer.b:
      user1.betting_money*=2
    if user1.a == user1.b and dealer.a == dealer.b:
      user1.betting_money/=2

    if user1_dice  >= dealer_dice:
      user1.seed_money += user1.betting_money
    else:
      user1.seed_money -= user1.betting_money
    print("user1's seed_money=",user1.seed_money)
    print()
    if user1.seed_money<=0:
      Number_of_Players-=1
      print("user1 out")


  if user2.playable():
    print("------------user2------------")
    print("user2's seed_money=",user2.seed_money)

    dealer_dice = dealer.dice()
    user2.betting()
    user2_dice = user2.dice()
    if user2.a == user2.b or dealer.a == dealer.b:
      user2.betting_money*=2
    if user2.a == user2.b and dealer.a == dealer.b:
      user2.betting_money/=2

    if user2_dice  >= dealer_dice:
      user2.seed_money += user2.betting_money
    else:
      user2.seed_money -= user2.betting_money
    print("user2's seed_money=",user2.seed_money)
    print()
    if user2.seed_money<=0:
      Number_of_Players-=1
      print("user2 out")


  if user3.playable():
    print("------------user3------------")
    print("user3's seed_money=",user3.seed_money)

    dealer_dice = dealer.dice()
    user3.betting()
    user3_dice = user3.dice()
    if user3.a == user3.b or dealer.a == dealer.b:
      user3.betting_money*=2
    if user3.a == user3.b and dealer.a == dealer.b:
      user3.betting_money/=2

    if user3_dice  >= dealer_dice:
      user3.seed_money += user3.betting_money
    else:
      user3.seed_money -= user3.betting_money
    print("user3's seed_money=",user3.seed_money)
    print()
    if user3.seed_money<=0:
      Number_of_Players-=1
      print("user3 out")

  if Number_of_Players <= 1:
    print()
    print("Game Over")
    break  

  if user1.remaining_money == 0 and user2.remaining_money ==0 and user3.remaining_money == 0:
    print()
    print("Game Over")
    break