def __init__(self):
self.s = None
self.width = SCREEN_W
self.height = SCREEN_H
self.hwnd_context = sf.ContextSettings()
self.hwnd_context.antialiasing_level = 4
self.hwnd = sf.RenderWindow(sf.VideoMode(self.width,
self.height), "Tankz2D",
sf.Style.DEFAULT, self.hwnd_context)
self.hwnd.framerate_limit = 60
self.hwnd.vertical_synchronization = True
self.state = STATE.IN_MENU
self.turn = GameTurn()
self.tank_sprites = [0] * 4
self.winner = -1
self.map_scroll = 0
for x in range(4):
self.tank_sprites[x] = sf.Sprite(texture_manager.textures[x + 1])
self.tank_sprites[x].origin = (11, 6)
self.tank_sprites[x].position = (SCREEN_W / 2, SCREEN_H / 2)
self.tank_sprites[x].scale((16, 16))
try:
with open('./data/cfg.yaml', 'r') as stream:
self.cfg = yaml.safe_load(stream)
except Exception as e:
print(f'reading config failed: [{e}]')
os._exit(-1)
self.ui = GUI(self.cfg['ui'])
self.ui.set_scene('main_menu')
self.map = None
self.map = GameMap(MAP_W, MAP_H)
self.tanks = []
self.tank_id = 0
self.timer = sf.Clock()
self.timer.restart()
self.finished = False
self.bg = Background(texture_manager.textures[TEXTURE.BACKGROUND])
self.landscape = sf.Sprite(texture_manager.textures[TEXTURE.LANDSCAPE])
self.think_callbacks = {
STATE.IN_MENU: self.menu_callback,
STATE.WAIT_FOR_START: self.wait_for_start_callback,
STATE.IN_GAME: self.ingame_callback,
STATE.RESULT: self.results_callback,
}
self.render_callbacks = {
STATE.IN_MENU: self.menu_render_callback,
STATE.WAIT_FOR_START: self.wait_for_start_render_callback,
STATE.IN_GAME: self.ingame_render_callback,
STATE.RESULT: self.results_render_callback
}
self.projectiles = []
self.cheat_active = False
def display_graph(self):
gui = GUI()
for edge in self.G.edges():
s = conversions.point_2_to_xy(edge[0])
t = conversions.point_2_to_xy(edge[1])
gui.add_segment(*s, *t)
gui.MainWindow.show()
def __init__(self):
self.parent_dir = abspath(join(dirname(__file__), ".."))
self.binary_dir = join(self.parent_dir, "bin")
if not isdir(self.binary_dir):
mkdir(self.binary_dir)
if not isfile(join(self.binary_dir, "engine.exe")):
print("Error: Engine not found!")
print("Place engine.exe in " + self.binary_dir)
sys.exit()
self.board: Chessboard = None
self.analyzer: BoardAnalyzer = None
self.bot: Bot = None
# Instantiate the GUI
self.interface = GUI(self.parent_dir, self.toggle_color,
self.set_coordinates)
self.interface.create_window()
# Instantiate the scanner
self.scanner = Scanner(self.parent_dir, self.interface)
# Retrieve the coordinates of the board from mouse input
self.scanner.retrieve_coordinates(self.set_coordinates)
# Required main loop for any tkinter application
self.interface.window.mainloop()
def display_cspace(self):
gui = GUI()
for he in self.cspace.edges():
s = conversions.point_2_to_xy(he.source().point())
t = conversions.point_2_to_xy(he.target().point())
gui.add_segment(*s, *t)
gui.MainWindow.show()
def show_path(self, game, path):
gui = GUI()
if gui is not None:
gui.update(game)
# print "%s has hand" % self.name, self.info.hand
gui.show_destinations(self.info.destinations)
gui.show_path(path)
raw_input("Continue?")
gui.close()
def main():
gui = GUI(draw_orientation=False)
rospy.init_node('gui_node')
goal_sub = rospy.Subscriber('goal_pose', Pose, gui.handle_goal)
arm_pose_sub = rospy.Subscriber('arm/link_poses', PoseArray,
gui.handle_link_poses)
rate = rospy.Rate(5)
for i in range(5):
rate.sleep()
while not rospy.is_shutdown():
gui.redraw()
rate.sleep()
def start(self):
"""
Displays the GUI frame.
"""
if self._system.get_settings().show_gui and not self.is_running():
self.frame = True
app = QtWidgets.QApplication(sys.argv)
self.gui = GUI(self._system)
if self.is_speech_enabled:
self.gui.enable_speech(True)
# if not self._system._domain._xml_file is None:
# self.gui.open_domain(self._system._domain)
# self._system.start_system()
sys.exit(app.exec_())
def __init__(self):
self.si = SingleInstance(32092)
self.settings = Settings('settings.json', DEFAULT_SETTINGS)
self.fs_sync = FSSync()
self.gui = GUI(self)
self.mw_emit = self.gui.main_window.act.emit # TODO: Switch from mw_emit to mw_act
self.mw_act = self.gui.main_window_act
self.time_offsets = None
self.sync_run = False
self.sync_thread = None
self.time_run = False
self.time_thread = None
self.live_sync_enabled = False
self.now_source = "S"
self.ntp_client = ntplib.NTPClient()
self.ntp_delta = None
self.offset = BasicTimeDelta()
def __init__(self, player):
self.player = player
self.gui = GUI()
self.worlds = []
self.current_page = 'main_menu'
self.pages = {}
self.exit = False
self.keys_pressed = []
keymap.add((pygame.K_ESCAPE,), self.quit)
def __init__(self):
import ulogging as logging
self.log = logging.getLogger("t-watch")
self.log.setLevel(logging.DEBUG)
self.log.debug("Starting LVGL")
self.drv = driver(width=240, height=240)
scr_style = lv.style_t()
scr_style.set_bg_color(lv.STATE.DEFAULT, lv_colors.BLACK)
lv.scr_act().add_style(lv.obj.PART.MAIN, scr_style)
self.log.debug("starting splash screen")
splash = Splashscreen()
sleep(1)
splash.set_label("Starting WiFi")
try:
from hardware.wifi import WiFi
wifi = WiFi()
wifi.connect()
#
# get CET time from NTP and set up the pcf8563 RTC
#
self.pcf8563 = self.drv.watch.rtc
wifi.getTime()
currentTime = wifi.cetTime()
year = currentTime[0]
month = currentTime[1]
date = currentTime[2]
hour = currentTime[3]
minute = currentTime[4]
second = currentTime[5]
day = currentTime[6]
month_short = [
"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
"Oct", "Nov", "Dec"
]
day_of_week_short = [
"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"
]
self.log.debug(
" Setting RTC to %s %d. %s %02d %02d:%02d:%02d" %
(day_of_week_short[day], date, month_short[month - 1], year,
hour, minute, second))
self.pcf8563.set_datetime(currentTime)
except:
pass
self.log.debug("Starting the power manager")
if hasattr(self.drv, "watch"):
print("Running on the twatch")
self.powermgr = PowerManager(self.drv)
splash.deinit()
self.gui = GUI(self.drv)
def __init__(self):
QCoreApplication.setOrganizationName('github.com/misdoro')
QCoreApplication.setApplicationName('Battery tester')
self.threadpool = QThreadPool()
self.instr_thread()
self.datastore = DataStore()
signal.signal(signal.SIGTERM, self.terminate_process)
signal.signal(signal.SIGINT, self.terminate_process)
self.data_receivers = set()
GUI(self)
class Game:
def __init__(self, player):
self.player = player
self.gui = GUI()
self.worlds = []
self.current_page = 'main_menu'
self.pages = {}
self.exit = False
self.keys_pressed = []
keymap.add((pygame.K_ESCAPE,), self.quit)
def add_world(self, setup):
self.worlds.append(World(setup))
def check_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
quit()
elif event.type == pygame.KEYDOWN:
if self.gui.selected:
if self.gui.selected.key_input(event.key):
continue
if event.key not in self.keys_pressed:
self.keys_pressed.append(event.key)
elif event.type == pygame.KEYUP:
if event.key in self.keys_pressed:
self.keys_pressed.remove(event.key)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
for widget in self.gui.widgets:
if widget.rect.collidepoint(mouse_pos):
widget.select()
for keys, action in keymap.keymap.items():
if all([True if key in self.keys_pressed else False
for key in keys]):
action()
def main_loop(self):
last_frame = time()
while not self.exit:
turn_time = time()
for world in self.worlds:
world.update()
if turn_time - last_frame >= 1/config.FPS:
self.pages[self.current_page].draw()
if config.SCENT_VISIBLE:
# ToDo: replace world below with self.player.world
self.gui.draw_markers(world.markers)
if not world.current_tick % 250:
world.markers.update()
self.gui.draw()
self.gui.update()
last_frame = time()
self.check_events()
def quit(self):
if self.exit:
pygame.quit()
else:
self.exit = True
def make_gui(board, main_controller, controllers, biosignal):
app = QtWidgets.QApplication(sys.argv)
main_scr = None
if FeatureFlags.GUI:
main_scr = GUI(board, biosignal, main_controller, controllers)
main_scr.views.setCurrentIndex(1)
if FeatureFlags.DEV_TOOLS:
main_scr = DevTools(board, biosignal, main_controller, controllers)
if main_scr is not None:
main_scr.resize(500, 100)
main_scr.show()
sys.exit(app.exec_())
def __init__(self, args):
# TODO добавить тесты
super().__init__()
lo = QVBoxLayout()
self.score = Score()
self.field = Field(getattr(args, '--field-size'))
self.gui = GUI(getattr(args, '--cell-size'), self.field, self.score)
self.restart_button = QPushButton('Restart')
self.watch_records_button = QPushButton('Record Table')
self.watch_records_button.clicked.\
connect(self.score.watch_record_table)
self.restart_button.clicked.connect(self.gui.restart)
lo.addWidget(self.score)
lo.addWidget(self.gui)
lo.addWidget(self.restart_button)
lo.addWidget(self.watch_records_button)
self.setLayout(lo)
self.setWindowTitle('Lines')
# подумать, как исправить
self.setFixedSize(self.sizeHint())
def setup(self):
# Initialization
for i in range(self.player_num):
self.engines[i] = TetrisEngine(self.width, self.height)
self.engines[i].clear()
if self.use_gui:
gui = GUI(self, self.block_size)
self.gui = gui
else:
self.stdscr = curses.initscr()
curses.noecho()
# Store play information
self.dbs = {}
self.done = False
for i in range(self.player_num):
# Initial rendering
self.engine_states[i] = {
"KO": 0,
"reward": 0,
"lines_sent": 0,
"lines_cleared": 0,
"hold_shape": None,
"hold_shape_name": None,
"hold_locked": False,
"garbage_lines": 0,
"highest_line": 0,
"combo": -1
}
# Initialize dbs
self.dbs[i] = []
self.game_count += 1
self.start_time = time.time()
def test_raises_exception(self):
with self.assertRaises(ValueError):
board = Field(2)
board = Field(-1)
gui = GUI(1, Field(9), Score())
gui = GUI(-1, Field(9), Score())
class GUIFrame(Module):
"""
Main GUI frame for the OpenDial toolkit, encompassing various tabs and menus to
control the application
"""
# logger
log = logging.getLogger('PyOpenDial')
def __init__(self, system):
from dialogue_system import DialogueSystem
if not isinstance(system, DialogueSystem):
raise NotImplementedError("UNDEFINED PARAMETERS")
"""
Constructs (but does not yet display) a new GUI frame for OpenDial.
:param system: system the dialogue system for the GUI
"""
self.frame = False
self.tabbed_pane = None
self.state_monitor_tab = None
self.chat_tab = None
self.editor_tab = None
self.menu = None
self._paused = True
self._system = system
self.gui = None
self.is_speech_enabled = False
self._audio_module = None
self._settings = system.get_settings()
@dispatch()
def start(self):
"""
Displays the GUI frame.
"""
if self._system.get_settings().show_gui and not self.is_running():
self.frame = True
app = QtWidgets.QApplication(sys.argv)
self.gui = GUI(self._system)
if self.is_speech_enabled:
self.gui.enable_speech(True)
# if not self._system._domain._xml_file is None:
# self.gui.open_domain(self._system._domain)
# self._system.start_system()
sys.exit(app.exec_())
@dispatch(bool)
def pause(self, pause):
"""
Pauses the GUI.
"""
self._paused = pause
@dispatch(DialogueState, Collection)
def trigger(self, state, update_vars):
for variable in [
self._system.get_settings().user_input,
self._system.get_settings().system_output
]:
if not self._paused and variable in update_vars and state.has_chance_node(
variable):
if variable in [
self._settings.system_output, self._settings.user_input
]:
table = self._system.get_content(variable).to_discrete()
text = self._get_text_rendering(table)
self.gui.chatlog.append(text)
self.gui.chatlog.setAlignment(Qt.AlignLeft)
self.gui.chatlog.moveCursor(QtGui.QTextCursor.End)
@dispatch(CategoricalTable)
def _get_text_rendering(self, table):
"""
Generates the text representation for the categorical table.
:param table: the table
:return: the text rendering of the table
"""
text_table = ''
base_variable = table.get_variable().replace("'", '')
if base_variable == self._system.get_settings().user_input:
text_table += '\n[user]\t'
elif base_variable == self._system.get_settings().system_output:
text_table += '[system]\t'
else:
text_table += '[' + base_variable + ']\t'
for value in table.get_values():
if not isinstance(value, NoneVal):
content = str(value)
if table.get_prob(value) < 0.98:
content += ' (' + StringUtils.get_short_form(
table.get_prob(value)) + ')'
text_table += content + '\n\t\t'
if base_variable == self._system.get_settings().user_input:
text_table += '\n'
text_table = text_table[0:-3]
return text_table
@dispatch()
def refresh(self):
pass
@dispatch()
def do_refresh(self):
pass
@dispatch(DialogueState, str)
def record_state(self, state, name):
pass
@dispatch(str)
def add_comment(self, comment):
pass
@dispatch(bool)
def enable_speech(self, to_enable):
self.is_speech_enabled = to_enable
if self.gui is None:
return
self.gui.enable_speech(to_enable)
# if self.chat_tab is not None:
# self.chat_tab.enable_speech(to_enable)
#
# if self.menu is not None:
# self.menu.enable_speech(to_enable)
@dispatch(bool)
def set_saved_flag(self, is_saved):
pass
@dispatch(int)
def set_action_tab(self, i):
pass
@dispatch()
def request_save(self):
pass
@dispatch()
def close_window(self):
pass
@dispatch()
def get_system(self):
pass
@dispatch()
def get_chat_tab(self):
pass
@dispatch()
def get_state_viewer_tab(self):
pass
@dispatch()
def get_editor_tab(self):
pass
@dispatch()
def get_frame(self):
pass
@dispatch()
def is_running(self):
return self.frame
@dispatch()
def is_speech_enabled(self):
pass
@dispatch()
def is_domain_saved(self):
pass
@dispatch()
def get_menu(self):
pass
@dispatch()
def new_domain(self):
pass
# TODO: 'File' type
@dispatch(object)
def new_domain(self, file_to_save):
pass
@dispatch()
def open_domain(self):
pass
@dispatch()
def save_domain(self):
pass
# TODO: 'File' type
@dispatch(object)
def save_domain(self, file_to_write):
pass
@dispatch()
def save_domain_as(self):
pass
@dispatch()
def reset_interaction(self):
pass
@dispatch(bool)
def import_interaction(self, is_wizard_of_oz):
pass
@dispatch()
def save_interaction(self):
pass
@dispatch(str)
def import_content(self, tag):
pass
@dispatch(str)
def export_content(self, tag):
pass
# TODO: ADD FROM/TO Graph generation
import json
from gui.gui import GUI
from logic.Graph import Graph
with open("resources/recipes.json", 'r') as recipes_file:
recipes = json.load(recipes_file)
g = Graph(recipes)
a = GUI(g)
a.run()
# def run():
# with open("resources{}recipes.json".format(os.sep), 'r') as recipes_file:
# recipes = json.load(recipes_file)
#
# g = Graph(recipes)
#
# compress_water = input("Do you want to compress water into nodes? (y/n): ")
# compress_water = len(compress_water) == 0 or compress_water.lower() == "y"
#
# dot = g.get_dot(compress_water)
#
# dot.render("output", view=True)
#
#
# if __name__ == "__main__":
# run()
from tkinter import Tk
from gui.gui import GUI
window = Tk()
window.title('TodoApp')
gui = GUI(window)
gui.start()
window.mainloop()
class FSTimeSync:
def __init__(self):
self.si = SingleInstance(32092)
self.settings = Settings('settings.json', DEFAULT_SETTINGS)
self.fs_sync = FSSync()
self.gui = GUI(self)
self.mw_emit = self.gui.main_window.act.emit # TODO: Switch from mw_emit to mw_act
self.mw_act = self.gui.main_window_act
self.time_offsets = None
self.sync_run = False
self.sync_thread = None
self.time_run = False
self.time_thread = None
self.live_sync_enabled = False
self.now_source = "S"
self.ntp_client = ntplib.NTPClient()
self.ntp_delta = None
self.offset = BasicTimeDelta()
def start(self):
try:
self.sync_thread = threading.Thread(None,
self.sync_thread_runner,
"Sync Thread",
daemon=True)
self.sync_thread.start()
self.time_thread = threading.Thread(None,
self.time_thread_loop,
"Time Thread",
daemon=True)
self.time_thread.start()
self.gui.start() # locking
finally:
self.stop()
def stop(self):
self.sync_run = False
self.time_run = False
self.fs_sync.close_pyuipc()
sys.exit(0)
def get_now(self):
if self.now_source == "NTP":
try:
if not self.ntp_delta:
response = self.ntp_client.request('pool.ntp.org')
print(time.ctime(response.tx_time))
self.ntp_delta = datetime.now(
timezone.utc) - datetime.fromtimestamp(
response.tx_time, timezone.utc)
print(self.ntp_delta)
self.gui.remove_message(1, 0)
return datetime.utcnow() - self.ntp_delta
except (ntplib.NTPException, socket.gaierror) as exc:
self.gui.add_message(1, 0, "Can't reach NTP server.")
print(exc)
return datetime.utcnow()
return datetime.utcnow()
def switch_now_source(self):
if self.now_source == "NTP": # Will switch to S
self.now_source = "S"
self.mw_emit([self.gui.main_window.ui.utc_label.setText, "UTC.S"])
self.mw_emit([
self.gui.main_window.ui.utc_label.setToolTip,
"UTC.S : Using System Time"
])
elif self.now_source == "S": # Will switch to NTP
self.ntp_delta = None # Refresh NTP
self.now_source = "NTP"
self.mw_emit(
[self.gui.main_window.ui.utc_label.setText, "UTC.NTP"])
self.mw_emit([
self.gui.main_window.ui.utc_label.setToolTip,
"UTC.NTP : Using Network Time Protocol, Online Time"
])
self.gui.remove_message(0, 1) # Remove will sync message
def time_thread_loop(self):
self.time_run = True
while self.time_run:
now = self.get_now()
self.mw_emit([
self.gui.main_window.ui.real_time_hour.setText,
"{:02d}".format(now.hour)
])
# self.mw_emit([self.gui.main_window.ui.real_time_seperator.setText, str(two_dots))
self.mw_emit([
self.gui.main_window.ui.real_time_minute.setText,
"{:02d}".format(now.minute)
])
self.mw_emit([
self.gui.main_window.ui.real_time_second.setText,
"{:02d}".format(now.second)
])
self.mw_emit([
self.gui.main_window.ui.real_date.setText,
"{:02d}.{:02d}.{}".format(now.day, now.month, now.year)
])
# print(now)
if bool(self.offset):
offsetted_dt = self.offset + now
self.gui.main_window_act(
self.gui.main_window.ui.left_value.setText,
f"{offsetted_dt.strftime('%H:%M | %d.%m.%Y')}")
else:
self.gui.main_window_act(
self.gui.main_window.ui.left_value.setText, "")
self.gui.main_window_act(
self.gui.main_window.ui.left_status.setText, str(self.offset))
time.sleep(0.5)
def toggle_live_sync(self):
print("toggle live sync")
if not self.live_sync_enabled:
self.enable_live_sync()
else:
self.disable_live_sync()
def disable_live_sync(self):
self.live_sync_enabled = False
self.gui.remove_message(0, 1) # Remove will sync message
self.mw_emit([
self.gui.main_window.ui.live_button.setIcon,
self.gui.icons["sync_disabled"]
])
self.mw_emit([
self.gui.main_window.ui.live_button.setToolTip,
"Live Sync: Disabled"
])
def enable_live_sync(self):
self.live_sync_enabled = True
self.mw_emit([
self.gui.main_window.ui.live_button.setIcon, self.gui.icons["sync"]
])
self.mw_emit([
self.gui.main_window.ui.live_button.setToolTip,
"Live Sync: Enabled"
])
def restart_sync_thread_runner(self, restart):
self.mw_act(self.gui.main_window.ui.sim_label.setText,
'Waiting Simulator...')
self.mw_act(self.gui.main_window.ui.sim_time_hour.setText, "")
self.mw_act(self.gui.main_window.ui.sim_time_minute.setText, "")
self.mw_act(self.gui.main_window.ui.sim_time_second.setText, "")
self.mw_act(self.gui.main_window.ui.sim_time_second.setToolTip, "")
self.mw_act(self.gui.main_window.ui.sim_time_seperator.setText, "")
self.mw_act(self.gui.main_window.ui.sim_date.setText, "")
self.fs_sync.reset()
time.sleep(10) # Sleep, make sure FSUIPC exits completely.
self.sync_thread_runner(restart=restart + 1)
def sync_thread_runner(self, restart=0):
# Est. FSUIPC connection.
# Try every 10 seconds.
self.sync_run = True
while self.sync_run:
if not self.fs_sync.connect_pyuipc():
# print(self.fs_sync.connect_pyuipc())
# print("Cannot connect FSUIPC.")
time.sleep(10)
continue
self.mw_act(self.gui.main_window.ui.sim_label.setText,
self.fs_sync.opened_sim)
break
offsets = {
"TIME_SECOND": [0x023A, "b"],
"TIME_HOUR": [0x023B, "b"],
"TIME_MINUTE": [0x023C, "b"],
"DATE_DAY": [0x023D, "b"],
"DATE_MONTH": [0x0242, "b"],
"DATE_YEAR": [0x0240, "H"], # Fixed from local
}
if self.fs_sync.pyuipc_open == SIMULATOR_XPLANE_ID:
offsets["DAY_OF_YEAR"] = [0x023E, "h"]
self.time_offsets = self.fs_sync.create_offset_set(offsets)
try:
self.sync_routine_loop()
except (pyuipc.FSUIPCException, SystemError) as exc:
if exc.errorCode == 12 or exc.errorCode == 13:
print(
f"Catched PYUIPC error, will restart. Code:{exc.errorCode}"
)
self.restart_sync_thread_runner(restart=restart)
def sync_routine_loop(self):
two_dots = FlipFlop(":")
while self.sync_run:
data_delta = self.sync_sim()
if not data_delta:
continue
data = data_delta[0]
delta = data_delta[1]
datetime = data_delta[2]
self.mw_emit([
self.gui.main_window.ui.sim_time_hour.setText,
"{:02d}".format(data["TIME_HOUR"])
])
self.mw_emit([
self.gui.main_window.ui.sim_time_seperator.setText,
str(two_dots)
])
self.mw_emit([
self.gui.main_window.ui.sim_time_minute.setText,
"{:02d}".format(data["TIME_MINUTE"])
])
self.mw_emit([
self.gui.main_window.ui.sim_time_second.setText,
"{:02d}".format(data["TIME_SECOND"])
])
self.mw_emit([
self.gui.main_window.ui.sim_date.setText,
datetime.strftime('%d.%m.%Y')
])
self.mw_emit([
self.gui.main_window.ui.sim_time_second.setToolTip,
"ε: ±{}s Δ: {}s".format(30, int(delta))
])
# print(data)
time.sleep(1)
def sync_sim(self, force=False):
"""
Returns initial data if no sync.
Returns new data if there has been sync.
"""
if not self.fs_sync.pyuipc_open:
return
try:
data = self.time_offsets.read()
if self.fs_sync.pyuipc_open == SIMULATOR_XPLANE_ID:
data["DATE_YEAR"] += SIMULATOR_XPLANE_YEAR_DELTA
time_from_data = datetime(data["DATE_YEAR"],
1,
1,
data["TIME_HOUR"],
data["TIME_MINUTE"],
second=data["TIME_SECOND"])
time_from_data = time_from_data + timedelta(
days=data["DAY_OF_YEAR"])
else:
time_from_data = datetime(data["DATE_YEAR"],
data["DATE_MONTH"],
data["DATE_DAY"],
data["TIME_HOUR"],
data["TIME_MINUTE"],
second=data["TIME_SECOND"])
now = self.offset + self.get_now()
delta = (now - time_from_data).total_seconds()
except ValueError as exc:
# ValueError generally thrown when FSUIPC is reporting year out of range.
# Happens on scenerio screen.
print(exc)
time.sleep(0.5)
return False
if self.live_sync_enabled or force:
if not self.fs_sync.pyuipc_open:
return
if abs(delta) > 30 or force:
if force:
if data["TIME_SECOND"] - now.second > 20:
self.time_offsets.write("TIME_SECOND", 0)
else:
if now.second > 3:
self.gui.add_message(
0, 1, "Will Sync At: {:02d}:{:02d}z".format(
now.hour, now.minute + 1))
return [data, delta, time_from_data]
self.time_offsets.write("TIME_SECOND", 0)
print("DOING A ZULU TIME SYNC.")
if self.fs_sync.pyuipc_open == SIMULATOR_XPLANE_ID:
self.time_offsets.write(
"DATE_YEAR", now.year - SIMULATOR_XPLANE_YEAR_DELTA)
self.time_offsets.write("DAY_OF_YEAR",
int(now.strftime('%j')) - 1)
self.time_offsets.write("TIME_HOUR", now.hour)
self.time_offsets.write("TIME_MINUTE", now.minute)
else:
self.time_offsets.write("DATE_YEAR", now.year)
self.time_offsets.write("DATE_MONTH", now.month)
self.time_offsets.write("DATE_DAY", now.day)
self.time_offsets.write("TIME_HOUR", now.hour)
self.time_offsets.write("TIME_MINUTE", now.minute)
self.gui.remove_message(0, 1) # Remove will sync message
self.gui.add_message(
0, 2, "Last Sync: {:02d}:{:02d}:{:02d}z".format(
now.hour, now.minute, now.second))
return [self.time_offsets.read(), delta,
time_from_data] # Return fresh data
return [data, delta, time_from_data]
class Main:
def __init__(self):
self.parent_dir = abspath(join(dirname(__file__), ".."))
self.binary_dir = join(self.parent_dir, "bin")
if not isdir(self.binary_dir):
mkdir(self.binary_dir)
if not isfile(join(self.binary_dir, "engine.exe")):
print("Error: Engine not found!")
print("Place engine.exe in " + self.binary_dir)
sys.exit()
self.board: Chessboard = None
self.analyzer: BoardAnalyzer = None
self.bot: Bot = None
# Instantiate the GUI
self.interface = GUI(self.parent_dir, self.toggle_color,
self.set_coordinates)
self.interface.create_window()
# Instantiate the scanner
self.scanner = Scanner(self.parent_dir, self.interface)
# Retrieve the coordinates of the board from mouse input
self.scanner.retrieve_coordinates(self.set_coordinates)
# Required main loop for any tkinter application
self.interface.window.mainloop()
def set_coordinates(self, width, height, top_left):
self.interface.loaded = True # Funky hack
if self.scanner.task_id != -1:
self.interface.cancel_task(self.scanner.task_id)
self.scanner = None
self.wait_for_start(self.initialize_bot, width, height, top_left)
def initialize_bot(self, width, height, top_left):
# Instantiate a chessboard object (wrapper for a python-chess board)
self.board = Chessboard(width, height, top_left, self.interface.color)
self.analyzer = BoardAnalyzer(self.board, self.interface)
self.bot = Bot(self.binary_dir, self.board,
self.analyzer.square_centers)
if self.board.color == chess.WHITE:
self.bot.play_move()
self.analyzer.set_previous_state()
self.loop()
else:
self.loop_initial_check()
def wait_for_start(self, callback, *args):
if self.interface.running:
callback(*args)
return
self.interface.delay_task(100, self.wait_for_start, callback, *args)
def loop(self):
if not self.interface.running:
self.interface.delay_task(TASK_REPEAT_INTERVAL, self.loop)
return
if self.board.is_game_over():
self.interface.log("Game over!")
self.bot.terminate()
return
move = self.analyzer.analyze_changes(self.analyzer.detect_changes())
if move is None:
self.interface.delay_task(TASK_REPEAT_INTERVAL, self.loop)
return
self.interface.log(f"Opponent move: {move}")
self.board.play_move(move)
self.bot.play_move()
self.analyzer.set_previous_state(
) # Take a shot AFTER the bot's own move
self.interface.delay_task(TASK_REPEAT_INTERVAL, self.loop)
def loop_initial_check(self):
if not self.interface.running:
self.interface.delay_task(TASK_REPEAT_INTERVAL,
self.loop_initial_check)
return
move = self.analyzer.detect_initial_changes()
if move is None:
self.interface.delay_task(TASK_REPEAT_INTERVAL,
self.loop_initial_check)
return
self.board.play_move(move)
self.bot.play_move()
self.analyzer.set_previous_state()
self.loop()
def toggle_color(self):
if self.board is not None:
self.board.color = not self.board.color
def __init__(self):
self._gui = GUI()
self.is_COM_enabled = False
self._synth = Synthesizer()
self.running = False
def main():
import sys
app = QtWidgets.QApplication(sys.argv)
gui = GUI()
gui.show()
sys.exit(app.exec_())
import sys
from tkinter import Tk
from dataset_repository import DatasetRepository
from misc.db_connection import get_database_connection
from stat_analyzer import StatAnalyzer
from analyses_config import get_analyses_config
from gui.gui import GUI
arguments = sys.argv
stat_analyzer = StatAnalyzer(dataset=None, analyses=get_analyses_config())
dataset_repository = DatasetRepository(get_database_connection())
window = Tk()
window.title("Stat analyzer")
ui = GUI(window, stat_analyzer, dataset_repository)
# If running with argument "dev". Load example data
if len(arguments) > 1 and arguments[1] == 'dev':
ui.load_exampledata()
ui.start()
# -*- coding: UTF-8 -*-
"""
# Classe Principal do Trabalho
#
# Autores:
# Data: 16/01/2021
"""
import pygame
from gui.gui import GUI
if __name__ == "__main__":
# Inicia as importações dos módulos do pygame
pygame.init()
# Inicia o loop do GUI
gui = GUI()
gui.loop()
# Finaliza todos os módulos do pygame
pygame.quit()
def main():
app = QApplication(sys.argv)
window = GUI()
window.show()
sys.exit(app.exec_())
from gui.gui import GUI
import logging
# Logging ---------------------------------------------------------------------
logging.basicConfig(level=logging.DEBUG,format='%(asctime)s (%(threadName)-2s) %(message)s')
LOG = logging.getLogger()
# Main method -----------------------------------------------------------------
if __name__ == '__main__':
# Find the script absolute path, cut the working directory
a_path = sep.join(abspath(argv[0]).split(sep)[:-1])
# Append script working directory into PYTHONPATH
path.append(a_path)
# Parsing arguments
parser = ArgumentParser(description="Sudoku Game Client of DS Homework2",
version = "RPC Version")
parser.add_argument('-l','--listenaddr', \
help='RPC broadcast recv address, '\
'defaults to %s' % DEFAULT_CLIENT_RPC_BRDCST_ADDR, \
default=DEFAULT_CLIENT_RPC_BRDCST_ADDR)
parser.add_argument('-p','--listenport', \
help='RPC broadcast recv port, '\
'defaults to %d' % DEFAULT_CLIENT_RPC_BRDCST_PORT, \
default=DEFAULT_CLIENT_RPC_BRDCST_PORT)
args = parser.parse_args()
try:
GUI(args.listenaddr, args.listenport).gui_start()
except KeyboardInterrupt:
LOG.info('Terminating client ...')
class _Game:
def __init__(self):
self._gui = GUI()
self.is_COM_enabled = False
self._synth = Synthesizer()
self.running = False
def start(self):
"""
Arduino threshold setting and Loop starting
"""
self.running = True
if self.is_COM_enabled:
# Подготовка COM порта
self._ser = serial.Serial(port='COM17', baudrate=9600) # fixme
# Считывание установленного порога
# self.threshold = int(
# re.search(
# "d{, 4}",
# str(self._ser.readline()),
# flags=re.ASCII))
self._clock = pygame.time.Clock()
# Старт петли
self._loop()
def _loop(self):
"""
Main cycle
"""
while self.running:
self._clock.tick(30)
for event in pygame.event.get():
# Обработка выхода
if event.type == pygame.QUIT:
self.quit()
# Работа с клавишами
if event.type == pygame.KEYDOWN:
if event.key == ord('q'):
self.quit()
# Обработка нажатий и отпускания.
for note in self._synth.notes:
if (event.key == self._synth.notes[note]['key_code']):
self._synth.handle_key_down(note)
if event.type == pygame.KEYUP:
for note in self._synth.notes:
if (event.key == self._synth.notes[note]['key_code']):
self._synth.handle_key_up(note)
if self.running:
if self.is_COM_enabled:
# Работа COM портом
if self._ser.in_waiting > 0:
# if self._ser.
# Считываем строку из COM порта
line = str(self._ser.readline())
# Ищем в строке A или !A
note_tags = re.findall('[!]?[A-F]',
line,
flags=re.ASCII)
for note_tag in note_tags:
if note_tag[0] != '!':
self._synth.handle_key_down(note_tag[0])
else:
self._synth._handle_key_up(note_tag[1])
self._gui.update(self._synth.notes)
self._synth.play()
def quit(self):
self.running = False
if self.is_COM_enabled:
self._ser.close()
self._synth.close()
pygame.quit()
def run_tests():
path = []
path_name = gui.get_field(5)
gp = importlib.import_module(path_name)
# for steer_eta in [FT(0.1), FT(0.2), FT(0.3), FT(0.4), FT(0.5), FT(0.6), FT(0.7), FT(0.8), FT(0.9), FT(1.0), FT(1.1), FT(1.2), FT(1.3), FT(1.4), FT(1.5)]:
# for i in range(10):
gp.generate_path(path, ps.robots, ps.obstacles, ps.destinations)
# print("Generated path via", path_name + ".generate_path")
def unused():
return
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
gui = GUI()
ps = Polygons_scene()
gui.set_program_name("Multi-robot Motion Planning")
gui.set_field(0, "scenes/optimal_length_1")
# gui.set_field(0, "data/scenes/warehouse0")
gui.set_field(3, "run_all")
gui.set_field(4, "path0.txt")
gui.set_field(5, "run_tests")
#gui.set_field(5, "path_out.txt")
gui.set_logic(0, set_up_scene)
gui.set_button_text(0, "Load scene")
gui.set_logic(1, run_and_animate)
gui.set_button_text(1, "run_and_animate")
gui.set_logic(2, unused)
gui.set_button_text(2, "unused")
gui.set_logic(3, generate_path)
def run_tests():
path = []
path_name = gui.get_field(5)
gp = importlib.import_module(path_name)
# for steer_eta in [FT(0.1), FT(0.2), FT(0.3), FT(0.4), FT(0.5), FT(0.6), FT(0.7), FT(0.8), FT(0.9), FT(1.0), FT(1.1), FT(1.2), FT(1.3), FT(1.4), FT(1.5)]:
# for i in range(10):
gp.generate_path(path, ps.robots, ps.obstacles, ps.destinations)
# print("Generated path via", path_name + ".generate_path")
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
gui = GUI()
ps = Polygons_scene()
gui.set_program_name("Multi-robot Motion Planning")
gui.set_field(0, "data/scenes/scene3_very_hard_multi")
# gui.set_field(0, "data/scenes/warehouse0")
gui.set_field(3, "srm_drrt")
gui.set_field(4, "path0.txt")
gui.set_field(5, "run_tests")
#gui.set_field(5, "path_out.txt")
gui.set_logic(0, set_up_scene)
gui.set_button_text(0, "Load scene")
gui.set_logic(1, run_and_animate)
gui.set_button_text(1, "run_and_animate")
gui.set_logic(2, set_destinations)
gui.set_button_text(2, "Set destinations")
gui.set_logic(3, generate_path)
from gui.gui import GUI gui = GUI() # TODO: # - Extended sessions # - Mark invalid responses # - Weeks # - As of now, have to update to do it once a week # - Validate Excel formats
def test_gui():
pygame.init()
window = pygame.display.set_mode((1024, 768))
pygame.display.set_caption("Testing GUI")
screen = pygame.display.get_surface()
background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill((0,0,0))
font = None
if pygame.font:
font = pygame.font.Font(None, 20)
gui = GUI(None)
gui.set_active(True)
menu = BasicMenu(gui, h_pad=10, v_pad=10)
gui.add_child(menu)
menu.set_active(True)
menu.add_child(BasicTextButton(menu, text = 'Select Mission', select_fxn = menu.mouse_over_callback, callback = gui.generic_click, callback_kwargs = {'target_id': 1}))
menu.add_child(BasicTextButton(menu, text = 'Exit', select_fxn = menu.mouse_over_callback, callback = gui.exit_click))
gui.add_child(BasicMenu(gui))
'''
frame = Frame(gui)
gui.add_child(frame)
frame.set_active(True)
testel = TestElement(frame)
testel.image = pygame.surface.Surface((100,50))
testel.image = testel.image.convert()
testel.image.fill((51, 102, 255))
testel.rect = testel.image.get_rect()
testel.rect.topleft = ((window.get_width() - testel.rect.width) * 0.5, (window.get_height() - testel.rect.height) * 0.5)
'''
while True:
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
sys.exit(0)
if gui.is_active(): gui.update(events)
screen.blit(background, (0,0))
if gui.is_active(): gui.draw()
pygame.display.flip()
handler_controller = controller_handler.ControllerHandler(
host_ip, port_controller, RUN_CONTROLLER_SERVER)
handler_auto = auto_steering_handler.AutoSteeringHandler(
OBSTACLE_DISTANCE, TL_STOP_DISTANCE) # Autonomous driving handler.
handler_auto.load_models(
F_MODEL_TO_LOAD, L_MODEL_TO_LOAD,
R_MODEL_TO_LOAD) # Loading trained forward, left, and right models.
# Creates a sign detector instance and starts the sign detector on a new thread.
sign_detector = SignDetector(DETECT_SIGNS, DISPLAY_SIGN_DETECTED,
DISPLAY_TRACKBARS)
tl_detector = TrafficLightDetector(DETECT_TRAFFIC_LIGHTS)
gui = GUI(handler_controller)
try:
while (True):
# Requesting/getting the frame from the pi.
raw_frame, _ = handler_cam.get_frame()
if raw_frame is None: # Ensuring a frame was received and processed successfully.
continue
frame = raw_frame.copy(
) # Creating a copy which I can alter, while still having the raw frame.
if DISPLAY_FPS: frame = handler_cam.display_fps(frame)
