def get_player_roll():
valid_choice = False
while not valid_choice:
choice = input("Choose Rock, Paper, or Scissors: ").lower()
if choice == 'rock':
return Roll('rock')
elif choice == 'paper':
return Roll('paper')
elif choice == 'scissors':
return Roll('scissors')
def generateNNTrainingData(policy, state_potentials, new_training_title,
n_trials):
labelout = open("training/" + new_training_title, "a")
sys.stdout.write('Generating training data')
sys.stdout.flush()
for x in range(0, n_trials):
sheet, roll, n_rerolls = sample_gamespace(policy.choose_dice,
policy.choose_category)
opt_move = optimal_strategy.queryMove(state_potentials,
sheet.as_bitmask(),
roll.as_list(), n_rerolls)
labeled_one_hot = None
labelout.write(sheet.as_csv() + "," + roll.as_string() + "," +
str(n_rerolls) + ",")
try:
best_category = YahtzeeScoresheet.categories[opt_move]
labelout.write(best_category + ",")
labeled_one_hot = label.build_one_hot(opt_move, 13)
except (ValueError, TypeError) as e:
kept_dice = Roll(opt_move)
labelout.write("[" + kept_dice.as_string() + "],")
labeled_one_hot = label.find_macro(kept_dice, roll, sheet,
n_rerolls)
labelout.write(labeled_one_hot + "\n")
if x % 1000 == 0:
sys.stdout.write('.')
sys.stdout.flush()
labelout.close()
def _advance_to_nearest_utility(player, state):
electric_company = INDEX[ELECTRIC_COMPANY]
water_works = INDEX[WATER_WORKS]
nearest_utility = Card._nearest_to(player.position,
[electric_company, water_works])
roll = Roll().value
return Card._advance_to_square(player, nearest_utility, roll, state)
async def _process_roll_character(self, message):
c = self.kv.get(self._char_key(message))
if not c:
await message.channel.send('You have not uploaded your character.')
return
tokens = message.content.strip().lower().split()[1:]
skill = tokens[0]
modifying_ability = SKILLS.get(skill, None)
if not modifying_ability:
await message.channel.send('{} is not supported.'.format(skill))
return
ability = c['abilities'][modifying_ability]
ability_modifier = (ability - 10) // 2
proficiency = c['proficiencies'][skill]
level = c['level']
base_modifier = ability_modifier + proficiency + level
extra_mods = [Modifier(m) for m in map(int, tokens[1:])]
rolls = [DiceRoll(1, 20), Modifier(base_modifier)]
rolls.extend(extra_mods)
r = Roll(rolls)
results, total = r.get()
msg = "{} rolled `{}` for a total of `{}`".format(
message.author.nick, ' + '.join(map(str, results)), total)
msg += ": {}".format(skill)
await message.channel.send(msg)
def scoreRoll(state, dice, c):
roll = Roll(dice)
score = index_to_function[cat_to_index[c]](roll, state)
marginal_upper_total = (
score % 100
) if c >= C_SIXES else 0 # if 1s, 2s, ... 6s, marginal upper total cannot include bonuses
return score, marginal_upper_total
def getValidCategories(state, roll):
local_time = time.time() * 10000.0
cats_to_probe = []
mroll = Roll(roll)
if isJoker(mroll, state):
if not (C_MASKS[mroll.sample_dice() - 1] & state
): # if one of the Yahtzee-making dice is not a used category
cats_to_probe.append(C_MASKS[mroll.sample_dice() -
1]) # must use that upper category
elif (not (C_FH & state) or not (C_SS & state) or not (C_LS & state)
or not (C_3K & state) or not (C_4K & state) or not (C_C & state)
): # if upper category filled and lower categories open...
for cat in C_MASKS[6:12]: # add all of the available lower cats
if not (cat & state):
cats_to_probe.append(cat)
else:
for cat in C_MASKS[
0:6]: # otherwise, score a zero in one of the upper cats
if not (cat & state):
cats_to_probe.append(cat)
else: # if not a joker, just add all available cats
for cat in C_MASKS:
if not (cat & state):
cats_to_probe.append(cat)
return cats_to_probe
def __find_child(self, mum):
# find all children under a mum
assert isinstance(mum, Tree)
for item in mum.node:
if item[0]:
l = mum.row[item[1]]
else:
l = mum.col[item[1]]
m = Roll(item[2], item[3], l)
# print(item)
# print(l)
m.move()
if item[0]:
table = mum.row.copy()
table[item[1]] = m.result
# print(table)
table_t = self.__transpose(table, self.n_col)
# print(table_t)
node_t = snap(table, table_t)
else:
table = mum.col.copy()
table[item[1]] = m.result
# print(table)
table_t = self.__transpose(table, self.n_row)
node_t = snap(table_t, table)
if len(node_t) != 0:
self.n += 1
if item[0]:
child = Tree(node_t, self.n, table, table_t, item)
else:
child = Tree(node_t, self.n, table_t, table, item)
mum.add_child(child)
def evaluate_blank(args: list, i: int) -> str:
while blank in args[i]:
if i + 1 == len(args):
raise util.ParseException(
"Failure: missing value for _ in '{}'".format(args[i]))
if blank in args[i + 1]:
# parse that blank first
evaluate_blank(args, i + 1)
# replace blanks with next value after executed
if args[i + 1] == left_sep:
# if the next arg is the beginning of a group, parse and execute the group
depth = 0
j = i + 1
while depth >= 0:
j += 1
depth += 1 if args[j] == left_sep else (
-1 if args[j] == right_sep else 0)
nextvalue = str(Group(args[i + 2:j]).execute(print_rolls=False))
del args[i + 1:j + 1]
elif expression.is_expression(args[i + 1]):
# if the arg is an expression, evaluate it
nextvalue = str(int(expression.parse_math(args[i + 1])))
del args[i + 1]
elif table.is_table(args[i + 1]):
nextvalue = table.Table(args[i + 1]).execute()
del args[i + 1]
else:
# try to parse next arg as a roll
nextvalue = str(Roll(args[i + 1]).execute(print_output=False))
del args[i + 1]
# replace blank with resulting value
args[i] = args[i].replace(blank, nextvalue, 1)
def run(self):
num_players = len(self._state.players)
idx = random.randint(0, num_players - 1)
while not self._completed():
# cash = [player.cash for player in self._state.players]
# print cash
player = self._state.players[idx]
idx = (idx + 1) % len(self._state.players)
roll = Roll()
print '%s rolled a %d%s' % (player.name, roll.value, ' (doubles)'
if roll.is_doubles else '')
if player.jail_moves > 0 and roll.is_doubles:
self._state.apply(
GroupOfChanges(
changes=[GameStateChange.leave_jail(player)]))
elif player.jail_moves >= 2:
self._state.apply(
GroupOfChanges(
changes=[GameStateChange.decrement_jail_moves(player)
]))
self._wait()
continue
elif player.jail_moves == 1:
# TODO: Allow player to choose to use a "Get out of jail free" card
pay_changes = player.pay(self._state.bank, 50, self._state)
leave_changes = GroupOfChanges(
changes=[GameStateChange.leave_jail(player)])
self._state.apply(
GroupOfChanges.combine([pay_changes, leave_changes]))
self._take_turn(player, roll.value)
num_rolls = 0
max_rolls = 2
while roll.is_doubles:
roll = Roll()
print '%s rolled a %d%s' % (player.name, roll.value,
' (doubles)'
if roll.is_doubles else '')
num_rolls += 1
if num_rolls > max_rolls:
self._state.apply(
GroupOfChanges(
changes=[GameStateChange.send_to_jail(player)]))
break
self._take_turn(player, roll.value)
def getNewState(state, roll, c, marginal_upper_total):
new_state = state
new_state += marginal_upper_total
new_state += c
mroll = Roll(roll)
if c == C_Y and mroll.is_n_kind(5) and not (
new_state & YSCORED
): # if scoring in Y and roll is Y, activate possibility for Yahtzee bonus
new_state += YSCORED
return new_state
def get_input():
questions = [
{
'type': 'list',
'name': 'system',
'message': 'What system are you using?',
'choices': ['5e', 'Pathfinder']
},
{
'type': 'input',
'name': 'ac',
'message': 'What AC are you attacking against?\n >',
'validate': lambda val: is_num(val)
},
{
'type': 'input',
'name': 'attack',
'message': "What's your to-hit bonus?\n >",
'validate': lambda val: is_num(str(val).replace('+', ''))
},
{
'type': 'input',
'name': 'base_damage',
'message': "What's your regular damage?\n >"
},
{
'type': 'input',
'name': 'crit_damage',
'message': "What's your critical hit damage?\n >"
},
{
'type': 'list',
'name': 'crit_range',
'message': "What's your critical hit chance?",
'choices': ['5%', '10%', '15%', '20%', '25%', '30%'],
'when': lambda answers: answers['system'] == 'Pathfinder'
}
]
answers = prompt(questions)
for key in ('ac', 'attack'):
if key in answers.keys():
answers[key] = float(answers[key])
if 'crit_range' in answers.keys():
if answers['crit_range'][-1] == '%':
answers['crit_range'] = answers['crit_range'][:-1]
answers['crit_range'] = int(answers['crit_range']) / 100.
for key in ('base_damage', 'crit_damage'):
if key in answers.keys():
damage_roll = Roll(answers[key])
answers[key] = damage_roll.average()
return answers
def roll(self, count=1, goal=None):
"""Appends a roll to the dice's rolls list.
"""
self.check_vars()
result = None
if goal == None and self.__goal != None:
goal = self.__goal
for _ in range(count):
value = randint(self.offset + 1, self.max_roll + self.offset + 1)
if self.__func != None:
result = self.__func(value)
self.__rolls.insert(0, Roll(self, value, goal=goal, result=result))
def __find_child(self, mum, pointy_mum):
# find all children under a mum
assert isinstance(mum, Tree)
for item in mum.node:
if item[0]:
l = mum.row[item[1]]
else:
l = mum.col[item[1]]
m = Roll(item[2], item[3], l)
# print(item)
# print(l)
m.move()
if item[0]:
table = mum.row.copy()
table[item[1]] = m.result
# print(table)
table_t = self.__transpose(table, self.n_col)
# print(table_t)
node_t = snap(table, table_t)
else:
table = mum.col.copy()
table[item[1]] = m.result
# print(table)
table_t = self.__transpose(table, self.n_row)
node_t = snap(table_t, table)
if len(node_t) != 0:
self.n += 1
if item[0]:
child = Tree(node_t, self.n, table, table_t, item)
else:
child = Tree(node_t, self.n, table_t, table, item)
n_row = 0
n_col = 0
for i in mum.row.keys():
if len(mum.row[i]) > 0: # not empty
n_row += 1
for i in mum.col.keys():
if len(mum.col[i]) > 0:
n_col += 1
if n_row == 1 or n_col == 1:
# solution found
solution = True
else:
solution = False
pointy_child = PointyTree(self.n,
pointy_mum.mum,
solution,
children=None)
pointy_child.add_point(child)
mum.add_child(child)
pointy_mum.add_child(pointy_child)
def startGame(self):
self.roll = Roll()
self.score = Score()
self.score.clearScore()
self.currentPlayer = 1
self.currentTurn = 1
self.clearDisplay(0)
self.clearDisplay(1)
self.remainRoll.setText('3')
self.roll.clearRollCount()
self.rollButton.setEnabled(True)
self.buttonSetting()
self.currentPlayer = 0
self.colorSetting(0)
self.scoreTypeClear()
def sample_gamespace(choose_dice, choose_category):
''' Returns the score earned in one game played with the policy
defined by the two given functions. Each position is logged with
the given function.
choose_dice -- a function that takes a scoresheet, roll, and number of
rerolls, returns a subroll of the roll
choose_category -- a function that takes a non-filled scoresheet and
a roll and returns the index of an unused category
on that scoresheet
log -- a function that takes a scoresheet, roll, and number of rerolls
'''
# start with empty scoresheet
sheet = YahtzeeScoresheet()
rand = random.randint(0, 38)
it = 0
while not sheet.game_over():
# do the initial roll
roll = Roll()
roll.reroll()
# reroll twice
for i in [2, 1]:
if it == rand:
return (sheet, roll, i)
it += 1
# choose dice to keep
keep = choose_dice(sheet, roll, i)
if not keep.subroll(roll):
raise ValueError("dice to keep %s not a subset of roll %s" %
(keep.as_list(), roll.as_list()))
keep.reroll()
roll = keep
if it == rand:
return (sheet, roll, 0)
it += 1
# choose category to use and mark it
cat = choose_category(sheet, roll)
sheet.mark(cat, roll)
return (None, None, None)
def submit_dice(self, d1, d2):
roll_number = self.game.get_roll_num()
game_number = self.session.get_game_num()
# Check if radio buttons were selected (0 if unselected)
if (d1 > 0 and d2 > 0):
roll = Roll(d1, d2)
self.session.process_roll(roll)
self.game.add_roll(roll)
self.console_out("Gm " + str(game_number + 1) + "- Rd " +
str(roll_number + 1) + ": " + str(d1) + " " +
str(d2))
self.make_game_decision(roll)
self.update_statistics()
else:
self.console_out("Select dice values before submitting")
def play_solitaire_test(choose_dice,
choose_category,
optimal_policy,
log=null_log):
''' Returns the score earned in one game played with the policy
defined by the two given functions. Each position is logged with
the given function.
choose_dice -- a function that takes a scoresheet, roll, and number of
rerolls, returns a subroll of the roll
choose_category -- a function that takes a non-filled scoresheet and
a roll and returns the index of an unused category
on that scoresheet
log -- a function that takes a scoresheet, roll, and number of rerolls
'''
# start with empty scoresheet
sheet = YahtzeeScoresheet()
while not sheet.game_over():
# do the initial roll
roll = Roll()
roll.reroll()
# reroll twice
for i in [2, 1]:
# choose dice to keep
keep = choose_dice(sheet, roll, i)
if not keep.subroll(roll):
raise ValueError("dice to keep %s not a subset of roll %s" %
(keep.as_list(), roll.as_list()))
keep.reroll()
roll = keep
# choose category to use and mark it
cat = choose_category(sheet, roll)
best_cat = optimal_policy.choose_category(sheet, roll)
if not cat == best_cat:
print(cat, best_cat, roll.as_list(), sheet.as_csv())
sheet.mark(cat, roll)
# print("=========GAME OVER==========")
return sheet.grand_total()
def generate_training_data(self, n_trials, all_data):
for x in range(0, n_trials):
current_line = ""
sheet, roll, n_rerolls = sample_gamespace(self.choose_dice,
self.choose_category)
opt_move = optimal_strategy.queryMove(self.state_potentials,
sheet.as_bitmask(),
roll.as_list(), n_rerolls)
labeled_one_hot = None
current_line = sheet.as_csv() + "," + roll.as_string() + "," + str(
n_rerolls) + ","
try: # assume in this situation you choose a category to score in
best_category = YahtzeeScoresheet.categories[opt_move]
current_line += best_category + ","
labeled_one_hot = label.build_one_hot(lookup_macro[opt_move],
10)
except (ValueError, TypeError) as e:
kept_dice = Roll(opt_move)
current_line += "[" + kept_dice.as_string() + "],"
labeled_one_hot = label.find_macro(kept_dice, roll, sheet,
n_rerolls)
current_line += labeled_one_hot + "\n"
all_data.append(current_line)
import asyncio
import os
import uvloop
from aiofile import AIOFile, Reader
from roll import Roll
from roll.extensions import cors, igniter, logger, simple_server, traceback
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
app = Roll()
cors(app)
logger(app)
traceback(app)
@app.route("/fullasync", methods=["POST"], lazy_body=True)
async def fullasync(request, response):
response.body = (chunk async for chunk in request)
if __name__ == "__main__":
simple_server(app)
keysBinds=[
["F1","F7","F13","F19"],
["F2","F8","F14","F20"],
["F3","F9","F15","F21"],
["F4","F10","F16","F22"],
["F5","F11","F17","F23"],
["F6","F12","F18","F24"],
]
set1= [4,17,27,22]
set2 = [10,9,11,7]
set3 = [15,18,23,24]
set4= [12,16,20,21]
set5= [6,13,19,26]
set6= [5,3,2,14]
choc=Roll(set1,"Choc",400)
led2=Roll(set2,"SX-MINI",100)
mx=Roll(set3,"Mx",400)
led1=Roll(set4,"SX6812-E",100)
diode=Roll(set5,"Diode",100)
led3=Roll(set6,"SX-50-50",100)
rolls=[
led3,
led1,
led2,
choc,
mx,
diode,
]
def app():
app_ = Roll()
traceback(app_)
return app_
elif args[j] == left_sep:
depth += 1
self.append(Group(args[i + 1:j], self.depth + 1))
i = j
# check if it is an expression
elif expression.is_expression(arg):
self.append(expression.Expression(arg))
# check if it is a table
elif table.is_table(arg):
self.append(table.Table(arg))
# assume it is a normal roll
else:
self.append(Roll(arg))
# last line of code in the loop
i += 1
if not self.all_tags[tags.YIELD]:
self.__set_yield(firstStatFound or tags.TOTAL)
self.__apply_supertags(self.all_tags)
def __set_yield(self, stat: str):
"""Determines what the group returns upon execution"""
self.all_tags[tags.YIELD] = tags.Tag(tags.YIELD, contents=stat)
self.all_tags[stat] = tags.get_tag(stat, [])
def __apply_supertags(self, _tags: list):
def test_choose():
roll = Roll()
choice = roll.choose()
assert choice == "Rock"
roll_number += 1
print("\nRound ",
round_number,
" - Roll ",
roll_number,
" - Point ",
point,
sep='')
# get user input for dice
die1 = ask_roll(1)
die2 = ask_roll(2)
# create Roll object with each die
roll = Roll(die1, die2)
dice_total = roll.get_dice_total()
# append every roll to a list
roll_list.append(roll)
print(dice_total)
# if comeout roll
if (roll_number == 1):
# if craps -- don't pass win
if (dice_total == 2 or dice_total == 3):
round_over = 1
print("Result: Craps")
# if craps -- don't pass push
elif (dice_total == 12):
from roll import Roll
from admin import Admin
from profile import Profile
from information import Information
from wishlist import Wishlist
from trade import Trade
from images import Images
intents = discord.Intents.default()
intents.members = True
load_dotenv()
BOT_TOKEN = os.getenv('BOT_TOKEN')
bot = commands.Bot(command_prefix='*', intents=intents)
bot.add_cog(Roll(bot))
bot.add_cog(Admin(bot))
bot.add_cog(Profile(bot))
bot.add_cog(Information(bot))
bot.add_cog(Wishlist(bot))
bot.add_cog(Trade(bot))
bot.add_cog(Images(bot))
#### Bot commands ####
@bot.command()
async def ping(ctx):
await ctx.message.delete()
await ctx.send('Yup, I\'m awake.', delete_after=5)
__author__ = "Mikron"
__version__ = "0.0-dev"
from roll import Roll
dice = [6, 6, 20]
if __name__ == "__main__":
rolls = Roll(dice)
roll_results = rolls.get_rolls()
for roll in roll_results:
print("Roll: " + str(roll) + "\n")
def build_the_three_rolls():
rock = Roll('rock')
paper = Roll('paper')
scissors = Roll('scissors')
rolls = [rock, paper, scissors]
return rolls
def make_choice(self):
if self.kind == 'computer':
return Roll.random_choice()
else:
return Roll(input('Select rock, paper or scissors. '))
import random
from roll import Roll
DRAW = 0
WIN = 1
LOSE = -1
roll = Roll()
truth_table = roll.truth_table
attack_options = roll.rolls
class Player:
def __init__(self, name):
self.name = name
self.score = 0
def attack(self):
while True:
print(f"{self.name}, select an attack:")
roll.print_attack_options()
attack = input("------->")
try:
attack_id = int(attack)
attack = attack_options[attack_id]
print(f"{self.name} chose to attack with {attack}")
return attack
except ValueError:
raise
except KeyError:
raise
def choose_dice(self, sheet, roll, rolls_remaining):
dice = optimal_strategy.queryMove(self.state_potentials,
sheet.as_bitmask(), roll.as_list(),
rolls_remaining)
roll = Roll(dice)
return roll