def main():
# Create Problem
polynomial = Polynomial(num_terms=5, num_dimensions=2)
log.info(polynomial)
# Define Search Range
search_range = SearchRange()
search_range.set_feasible_range(10000, 2)
# Solvers
# brute_force_solver = BruteForceSolver(search_range)
genetic_algorithm_solver = GeneticAlgorithmSolver(search_range)
gui = Gui(polynomial, search_range)
# benchmark = Benchmark([brute_force_solver, genetic_algorithm_solver])
benchmark = Benchmark([genetic_algorithm_solver])
# Benchmark
benchmark.evaluate(polynomial)
# Visualize Solvers
# gui.create_animation(brute_force_solver)
animation = gui.create_animation(genetic_algorithm_solver)
# Create Default Visual
# gui.plot_problem()
gui.show()
def setUp(self):
from gui.gui import Gui
self.gui = Gui()
self.panel = self.gui.create(Panel)
self.panel.rect = Rect(50, 80, 100, 120)
self.panel.padding = Rect(2, 3, 5, 11)
self.panel.margins = Rect(17, 23, 29, 37)
self.panel.layout_dirty = False
self.gui.world.layout_dirty = False
def __init__(self):
self._detect = GPIODetect(self.gpio_detect)
self._detect.setup()
self._detect.detct()
self._sysInfo.setcommCallback(self.get_system_info)
# DBG("Welcome to Controller!")
self._scannerble = ScannerBLE(self.scanner_comm, "hci0")
self._gui = Gui(self.gui_comm)
# 注册信号处理函数
self._thread.signal.connect(self.update_ui)
self._thread.start()
self._gui.start_gui()
def start_gui():
board = GuiBoard(9, 9)
strategy = Strategy()
p1 = GuiHuman('x', board)
p2 = Computer('0', board, strategy)
game = GuiGame(p1, p2, board)
root = tkinter.Tk()
my_gui = Gui(root, game)
root.mainloop()
def __init__(self):
# register signal handler
signal.signal(signal.SIGINT, self._signal_handler)
signal.signal(signal.SIGTERM, self._signal_handler)
# flag for activity before quit
self.is_running = True
self.is_sig = False
# user's attributes
self.nick = None
self.ip = None
self.port = None
# create Hnefatafl
self.hnef = Hnefatafl()
# create client network
self.net = Network(self)
# create gui
self.gui = Gui(self)
def main():
while True:
gui = Gui()
game = Game(gui)
gui.player_bet.destroy()
for widget in gui.player_info_frame.winfo_children():
widget.destroy()
new_round = messagebox.askquestion("New game?")
if new_round == "no":
gui.root.destroy()
break
else:
gui.root.destroy()
return
def main():
os.environ.setdefault("INFERENCE_SETTINGS_MODULE", "settings")
arg_list = ["read", "test"]
parser = argparse.ArgumentParser(prog="manage.py", description="Inference:\
a tool to infer missing data from its context")
parser.add_argument("-i", "--data", help="File name of the data file stored in data/",
type=str, action="store", default=False)
parser.add_argument("-u", "--upload", help="Add this to upload data through the gui",
action="store_true")
parser.add_argument("-t", "--test", help="Runs all tests. For develpment use only",
action="store_true")
args = parser.parse_args()
if not args.data and args.upload:
# start gui uploader
root = tk.Tk()
root.title("Iference")
root.geometry('500x500')
gui = Gui(master=root)
gui.mainloop()
if args.data:
# start some work with the data
data = Data(args.data)
data.load_data()
def testNetwork(inputCount, hiddensCount, outputCount, patterns, initSetup=None, cycles=1000, learnRate=0.9, momentumRate=0.4, activationFn=fnSigmoid(1), stopEarly=False, gui=False, metadata=defaultMetadata):
""" Tests a network based on the number of nodes provided and the test patterns.
Does nothing if succeeds, else prints failure string.
inputCount -- number of input nodes
hiddensCount -- list of number of hidden nodes for respective layers
outputCount -- number of output nodes
initSetup -- initial node weights / biases (default None, random) e.g. ([[[input1hiddens], [input2hiddens] ...], [[hidden1outputs], [hidden2outputs] ...]], [[hidden1biases], [hidden2biases], ... [outputbiases]])
patterns -- training patterns ([inputs], [expected outputs], [conditions], [failure string])
cycles -- number of epochs to train for (default 10)
learnRate -- rate of learning (default 0.9)
momentumRate -- weight of previous deltas (default 0.4)
activationFn -- activation function for neurons (default fnSigmoid(1))
stopEarly -- stop when all patterns succeed (default False)
gui -- boolean for gui testing (default False)
metadata -- TestMetadata object (default None)
"""
net = makeNetwork(inputCount, hiddensCount, outputCount, initSetup, activationFn)
for cycle in range(1, cycles + 1):
if gui:
Gui.drawNetwork(net, title=metadata.testName)
if net.train(patterns, learnRate, momentumRate, stopEarly):
break
# Testing
for (inputStates, _, conds, failureString) in patterns:
for (s, i) in zip(inputStates, net.getInputNodes()):
i.setState(s)
net.fireAll()
print("Input " + str(inputStates) +", Output " + str(net.getOutputNodes()[0].state))
for (out, cond) in zip(map(lambda o: o.state, net.getOutputNodes()), conds):
if not testResult(cond(out), failureString):
return
print("Passed after {0} cycles".format(cycle))
'''
BLACK-AND-WHITE
WinterSalmon
Main
'''
from gui.gui import Gui
from cli.cli import Cli
if __name__ == "__main__":
# if pygame is not installed run game in commandline mode
try:
UI = Gui()
except ImportError:
UI = Cli()
UI.init_screen()
UI.game_screen()
UI.credit_screen()
def run_benchmark(root_folder, times, feasible_ranges, polynomial=None):
if not os.path.exists(root_folder):
log.info('Creating Folder')
os.makedirs(root_folder)
# Create Problem
if not polynomial:
polynomial = Polynomial(num_terms=5, num_dimensions=2)
log.info(polynomial)
for feasible_range in feasible_ranges:
search_range = SearchRange()
search_range.set_feasible_range(feasible_range, 2)
folder = os.path.join(root_folder,
'feasible_range_{}'.format(feasible_range))
solution_payload = {}
if not os.path.exists(folder):
os.mkdir(folder)
for i in range(times):
# Create Folder
run_folder = os.path.join(folder, 'run_{}'.format(i))
if not os.path.exists(run_folder):
os.mkdir(run_folder)
# Solvers
brute_force_solver = BruteForceSolver(search_range)
genetic_algorithm_solver = GeneticAlgorithmSolver(search_range)
solvers = [brute_force_solver, genetic_algorithm_solver]
# Benchmark
benchmark = Benchmark(solvers)
benchmark.evaluate(polynomial)
# Add to Benchmark
for solver in solvers:
metric = benchmark.get_metrics(solver._id)
add_to_benchmark_payload(solution_payload, solver, metric)
# Save Animations
gui = Gui(polynomial, search_range)
genetic_animation = gui.create_animation(
genetic_algorithm_solver)
genetic_animation.save(os.path.join(run_folder, 'genetic.gif'),
writer='imagemagick',
fps=30)
brute_animation = gui.create_animation(brute_force_solver)
brute_animation.save(os.path.join(run_folder, 'brute.gif'),
writer='imagemagick',
fps=30)
# Save Problem
figure, plot = gui.plot_problem()
figure.savefig(os.path.join(run_folder, 'problem.png'))
# Pickle benchmark && solvers && polynomial
pickle_object(
genetic_algorithm_solver,
os.path.join(run_folder, 'genetic_solver.pickle'))
pickle_object(brute_force_solver,
os.path.join(run_folder, 'brute_solver.pickle'))
pickle_object(benchmark,
os.path.join(run_folder, 'brute_solver.pickle'))
pickle_object(gui, os.path.join(run_folder, 'gui.pickle'))
# Clear Matplotlib figures
gui.close()
pickle_object(solution_payload,
os.path.join(folder, 'benchmark.pickle'))
from gui.threadgui import ThreadGui
from camera.camera import Camera
from camera.threadcamera import ThreadCamera
from detector.detector import Detector
from detector.threaddetector import ThreadDetector
import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)
if __name__ == '__main__':
camera = Camera()
print(camera)
app = QtGui.QApplication(sys.argv)
window = Gui(camera)
detector = Detector(camera, window)
print(detector)
t_cam = ThreadCamera(camera)
t_cam.start()
t_detector = ThreadDetector(detector)
t_detector.start()
window.setCamera(camera, t_cam)
window.show()
window.setDetector(detector, t_detector)
window.show()
def main(stdscr):
from gui.gui import Gui
log.init()
Gui(stdscr)
def main():
ui = Gui()
ui.mainloop()
from gui.threadgui import ThreadGui
from camera.camera import Camera
from camera.threadcamera import ThreadCamera
from detector.detector import Detector
from detector.threaddetector import ThreadDetector
import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)
if __name__ == '__main__':
camera = Camera()
print(camera)
app = QtGui.QApplication(sys.argv)
window = Gui(camera)
detector = Detector(camera, window)
print(detector)
t_cam = ThreadCamera(camera)
t_cam.start()
t_detector = ThreadDetector(detector)
t_detector.start()
window.setCamera(camera, t_cam)
window.show()
window.setDetector(detector, t_detector)
window.show()
class Controller:
_scannerble = None
_gui = None
conn = None
array_full = []
# 创建线程
_thread = UIThread()
_sysInfo = GetSysInfo()
_detect = None
def __init__(self):
self._detect = GPIODetect(self.gpio_detect)
self._detect.setup()
self._detect.detct()
self._sysInfo.setcommCallback(self.get_system_info)
# DBG("Welcome to Controller!")
self._scannerble = ScannerBLE(self.scanner_comm, "hci0")
self._gui = Gui(self.gui_comm)
# 注册信号处理函数
self._thread.signal.connect(self.update_ui)
self._thread.start()
self._gui.start_gui()
def beacon_comm(self, msg):
# DBG("Welcome to beacon_comm!")
if msg.get_type() is IntMessage.BEACON_DATA_ERROR: # pass input error back to GUI
self._gui.comm(IntMessage(IntMessage.ALERT_GUI, {'ALERT_TEXT': "Your input is not correct!",
'ALERT_DETAIL': msg.get_payload()['ERROR']}))
def gui_comm(self, msg):
if not isinstance(msg, IntMessage):
raise Exception("Message has to be an IntMessage")
msg_type = msg.get_type()
# start different beacon standards
if msg_type is IntMessage.START_SCAN_BLE:
self._scannerble.scan()
elif msg_type is IntMessage.STOP_SCAN_BLE:
DBG('Stopped BLE Scan')
self._scannerble.stop_scan()
elif msg_type is IntMessage.GETSYSINFO:
self._sysInfo.detct()
elif msg_type is IntMessage.STOPGETSYSINFO:
self._sysInfo.cleanup()
elif msg_type is IntMessage.QUITAPP:
self._sysInfo.cleanup()
self._scannerble.stop_scan()
self._detect.cleanup()
@staticmethod
def scanner_comm(msg):
dic = {'type': int(msg.get_type()), 'pyload': str(msg.get_payload())}
g_data_queue.put(json.dumps(dic))
def update_ui(self, msg):
dic = json.loads(msg)
self._gui.comm(IntMessage(dic['type'], eval(dic['pyload'])))
@staticmethod
def gpio_detect(msg):
dic = {'type': msg, 'pyload': '{}'}
# msg1 = IntMessage(IntMessage.SCANNED_IBEACON,
# {'UUID': '111', 'MAJOR': '333', 'MINOR': '444', 'TX': '5555', 'RSSI': '6666',
# 'time': time.time()})
# dic = {'type': int(msg1.get_type()), 'pyload': str(msg1.get_payload())}
g_data_queue.put(json.dumps(dic))
@staticmethod
def get_system_info(msg):
DBG('get_system_info')
dic = {'type': int(msg.get_type()), 'pyload': str(msg.get_payload())}
g_data_queue.put(json.dumps(dic))
@staticmethod
def dummy_fun(msg):
DBG(msg)
class Application:
def __init__(self):
# register signal handler
signal.signal(signal.SIGINT, self._signal_handler)
signal.signal(signal.SIGTERM, self._signal_handler)
# flag for activity before quit
self.is_running = True
self.is_sig = False
# user's attributes
self.nick = None
self.ip = None
self.port = None
# create Hnefatafl
self.hnef = Hnefatafl()
# create client network
self.net = Network(self)
# create gui
self.gui = Gui(self)
def _signal_handler(self, sig, frame):
self.is_running = False
self.is_sig = True
self.gui.destroy()
logger.info("Closing client with signal.")
def run(self):
# start network
self.net.start()
# start the application -- has to be last command,
# because it runs, until the window is closed == everything else freezes
self.gui.mainloop()
# if windows was closed with button or cross, set flag in standard way
self.is_running = False
if not self.is_sig:
logger.info("Closing client standard way.")
# notify network thread, in order to end it
with self.net.cv:
self.net.cv.notify()
# join Network thread
self.net.join()
# print statistics through lifetime
self.net.pr_statistics()
def hnef_connect(self, nick, ip, port):
self.nick = nick
self.ip = "127.0.0.1" if ip == "localhost" else ip
self.port = int(port)
# connect to server
self.net.connect(self.nick, self.ip, self.port)
def gui_connected(self):
self.gui.make_connected()
def gui_disconnected(self):
self.gui.make_disconnected()
def send_to_server(self, code, value=None):
self.net.send_msg(code, value)
def send_to_chat(self, msg, bot):
self.gui.chat_msg_server(msg, bot, self.hnef.nick_opponent)
def send_to_menu(self, msg):
self.gui.set_state(msg)
def is_in_game(self):
# True, if somebody is on turn -- means game is on
return self.hnef.on_turn is not None
def start_game(self, turn, opn_name):
# start new game in Hnefatafl class
self.hnef.new_game(turn, opn_name)
# switch frame in GUI, so user can play
self.gui.new_game(self.nick, self.hnef.game_state, self.hnef.pf, self.hnef.allowed_squares)
# tell player, who is on turn
self.send_to_chat("'{}' is black and on turn.".format(self.nick if turn else opn_name), bot=True)
def leave_game(self):
self.send_to_server(protocol.CC_LEAV)
self.hnef.quit_game()
def reset_game(self, turn, nick_opn, pf):
# reset game in Hnefatafl class
self.hnef.reset_game(turn, nick_opn, pf)
# not actually new game -- it has state like in received message from server
self.gui.new_game(self.nick, self.hnef.game_state, self.hnef.pf, self.hnef.allowed_squares)
def quit_game(self, result):
# quit game after game-over
self.hnef.quit_game()
self.gui.quit_game(result)
def handle_click(self, x_pos, y_pos):
redraw = True
# playfield have not been clicked
if self.hnef.game_state == Click.THINKING:
# find fields where player may move after click on stone
self.hnef.find_placeable_fields(x_pos, y_pos)
# set position, which is being moved from
self.hnef.x_from = x_pos
self.hnef.y_from = y_pos
# change state to clicked
self.hnef.game_state = Click.CLICKED
# playfield have been clicked
elif self.hnef.game_state == Click.CLICKED:
# field without stone have been clicked -- make a move
if self.hnef.is_field(x_pos, y_pos):
# send move message to server
move = self.compose_move_msg([self.hnef.x_from, self.hnef.y_from, x_pos, y_pos])
self.send_to_server(protocol.CC_MOVE, value=move)
# save also position which is being moved to and move after server's confirmation of valid move
self.hnef.x_to = x_pos
self.hnef.y_to = y_pos
# playfield is updated and redrawn after server's MOVE_VALID message
redraw = False
# field with same stone have been clicked -- go back to thinking state
elif self.hnef.is_same_stone(x_pos, y_pos):
# find stones, which player can move with
self.hnef.find_movables_stones()
# reset position, which is being moved from
self.hnef.x_from = None
self.hnef.y_from = None
# change state to thinking
self.hnef.game_state = Click.THINKING
# field with other stone have been clicked -- find allowed squares again
else:
# find stones, which player can move with
self.hnef.find_movables_stones()
# find fields where player may move after click on stone
self.hnef.find_placeable_fields(x_pos, y_pos)
# set position, which is being moved from
self.hnef.x_from = x_pos
self.hnef.y_from = y_pos
# update playfield in gui
if redraw:
self.gui.pf_update(self.hnef.game_state, self.hnef.pf, self.hnef.allowed_squares)
def move_self(self):
# move chosen stone (after server confirmation -- so use cached values)
self.hnef.move(self.hnef.x_from, self.hnef.y_from, self.hnef.x_to, self.hnef.y_to)
# check captures of local player -- capturing white if local is black
self.hnef.check_captures(self.hnef.is_surrounded_white if self.hnef.black else self.hnef.is_surrounded_black)
# after move, player cannot move anything
self.hnef.allowed_squares.clear()
# update playfield in gui
self.gui.pf_update(self.hnef.game_state, self.hnef.pf, self.hnef.allowed_squares)
def move_opponent(self, x_from, y_from, x_to, y_to):
# move opponent's piece
self.hnef.move(x_from, y_from, x_to, y_to)
# check captures of opponent player -- capturing black if local is black
self.hnef.check_captures(self.hnef.is_surrounded_black if self.hnef.black else self.hnef.is_surrounded_white)
# get pieces of player, who is on turn now
self.hnef.find_movables_stones()
# update playfield in gui
self.gui.pf_update(self.hnef.game_state, self.hnef.pf, self.hnef.allowed_squares)
def compose_move_msg(self, coordinates):
move = ""
for coor in coordinates:
# if number has only one place, so append 0 at beginning according to protocol
# else it is 10 with two places
move += "0" + str(coor) if coor < 10 else str(coor)
return move
import PySimpleGUI as sg
import traceback
import sys
from common.handleconfig import HandleConfig
from gui.gui import Gui
Version = '4.6'
if len(sys.argv) <= 1:
# normal start, run with a gui
# cmd:python D:\Projects\ExcelToDatabase\main.py
# exe:ExcelToDatabase.exe
sg.ChangeLookAndFeel('dark')
HandleConfig = HandleConfig()
Gui = Gui()
def exception_format():
# format exception output
return "".join(
traceback.format_exception(sys.exc_info()[0],
sys.exc_info()[1],
sys.exc_info()[2],
limit=-1))
default_values = HandleConfig.get_defaults()
window = sg.Window('ExcelToDatabase {0}'.format(Version),
Gui.generate_layout(),
location=(700, 50))
while True:
import sys
import argparse
from PyQt5.QtWidgets import QApplication
from gui.gui import Gui
app = QApplication(sys.argv)
app.setOrganizationDomain('rahmedov.com')
app.setObjectName('rahmedov')
app.setApplicationName('rahmedov')
app.setApplicationVersion('0.0.0')
parser = argparse.ArgumentParser(description='Home')
parser.add_argument('-r', '--root', type=str, default='', help='''Root Path''')
args = parser.parse_args()
g = Gui(root=args.root, parent=None)
g.show()
sys.exit(app.exec_())
await run_tk(root)
if __name__ == "__main__":
data = Data([150, 41], [540, 386])
# address = "A6C01837-C772-4ED8-9984-5A006FA27336"
# address = "0880E3E7-E6A4-4367-A655-9C6E130303A9"
address = "C0:98:E5:49:00:00"
parser = argparse.ArgumentParser()
parser.add_argument('--thread', action='store_true', default=False)
parser.add_argument('--ble_debug', action='store_true', default=False)
parser.add_argument('--gui_debug', action='store_true', default=False)
args = parser.parse_args()
root = Gui(data, args.gui_debug)
ble_comm = BleComm(address)
if not args.thread:
loop = asyncio.get_event_loop()
loop.run_until_complete(main_async(root, ble_comm, args.ble_debug))
else:
cv_client = CV_Detector(data)
t1 = Thread(target=cv_client.run_cv)
t1.setDaemon(True)
t1.start()
loop = asyncio.get_event_loop()
loop.run_until_complete(main_async(root, ble_comm, args.ble_debug))
t1.join()
import sys
from PyQt4 import QtGui
from gui.gui import Gui
from gui.threadgui import ThreadGui
from control.control import Control
from control.threadcontrol import ThreadControl
import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)
if __name__ == '__main__':
control = Control()
app = QtGui.QApplication(sys.argv)
print 'app creada'
window = Gui()
window.setControl(control)
window.show()
print 'window'
t1 = ThreadControl(control)
t1.start()
print 'threadcontrol'
t2 = ThreadGui(window)
t2.start()
print 'threadgui'
sys.exit(app.exec_())
class PanelTest(unittest.TestCase):
def setUp(self):
from gui.gui import Gui
self.gui = Gui()
self.panel = self.gui.create(Panel)
self.panel.rect = Rect(50, 80, 100, 120)
self.panel.padding = Rect(2, 3, 5, 11)
self.panel.margins = Rect(17, 23, 29, 37)
self.panel.layout_dirty = False
self.gui.world.layout_dirty = False
def test_rect(self):
self.assertEqual(Rect(50, 80, 100, 120), self.panel.rect)
rect = Rect(11, 22, 33, 44)
self.panel.rect = rect.as_tuple()
self.assertEqual(rect, self.panel.rect)
self.assertTrue(self.panel.layout_dirty)
self.panel.layout_dirty = False
self.panel.rect = rect
self.assertFalse(self.panel.layout_dirty)
self.panel.rect = rect.as_tuple()
self.assertFalse(self.panel.layout_dirty)
def test_padding(self):
self.assertEqual(Rect(2, 3, 5, 11), self.panel.padding)
rect = Rect(11, 22, 33, 44)
self.panel.padding = rect.as_tuple()
self.assertEqual(rect, self.panel.padding)
self.assertTrue(self.panel.layout_dirty)
self.panel.layout_dirty = False
self.panel.padding = rect
self.assertFalse(self.panel.layout_dirty)
def test_margins(self):
self.assertEqual(Rect(17, 23, 29, 37), self.panel.margins)
rect = Rect(11, 22, 33, 44)
self.panel.margins = rect.as_tuple()
self.assertEqual(rect, self.panel.margins)
self.assertTrue(self.panel.layout_dirty)
self.panel.layout_dirty = False
self.panel.margins = rect
self.assertFalse(self.panel.layout_dirty)
def test_inner(self):
self.assertEqual(Rect(52, 83, 93, 106), self.panel.rect_inner)
rect = Rect(22, 33, 44, 55)
self.panel.rect_inner = rect
self.assertEqual(rect, self.panel.rect_inner)
self.assertEqual(Rect(20, 30, 51, 69), self.panel.rect)
self.assertTrue(self.panel.layout_dirty)
self.panel.layout_dirty = False
self.panel.rect_inner = rect
self.assertFalse(self.panel.layout_dirty)
def test_outer(self):
self.assertEqual(Rect(33, 57, 146, 180), self.panel.rect_outer)
rect = Rect(55, 66, 77, 88)
self.panel.rect_outer = rect
self.assertEqual(rect, self.panel.rect_outer)
self.assertEqual(Rect(72, 89, 31, 28), self.panel.rect)
self.assertTrue(self.panel.layout_dirty)
self.panel.layout_dirty = False
self.panel.rect_outer = rect
self.assertFalse(self.panel.layout_dirty)
def test_x(self):
self.assertEqual(50, self.panel.x)
self.panel.x = 127
self.assertEqual(Rect(127, 80, 100, 120), self.panel.rect)
self.assertTrue(self.panel.layout_dirty)
self.panel.layout_dirty = False
self.panel.x = 127
self.assertFalse(self.panel.layout_dirty)
def test_y(self):
self.assertEqual(80, self.panel.y)
self.panel.y = 127
self.assertEqual(Rect(50, 127, 100, 120), self.panel.rect)
self.assertTrue(self.panel.layout_dirty)
self.panel.layout_dirty = False
self.panel.y = 127
self.assertFalse(self.panel.layout_dirty)
def test_width(self):
self.assertEqual(100, self.panel.width)
self.panel.width = 127
self.assertEqual(Rect(50, 80, 127, 120), self.panel.rect)
self.assertTrue(self.panel.layout_dirty)
self.panel.layout_dirty = False
self.panel.width = 127
self.assertFalse(self.panel.layout_dirty)
def test_height(self):
self.assertEqual(120, self.panel.height)
self.panel.height = 127
self.assertEqual(Rect(50, 80, 100, 127), self.panel.rect)
self.assertTrue(self.panel.layout_dirty)
self.panel.layout_dirty = False
self.panel.height = 127
self.assertFalse(self.panel.layout_dirty)
def test_pos(self):
self.assertEqual((50, 80), self.panel.pos)
self.panel.pos = (127, 99)
self.assertEqual(Rect(127, 99, 100, 120), self.panel.rect)
self.assertTrue(self.panel.layout_dirty)
self.panel.layout_dirty = False
self.panel.pos = (127, 99)
self.assertFalse(self.panel.layout_dirty)
def test_size(self):
self.assertEqual((100, 120), self.panel.size)
self.panel.size = (127, 99)
self.assertEqual(Rect(50, 80, 127, 99), self.panel.rect)
self.assertTrue(self.panel.layout_dirty)
self.panel.layout_dirty = False
self.panel.size = (127, 99)
self.assertFalse(self.panel.layout_dirty)
def test_parent(self):
self.assertIs(self.gui.world, self.panel.parent)
self.panel.parent = self.gui.world
self.assertFalse(self.panel.layout_dirty)
parent = self.gui.create(Panel)
self.assertTrue(self.gui.world.layout_dirty)
self.gui.world.layout_dirty = False
self.panel.parent = parent
self.assertNotIn(self.panel, self.gui.world.children)
self.assertIn(self.panel, parent.children)
self.assertTrue(self.panel.layout_dirty)
self.assertTrue(parent.layout_dirty)
self.assertTrue(self.gui.world.layout_dirty)
def test_request_layout(self):
self.assertFalse(self.panel.layout_dirty)
self.assertFalse(self.gui.world.layout_dirty)
self.panel.request_layout()
self.assertTrue(self.panel.layout_dirty)
self.assertTrue(self.gui.world.layout_dirty)
from gui.gui import Gui
if __name__ == '__main__':
app = Gui()
app.mainloop()
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--p0-agent",
type=str,
choices=['static', 'rule', 'random', 'alphasheep', 'user'],
required=True)
parser.add_argument(
"--alphasheep-checkpoint",
help="Checkpoint for AlphaSheep, if --p0-agent=alphasheep.",
required=False)
parser.add_argument(
"--agent-config",
help="YAML file, containing agent specifications for AlphaSheep.",
required=False)
args = parser.parse_args()
agent_choice = args.p0_agent
as_checkpoint_path = args.alphasheep_checkpoint
as_config_path = args.agent_config
if agent_choice == "alphasheep" and (not as_checkpoint_path
or not as_config_path):
raise ValueError(
"Need to specify --alphasheep-checkpoint and --agent-config if --p0_agent=alphasheep."
)
# Init logging and adjust log levels for some classes.
init_logging()
logger = get_named_logger("{}.main".format(
os.path.splitext(os.path.basename(__file__))[0]))
get_class_logger(GameController).setLevel(
logging.DEBUG) # Log every single card.
get_class_logger(Gui).setLevel(logging.DEBUG) # Log mouse clicks.
get_class_logger(RuleBasedAgent).setLevel(
logging.DEBUG) # Log decisions by the rule-based players.
# Create the agent for Player 0.
if agent_choice == "alphasheep":
# Load config. We ignore the "training" and "experiment" sections, but we need "agent_config".
logger.info(f'Loading config from "{as_config_path}"...')
config = load_config(as_config_path)
get_class_logger(DQNAgent).setLevel(logging.DEBUG) # Log Q-values.
alphasheep_agent = DQNAgent(0, config=config, training=False)
alphasheep_agent.load_weights(as_checkpoint_path)
p0 = Player("0-AlphaSheep", agent=alphasheep_agent)
elif agent_choice == "user":
p0 = Player("0-User", agent=GUIAgent(0))
elif agent_choice == "rule":
p0 = Player("0-Hans", agent=RuleBasedAgent(0))
elif agent_choice == "static":
p0 = Player("0-Static", agent=StaticPolicyAgent(0))
else:
p0 = Player("0-RandomGuy", agent=RandomCardAgent(0))
# Players 1-3 are RuleBasedAgents.
players = [
p0,
Player("1-Zenzi", agent=RuleBasedAgent(1)),
Player("2-Franz", agent=RuleBasedAgent(2)),
Player("3-Andal", agent=RuleBasedAgent(3))
]
# Rig the game so Player 0 has the cards to play a Herz-Solo.
# Also, force them to play it.
game_mode = GameMode(GameContract.suit_solo,
trump_suit=Suit.herz,
declaring_player_id=0)
controller = GameController(players,
dealing_behavior=DealWinnableHand(game_mode),
forced_game_mode=game_mode)
# The GUI initializes PyGame and registers on events provided by the controller. Everything single-threaded.
#
# The controller runs the game as usual. Whenever the GUI receives an event, it can block execution, so the controller must wait
# for the GUI to return control. Until then, it can draw stuff and wait for user input (mouse clicks, card choices, ...).
logger.info("Starting GUI.")
with Gui(controller.game_state) as gui:
# Run an endless loop of single games.
logger.info("Starting game loop...")
try:
while True:
controller.run_game()
except UserQuitGameException: # Closing the window or pressing [Esc]
logger.info("User quit game.")
logger.info("Shutdown.")
import sys
from PyQt4 import QtGui
from gui.gui import Gui
from gui.threadgui import ThreadGui
from camera.camera import Camera
from camera.threadcamera import ThreadCamera
import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)
if __name__ == '__main__':
camera = Camera()
print(camera)
app = QtGui.QApplication(sys.argv)
window = Gui()
window.setCamera(camera)
window.show()
t1 = ThreadCamera(camera)
t1.start()
t2 = ThreadGui(window)
t2.start()
sys.exit(app.exec_())
parser.add_argument("-s",
"--speed",
type=float,
help="simulation speed, default = 1",
default=1)
parser.add_argument("--fps",
help="frames per second, default=30",
type=int,
default=30)
args = parser.parse_args()
pygame.init()
speed = args.speed
fps = args.fps
parameters = SimulationParameters()
world = World(parameters.options["world_pixel_size"],
parameters.options["world_nrof_tiles"])
creature_manager = CreatureManager(parameters.options["nrof_creatures"],
world)
statistics = Statistics(creature_manager)
clock = pygame.time.Clock()
gui = Gui(1000, 600, creature_manager, world, clock, statistics, speed)
main_loop()
#cProfile.run("main_loop()")
"""
TODO: Implement Pause function
TODO: Implement Neural Network Viewer
TODO: Partial Screen udpates
TODO: Collect all variables/constants and make them be changeable by parameter or a file
TODO: Creature vision viewer
TODO: Something about the borders
"""