def move(self, row: int, col: int) -> bool:
"makes the move after checking if move is valid"
# displaying move
# move must be on grid
if not rules.Rules().moveIsOnGrid(self._board, row, col):
#print("INVALID: move is off grid")
return False
# move must be available
if rules.Rules().moveIsTaken(self._board, row, col):
#print("INVALID: move is unavailable")
return False
# move must have adjacent enemies
if not rules.Rules().moveHasAdjacentEnemies(self._board, row, col,
self.get_enemy_kind()):
#print("INVALID: no adjacent opponents")
return False
# move must have flippable enemies
if not rules.Rules().moveHasFlippableEnemies(self._board, row, col,
self.get_ally_kind(),
self.get_enemy_kind()):
#print("INVALID: no flippable opponents")
return False
# all conditions are satisfied
self._board.set_piece(row, col, self.get_ally_kind())
# flipping pieces
pieces = search.Search().getFlippableEnemies(self._board, row, col,
self.get_ally_kind(),
self.get_enemy_kind())
for piece in pieces:
piece.flip()
return True
def getAllMoves(self, board: board.Board, enemy_kind, ally_kind) -> list:
"list of all available moves pieces on ally_kind"
move = []
for row in range(board.get_rows()):
for col in range(board.get_columns()):
if rules.Rules().moveIsTaken(board, row, col) == True:
continue
if rules.Rules().moveIsOnGrid(board, row, col) == False:
continue
if rules.Rules().moveHasFlippableEnemies(
board, row, col, ally_kind, enemy_kind) == False:
continue
move.append(board.get_piece(row, col))
return move
def __init__(self):
""" Nothing much really for users to change here ... except change the name """
super().__init__()
self.filter_name = 'BW'
self._rules = rules.Rules(
) # We only want to do this once, so it's part of BW
log.info("{}".format(self.say_hi()))
def __init__(self, wzrd, db):
'''
(Wizard, Database) -> None
Initial class creation:
- Creates supporting Scenario class with initial session parameters
- Gets parameters and players from wizard.
- Makes self as the players session.
'''
self.id = wzrd.id
self.db = db
self.players = wzrd.players
self.rules = rules.Rules(self)
self.map = []
self.scenario = scenario.Scenario(wzrd.conditions['scenario'], self,
self.db)
self.phase = 'allocation' # Allocation/Day/Evening/Night
self.log = {} # Game events that will be show to player
self.round = 1
self.points = {}
self.first_turn = self.players[0]
self.player_turn = self.players[0]
self.turn_start_time = time.time()
for player in self.players:
player.set_session(self)
self.scenario.initial_setup()
return None
def test_part_one(self):
"Test part one example of Rules object"
# 1. Create Rules object from text
myobj = rules.Rules(text=aoc_07.from_text(PART_ONE_TEXT))
# 2. Check the part one result
self.assertEqual(myobj.part_one(verbose=False), PART_ONE_RESULT)
def get_bet(player):
rules = r.Rules()
bet = float(raw_input(player.name + ", Enter bet: "))
while bet > rules.max_bet:
bet = get_bet(player)
# TODO something about negative bets here
return bet
def test_part_two(self):
"Test part two example of Rules object"
# 1. Create Rules object from text
myobj = rules.Rules(part2=True, text=aoc_07.from_text(PART_TWO_TEXT))
# 2. Check the part two result
self.assertEqual(myobj.part_two(verbose=False), PART_TWO_RESULT)
def test_try_rules(self):
"Test the Rules try_rules() method"
# 1. Create Rules object from text
myobj = rules.Rules(text=aoc_19.from_text(EXAMPLE_TEXT))
# 2. Make sure it has the expected values
self.assertEqual(len(myobj.text), 11)
self.assertEqual(len(myobj.rules), 6)
# 3. Check method
self.assertEqual(myobj.try_rules('', 'a'), ['a'])
self.assertEqual(myobj.try_rules('4', 'a'), [''])
self.assertEqual(myobj.try_rules('4', 'b'), [])
self.assertEqual(myobj.try_rules('4 4', 'aa'), [''])
self.assertEqual(myobj.try_rules('4 4', 'aaa'), ['a'])
self.assertEqual(myobj.try_rules('4 4', 'aab'), ['b'])
self.assertEqual(myobj.try_rules('4 4', 'abb'), [])
self.assertEqual(myobj.try_rules('5', 'a'), [])
self.assertEqual(myobj.try_rules('5', 'b'), [''])
self.assertEqual(myobj.try_rules('2', 'a'), [])
self.assertEqual(myobj.try_rules('2', 'aa'), [''])
self.assertEqual(myobj.try_rules('2', 'bbb'), ['b'])
self.assertEqual(myobj.try_rules('2', 'ab'), [])
self.assertEqual(myobj.try_rules('3', 'bb'), [])
self.assertEqual(myobj.try_rules('3', 'ab'), [''])
self.assertEqual(myobj.try_rules('1', 'a'), [])
self.assertEqual(myobj.try_rules('1', 'aa'), [])
self.assertEqual(myobj.try_rules('1', 'ab'), [])
self.assertEqual(myobj.try_rules('1', 'aaaa'), [])
self.assertEqual(myobj.try_rules('1', 'aaab'), [''])
self.assertEqual(myobj.try_rules('1', 'bbaba'), ['a'])
self.assertEqual(myobj.try_rules('1', 'abbb'), [''])
self.assertEqual(myobj.try_rules('2 3', 'a'), [])
self.assertEqual(myobj.try_rules('2 3', 'aa'), [])
self.assertEqual(myobj.try_rules('2 3', 'bb'), [])
self.assertEqual(myobj.try_rules('2 3', 'ab'), [])
self.assertEqual(myobj.try_rules('2 3', 'aaaa'), [])
self.assertEqual(myobj.try_rules('2 3', 'aaab'), [''])
self.assertEqual(myobj.try_rules('2 3', 'bbaba'), ['a'])
self.assertEqual(myobj.try_rules('2 3', 'abbb'), [])
self.assertEqual(myobj.try_rules('3 2', 'abbb'), [''])
self.assertEqual(myobj.try_rules('3 2', 'abaaa'), ['a'])
self.assertEqual(myobj.try_rules('0', 'ab'), [])
self.assertEqual(myobj.try_rules('0', 'aaaa'), [])
self.assertEqual(myobj.try_rules('0', 'abbb'), [])
self.assertEqual(myobj.try_rules('0', 'ababbb'), [''])
self.assertEqual(myobj.try_rules('0', 'abbbab'), [''])
self.assertEqual(myobj.try_rules('0', 'bababa'), [])
self.assertEqual(myobj.try_rules('0', 'aaabbb'), [])
self.assertEqual(myobj.try_rules('0', 'aaaabbb'), ['b'])
self.assertEqual(myobj.try_rules('4 1 5', 'abbb'), [])
self.assertEqual(myobj.try_rules('4 1 5', 'ababbb'), [''])
self.assertEqual(myobj.try_rules('4 1 5', 'abbbab'), [''])
self.assertEqual(myobj.try_rules('4 1 5', 'bababa'), [])
self.assertEqual(myobj.try_rules('4 1 5', 'aaabbb'), [])
self.assertEqual(myobj.try_rules('4 1 5', 'aaaabbb'), ['b'])
def test_text_init(self):
"Test the Rules object creation from text"
# 1. Create Rules object from text
myobj = rules.Rules(text=aoc_07.from_text(EXAMPLE_TEXT))
# 2. Make sure it has the expected values
self.assertEqual(myobj.part2, False)
self.assertEqual(len(myobj.text), 9)
self.assertEqual(len(myobj.rules), 9)
def test_empty_init(self):
"Test the default Rules creation"
# 1. Create default Rules object
myobj = rules.Rules()
# 2. Make sure it has the default values
self.assertEqual(myobj.part2, False)
self.assertEqual(myobj.text, None)
self.assertEqual(len(myobj.rules), 0)
def options():
action = ui.options()
if (action == 'r'):
print r.Rules()
elif (action == 's'):
players = f.read_players()
for plr in players:
print "Stats for", plr
plr.stats.print_stats()
else:
pass
def allyFoundAtLineEnd(self, board: board.Board, enemy_line: list,
row_delta: int, col_delta: int,
ally_kind: str) -> bool:
"used in get flippable enemies function"
last_piece = enemy_line[len(enemy_line) - 1]
search_row = last_piece.get_row() + row_delta
search_col = last_piece.get_col() + col_delta
if not rules.Rules().moveIsOnGrid(board, search_row, search_col):
return False
piece = board.get_piece(search_row, search_col)
if not piece.get_kind() == ally_kind:
return False
return True
def __init__(self, game_area):
self.rules = r.Rules()
self.pack = c.Pack()
self.discard_pack = c.Pack()
self.dealer = p.Player('Dealer')
self.dealer.hand_list.append(c.Hand())
self.players = []
# There should be a better way. see if-elses later on.
self.GUI = False
self.game_area = game_area
def getAdjacentPieces(self, board: board.Board, row: int,
column: int) -> list:
"list of all adjacent pieces givent a row,column coordinate"
pieces = []
for i in range(3):
row_delta = i - 1
for j in range(3):
col_delta = j - 1
search_row = row + row_delta
search_col = column + col_delta
if (rules.Rules().moveIsOnGrid(board, search_row, search_col)):
piece = board.get_piece(search_row, search_col)
pieces.append(piece)
return pieces
def part_two(args, input_lines):
"Process part two of the puzzle"
# 1. Create the puzzle solver
solver = rules.Rules(part2=True, text=input_lines)
# 2. Determine the solution for part two
solution = solver.part_two(verbose=args.verbose, limit=args.limit)
if solution is None:
print("There is no solution")
else:
print("The solution for part two is %s" % (solution))
# 3. Return result
return solution is not None
def getEnemiesInLine(self, board: board.Board, first_enemy: piece.Piece,
row_delta: int, col_delta: int) -> list:
'runs at least once and updates the current piece at the end of looop'
"used in getFlippableEnemies"
pieces = []
current_piece = first_enemy
while True:
if not current_piece.get_kind() == first_enemy.get_kind():
break
pieces.append(current_piece)
search_row = current_piece.get_row() + row_delta
search_col = current_piece.get_col() + col_delta
if not rules.Rules().moveIsOnGrid(board, search_row, search_col):
break
current_piece = board.get_piece(search_row, search_col)
return pieces
def __init__(self):
"""Initialize variables and connect actions with functions."""
super(Ui, self).__init__()
uic.loadUi(os.path.join(CURRDIR, "ui", "main_simpledms.ui"), self)
self.loadpref()
self.rules = rules.Rules(self.pref["dmsroot"])
self.currentselectedrulesfolder = None
self.currentselectedsearchfolder = None
self.current_monitorfolder_index = None
self.parent_index = None
self.filemodelmonitor = QFileSystemModel()
self.rulesfoldermodel = QFileSystemModel()
self.resultfoldermodel = QFileSystemModel()
self.searchfoldermodel = QFileSystemModel()
self.textEdit_tags = MyTextEdit(self.textEdit_tags)
self.updateui_settings()
self.updateui_pdfrename()
self.show()
# Connect Widget Toolbar Actions
self.actionScan.triggered.connect(self.select_widget)
self.actionPdf.triggered.connect(self.select_widget)
self.actionSettings.triggered.connect(self.select_widget)
self.actionAbout.triggered.connect(self.show_ui_about)
self.actionExit.triggered.connect(self.select_widget)
# Connect Preferences
self.pushButton_setmonitorfolder.clicked.connect(
self.browse_monitor_folder)
self.pushButton_setdmsroot.clicked.connect(self.browse_dms_root)
self.treeView_rulesfolders.clicked.connect(self.rulesfolderselected)
self.treeView_rules.doubleClicked.connect(self.ruledoubleclicked)
self.pushButton_addrule.clicked.connect(self.addruleclicked)
self.pushButton_deleterule.clicked.connect(self.deleteruleclicked)
# Connect page pdf renaming
self.listView_monitorfiles.clicked.connect(
self.listView_monitorfiles_clicked)
self.treeView_output.clicked.connect(self.treeView_output_clicked)
self.pushButton_ok.clicked.connect(self.pushButton_ok_clicked)
self.listView_monitorfiles.doubleClicked.connect(
self.listView_monitorfiles_doubleclicked)
self.lineEdit_outputfilename.textChanged.connect(self.readyforstorage)
self.pushButton_addDate.clicked.connect(
self.pushButton_addDate_clicked)
def test_match_rule(self):
"Test the Rules match_rule() method"
# 1. Create Rules object from text
myobj = rules.Rules(text=aoc_19.from_text(EXAMPLE_TEXT))
# 2. Make sure it has the expected values
self.assertEqual(myobj.part2, False)
self.assertEqual(len(myobj.text), 11)
self.assertEqual(len(myobj.rules), 6)
self.assertEqual(len(myobj.messages), 5)
# 3. Check method
self.assertEqual(myobj.match_rule(0, 'a'), False)
self.assertEqual(myobj.match_rule(1, 'a'), False)
self.assertEqual(myobj.match_rule(2, 'a'), False)
self.assertEqual(myobj.match_rule(3, 'a'), False)
self.assertEqual(myobj.match_rule(4, 'a'), True)
self.assertEqual(myobj.match_rule(5, 'a'), False)
self.assertEqual(myobj.match_rule(5, 'b'), True)
self.assertEqual(myobj.match_rule(2, 'a'), False)
self.assertEqual(myobj.match_rule(2, 'aa'), True)
self.assertEqual(myobj.match_rule(2, 'ab'), False)
self.assertEqual(myobj.match_rule(2, 'bb'), True)
self.assertEqual(myobj.match_rule(2, 'aaaabb'), False)
self.assertEqual(myobj.match_rule(3, 'a'), False)
self.assertEqual(myobj.match_rule(3, 'aa'), False)
self.assertEqual(myobj.match_rule(3, 'ab'), True)
self.assertEqual(myobj.match_rule(3, 'bb'), False)
self.assertEqual(myobj.match_rule(3, 'aaaabb'), False)
self.assertEqual(myobj.match_rule(1, 'a'), False)
self.assertEqual(myobj.match_rule(1, 'aa'), False)
self.assertEqual(myobj.match_rule(1, 'ab'), False)
self.assertEqual(myobj.match_rule(1, 'bb'), False)
self.assertEqual(myobj.match_rule(1, 'aaaa'), False)
self.assertEqual(myobj.match_rule(1, 'aaab'), True)
self.assertEqual(myobj.match_rule(1, 'abaa'), True)
self.assertEqual(myobj.match_rule(1, 'aaaabb'), False)
self.assertEqual(myobj.match_rule(0, ''), False)
self.assertEqual(myobj.match_rule(0, 'ababbb'), True)
self.assertEqual(myobj.match_rule(0, 'abbbab'), True)
self.assertEqual(myobj.match_rule(0, 'bababa'), False)
self.assertEqual(myobj.match_rule(0, 'aaabbb'), False)
self.assertEqual(myobj.match_rule(0, 'aaaabbb'), False)
def test_text_init(self):
"Test the Rules object creation from text"
# 1. Create Rules object from text
myobj = rules.Rules(EXAMPLE_TEXT)
# 2. Make sure it has the expected values
self.assertEqual(myobj.part2, False)
self.assertEqual(myobj.text, EXAMPLE_TEXT)
self.assertEqual(len(myobj.rules), 3)
self.assertEqual(len(myobj), 3)
# 3. Test methods
self.assertEqual(myobj.is_valid(1), True)
self.assertEqual(myobj.is_valid(4), False)
self.assertEqual(myobj.is_valid(6), True)
self.assertEqual(myobj.is_valid(11), True)
self.assertEqual(myobj.is_valid(12), False)
self.assertEqual(myobj.is_valid(45), True)
self.assertEqual(myobj.is_valid(99), False)
def process_text(self, text):
"Process the three part input"
# 1. Start with the rules
self.rules = rules.Rules(text=text, part2=self.part2)
# 2. Process your ticket
found = False
for line in text:
if found:
self.mine = ticket.Ticket(text=line, part2=self.part2)
break
if line.startswith('your ticket'):
found = True
# 3. Process the other ticket
found = False
for line in text:
if found:
self.nearby.append(ticket.Ticket(text=line, part2=self.part2))
continue
if line.startswith('nearby ticket'):
found = True
bigDir = 1024 ** 3
hname = "help"
infoKey = {
"modifyTime" : "修改时间",
"createTime" : "创建时间",
"fileLength" : "文件大小",
"parentDir" : "上级目录",
"fileName" : "文件名",
"fileType" : "文件类型"
}
arguments = deque(maxlen = 1)
analyser = rules.Analyser('', []) # 文件分析器
opreators = rules.opreators.functions # 所有注册操作
opreatorList = list(opreators.keys()) # 显示用操作列表
division = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB'] # 文件单位
rulefunctions = rules.Rules() # 操作函数实例
opreatorList.sort()
webOpen = lambda target : webbrowser.open(target)
cleanTree = lambda treeview : treeview.delete(*treeview.get_children())
removeSelect = lambda treeview : [treeview.delete(treeview.selection()[0]) if treeview.focus() else None]
getSelectValue = lambda treeview : treeview.item(treeview.focus())
openDir = lambda location : os.system("explorer.exe %s" % location)
# author : [email protected]
# 返回文件详情页面需要的字符
def fileInfo(location, fileName):
fileLocation = location + "/" + fileName
fileInfo = basic.getFileInfo(fileLocation)
string = list()
# -*- coding: utf-8 -*-
"""
Obtenir tous les états menant à tout mort en partant de l'état tout mort et
en remontant aux états qui mènent à cet état, et en remontant aux états qui
mènent à ces états ...
"""
import rules as rl
import time
print("[Backward]")
height = input("Hauteur de la grille : ")
width = input("Largeur de la grille : ")
print("*****")
start_time = time.time()
r = rl.Rules(int(height), int(width)) # création d'un objet Rules
end = False
result = [r.allDead()
] # liste des états menant à tout mort initialisée avec tout mort
while not end:
end = True
for state in r.getAll():
if any((state == x).all() for x in result):
continue
elif any((r.next(state) == x).all() for x in result):
result.append(state)
end = False
print("Proportion d'états menant à tout mort :")
print(len(result), "/", 2**(int(height) * int(width)))
print("--- %s seconds ---" % (time.time() - start_time))
import sys, random, math, pygame
from pygame.locals import *
from math import sqrt, cos, sin, atan2, pi
from time import sleep
import playGround as pg
import weasel
import rules
import turtle
groundRules = rules.Rules()
ball1 = weasel.WeaselBall('ball1', {
'xloc': 2.25,
'yloc': .4
},
velocity=.25,
orientation=27)
ball2 = weasel.WeaselBall('ball2', {
'xloc': .25,
'yloc': .25
},
velocity=.25,
orientation=105)
ball3 = weasel.WeaselBall('ball1', {
'xloc': 1.25,
'yloc': 2.4
},
velocity=.25,
orientation=290)
playPlace = pg.PlayGround(groundRules)
print playPlace.xbound
def __init__(self):
self.rules_db = rules.Rules()
add_builtins(self.rules_db)
self.expressions_to_print = {}
self.compiled_files = set()
def __init__(self):
self.rules = rules.Rules()
self.playPlace = playGround.PlayGround(self.rules)
self.window = turtle.Screen()
turtle.setworldcoordinates(0,0,self.playPlace.xbound, self.playPlace.ybound)
self.window.colormode(255)
def placeholder3(screen):
pygame.mixer.music.fadeout(1500)
rules.Rules(screen)
pass
rule.show_rules()
def open_cubes(self):
cube.show()
def open_history(self):
his.show()
his.show_history()
if __name__ == "__main__":
import sys
# create app
app = QtWidgets.QApplication(sys.argv)
# main window
showMain = Main()
showMain.show()
# answer
ans = answer.Answer()
# letters
letter = letters.Letters()
# rules
rule = rules.Rules()
# cubes
cube = cubes.Cubes()
# history
his = history.History()
# run main loop
sys.exit(app.exec_())
import tensorflow as tf
import numpy as np
import random
import rules
from utils import one_hot_encode_cards, translate_cards_to_str, one_hot_encode_position, one_hot_encode_protocol
model = tf.keras.models.load_model(
'/home/pirate/PycharmProjects/SchafkopfAI/models/trained_models/bidding-pos-nn'
)
hands = []
position = 0
protocol = [None, None, None, None]
for i in range(100):
hand = [hand for hand in random.sample(rules.Rules().cards, 8)]
hands.append(hand)
for hand in hands:
prediction = model.predict(
x={
'x1': np.array([one_hot_encode_cards(hand)]),
'x2': np.array([one_hot_encode_position(position)]),
'x3': np.array([one_hot_encode_protocol(protocol)])
})
choice = np.argsort(np.max(prediction, axis=0))[-1]
if choice == 0 and 0.5 < np.amax(prediction) < 0.85:
second_choice = np.argsort(np.max(prediction, axis=0))[-2]
print(f"Cards: {translate_cards_to_str(hand)}, Position: {position},\n"
f"First Choice: {rules.Rules().games[choice + 1]}),\n"
f"Second Choice: {rules.Rules().games[second_choice + 1]}, \n"
def enemy_can_move(self) -> bool:
"returns bool to check for enemy moves"
enemy_moves = rules.Rules().moveIsAvailable(self._board,
self.get_enemy_kind(),
self.get_ally_kind())
return enemy_moves
