class Player(object):
def __init__(self):
"""Has a pair of dice and an empty rolls list."""
self._die1 = Die()
self._die2 = Die()
self._rolls = []
def __str__(self):
"""Return the string rep of the history of rolls."""
result = ""
for (v1, v2) in self._rolls:
result = result + str((v1, v2)) + " " + \
str(v1 + v2) + "\n"
return result
def getNumberOfRolls(self):
"""Returns the number of the rolls in one game."""
return len(self._rolls)
def play(self):
"""Plays a game, saves the rolls for that game,
and returns True for a win and False for a loss."""
self._rolls = []
self._die1.roll()
self._die2.roll()
(v1, v2) = (self._die1.getValue(),
self._die2.getValue())
def main():
sense.show_message("Welcome to the game! This is a two player"+
"game. Player 1 goes first. Take turns shaking the device to"+
"roll die. First one to 30 points wins!")
i = 1
die = Die()
players = [Player(1),Player(2)]
while (i < 61):
if (i % 2 != 0):
sense.show_message("Player 1's turn!")
sleep(3)
while True:
if die.checkShake(sense):
break
die.roll(sense)
players[0].updatePoints(die.getValue())
else:
sense.show_message("Player 2's turn!")
sleep(3)
while True:
if die.checkShake(sense):
break
die.roll(sense)
players[1].updatePoints(die.getValue())
if checkWinStatus(players,sense):
break
i += 1
sense.clear()
recordWinner(players)
class Player(object):
def __init__(self):
"""Has a pair of dice and an empty rolls list."""
self._die1 = Die()
self._die2 = Die()
self._rolls = []
def __str__(self):
"""Returns a string representation of the list of rolls."""
result = ""
result = result + str((v1, v2)) + " " +\
str(v1 + v2) + "\n"
return result
def getNumberOfRolls(self):
"""Returns the number of the rolls."""
return len(self._rolls)
def play(self):
"""Plays a game, saves the rolls for that game,
and returns True for a win and False for a loss."""
self._rolls = []
self._die1.roll()
self._die2.roll()
(v1, v2) = (self._die1.getValue(), self._die2.getValue())
self._rolls.append((v1, v2))
initialSum = v1 + v2
if initialSum in (2, 3, 12):
return False
elif initialSum in (7, 11):
return True
class Dice( QMainWindow) :
"""A game of Dice."""
die1 = die2 = None
def __init__( self, parent=None ):
"""Build a game with two dice."""
super().__init__(parent)
uic.loadUi("Dice.ui", self)
self.die1 = Die()
self.die2 = Die()
self.rollButton.clicked.connect(self.rollButtonClickedHandler)
def __str__( self ):
"""String representation for Dice.
"""
return "Die1: %s\nDie2: %s" % ( self.die1, self.die2)
def updateUI ( self ):
self.die1View.setPixmap(QtGui.QPixmap(":/" + str(self.die1.getValue())))
self.die2View.setPixmap(QtGui.QPixmap(":/" + str(self.die2.getValue())))
pass
#@QtCore.pyqtSignature("") # Player asked for another roll of the dice.
def rollButtonClickedHandler ( self ):
print("Roll button clicked")
self.die1.roll()
self.die2.roll()
self.updateUI()
class Player(object):
def __init__(self):
"""Has a pair of dice and an empty rolls list."""
self.die1 = Die()
self.die2 = Die()
self.roll = ""
self.rollsCount = 0
self.atStartup = True
self.winner = self.loser = False
def __str__(self):
"""Returns a string representation of the last roll."""
return self.roll
def getNumberOfRolls(self):
"""Returns the number of the rolls."""
return self.rollsCount
def rollDice(self):
"""Rolls the dice once. Updates the roll, the won and
lost outcomes, and returns a tuple of the values
of the dice."""
self.rollsCount += 1
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.roll = str((v1, v2)) + " total = " + str(v1 + v2)
# Game logic for one roll of the dice.
if self.atStartup:
self.initialSum = v1 + v2
self.atStartup = False
if self.initialSum in (2, 3, 12):
self.loser = True
elif self.initialSum in (7, 11):
self.winner = True
else:
laterSum = v1 + v2
if laterSum == 7:
self.loser = True
elif laterSum == self.initialSum:
self.winner = True
return (v1, v2)
# Note: both isWinner() and isLoser() can be False,
# if the game is not finished.
def isWinner(self):
"""Returns True if player has won."""
return self.winner
def isLoser(self):
"""Returns True if player has lost."""
return self.loser
def play(self):
"""Plays a game, counts the rolls for that game,
and returns True for a win and False for a loss."""
while not self.isWinner() and not self.isLoser():
self.rollDice()
return self.isWinner()
class Player(object):
"""
Initializing variables
and creating a pair of dice
"""
def __init__(self):
self.die1 = Die()
self.die2 = Die()
self.roll = ""
self.rollsCtr = 0
self.atStartup = True
self.winner = False
self.loser = False
def __str__(self):
return self.roll
"""
This method returns the number of rolls
"""
def getRollsCount(self):
return self.rollsCtr
def rollDice(self):
self.rollsCtr += 1
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.roll = str((v1, v2)) + " total = " + str(v1 + v2)
if self.atStartup:
self.initialSum = v1 + v2
self.atStartup = False
if self.initialSum in (2, 3, 12):
self.loser = True
elif self.initialSum in (7, 11):
self.winner = True
else:
laterSum = v1 + v2
if laterSum == 7:
self.loser = True
elif laterSum == self.initialSum:
self.winner = True
return (v1, v2)
def isWinner(self):
return self.winner
def isLoser(self):
return self.loser
def play(self):
while not self.isWinner() and not self.isLoser():
self.rollDice()
return self.isWinner()
"""
class Player(object):
def __init__(self):
"""Has a pair of dice and an empty rolls list."""
self.die1 = Die()
self.die2 = Die()
self.rolls = ""
self.rollsCount = 0
self.atStartup = True
self.winner = self.loser = False
def __str__(self):
"""Returns a string representation of the list of rolls."""
return self.roll
def getRollsCount(self):
"""Returns the number of the rolls."""
return self.rollsCount
def rollDice(self):
self.rollsCount += 1
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(),
self.die2.getValue())
self.roll = str((v1, v2)) + " total = " + str(v1 + v2)
if self.atStartup:
self.initialSum = v1 +v2
self.atStartup = False
if self.initialSum in (2,3,12):
self.loser = True
elif self.initialSum in (7,11):
self.winner = True
else:
laterSum = v1 + v2
if laterSum == 7:
self.loser == True
elif laterSum == self.initialSum:
self.winner == True
return(v1,v2)
def isWinner(self):
return self.winner
def isLoser(self):
return self.loser
def play(self):
"""Plays a game, saves the rolls for that game,
and returns True for a win and False for a loss."""
while not self.isWinner() and not self.isLoser():
self.rollDice()
return self.isWinner()
class Player(object):
def __init__(self):
"""Has a pair of dice and an empty rolls list, as well as state variables."""
self.atStartup = True
self.winner = False
self.loser = False
self.die1 = Die()
self.die2 = Die()
self.roll = ()
self.firstSum = 0
self.rollCount = 0
def __str__(self):
"""Returns a string representation of the most recent roll."""
return "Roll " + str(self.rollCount) + ": " + str(self.roll) + "\n"
def getNumberOfRolls(self):
"""Returns the number of the rolls."""
return self.rollCount
def isLoser(self, sum):
if (sum in (2, 3, 12) and self.atStartup) or \
(sum == 7 and not self.atStartup):
return True
else:
return False
def isWinner(self, sum):
if (sum in (7, 11) and self.atStartup) or \
(sum == self.firstSum and not self.atStartup):
return True
else:
return False
def rollDice(self):
"""Plays a game, saves the rolls for that game,
and returns True for a win and False for a loss."""
v1, v2 = self.roll_and_record()
sum = v1 + v2
if self.atStartup:
self.firstSum = sum
return sum
def roll_and_record(self):
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.roll = (v1, v2)
self.rollCount += 1
return v1, v2
class Player(object):
def __init__(self):
"""Player object will have a pair of dice and an empty rolls list"""
self.die1 = Die()
self.die2 = Die()
self.rolls = []
def __str__(self):
"""Returns the string rep of the history of rolls."""
result = ""
for (v1, v2) in self.rolls:
result = result + str((v1, v2)) + " " + str(v1 + v2) + "\n"
return result
def getNumberOfRolls(self):
"""Returns the number of rolls in one game"""
return len(self.rolls)
def play(self):
"""Plays a game, saves the rolls for that game, and returns True for a win and False for a lose"""
self.rolls = []
self.die1.roll()
self.die2.roll()
# Creates a tuple which grabs the values of the two dice that have been rolled
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.rolls.append((v1, v2))
# Variable that stores the sum of each die value per roll
initialSum = v1 + v2
# Check to see if the player won or lost on the first rolls
if initialSum in (2, 3, 12):
return False
elif initialSum in (7, 11):
return True
# If initial rolls are not a win or loss, continue rolling
while True:
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.rolls.append((v1, v2))
laterSum = v1 + v2
if laterSum == 7:
return False
elif laterSum == initialSum:
return True
class DiceDemo(EasyFrame):
def __init__(self):
"""Creates the dice, and sets up the Images and labels
for the two dice to be displayed, the state label,
and the two command buttons."""
EasyFrame.__init__(self, title="Dice Demo")
self.setSize(220, 200)
self.die1 = Die()
self.die2 = Die()
self.dieLabel1 = self.addLabel("", row=0, column=0, sticky="NSEW")
self.dieLabel2 = self.addLabel("",
row=0,
column=1,
sticky="NSEW",
columnspan=2)
self.stateLabel = self.addLabel("",
row=1,
column=0,
sticky="NSEW",
columnspan=2)
self.addButton(row=2, column=0, text="Roll", command=self.nextRoll)
self.addButton(row=2, column=1, text="New game", command=self.newGame)
self.refreshImages()
def nextRoll(self):
"""Rools the dice and updates the view with
the results."""
self.die1.roll()
self.die2.roll()
total = self.die1.getValue() + self.die2.getValue()
self.stateLabel["text"] = "Total = " + str(total)
self.refreshImages()
def newGame(self):
"""Create a new craps game and updates the view."""
self.die1 = Die()
self.die2 = Die()
self.stateLabel["text"] = ""
self.refreshImages()
def refreshImages(self):
"""Updates the images in the window."""
fileName1 = "DICE/" + str(self.die1) + ".gif"
fileName2 = "DICE/" + str(self.die2) + ".gif"
self.image1 = PhotoImage(file=fileName1)
self.dieLabel1["image"] = self.image1
self.image2 = PhotoImage(file=fileName2)
self.dieLabel2["image"] = self.image2
class Player(object):
def __init__(self):
self.die1 = Die()
self.die2 = Die()
self.roll = ""
self.rollsCount = 0
self.atStartup = True
self.winner = self.loser = False
def __str__(self):
return self.roll
def getNumberOfRolls(self):
return self.rollsCount
def rollDice(self):
self.rollsCount += 1
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.roll = str((v1, v2)) + " total = " + str(v1 + v2)
if self.atStartup:
self.initialSum = v1 + v2
self.atStartup = False
if self.initialSum in (2, 3, 12):
self.loser = True
elif self.initialSum in (7, 11):
self.winner = True
else:
laterSum = v1 + v2
if laterSum == 7:
self.loser = True
elif laterSum == self.initialSum:
self.winner = True
return (v1, v2)
def isWinner(self):
return self.winner
def isLoser(self):
return self.loser
def play(self):
while not self.isWinner() and not self.isLoser():
self.rollDice()
return self.isWinner()
class Player(object):
def __init__(self):
"""Has a pair of dice and an empty rolls list."""
self.die1 = Die()
self.die2 = Die()
self.rolls = []
def __str__(self):
"""Returns a string representation of the list of rolls."""
result = ""
for (v1, v2) in self.rolls:
result = result + str((v1, v2)) + " " +\
str(v1 + v2) + "\n"
return result
def getNumberOfRolls(self):
"""Returns the number of the rolls."""
return len(self.rolls)
def play(self):
"""Plays a game, saves the rolls for that game,
and returns True for a win and False for a loss."""
self.rolls = []
v1, v2 = self.roll_and_record()
initialSum = v1 + v2
if initialSum in (2, 3, 12):
return False
elif initialSum in (7, 11):
return True
while (True):
v1, v2 = self.roll_and_record()
laterSum = v1 + v2
if laterSum == 7:
return False
elif laterSum == initialSum:
return True
def roll_and_record(self):
"""Rolls two dice and records the result in the rolls history.
Returns the results of the rolls"""
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.rolls.append((v1, v2))
self.display_rolls((v1, v2))
return v1 + v2
class Player(object):
def __init__(self):
"""Has a pair of dice and an empty rolls list."""
self._die1 = Die()
self._die2 = Die()
self._rolls = []
def __str__(self):
"""Returns a string representation of the list of rolls."""
result = ""
for (v1, v2) in self._rolls:
result = result + str((v1, v2)) + " " + str(v1 + v2) + "\n"
return result
def getNumberOfRolls(self):
"""Returns the number of the rolls."""
return len(self._rolls)
def play(self):
"""Plays a game, saves the rolls for that game,
and returns True for a win and False for a loss."""
self._rolls = []
self._die1.roll()
self._die2.roll()
(v1, v2) = (self._die1.getValue(), self._die2.getValue())
self._rolls.append((v1, v2))
initialSum = v1 + v2
if initialSum in (2, 3, 12):
return False
elif initialSum in (7, 11):
return True
while True:
self._die1.roll()
self._die2.roll()
(v1, v2) = (self._die1.getValue(), self._die2.getValue())
self._rolls.append((v1, v2))
sum = v1 + v2
if sum == 7:
return False
elif sum == initialSum:
return True
class CrapsGame(object):
"""Represents the game of craps."""
def __init__(self):
self.die1 = Die()
self.die2 = Die()
self.initalValue = 0
self.startUp = True
self.gameState = ""
def initialRoll(self):
"""Performs the first roll in the game, and
returns a tuple of the two dice and the
outcome (a string)."""
self.die1.roll()
self.die2.roll()
dieSum = self.die1.getValue() + self.die2.getValue()
self.initialValue = dieSum
outcome = None
if dieSum == 7 or dieSum == 11:
outcome = "You win!"
elif dieSum == 2 or dieSum == 3 or dieSum == 12:
outcome = "You lose!"
return (self.die1, self.die2, outcome)
def step(self):
"""Performs the first roll at startup,
and subsequent rolls thereafter, and returns
a tuple of the two dice and the outcome (a string)."""
# Two cases: the initial roll or any subsequent roll
if self.startUp:
self.startUp = False
return self.initialRoll()
else:
self.die1.roll()
self.die2.roll()
# Your game logic for any subsequent roll goes here
dieSum = self.die1.getValue() + self.die2.getValue()
outcome = None
if dieSum == self.initialValue:
outcome = "You win!"
elif dieSum == 7:
outcome = "You lose!"
return (self.die1, self.die2, outcome)
def __str__(self):
"""Returns the current state of the game."""
self.gameState = "Die1 = " + str(self.die1.getValue()) + \
" Die2 = " + str(self.die2.getValue()) + \
" Total = " + str(self.die1.getValue() + self.die2.getValue())
return self.gameState
class Player(object):
def __init__(self):
#Has a pair of dice and an empty rolls list
self._die1 = Die()
self._die2 = Die()
self._rolls = []
def __str__(self):
#Returns the string rep of the history of rolls
result = ""
for (v1, v2) in self._rolls:
result = result + str((v1, v2)) + " " + str(v1 + v2) + '\n'
return result
def getNumberOfRolls(self):
#Returns the number of the rolls in one game
return len(self._rolls)
def play(self):
#Plays a game, saves the rolls for that game, and returns True for a win and False for a loss
self._rolls = []
self._die1.roll()
self._die2.roll()
(v1, v2) = (self._die1.getValue(), self._die2.getValue())
self._rolls.append((v1, v2))
initialSum = v1 + v2
if initialSum in (2, 3, 12):
return False
elif initialSum in (7, 11):
return True
while True:
self._die1.roll()
self._die2.roll()
(v1, v2) = (self._die1.getValue(), self._die2.getValue())
self._rolls.append((v1, v2))
sum = v1 + v2
if sum == 7:
return False
elif sum == initialSum:
return True
class Player(object):
def __init__(self):
""" coppia dei dadi da lanciare ed una lista vuota """
self.die1 = Die()
self.die2 = Die()
self.rolls = []
def __str__(self):
""" stringa con i valori dei lanci """
result = " "
for (v1, v2) in self.rolls:
result += str((v1, v2)) + " " + str(v1, v2)
return result
def getNumberRolls(self):
""" numero dei lanci """
return len(self.rolls)
def play(self):
""" gioca una partita, true vittora-false sconfitta"""
self.rolls = []
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.rolls.append((v1, v2))
initialSum = v1 + v2
if initialSum in (2, 3, 12):
return False
elif initialSum in (7, 11):
return True
while True:
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.rolls.append((v1, v2))
if (v1 + v2) == 7:
return False
elif (v1 + v2) == initialSum:
return True
def main():
#Declare our dice
die1 = Die()
die2 = Die()
#init (Randomizes our face values)
die1.roll()
die2.roll()
#While we don't have snake eyes
while (die1.getValue() + die2.getValue()) != 2:
#Update (Reroll our die)
die1.roll()
die2.roll()
#Print the roll of our die, this comes after update so that it will print 1,1 at the end
print(die1.getValue(), die2.getValue())
#Since our while statement doesn't stop until snake eyes, we're good
print("Snake Eyes!!!!")
class Player(object):
def __init__(self):
"""Has a pair of dice and an empty rolls list."""
self.die1 = Die()
self.die2 = Die()
self.rolls = 0
self.winner = False
self.loser = False
self.recent = ""
self.startup = False
def __str__(self):
"""Returns a string representation of the list of rolls."""
result = ""
for (v1, v2) in self.rolls:
result = result + str((v1, v2)) + " " +\
str(v1 + v2) + "\n"
return result
def getNumberOfRolls(self):
"""Returns the number of the rolls."""
return self.rolls
def rollDice(self, other):
self.value = randint(1,6)
other.value = randint(1,6)
dice_values = (self.value, other.value)
def isWinner(self):
return self.winner
def isloser(self):
return self.loser
def play(self):
"""Plays a game, saves the rolls for that game,
and returns True for a win and False for a loss."""
self.rolls = []
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(),
self.die2.getValue())
self.rolls.append((v1, v2))
initialSum = v1 + v2
if initialSum in (2, 3, 12):
return False
elif initialSum in (7, 11):
return True
while (True):
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(),
self.die2.getValue())
self.rolls.append((v1, v2))
laterSum = v1 + v2
if laterSum == 7:
return False
elif laterSum == initialSum:
return True
class Player(object):
def __init__(self):
"""Has a pair of dice and an empty rolls list."""
self.die1 = Die()
self.die2 = Die()
self.rolls = []
self.rollscount = 0
self.atStartup = True
self.winner = False
self.loser = False
def __str__(self):
"""Returns a string representation of the list of rolls."""
result = ""
for (v1, v2) in self.rolls:
result = result + str((v1, v2)) + " " +\
str(v1 + v2) + "\n"
return result
def getNumberOfRolls(self):
"""Returns the number of the rolls."""
return len(self.rolls)
##1
def rollDice(self):
#roll the dice q
self.die1.roll()
diefirst = self.die1.getValue()
self.die2.roll()
#roll the dice2
diesecond = self.die2.getValue()
res = (diefirst, diesecond)
#update the roll count
self.rollscount += 1
"""same logic as play but just updating
is loser and is win variable"""
self.rolls = []
v1 = diefirst
v2 = diesecond
#append dies to the rolls
self.rolls.append((v1, v2))
#sum thereslu of the two dies
initialSum = v1 + v2
#check if sum is loser
if initialSum in (2, 3, 12):
self.loser = True
elif initialSum in (7, 11):
#check if sum is not loser
#then set winner to true
self.winner = True
else: #if sum is not in the both then
#roll again the two dies
while (True):
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.rolls.append((v1, v2))
#find sum of the two dies
laterSum = v1 + v2
#check if sum is 7
#then set loser to true
if laterSum == 7:
self.loser = True
self.winner = False
break
elif laterSum == initialSum:
#check if sum is initialSum
#then set winner to true
self.winner = True
self.loser = False
break
"""else continue loop unitl eithercondition is satisfied"""
return res
##1
##2
def isWinner(self):
#checking the varible if true the return true
if self.winner is True:
return True
##2
##3
def isLoser(self):
#checking the varible if true the return true
if self.loser is True:
return True
##3
##4
def __str__(self):
"""Returns a string representation of
the list of rolls."""
result = ""
for (v1, v2) in self.rolls:
result = result + str((v1, v2)) + " " +\
str(v1 + v2) + "\n"
return result
class CrapsGUI(EasyFrame):
def __init__(self):
"""Creates the dice, and sets up the Images and labels
for the two dice to be displayed, the state label,
and the two command buttons."""
EasyFrame.__init__(self, title="Craps Game")
# self.setSize(270, 200)
self.die1 = Die()
self.die2 = Die()
self.rolls = []
self.dieLabel1 = self.addLabel("", row=0, column=0, sticky="NSEW")
self.dieLabel2 = self.addLabel("", row=0, column=1, sticky="NSEW")
# self.stateLabel = self.addLabel("", row=1, column=0,
# sticky="NSEW",
# columnspan=2)
# self.summary = self.addLabel("", row=1, column=0,
# sticky="W",
# columnspan=2)
self.stateArea = self.addTextArea("",
row=1,
column=0,
width=40,
height=10)
self.rollButton = self.addButton(row=2,
column=0,
text="Roll",
command=self.nextRoll)
self.gameButton = self.addButton(row=2,
column=1,
text="New game",
command=self.newGame)
# self.summary_button = self.addButton(row=2, column=2,
# text="Game summary",
# command=self.game_summary)
self.refreshImages()
def __str__(self):
"""Returns a string representation of the list of rolls."""
# result = "Game summary:\n"
for (v1, v2) in self.rolls:
result = result + str((v1, v2)) + " " + \
str(v1 + v2) + "\n"
return result
# def game_summary(self):
# # self.summary_label["text"] = "Game summary:\n" + self.__str__()
# self.summary["text"] = str(self)
def getNumberOfRolls(self):
"""Returns the number of the rolls."""
return len(self.rolls)
def check_win(self, roll_total):
"""Checks if the current roll is a winner
:param roll_total:
"""
# Is it the first roll?
if self.getNumberOfRolls() == 1:
self.first_roll = roll_total
if roll_total in (2, 3, 12):
self.update_state("lost", roll_total)
elif roll_total in (7, 11):
self.update_state("won", roll_total)
else:
self.update_state("reroll", roll_total)
else:
if roll_total == 7:
self.update_state("lost", roll_total)
elif roll_total == self.first_roll:
self.update_state("won", roll_total)
else:
self.update_state("reroll", roll_total)
def nextRoll(self):
"""Rolls the dice and updates the view with
the results."""
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.rolls.append((v1, v2))
self.check_win(v1 + v2)
self.refreshImages()
def update_state(self, state, roll_total):
self.stateArea.appendText("Total = " + str(roll_total) + "\n")
if state == "lost":
# self.stateLabel["text"] = "You lose on " + str(roll_total)
self.stateArea.appendText("You lose!" + "\n")
self.rollButton["state"] = "disabled"
elif state == "won":
# self.stateLabel["text"] = "You win with " + str(roll_total)
self.stateArea.appendText("You win!" + "\n")
self.rollButton["state"] = "disabled"
def newGame(self):
"""Create a new craps game and updates the view."""
self.die1 = Die()
self.die2 = Die()
self.rolls = []
# self.stateLabel["text"] = ""
# self.summary["text"] = ""
self.stateArea.setText("")
self.rollButton["state"] = "normal"
self.refreshImages()
def refreshImages(self):
"""Updates the images in the window."""
fileName1 = "DICE/" + str(self.die1) + ".gif"
fileName2 = "DICE/" + str(self.die2) + ".gif"
self.image1 = PhotoImage(file=fileName1)
self.dieLabel1["image"] = self.image1
self.image2 = PhotoImage(file=fileName2)
self.dieLabel2["image"] = self.image2
class CrapsGame(QMainWindow):
"""A Game of Craps."""
def __init__(self, parent=None):
"""Build a game with two dice."""
super().__init__(parent)
uic.loadUi("crapsUI.ui", self)
self.winsCount = 0
self.lossesCount = 0
self.currentBet = 10
self.startingBank = 1000
self.currentBank = self.startingBank
self.currentRoll = 0
self.secondRoll = False
self.previousRoll = 0
self.die1 = Die(6)
self.die2 = Die(6)
self.payouts = {4: 2, 5: 1.5, 6: 1.2, 8: 1.2, 9: 1.5, 10: 1.2}
self.results = "Welcome to Craps!"
self.rollButton.clicked.connect(self.betSystem)
def betSystem(self):
try:
betAmt = int(self.bankBet.toPlainText())
self.placeBet(betAmt)
self.rollButtonClickedHandler()
except:
self.results = "You cannot bet in letters or just integers."
self.updateUI()
def __str__(self):
"""String representation for Dice."""
return ""
def updateUI(self):
if self.getCurrentBank() <= 0:
self.results = " You lost all your money."
self.rollButton.setEnabled(False)
self.winsLabel.setText(str(self.winsCount))
self.lossesLabel.setText(str(self.lossesCount))
self.resultsLabel.setText(str(self.results))
self.die1View.setPixmap(QtGui.QPixmap(":/" +
str(self.die1.getValue())))
self.die2View.setPixmap(QtGui.QPixmap(":/" +
str(self.die2.getValue())))
self.bankAmt.setText(str(self.getCurrentBank()))
def setWinsCount(self, newWinsCount):
self.winsCount = newWinsCount
def getWinsCount(self):
return self.winsCount
def setLossesCount(self, newLossesCount):
self.LossesCount = newLossesCount
def getLossesCount(self):
return self.lossesCount
def getRollNumber(self):
if self.secondRoll:
return 2
else:
return 1
def setCurrentBet(self, newCurrentBet):
self.currentBet = newCurrentBet
def getCurrentBet(self):
return self.currentBet
def setCurrentBank(self, newCurrentBank):
self.currentBank = newCurrentBank
def getCurrentBank(self):
return self.currentBank
def getCurrentRoll(self):
return self.currentRoll
def placeBet(self, betValue):
self.setCurrentBet(betValue)
@pyqtSlot() #Player asked for a roll of dice.
def rollButtonClickedHandler(self):
print("Roll button clicked!")
self.currentRoll = self.die1.roll() + self.die2.roll()
if self.secondRoll:
print("Roll: %i Second" % self.currentRoll)
else:
print("Roll: %i First" % self.currentRoll)
if self.secondRoll == False:
if self.currentRoll == 7 or self.currentRoll == 11:
self.results = ("You Win!")
self.currentBank += self.currentBet
self.winsCount += 1
elif self.currentRoll == 2 or self.currentRoll == 3 or self.currentRoll == 12:
self.results = ("You Lose")
self.currentBank -= self.currentBet
self.LossesCount += 1
else:
self.secondRoll = True
self.previousRoll = self.currentRoll
else:
if self.previousRoll == self.currentRoll:
print("You Win!")
self.currentBank += self.currentBet * self.payouts[
self.previousRoll]
else:
self.results = ("You Lose")
self.currentBank -= self.currentBet * self.payouts[
self.previousRoll]
self.lossesCount += 1
self.secondRoll = False
self.updateUI()
class Player(object):
def __init__(self):
"""Has a pair of dice and an empty rolls list."""
self.die1 = Die()
self.die2 = Die()
self.stillPlaying = True
self.roll = ""
self.rollsCount = 0
self.atStartup = False #Represents
self.prompt = ""
self.winner = False
self.loser = False
def getRollsCount(self):
print("Current Roll Count: " + str(self.rollsCount))
def isWinner(self):
self.winner = True
self.loser = False
print("You win")
def isLoser(self):
self.loser = True
self.winner = False
print("You lose")
def rollDice(self):
self.roll = 0
self.atStartup = False
self.stillPlaying = True
self.atStartup = True
self.prompt = input(
"Welcome To Craps Dice Game, Would You Like to Play a Round? (y/n)"
)
if self.prompt == 'y':
self.die1.roll()
self.die2.roll()
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
self.roll = "Rolls: " + str(v1) + " & " + str(
v2) + "Total: " + str(v1 + v2)
initialValue = v1 + v2
self.rollsCount = self.rollsCount + 1
print(self.roll)
self.getRollsCount()
if initialValue == (2, 3, 12):
return self.isLoser()
elif initialValue == (7, 11):
return self.isWinner()
else:
pass
else:
print("Good Bye")
sys.exit()
time.sleep(5)
self.atStartup = False
while (True):
self.die1.roll()
self.die2.roll()
self.rollsCount = self.rollsCount + 1
(v1, v2) = (self.die1.getValue(), self.die2.getValue())
latestValue = v1 + v2
self.roll = "Rolls: " + str(v1) + " & " + str(
v2) + "Total: " + str(v1 + v2)
print(self.roll)
self.getRollsCount()
if latestValue == 7:
return self.isLoser()
elif latestValue == initialValue:
return self.isWinner()
else:
pass
time.sleep(5)
