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 __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)
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 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, 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()
# 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()
def __init__(self):
"""Конструктор."""
self.running = True
self._get_config()
self._gui = GUI()
self._synth = Synthesizer()
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())
from tkinter import Tk
from gui.gui import GUI
window = Tk()
window.title('TodoApp')
gui = GUI(window)
gui.start()
window.mainloop()
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()
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)
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)
def run():
app = QApplication(sys.argv)
gui = GUI()
gui.showMaximized()
sys.exit(app.exec_())
def main():
import sys
app = QtWidgets.QApplication(sys.argv)
gui = GUI()
gui.show()
sys.exit(app.exec_())
def __init__(self):
self._gui = GUI()
self.is_COM_enabled = False
self._synth = Synthesizer()
self.running = False
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 ...')
@email: [email protected] @date: 7/23/18 19:19 """ from PyQt5.QtWidgets import QApplication from utils.tests import Tests from domain.validator import BookValidator from repository.repository import Repository from repository.file_repo import FileRepository from service.service import Service from gui.gui import GUI import sys t = Tests() t.run_tests() val = BookValidator() #repo = Repository(val) repo = FileRepository(val, "book_file.txt") repo.clear_file() srv = Service(repo) if __name__ == '__main__': app = QApplication(sys.argv) w = GUI(srv) w.show() sys.exit(app.exec())