print('Lets Pick A Class!')
for dict in class_list.keys():
for x in dict:
listed_class = class_list[x]
for z,y in listed_class.items():
if z == "Name":
print(x + ":" + y)
pChoice = input()
myClass = class_list[str(pChoice)]
print('You Chose the ' + myClass["Name"] + ' Class!')
print(myName + ' you have decided on a ' + myRace["Name"] + ":" + myClass["Name"])
print("OK, Let us find our ability scores!")
abilityScores = {"Strength" : 0, "Dexterity" : 0, "Constitution" : 0, "Intelligence" : 0, "Wisdom" : 0, "Charisma" : 0}
for a,b in abilityScores.items():
abRoll = dice.Dice()
abRoll.roll(4)
b = abRoll.total
print(f"{a}: {b}")
c = {a: b}
abilityScores.update(c)
for a in abilityScores.items():
print(str(a))
character_list.append(myName)
if 'nouserfound' in character_list:
character_list.remove('nouserfound')
myDict = {"Name" : myName, "Race" : myRace, "Class" : myClass, "Ability Scores" : abilityScores}
save_dict(myName + '_info.json', myDict)
with io.open('character_list.json', 'w', encoding='utf8') as f:
def __init__(self):
super().__init__()
self.dice = dice.Dice()
def pass_dice(self):
self.dice = dice.Dice()
def __init__(self):
super(Shell, self).__init__()
self.dice = dice.Dice()
#!/usr/bin/env python
# Project file names: yahtzee.py, dice.py, scorecard.py, scorefuncs.py
# Author: Steven Spangler
# MRM 8000 Midterm Project
# Date created: 8/7/2016
# Python Version: 2.7
import dice
import scorecard
print "\nLet's play Yahtzee!"
gamedice = dice.Dice()
playercount = int(raw_input("1 or 2 players? "))
if playercount == 2:
player1 = scorecard.Scorecard(raw_input("What is Player 1's name? "))
player2 = scorecard.Scorecard(raw_input("What is Player 2's name? "))
for x in range(13):
player1.printcard()
print "\n%s, it's your turn." % player1.playername
while gamedice.rollcount < 3:
raw_input("Press Enter to roll ...... ")
gamedice.roll(5-len(gamedice.dice))
if gamedice.rollcount < 3:
gamedice.keep()
gamedice.rollcount = 0
player1.addturn(gamedice.dice)
gamedice.dice = []
player2.printcard()
def prediction_mc1(self, sequence, num):
d = dice.Dice(self.dim)
#for MC1 prediction
sequence_mc1 = sequence[:]
for j in range(num):
prob = [0]
last = sequence_mc1[-1]
for i in range(self.dim - 1):
prob.append(self.p1[last - 1][i] + prob[-1])
prob.append(1)
d.set_bounds(prob)
sequence_mc1.append(d.roll())
plt.figure(figsize=(8, 5), dpi=80)
plt.subplot(1, 1, 1)
plt.yticks([0, 1, 2, 3, 4, 5])
plt.title('Prediction by MC1 model')
X1 = []
Y1 = []
idx = 0
for i in sequence_mc1:
X1.append(idx)
Y1.append(i)
idx += 1
plt.plot(X1, Y1, 'red')
#for MC2 prediction
sequence_mc2 = sequence[:]
for j in range(num):
prob = [0]
last = sequence_mc2[-1]
last2 = sequence_mc2[-2]
for i in range(self.dim - 1):
row = last - 1 + (last2 - 1) * self.dim
prob.append(self.p2[row][i] + prob[-1])
prob.append(1)
d.set_bounds(prob)
sequence_mc2.append(d.roll())
plt.figure(figsize=(8, 5), dpi=80)
plt.subplot(1, 1, 1)
plt.yticks([0, 1, 2, 3, 4, 5])
plt.title('Prediction by MC2 model')
X2 = []
Y2 = []
idx = 0
for i in sequence_mc2:
X2.append(idx)
Y2.append(i)
idx += 1
plt.plot(X2, Y2, 'blue')
#for MC3 prediction
sequence_mc3 = sequence[:]
for j in range(num):
prob = [0]
last = sequence_mc3[-1]
last2 = sequence_mc3[-2]
last3 = sequence_mc3[-3]
for i in range(self.dim - 1):
row = last - 1 + (last2 - 1) * self.dim + (
last3 - 1) * self.dim * self.dim
prob.append(self.p3[row][i] + prob[-1])
prob.append(1)
d.set_bounds(prob)
sequence_mc3.append(d.roll())
plt.figure(figsize=(8, 5), dpi=80)
plt.subplot(1, 1, 1)
plt.yticks([0, 1, 2, 3, 4, 5])
plt.title('Prediction by MC3 model')
X3 = []
Y3 = []
idx = 0
for i in sequence_mc3:
X3.append(idx)
Y3.append(i)
idx += 1
plt.plot(X3, Y3, 'green')
return sequence_mc1, sequence_mc2, sequence_mc3
import dice
D6 = dice.Dice(6)
print(D6.showNumberOfSides())
print(D6.rollDice())
Dtesti = dice.Dice("A#")
if (Dtesti):
print(Dtesti.showNumberOfSides())
Dtesti2 = dice.Dice(-3)
if (Dtesti2):
print(Dtesti2.rollDice())
def __init__(self, stalls):
self.active_chesser = None
self.chessers_count = 0
self.stalls = stalls
self.players = {}
self.dice = dice.Dice()
def test_valid_die(self, sides, is_valid):
if is_valid:
dice.Dice(sides)
else:
with self.assertRaises(ValueError):
dice.Dice(sides)
player_unit = {
"red": "images/red_tank.png",
"green": "images/green_tank.png",
"blue": "images/blue_tank.png",
"gray": "images/gray_tank.png",
"yellow": "images/yellow_tank.png",
"brown": "images/brown_tank.png",
"purple": "images/purple_tank.png",
"white": "images/white_tank.png"
}
B_rnd = {
"green": "images/btn_green.png",
"gray": "images/btn_gray.png",
"red": "images/btn_red.png"
}
dice = dice.Dice()
player_info_area = (605, 165, 20, 20)
unit_active_y = {
0: player_info_area[1] + 24 * 1,
1: player_info_area[1] + 24 * 2,
2: player_info_area[1] + 24 * 3,
3: player_info_area[1] + 24 * 4,
4: player_info_area[1] + 24 * 5,
5: player_info_area[1] + 24 * 6,
6: player_info_area[1] + 24 * 7,
7: player_info_area[1] + 24 * 8
}
class Unit(Sprite):
def main(no_of_rolls=1):
check_if_incorrect_usage()
the_dice = dice.Dice()
no_of_rolls = 1 if no_of_rolls <= 0 else no_of_rolls
return [the_dice.roll for _ in range(no_of_rolls)]
def baum_welch(
multiple_observations: List[np.ndarray],
epochs: int = 50
) -> Tuple[dice.Dice, dice.Dice, np.ndarray, np.ndarray]:
# Initialize first dice parameters
first_dice_probabilities = np.random.rand(6)
first_dice_probabilities /= first_dice_probabilities.sum(
) # Make probabilities sum up to 1.0
first_dice = dice.Dice(first_dice_probabilities)
# Initialize second dice parameters
second_dice_probabilities = np.random.rand(6)
second_dice_probabilities /= second_dice_probabilities.sum(
) # Make probabilities sum up to 1.0
second_dice = dice.Dice(second_dice_probabilities)
# Initialize probabilities which were used to randomize first dice
initial_dice_probability = np.random.rand(2)
initial_dice_probability /= initial_dice_probability.sum(
) # Make probabilities sum up to 1.0
# Initialize transition probabilities
transition_matrix = np.random.rand(2, 2)
transition_matrix /= np.sum(
transition_matrix,
axis=1)[:, None] # Make probabilities sum up to 1.0 for each dice
# Train our Hidden Markov Model in epochs
for epoch in range(epochs):
# Prepare placeholders for collecting computations from all observations
new_transition_matrix = np.zeros((2, 2))
new_initial_dice_probability = np.zeros(2)
new_first_dice_probabilities = np.zeros(6)
new_second_dice_probabilities = np.zeros(6)
fitness = 0
# In each epoch walk through all collected observations
for observations in multiple_observations:
observations_rows = observations.shape[0]
# E Step - use forward and backward pass to calculate alphas and betas
alpha_probabilities = calculate_forward_probabilities(
observations, first_dice, second_dice,
initial_dice_probability, transition_matrix)
beta_probabilities = calculate_backward_probabilities(
observations, first_dice, second_dice,
initial_dice_probability, transition_matrix)
aposteriori_probabilities = np.multiply(alpha_probabilities,
beta_probabilities)
# Collect probabilities for each observations which can be defined as P(O|parameters)
probability_of_observation = initial_dice_probability[0] * beta_probabilities[0][0] \
+ initial_dice_probability[1] * beta_probabilities[0][1]
fitness += probability_of_observation
# KSI (Greek Letter) parameters are known as probability of being in state `i` at time `t` and in
# state `j` at time `t+1`, given the model and the sequence of observations
ksi = np.zeros([observations_rows, 2, 2])
for t in range(observations_rows - 1):
denominator = (
alpha_probabilities[t][0] * beta_probabilities[t][0] +
alpha_probabilities[t][1] * beta_probabilities[t][1])
ksi[t, 0,
0] = (alpha_probabilities[t][0] * transition_matrix[0, 0] *
first_dice_probabilities[observations[t + 1]] *
beta_probabilities[t + 1][0]) / denominator
ksi[t, 0,
1] = (alpha_probabilities[t][0] * transition_matrix[0, 1] *
second_dice_probabilities[observations[t + 1]] *
beta_probabilities[t + 1][1]) / denominator
ksi[t, 1,
0] = (alpha_probabilities[t][1] * transition_matrix[1, 0] *
first_dice_probabilities[observations[t + 1]] *
beta_probabilities[t + 1][0]) / denominator
ksi[t, 1,
1] = (alpha_probabilities[t][1] * transition_matrix[1, 1] *
second_dice_probabilities[observations[t + 1]] *
beta_probabilities[t + 1][1]) / denominator
# Gamma (another Greek Letter) parameters stands for probability of being in state `i` at time `t`
gamma = np.zeros([observations_rows, 2])
for t in range(observations_rows - 1):
gamma[t, 0] = np.sum(ksi[t, 0, :])
gamma[t, 1] = np.sum(ksi[t, 1, :])
# Compute initial probabilities for this observation and add it for later use
new_initial_dice_probability += gamma[0] / np.sum(gamma[0])
# Compute transition matrix and add it up to for later use
new_transition_matrix[0, 0] += np.sum(ksi[:, 0, 0]) / np.sum(
gamma[:, 0]) / probability_of_observation
new_transition_matrix[0, 1] += np.sum(ksi[:, 0, 1]) / np.sum(
gamma[:, 0]) / probability_of_observation
new_transition_matrix[1, 0] += np.sum(ksi[:, 1, 0]) / np.sum(
gamma[:, 1]) / probability_of_observation
new_transition_matrix[1, 1] += np.sum(ksi[:, 1, 1]) / np.sum(
gamma[:, 1]) / probability_of_observation
# Compute probabilities for each dice (hidden states) and collect them for later use
for wall in range(6):
# Emission probabilities can be computed as expected number of times in state `j` and observing `k-th` wall on dice
# divided by expected number of times in state `j`
new_first_dice_probabilities[wall] = np.sum(
np.take(aposteriori_probabilities[:, 0],
np.where(observations == wall)))
new_first_dice_probabilities[wall] /= np.sum(
aposteriori_probabilities[:,
0]) / probability_of_observation
new_second_dice_probabilities[wall] = np.sum(
np.take(aposteriori_probabilities[:, 1],
np.where(observations == wall)))
new_second_dice_probabilities[wall] /= np.sum(
aposteriori_probabilities[:,
1]) / probability_of_observation
# Normalize all values for probabilities, so that they won't blow up quickly...
initial_dice_probability = new_initial_dice_probability / np.sum(
new_initial_dice_probability)
transition_matrix = new_transition_matrix / np.sum(
new_transition_matrix, axis=1)[:, None]
first_dice_probabilities = new_first_dice_probabilities / np.sum(
new_first_dice_probabilities)
second_dice_probabilities = new_second_dice_probabilities / np.sum(
new_second_dice_probabilities)
# Put dice probabilities into Dice instances
first_dice = dice.Dice(first_dice_probabilities)
second_dice = dice.Dice(second_dice_probabilities)
# Some logging is always good :)
print('= EPOCH #{} ='.format(epoch))
print('Transition Matrix:', transition_matrix)
print('Initial Dice Probability:', initial_dice_probability)
print('First Dice:', first_dice_probabilities)
print('Second Dice:', second_dice_probabilities)
print('Fitness:', fitness)
print()
return first_dice, second_dice, initial_dice_probability, transition_matrix
####################
### Farkel Game ####
####################
import dice
import player
dice_list = [dice.Dice() for i in range(6)]
### Set up players ###
number_of_players = input("How many players? ")
player_list = []
for i in range(number_of_players):
player_list.append(
player.Player(raw_input("What is player " + str(i + 1) +
"'s name?\n")))
print player_list[0].name
### Set up variables for game play ###
game_over = False
##########
## GAME ##
##########
def check_validity_of_selection(choosen_dice):
if len(choosen_dice) == 0:
return False
for i in range(len(choosen_dice)):
if choosen_dice[i] > 6 or choosen_dice[i] < 1:
import dice
choice = int(input('4,6,8,12,20のどれで勝負しますか？：'))
cpu_sai = dice.Dice(choice)
your_sai = dice.Dice(choice)
cpu_ans = cpu_sai.shoot()
your_ans = your_sai.shoot()
print('CPU：{} / あなた：{}'.format(cpu_ans, your_ans))
if cpu_ans > your_ans:
print('残念。あなたの負けです')
elif cpu_ans < your_ans:
print('おめでとう。あなたの勝ちです')
else:
print('引き分けです')
# -*- coding: utf-8 -*-
import dice
# input関数で値を受け取る
num=input('4,6,8,12,20の面を持つサイコロのどれにしますか？:')
my_dice=dice.Dice(num)
cpu_dice=dice.Dice(num)
my_pip=my_dice.shoot()
cpu_pip=cpu_dice.shoot()
# 出目を画面に出力 数字はstr関数を使って文字列に変換
print('CPU: '+str(cpu_pip)+' あなた: '+str(my_pip))
# 状況によってメッセージを変える
if my_pip>cpu_pip:
print('おめでとうございます。あなたの勝ちです！')
elif my_pip<cpu_pip:
print('残念！あなたの負けです。')
else:
print('引き分けです！')
import test
import dice
import game
d = dice.Dice()
g = game.Game()
print('Welcome to Monopoly')
numPlayers = input('How many folk are playing?')
g.start(int(numPlayers))
print('Let us begin!')
while (True):
for p in g.players:
player, index = g.board.get_player_by_id(p.id)
print('hi player ' + str(p.id) + ', you are at space: ' + str(index))
print('you have $' + str(player.Money) + ' in your pocket')
input('press Enter to roll the die')
roll1 = d.roll()
roll2 = d.roll()
fullroll = roll1 + roll2
print('you rolled: ' + str(roll1) + ' and ' + str(roll2))
print('you moved ' + str(fullroll) + ' spaces')
g.board.move_player_by_player_id(p.id, fullroll)
print('')
def get_rent(self):
d = dice.Dice()
d.roll()
return self.rent_now * d.roll_sum
#Single player against computer #usees a single 9 sided dice #bet on a single or upto 3 dices #win 4x the betwin 9 times if you bet on a 9 andget money bet back if you bet on an even number and roll a 9 import dice from dice #initialize 3 dices d1 = dice.Dice(9) d2 = Dice(9) d3 = Dice(9) d1.roll() d2.roll() d3.roll() print(d1, d2, d3)
def test(self):
# First order markov chain
FirstOrderMarkovChain = np.array([[0.7, 0.2, 0.1], [0.2, 0.6, 0.2],
[0.1, 0.4, 0.5]])
P1 = np.zeros(9).reshape(3, 3)
Output1 = [1]
dim = FirstOrderMarkovChain.shape[0]
d = dice.Dice(dim)
for i in range(5000):
last = Output1[-1]
prob = [0]
for i in range(dim - 1):
prob.append(FirstOrderMarkovChain[last - 1][i] + prob[-1])
prob.append(1)
d.set_bounds(prob)
Output1.append(d.roll())
for j in range(len(Output1) - 1):
row = Output1[j] - 1
col = Output1[j + 1] - 1
P1[row][col] += 1
for k in range(dim):
Sum = sum(P1[k, :])
for m in range(dim):
P1[k][m] /= Sum
print("First Order Input:\n", FirstOrderMarkovChain)
print("First Order Output:\n", P1)
# Second order markov chain
SecondOrderMarkovChain = np.dot(FirstOrderMarkovChain,
FirstOrderMarkovChain)
P2 = np.zeros(9).reshape(3, 3)
for j in range(len(Output1) - 2):
row = Output1[j] - 1
col = Output1[j + 2] - 1
P2[row][col] += 1
for k in range(dim):
Sum = sum(P2[k, :])
for m in range(dim):
P2[k][m] /= Sum
print("Second Order Input:\n", SecondOrderMarkovChain)
print("Second Order Output:\n", P2)
# Reduced Transition Matrix
ReducedTransitionMatrix = np.array([[0.7, 0.2, 0.1], [0.2, 0.6, 0.2],
[0.1, 0.4, 0.5], [0.1, 0.8, 0.1],
[0.2, 0.4, 0.4], [0.1, 0.7, 0.2],
[0.4, 0.3, 0.3], [0.2, 0.1, 0.7],
[0.5, 0.1, 0.4]])
P = np.zeros(27).reshape(9, 3)
Output = [1, 2]
dim0 = ReducedTransitionMatrix.shape[0] #9
dim1 = ReducedTransitionMatrix.shape[1] #3
d = dice.Dice(dim1)
for i in range(10000):
last1 = Output[-1]
last2 = Output[-2]
prob = [0]
for i in range(dim1 - 1):
idx = last2 - 1 + (last1 - 1) * 3
prob.append(ReducedTransitionMatrix[idx][i] + prob[-1])
prob.append(1)
d.set_bounds(prob)
Output.append(d.roll())
for j in range(len(Output) - 2):
last2 = Output[j]
last1 = Output[j + 1]
last0 = Output[j + 2]
row = last2 - 1 + (last1 - 1) * 3
col = last0 - 1
P[row][col] += 1
for k in range(dim0): #row
Sum = sum(P[k, :])
P[k, :] /= Sum
print("Reduced Transition Matrix Input:\n", ReducedTransitionMatrix)
print("Reduced Transition Matrix Output:\n", P)
import configurations
import dice
import users
import games
token = os.environ['discord_token']
google_spreadsheet_key = os.environ['google_spreadsheet_key']
configurations.init(google_spreadsheet_key)
bot = commands.Bot(command_prefix=".",
description="DolaTRPG discord bot",
self_bot=False,
owner_id=int(configurations.key['owner']))
bot.add_cog(users.Users(bot, google_spreadsheet_key))
bot.add_cog(channel.Channel(bot))
bot.add_cog(games.Games(bot))
bot.add_cog(dice.Dice(bot))
@bot.event
async def on_ready():
print('Logged in as')
print(bot.user.name)
print(bot.user.id)
print('------')
await bot.change_presence(activity=discord.Game(name='.help'))
bot.run(token)