def main(myAddr, clAddr): myDisplay = Display() myDisplay.init() backSender = BackSender(clAddr) # start threads displayThread = threading.Thread(None, displayMain, 'display', (myDisplay, )) displayThread.start() serverThread = threading.Thread(None, displayServerMain, 'displayserver', (myDisplay, myAddr)) serverThread.start() connectTread = threading.Thread(None, connectMain, 'connection', (myAddr, backSender)) connectTread.start() inputThread = threading.Thread(None, inputMain, 'input', (myDisplay, backSender)) inputThread.start() # wait till threads end while displayThread.is_alive() and serverThread.is_alive(): try: littlePause = 0.1 displayThread.join(littlePause) except KeyboardInterrupt: logging.info('exit on keyboard interrupt') myDisplay.quit = True except Exception as err: logging.error('unhandled exception in main thread:') logging.error(str(err)) logging.debug(traceback.format_exc())
class Test: def __init__(self, stream): self.display = Display() self.stream = Stream(stream) def parse(self): if not self.stream.line: return False parse = self.stream.line.split('#') if len(parse) == 2: try: self.result = int(parse[0].rstrip(' ')) self.message = parse[1].rstrip(' ') except: return False if self.result != 0 and self.result != 1: return False return True return False def launch(self): sucess = 0 total = 0 while self.stream.read(): if self.parse(): if self.result == 1: sucess += 1 else: self.display.error("Error on" + self.message) total += 1 self.display.summary(sucess, total)
def run_game(size): gol = GameOfLife(size) display = Display() while True: display.show_board(gol.get_board()) time.sleep(1)
class Simulator(object): def __init__(self, num_tokens=5, size=(8, 8), frames_per_second=30): self.arena = Arena() for i in range(num_tokens): token = Token(self.arena, i) token.location = (random() * 4 - 2, random() * 4 - 2) self.arena.objects.append(token) self.display = Display(self.arena) self._loop_thread = threading.Thread(target=self._main_loop, args=(frames_per_second,)) self._loop_thread.start() def _main_loop(self, frames_per_second): clock = pygame.time.Clock() while True: for event in pygame.event.get(): if event.type == pygame.QUIT: return self.display.tick(1/frames_per_second) clock.tick(frames_per_second) def __del__(self): pygame.quit()
class OutputHandler(object): def __init__(self, outputs, pars, neuron2NoteConversion=4): self.pars = pars super(OutputHandler, self).__init__() self.display = Display(pars['N_col'], pars['N_row'],\ ['Ne', 'Ni', 's_e', 's_i', 'tau_e', 'tau_i', 'midi_ext_e', 'midi_ext_i', 'cam_ext', 'cam_external_max'], 'lines', screenSize=pars['screen_size']) pm.init() self.__output = outputs if Visuals.NAME in self.__output: self.__output[Visuals.NAME].note_on(1) # self.__membraneViewer = Test() self.__now = time.time() self.__activeNotes = set() self.__neuron2NoteConversion = neuron2NoteConversion def __setupInputs(self, inputList): self.__input = {} for name in inputList: self.__input[name] = \ self.__getDevice(self.__name2Identifier[name], type = 'input') def update(self,fired): # print 'es feuern', fired neuron_ids = intersect1d(fired, self.pars['note_ids']) self.__checkKeyChange(neuron_ids) n_fired = neuron_ids.__len__() if n_fired > 0: for neuron_id in neuron_ids: for name, output in self.__output.iteritems(): output.note_on(neuron_id) # self.__membraneViewer.move() # display spikes and update display self.display.update_fired(fired) self.display.update_pars( ['cam_ext', 'midi_ext_e', 'midi_ext_i', 's_e', 's_i', 'tau_e', 'tau_i', 'cam_external_max']) pygame.display.update() def turnOff(self): for outputName in self.__output.iterkeys(): if outputName == NeuronNotes.NAME: self.__output[outputName].turnAllOff() def __checkKeyChange(self, neuron_ids): if len(neuron_ids)>20: self.__neuron2NoteConversion = (1 if self.__neuron2NoteConversion==7 else 7) self.__output[NeuronNotes.NAME].setNeuron2NoteConversion( self.__neuron2NoteConversion ) # [output.setNeuron2NoteConversion(self.__neuron2NoteConversion) for # name, output in self.__output.iteritems()] print '----------------------------------------key change'
def run(): dis = Display() start_time = arrow.now() while True: td = fmt_timedelta(start=start_time) print td dis.simple_static_message(td) sleep(1)
def example1(): coefficients = np.array([[1, 1], [1, -1]], dtype='float') constraints = np.array([[4], [2]], dtype='float') objective = np.array([3, 2]) simplex = Simplex(coefficients=coefficients, constraints=constraints, objective=objective) display = Display(simplex_init=simplex) display.run_simplex()
def example2(): coefficients = np.array([[4.1, 2], [2, 4]], dtype='float') constraints = np.array([[40], [32]], dtype='float') objective = np.array([80, 55]) simplex = Simplex(coefficients=coefficients, constraints=constraints, objective=objective) display = Display(simplex_init=simplex) display.run_simplex()
class Session: """ for stand-alone usage by the ox-user. ?for collaborative sessions see CoSession """ print("DEL import Session") def __init__(self, name, window): self._name = name self._dis = Display(window) self._co = Coach() self._co.register(self, self._dis) self._dis.register(self, self._co) self._co.create_exercises() #TODO.WN091101 replace by storing Exerc.s self._calcs = None #pop ! def run(self): """as long as user does exercises""" #print("in Session.run") self._co.request_exercise() self._dis.init_calc() #TODOWN091101 take Exercise as argument def notify(self, (msg, data)): '''called by the observed objects''' #print('in Session.notify: msg=,data=', msg, data) if msg == 'setting-done': # from Coach self._ex = data self._calcs = data._generate_calcs() self._key = data.get_topic() (self._calcs).reverse() _calc = (self._calcs).pop() #print('in Session.notify: calc=', _calc) _lines, self._input = data.format(_calc) self._dis.display_calc(_lines) self._curr_in = self._input.pop() #need _curr_in in notify self._dis.create_entryline(self._curr_in) # create_entryline sets the callback from gtk to Display if msg == 'digit-done': # from Display #print('in Session.notify, digit-done: _input=', self._input) (lino, pos, dig, proterr, protok, li) = self._curr_in self._dis.create_entryline((lino, -1, dig, proterr, protok, li)) if len(self._input) > 0: self._curr_in = self._input.pop() self._dis.create_entryline(self._curr_in) else: # start new calc self._dis.show_progress() if len(self._calcs) > 0: _calc = (self._calcs).pop() print('in Session.notify: calc=', _calc) _lines, self._input = self._ex.format(_calc) self._dis.display_calc(_lines) self._curr_in = self._input.pop() #need _curr_in in notify self._dis.create_entryline(self._curr_in) # create_entryline sets the callback from gtk to Display else: self._dis.finish_calc()
class Browser(object): display = None browser = None def __init__(self, downloaded_data_dir=None, implicitly_wait_seconds=10, is_visible=False, profile_directory=None): if not is_visible: self.display = Display() self.downloaded_data_dir = downloaded_data_dir self.start_browser(downloaded_data_dir, implicitly_wait_seconds, profile_directory) def __enter__(self): return self def __exit__(self, type, value, trace): if type and self.downloaded_data_dir: try: save_to = join(self.downloaded_data_dir, 'error_screenshot_' + datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S")) self.browser.save_screenshot(save_to) except: pass self.close() def start_browser(self, downloaded_data_dir=None, implicitly_wait_seconds=10, profile_directory=None): profile = webdriver.FirefoxProfile(profile_directory) if downloaded_data_dir: '''start browser with profile''' profile.set_preference("browser.download.folderList", 2) profile.set_preference("browser.download.manager.showWhenStarting", False) profile.set_preference("browser.download.dir", downloaded_data_dir) profile.set_preference("browser.helperApps.neverAsk.saveToDisk", "application/csv,text/csv") profile.set_preference("browser.download.manager.scanWhenDone", False) profile.set_preference("browser.download.manager.showAlertOnComplete", True) profile.set_preference("browser.download.manager.useWindow", False) profile.set_preference("browser.helperApps.alwaysAsk.force", False) self.browser = webdriver.Firefox(firefox_profile=profile) self.browser.implicitly_wait(implicitly_wait_seconds) def get_browser(self): if self.browser: return self.browser raise Exception("browser don't exist") def close_browser(self): '''browser.quit() closes the browser & deleted the temp files''' if self.browser: try: self.browser.quit() except Exception as e: log.error("error closing browser, reason: " + str(e)) self.browser = None def close(self): self.close_browser() if self.display: self.display.stop_display()
def run_from_txt(): with open("lp.txt") as file: content = file.read() kw = {} exec(content, globals(), kw) A = np.array(kw['A']) b = np.array(kw['b']) c = np.array(kw['c']) d = Display(Simplex(coefficients=A, constraints=b, objective=c)) d.run_simplex()
def complex_camera(camera, target_rect): l, t, _, _ = target_rect _, _, w, h = camera l, t, _, _ = -l+Display.getHalfWidth(), -t+Display.getHalfHeight(), w, h #l = min(0, l) # stop scrolling at the left edge #l = max(-(camera.width-WIN_WIDTH), l) # stop scrolling at the right edge #t = max(-(camera.height-WIN_HEIGHT), t) # stop scrolling at the bottom #t = min(0, t) # stop scrolling at the top return Rect(l, t, w, h)
def run(self): self.setup_logging() scheduler = BlockingScheduler() weather = Weather(scheduler, zip=self._args['zip'], station=self._args['station']) dimmer = Dimmer(scheduler) display = Display(weather, dimmer) display.start() scheduler.start()
def example3(): coefficients = np.array([[2, 1, 0], [1, 2, -2], [0, 1, 2]], dtype='float') constraints = np.array([[10], [20], [ 5]], dtype='float') objective = np.array([2, -1, 2]) simplex = Simplex(coefficients=coefficients, constraints=constraints, objective=objective) display = Display(simplex_init=simplex) display.run_simplex()
class Simulator(object): def __init__(self, config={}, size=(8, 8), frames_per_second=30, foreground=False): try: game_name = config["game"] del config["game"] except KeyError: game_name = DEFAULT_GAME game = GAMES[game_name] self.GAME_CODE = GAME_CODES[game_name] self.arena = game(**config) self.display = Display(self.arena, self.GAME_CODE) self.foreground = foreground self.frames_per_second = frames_per_second if not self.foreground: self._loop_thread = threading.Thread(target=self._main_loop, args=(frames_per_second,)) self._loop_thread.setDaemon(True) self._loop_thread.start() def run(self): if not self.foreground: raise RuntimeError("Simulator runs in the background. Try passing foreground=True") self._main_loop(self.frames_per_second) def set_robots(self, robots): self.robots = robots def _main_loop(self, frames_per_second): clock = pygame.time.Clock() while True: if any( event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE) for event in pygame.event.get() ): break self.display.tick(1 / frames_per_second) clock.tick(frames_per_second) for robot in self.robots: try: robot.raiseExc(KeyboardInterrupt) except threading.ThreadError: pass pygame.quit() sys.exit(0)
class Game(object): def __init__(self): self.clock = pygame.time.Clock() self.display = Display() self.game_state = GameState() self.control_state = ControlState() def run(self): pygame.init() while True: self.control_state.update() self.game_state.update(self.control_state) self.display.update(self.game_state) self.clock.tick(60)
class Life(object): __display = None grid_size = [100, 100] def __init__(self): self.__display = Display(title='PyLife', grid_size=self.grid_size, width=800, height=800) def initial_seed(self): cells = {} for x in range(self.grid_size[0]): for y in range(self.grid_size[1]): if random.randint(0, 1) == 1: cells[(x, y)] = 1 return cells def get_cell_neighbours(self, item, cells): neighbours = 0 for x in range(-1, 2): for y in range(-1, 2): cell = (item[0] + x, item[1] + y) if cell[0] in range(0, self.grid_size[0]) and cell[1] in range(0, self.grid_size[1]) and cell in cells: if (x == 0 and y == 0) is False: neighbours += 1 return neighbours def get_cells(self, cells): new_cells = {} for x in range(self.grid_size[0]): for y in range(self.grid_size[1]): neighbours = self.get_cell_neighbours((x, y), cells) if ((x, y) in cells) and (neighbours == 2 or neighbours == 3): new_cells[(x, y)] = 1 elif ((x, y) in cells) is False and neighbours == 3: new_cells[(x, y)] = 1 del cells return new_cells def run(self): cells = self.initial_seed() while True: if self.__display.update() is False: self.__display.quit() sys.exit(0) cells = self.get_cells(cells) for cell in cells: self.__display.draw(cell[0], cell[1])
def __init__(self, args): """ BoomBoomClient constructor. @param host: Server hostname. @type host: C{str} @param display_port: Server port for "display"/"view" connection. @type display_port: C{int} @param input_port: Server port for "input" connection. @type input_port: C{int} @param verbose: Verbose mode flag. @type verbose: C{bool} @param debug: Debug mode flag. @type debug: C{bool} @param max_fps: Maximal number of frames per second, for optimization. @type max_fps: C{int} """ args["protocol"] = protocol.loadProtocol("protocol.xml") args["features"] = ["game"] # Constant features Happyboom.__init__(self, args) EventListener.__init__(self, prefix="evt_") self.display = Display(args) self.input = Input(args) self.__verbose = args.get("verbose", False) self.registerEvent("happyboom") self.registerEvent("game")
def __init__(self, width=800, height=600): (self.__width, self.__height) = (width, height) self.__display = Display(width, height) self.__bts = {} self.__ms = set() self.__color_index = 0 self.__filename = None self.__speed = 1. self.__freqs_color = {} log.nb_handover = 0 self.__display.action_load.triggered.connect(self.load_file) self.__display.action_reload.triggered.connect(self.reload_file) self.__display.action_play.triggered.connect(self.__update_moving_ms) self.__display.action_incSpeed.triggered.connect( lambda: self.change_speed(1)) self.__display.action_decSpeed.triggered.connect( lambda: self.change_speed(-1)) self.__display.speed_lineedit.editingFinished.connect( lambda: self.set_speed(float(self.__display.speed_lineedit.text()))) self.__move_timer = QtCore.QTimer() self.__move_timer.timeout.connect(self.movems) self.set_speed(1) self.__display.show()
def __init__(self): self.logger = Logger(level='debug') self.logger.debug("Create display") self.display = Display() self.logger.debug(" + size: %sx%s" % (self.display.width, self.display.height)) ## Config self.blocks_width = 5 self.aliens_width = 10 self.aliens_height = 4 self.aliens_margin = 2 self.torpedos = [] self.max_speed = 10 self.frame_rate = 25 self.speed_down = 3 self.score = 0 # Build Aliens self.aliens = self.build_aliens() # Build Blocks self.blocks = self.build_blocks() # Build ship self.ship = Ship( logger=self.logger, display=self.display, game=self )
def __enter__(self): # init curses and it's wrapper self.screen = curses.initscr() self.display = Display(self.screen, self.encoding) # create keyhandler self.keyhandler = key.KeyHandler(self.screen) # create view self.view = SelectorView(percol = self) # create command self.command_candidate = SelectorCommand(self.model_candidate, self.view) self.command_action = SelectorCommand(self.model_action, self.view) # suppress SIGINT termination signal.signal(signal.SIGINT, lambda signum, frame: None) # handle special keys like <f1>, <down>, ... self.screen.keypad(True) curses.raw() curses.noecho() curses.cbreak() return self
def __init__(self): self.display = Display() self.player = Charactor(self) self.level = Level(self) self.hud = Hud() self.prepare_stage()
def initialize_interface(self): self.display = Display(self.game_data) self.uis = UIState(self.game_data) #Building buttons callbacks self.uis.button_homes.callback = self.generate_building_callback('houses') self.uis.button_fields.callback = self.generate_building_callback('field') self.uis.button_woodcutter.callback = self.generate_building_callback('woodcutter') self.uis.button_road.callback = self.generate_building_callback('road') self.uis.button_port.callback = self.generate_building_callback('port') self.uis.button_stockpile.callback = self.generate_building_callback('stockpile') self.uis.button_stone_carrier.callback = self.generate_building_callback('stone_carrier') self.uis.button_workshop.callback = self.generate_building_callback('workshop') self.uis.button_iron_mine.callback = self.generate_building_callback('iron_mine') self.uis.button_destruct.callback = self.generate_building_callback('destruct') self.display.uis = self.uis self.game_data.uis = self.uis self.uis.display = self.display self.uis.save_button.callback = self.save_game self.uis.load_button.callback = self.load_game #Listeners event_manager.event_manager.add_listener(event_manager.MESSAGE_MOUSE_UP, self.uis.mouse_button_up_callback) event_manager.event_manager.add_listener(event_manager.MESSAGE_KEY_UP, self.keyup_callback) event_manager.event_manager.add_listener(event_manager.MESSAGE_KEY_DOWN, self.keydown_callback) event_manager.event_manager.add_listener(event_manager.MESSAGE_MOUSE_MOTION, self.mouse_move) event_manager.event_manager.add_listener(event_manager.MESSAGE_MOUSE_DOWN, self.mouse_key_down_callback) event_manager.event_manager.add_listener(event_manager.MESSAGE_KEY_UP, self.uis.check_button_up)
def __init__(self): """ connect hardware, initialize state dir """ self.trigger = Trigger() self.display = Display() self.current_address = None self.cost = 0 self.set_state(Vend.STARTUP)
def create_displays2(self, fullscreen): #create display objects for each projector image self.create_images() self.shadows = [] self.display = Display() self.display.setup(fullscreen) self.draw()
def __init__(self, verbose = False, scan_interval_timeout = constants.SCAN_INTERVAL_TIMEOUT): self.scan_interval_timeout = scan_interval_timeout self.last_tag = None self.last_tag_type = None self.current_tag_type = None self.last_read_tstamp = -1 self.display = Display()
def __init__(self): self.config = {} # dict to contain combined list of config file options and commandline parameters self.email_list = [] # list of email targets self.webserver = None # web server process # initialize some config options self.config["domain_name"] = "" self.config["company_name"] = "" self.config["config_filename"] = "" self.config["email_list_filename"] = "" # default all bool values to False self.config["verbose"] = False self.config["gather_emails"] = False self.config["enable_externals"] = False self.config["enable_web"] = False self.config["enable_email"] = False self.config["enable_email_sending"] = False self.config["simulate_email_sending"] = False self.config["daemon_web"] = False self.config["always_yes"] = False # get current IP self.config['ip'] = Utils.getIP() # set a few misc values self.pid_path = os.path.dirname(os.path.realpath(__file__)) + "/../" self.display = Display() self.email_templates = defaultdict(list)
def load(self): self._map = {} self._tiles = {} self._attributes = {} file = Files.openFile(self._file) self._attributes = self.loadAttributes('attribs', file) self._enemies = self.loadAttributes('enemies', file) self.w = self.getAttr("w") * const.res self.h = self.getAttr("h") * const.res self._display = Display(Surface((self.w, self.h)), klass=self, transparent=True) file = re.search("map: {(.*?)}", file, flags=re.DOTALL).group(1) for tile in re.finditer(r"\((.*?):(.*?)\)", file): rect, right = tile.group(1), tile.group(2) rect = re.match(r"(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)", rect) if not rect: raise Exception("Unrecognized pattern: {}".format(rect)) details = re.match(r"(\d+),(\d+)$", right) if not details: raise Exception("Unrecognized pattern: {}".format(right)) i, e = int(rect.group(1)), int(rect.group(2)) x, y, w, h = rect.group(3), rect.group(4), rect.group(5), rect.group(6) x, y, w, h = int(x), int(y), int(w), int(h) typ, tile = int(details.group(1)), int(details.group(2)) attrib = {} wall = Wall((x, y, w, h), typ, tile, attrib) wall.subscribe("map", self._updateMap) self._map[(i, e)] = wall self._tiles.setdefault(wall.getType(), []).append(wall)
def start(self, ip, port): self.sock.connect((ip, port)) self.sendline("name {}".format(self.name)) for line in readline_from_socket(self.sock): data = json.loads(line) if "status" in data: self.handle_status_message(data) continue if not self.display: self.board = GameBoardClient(*data["map_size"]) self.players = [Player(None, name="Player"+str(i)) for i in range(data["num_players"])] self.my_id = data["player_id"] self.players[self.my_id].name = self.name self.display = Display(600, 600, self.board.width, self.board.height) self.display.init() self.board.update(data["map"]) self.display.clear() self.display.draw_board(self.board, self.players) self.display.update(fps=0) self.resolve_round() for event in pygame.event.get(): if event.type == pygame.QUIT: print("Game terminated by host.") sys.exit(0)
def case2(self): filepath = os.path.dirname(os.path.abspath(__file__)) + '/sample/sample5.json' layout = GreedyLayout(filepath, 1500, 1000) self.display = Display(layout) self.display.show() self.score(layout)
try: import boot2 except: pass import ckcc import uasyncio.core as asyncio loop = asyncio.get_event_loop() print("---\nColdcard Wallet from Coinkite Inc. (c) 2018.\n") # Setup OLED and get something onto it. from display import Display, FontFixed, FontSmall, FontLarge dis = Display() dis.splash() if version.is_mark2(): # Setup membrane numpad (mark 2) from mempad import MembraneNumpad numpad = MembraneNumpad(loop) else: # Setup touch numpad (mark 1 hardware) from touchpad import TouchNumpad numpad = TouchNumpad(loop) # Serial Flash memory from sflash import SPIFlash sf = SPIFlash()
class GameServer: def __init__(self, port, mapfile, rounds_per_second, w, h, observers): self._port = port self.players = [] self.observers = [] self.numObservers = observers self.numPlayers = 0 # Will be overwritten by loadmap. (but included here to make PyCharm happy) self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.bind(('', port)) self.socket.listen(3) self.loadmap(mapfile) self.display = Display(w, h, self.board.width, self.board.height) self.rounds_per_second = rounds_per_second def start(self): print("Server started on port {}.".format(self._port)) self.wait_for_observsers() self.wait_for_players() print("All players are ready, game is now starting.") self.send_gamestate_to_observers(unfiltered=True) self.display.init() first_round = True while True: self.display.clear() self.start_next_turn() self.resolve_food_harvest() self.move_and_spawn_units() self.resolve_fights() self.destroy_spawners() if random.randrange(0, 100) < 17: self.board.spawn_food() self.send_gamestate_to_players() self.send_gamestate_to_observers() self.display.draw_board(self.board, self.players) if first_round: self.wait_for_next_round(1) first_round = False if self.wait_for_next_round(self.rounds_per_second): return True def wait_for_next_round(self, rounds_per_seconds): num_updates = int(20 / rounds_per_seconds) for _ in range(num_updates): self.display.update(20) for event in pygame.event.get(): if event.type == pygame.QUIT: print("Game terminated by host.") return True return False def wait_for_observsers(self): print("Waiting for {} observer(s) to connect...".format( self.numObservers)) for _ in range(self.numObservers): observer = self.get_player_from_socket() observer.name = "Observer" self.observers.append(observer) def wait_for_players(self): print("Waiting for {} player(s) to connect...".format(self.numPlayers)) for _ in range(self.numPlayers): player = self.get_player_from_socket() player.start() self.players.append(player) while not self.check_players_ready(): time.sleep(0.5) def start_next_turn(self): for player in self.players: player.start_next_turn() def get_player_from_socket(self): conn, addr = self.socket.accept() print("Recieved new connection from {}:{}".format(*addr)) return Player(conn) def check_players_ready(self): for player in self.players: if not player.ready: return False return True def move_and_spawn_units(self): for playerNum, player in enumerate(self.players): # Set new spawning mode for the player mode = player.command.get("mode", "standard") if mode == "standard": player.mode = Unit elif mode == "harvester": player.mode = Harvester elif mode == "soldier": player.mode = Soldier # move all the units he sent a command for legal_moves = [ ] # Used so we do not send loads of illegal-moves to the observers for move in player.command.get("moves", []): try: x, y, direction = move if self.board.move_unit(x, y, playerNum, direction): legal_moves.append(move) except (IndexError, ValueError, TypeError) as e: print( "{} sent an invalid move-command: '{}' Exception: {}". format(player.name, move, e.message)) player.command["moves"] = legal_moves self.board.resolve_moves() # Spawn new units spawners = copy(self.board.spawners) random.shuffle(spawners) for spawner in filter(lambda s: not s.dead, spawners): owner = self.players[spawner.owner] if owner.food > 0: if not self.board.any_units_on_position(spawner.position): self.board.add_unit(spawner.position[0], spawner.position[1], owner.mode, spawner.owner) owner.food -= 1 def resolve_fights(self): self.board.calculate_attack_strengths(5) deadUnits = [] for unit in self.board.units: x, y = unit.position for enemy in self.board.get_neighbour_enemy_units( x, y, 5, unit.owner): if unit.attackStrength >= enemy.attackStrength: unit.dead = True if unit not in deadUnits: deadUnits.append(unit) self.display.draw_attack(enemy, unit) for unit in deadUnits: x, y = unit.position self.board[x][y].unit = None self.board.units.remove(unit) def destroy_spawners(self): for spawner in filter(lambda s: not s.dead, self.board.spawners): x, y = spawner.position if self.board[x][y].unit is not None: if self.board[x][y].unit.owner != spawner.owner: spawner.dead = True def resolve_food_harvest(self): removedCells = [] for foodcell in self.board.foodcells: players = set() harvest = 0 neighbourCells = self.board.get_neighbour_cells( foodcell.x, foodcell.y, 1) for cell in filter( lambda c: c.unit is not None and c.unit.type != "soldier", neighbourCells): players.add(cell.unit.owner) if cell.unit.harvest > harvest: harvest = cell.unit.harvest foodcell.hasFood = False removedCells.append(foodcell) break if len(players) == 1: self.players[players.pop()].food += harvest for cell in removedCells: self.board.foodcells.remove(cell) def loadmap(self, mapfile_path): with open(mapfile_path) as mapfile: line = mapfile.readline().rstrip().split(" ") width, height, numPlayers = int(line[0]), int(line[1]), int( line[2]) self.numPlayers = numPlayers self.board = GameBoard(width, height) for y in range(height): line = mapfile.readline().rstrip() for x in range(width): if line[x] == "#": self.board.add_wall(x, y) if line[x].isdigit(): self.board.add_spawner(x, y, int(line[x])) def send_gamestate_to_players(self): visibility_board = self.get_unit_visibility() for player_id, player in enumerate(self.players): state = { "map_size": (self.board.width, self.board.height), "player_id": player_id, "num_players": self.numPlayers } state["map"] = [] for x in range(len(visibility_board)): for y in range(len(visibility_board[x])): if player_id in visibility_board[x][y]: state["map"].append(self.board[x][y].as_dict()) player.send_gamestate(state) def get_unit_visibility(self): cell_visibility_mask = [[[] for _ in range(self.board.height)] for _ in range(self.board.width)] for unit in self.board.units: x, y = unit.position if unit.owner not in cell_visibility_mask[x][y]: cell_visibility_mask[x][y].append(unit.owner) for cell in filter(lambda cell: not cell.empty(), self.board.get_neighbour_cells(x, y, 55)): if unit.owner not in cell_visibility_mask[cell.x][cell.y]: cell_visibility_mask[cell.x][cell.y].append(unit.owner) return cell_visibility_mask def send_gamestate_to_observers(self, unfiltered=False): if self.numObservers == 0: return players = [] for i, player in enumerate(self.players): players.append({ "id": i, "name": player.name, "food": player.food, "command": player.command }) state = dict(map_size=(self.board.width, self.board.height), players=players) cells = filter( lambda c: (not c.empty()) and (unfiltered or not c.isWall), chain.from_iterable(self.board)) state["map"] = [cell.as_dict() for cell in cells] for observer in self.observers: observer.send_gamestate(state)
class Core: def __init__(self): pass ''' @name initiate @description start core services ''' def initiate(self): format = "%(asctime)s: %(message)s" logging.basicConfig(format=format, level=logging.INFO, datefmt="%H:%M:%S") logging.info("Core: creating run_scheduler_job thread") ######run scheduler self.run_scheduler_job() logging.warning("Core: creating get_display_information thread") #reset display storage self.run_display_information_job() # get a model logging.info("Core: creating fetch_model_library thread") self.run_fetch_model_job() #begin flask server, after initiation tasks server.run() ''' @name run_scheduler_job @description start scheduler on a new thread. scheduler runs: - process engine, - risk engine - model engine, - anomaly engine ''' def run_scheduler_job(self): x = threading.Thread(target=scheduler_run, args=("Test parameter to scheduler_run", )) logging.info("core: before running thread") x.start() logging.info("core: wait for the thread to finish") ''' @name run_display_information_job @description run display information job ''' def run_display_information_job(self): print("Getting display information") self.display = Display() self.display.get_system_display() ''' @name run_fetch_model @description get model ''' def run_fetch_model_job(self): print("Getting model") ModelLibrary.fetch_model()
def run(self): "初始值设置" IDs = [1, 2, 3, 4, 5, 6] pointMap = {} act_flocks = [] pot_flocks = [] curid = 0 colorlist = np.zeros((2, 3)) for j in range(3): colorlist[0][j] = 1 for j in range(3): colorlist[1][j] = 0.9 onedata = np.zeros((0, 0)) lasttype = [] assigned = [0, 0, 0, 0, 0, 0] flockmap = {} cmap = {} maxid = -2 start = 0 end = 0 # XAXISSIZE = 1000 WIN = 100 left = '' # fig, ax = plt.subplots() # plt.axis([0, XAXISSIZE, 0, 10]) # ax = plt.axis() Display.drawFlock(colorlist, onedata, IDs, self.ax, start) while True: data = self.client.recv(BUFSIZE) if data: string = bytes.decode(data, encoding) # print(string) self.client.send("ok".encode(encoding='utf-8')) IDs, pointMap, left = decodeMsg(string, left, IDs, pointMap) # print(IDs) # if string.startswith('#'): # ts, points = dePositionMsg(string) # if ts not in pointMap: # pointMap[ts] = [] # pointMap[ts] = points # elif string.startswith('%'): # IDs = deIdMsg(string) # print(IDs) if len(pointMap) == WIN: pointmap = pointMap pointMap = {} end = start + WIN start = end "画图" draw_array, flockmap, act_flocks, pot_flocks, curid = FD.rtFlockDetect( IDs, self.gama, self.delta, pointmap, self.eps, self.minPts, 0, 0.4, act_flocks, pot_flocks, flockmap, curid, self.spatialType) draw_array1 = np.transpose(draw_array) onedata = Display.combinedata(onedata, draw_array1) "获得色彩数组" colorlist, lasttype, assigned, cmap, maxid = color.chooseColor( colorlist, draw_array, lasttype, assigned, cmap, maxid) # print(list(colorlist)) "画图" plt.clf() Display.drawFlock(colorlist, onedata, IDs, self.ax, start) else: print('no data') break # plt.show() print("close:", self.client.getpeername())
class Client(Happyboom, EventListener): """ The main class of the client of BoomBoom. @ivar display: Display manager of the game. @type display: C{L{BoomBoomDisplay}} @ivar input: Input manager of the game. @type input: C{L{BoomBoomInput}} @ivar __verbose: Verbose mode flag. @type __verbose: C{bool} @ivar __stopped: Stopped game flag. @type __stopped: C{bool} @ivar __stoplock: Mutex for synchronizing __stopped. @type __stoplock: C{thread.lock} """ def __init__(self, args): """ BoomBoomClient constructor. @param host: Server hostname. @type host: C{str} @param display_port: Server port for "display"/"view" connection. @type display_port: C{int} @param input_port: Server port for "input" connection. @type input_port: C{int} @param verbose: Verbose mode flag. @type verbose: C{bool} @param debug: Debug mode flag. @type debug: C{bool} @param max_fps: Maximal number of frames per second, for optimization. @type max_fps: C{int} """ args["protocol"] = protocol.loadProtocol("protocol.xml") args["features"] = ["game"] # Constant features Happyboom.__init__(self, args) EventListener.__init__(self, prefix="evt_") self.display = Display(args) self.input = Input(args) self.__verbose = args.get("verbose", False) self.registerEvent("happyboom") self.registerEvent("game") def start(self): """ Starts the game client.""" if self.__verbose: log.info("[BOOMBOOM] Starting client...") Happyboom.start(self) # Create thread for display thread.start_new_thread(self.displayThread, ()) quit = False while not quit: self.input.process() time.sleep(0.100) quit = self.stopped def stop(self): """ Stops the game client.""" if self.__verbose: log.info("[BOOMBOOM] Stopping client...") Happyboom.stop(self) self.launchEvent("happyboom", "disconnection", self._io, u"Quit.") self.display.stop() def evt_game_stop(self): self.stop() def evt_happyboom_stop(self): """ Stop event handler. """ self.stop() def displayThread(self): """ Thread handler for the "display" part.""" try: self.display.start() except Exception, msg: bt = getBacktrace() log.error("EXCEPTION IN DISPLAY THREAD:\n%s\n%s" % (msg, bt)) try: self.stop() except Exception, msg: bt = getBacktrace() log.error("EXCEPTION (2) IN DISPLAY THREAD:\n%s\n%s" % (msg, bt))
""" CS550 Project: Solitaire Due September 24, 2018 @author: Ethan Chapman Dependencies: termcolor - package for changing the console colors pyparsing - parsing colored strings """ from display import Display from game import Game game = Game() while sum([len(i) for i in game.piles]) > 0: Display.clear() Display.display(game) game.do_turn() print("You Win!")
async def display_task(display_queue, config): num_leds = config['num_leds'] led_display = Display(config['pin_l'], config['pin_r'], num_leds) update_rate = config['update_rate'] last_msg = None last_percent = 0.0 pulse_rate = 60 try: while True: msg = await display_queue.get() if msg != last_msg: last_msg = msg data = msg[1] if msg[0] == 'percent_smooth': if data >= 1.0: for i in range(pulse_rate/2): led_display.display_pulse((-0.8/(pulse_rate/2))*i+1) time.sleep(update_rate/pulse_rate) await asyncio.sleep(0) for i in range(pulse_rate/2): led_display.display_pulse((0.8/(pulse_rate/2))*i+0.2) time.sleep(update_rate/pulse_rate) await asyncio.sleep(0) else: percent = data num_prev_leds = ceil(last_percent*num_leds) num_active_leds = ceil(percent*num_leds) leds_to_update = abs(num_prev_leds-num_active_leds) if leds_to_update > 0: if percent > last_percent: for i in range(num_prev_leds, num_active_leds): led_display.display_values(i/num_leds) await asyncio.sleep(update_rate/leds_to_update) else: for i in range(num_prev_leds-1, num_active_leds-1, -1): led_display.display_values(i/num_leds) await asyncio.sleep(update_rate/leds_to_update) last_percent = data elif msg[0] == 'percent': led_display.display_config(data) else: print('unkown message in display task ' + str(msg)) except asyncio.CancelledError: return
class DroneManager: def __init__(self): self.pids = DronePIDs() self.orbslam = OrbSlam() self.display = Display() self.marker_vision = CopterMarkerVision() self.drone_rc_controller = DroneRCController() self.shared_state = {} #self.joystick = JoystickInput() def process_loop(self): # Get Telemetry # self.shared_state['marker_telemetry'] = self.marker_vision.process() self.shared_state['slam_telemetry'] = self.orbslam.process( self.shared_state) # Scan keyboard self.shared_state['cv_keyboard'] = self.handle_opencv_keyboard_input() self.shared_state[ 'pygame_keyboard'] = self.display.get_keyboard_events() # Tune yaw on spacebar if 'space' in self.shared_state.get('pygame_keyboard'): self.pids.pids['yaw'].begin_tuning() # Lock in setpoints on 'S' key if 's' in self.shared_state.get( 'pygame_keyboard' ) and 'last_known_pose' in self.shared_state['slam_telemetry']: self.pids.hold_current_position( self.shared_state['slam_telemetry']['last_known_pose']) # Only update PIDs if new telemetry pose data is available if self.shared_state['slam_telemetry'].get('pose_update'): self.shared_state['pid_output'] = self.pids.update( self.shared_state['slam_telemetry']['pose_update']) self.drone_rc_controller.update_channels( self.shared_state['pid_output']['aileron'], self.shared_state['pid_output']['pitch'], self.shared_state['pid_output']['throttle'], self.shared_state['pid_output']['yaw'], ) # Kill throttle if telemetry is lost if self.shared_state['slam_telemetry'].get('telemetry_lost'): self.drone_rc_controller.pause_stream() self.display.rerender(self.shared_state) sleep(.05) def cleanup(self): self.drone_rc_controller.kill_throttle() self.drone_rc_controller.pause_stream() self.marker_vision.cleanup() self.orbslam.cleanup() self.display.cleanup() @staticmethod def handle_opencv_keyboard_input(): k = cv2.waitKey(30) & 0xff if k == 27: raise Exception('Shutdown')
def screen_timeout(timer): Disp.enable(False) timer.deinit()
def draw_menu(): for prog in PROGRAMS: Disp.add_link(prog.name, SCR_PROG) Disp.set_highlighted(Config.cur_program())
#!/usr/bin/env python3 import cv2 import time from display import Display W = 1920 // 2 H = 1080 // 2 disp = Display(W, H) class FeatureExtractor(object): GX = 16 GY = 12 def __init__(self): self.orb = cv2.ORB_create() def extract(self, img): # run detect in grid sy = img.shape[0] // self.GY sx = img.shape[1] // self.GX for ry in range(0, img.shape[0], sy): for rx in range(0, img.shape[1], sx): img_chunk = img[ry:ry + sy, rx:rx + sx] kp = self.orb.detect(img_chunk, None) for p in kp: print(p) fe = FeatureExtractor()
parser.add_argument('--labels', type=str, nargs='+', default=[]) args = parser.parse_args() args.temp_dir_root = os.path.expanduser(args.temp_dir_root) args.repo_cache_dir = os.path.expanduser(args.repo_cache_dir) args.trash_dir_root = os.path.expanduser(args.trash_dir_root) db = connection = pymysql.connect( host=args.host, user=args.user, password=args.password, database=args.database, cursorclass=pymysql.cursors.DictCursor, autocommit=True, ) available_gpu_ids = '' if args.gpus: available_gpu_ids = list(map(int, args.gpus.split(','))) with Display() as display: ExecutorManager( display, db, available_gpu_ids, args.temp_dir_root, args.repo_cache_dir, args.trash_dir_root, args.max_parallel, args.labels, ).run()
class Environment(object): """ Represents the virtual environment -- the 'OS' behind Tal, which manages all other running apps and services, and centrally monitors and dispatches updates to Tals peripherals. """ ENABLED_APPS = [ ReaderApp, TracerApp, ] ENABLED_SERVICES = [ NetworkService, ] activeHandlers = [ LuxControlHandler, ] activeSession = None runningServices = [] message = '' tiltSensorRight = None tiltSensorLeft = None # for now display = None def __init__(self): self.beforeStartUp() self.startUp() self.afterStartUp() def beforeStartUp(self): self.message = 'Starting up ...' def startUp(self): if YAPI.RegisterHub('usb', YRefParam()) != YAPI.SUCCESS: sys.exit('Connection error: connection through USB failed') self.tiltSensorRight = Sensor() self.display = Display() # bootstrap handlers for h in self.activeHandlers: self.tiltSensorRight.attachHandler(h()) self.tiltSensorRight.startWatching() # start display update loop def loop(): threading.Timer(.10, loop).start() self.display.updateStatus() # for debugging, show data in the message row for now self.display.updateMessage('P:{} R:{}'.format( str(pitch), str(roll))) loop() def afterStartUp(self): self.message = 'Idle' def beforeStartApp(self, app): if app not in self.ENABLED_APPS: return False self.message = 'Starting {}...'.format(app.name) def startApp(self, app): if app in self.ENABLED_APPS: self.activeSession = app(environment=self) else: return False def afterStartApp(self, app): self.message = 'Running {}'.format(app.name) def beforeCloseApp(self, app): if not self.activeSession: return False self.activeSession.beforeClose() def closeApp(self, app): if not self.activeSession: return False self.activeSession = None def afterCloseApp(self, app): return def registerHandler(self, handlerInstance): self.activeHandlers.append(handlerInstance) def unregisterHandler(self, handlerInstance): self.activeHandlers.remove(handlerInstance)
self.sSocket.send(bMensagem) except BrokenPipeError: self.mataThread() # definicao das variaveis e funções serverName = '' # ip do servidor (em branco) serverPort = 65000 # porta a se conectar serverSocket = socket(AF_INET, SOCK_STREAM) # criacao do socket TCP # bind do ip do servidor com a porta serverSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) serverSocket.bind((serverName, serverPort)) serverSocket.listen(1) # socket pronto para 'ouvir' conexoes # Inicia o diplay display = Display() display.start() listaDeUsuarios = [] # Manda a mensagem recebida para todos os usuários logados e para o display do servidor def sendBroadcast(bMensagem): for usuario in listaDeUsuarios: try: usuario.sSocket.send(bMensagem) except OSError: usuario.mataThread() # Tenta mandar a mensagem recebida para o usuário especificado no comando privado()
class Monitor(object): def __init__(self): self._name = 'Monitor/{}'.format(str(uuid.uuid4())) self._logger = self._make_logger(self._name) self._logger.debug('Initialized Logger') observer = log.PythonLoggingObserver() observer.start() self._last_query = None self._tasks = [] self._display = Display() self._notifiers = { 'display': self._notify_display, 'thingspeak': self._notify_thingspeak, } self._logger.info('Initialized {}'.format(self._name)) self.start_tasks() def __del__(self): if self._display: self._display.clear() GPIO.cleanup() def start_tasks(self): update_display = LoopingCall(self._update_display_last_query) update_display.start(UPDATE_DISPLAY_INTERVAL) self._tasks.append(update_display) query = LoopingCall(self._query_sensors_and_notify) query.start(QUERY_INTERVAL) self._tasks.append(query) def stop_tasks(self): for task in self._tasks: task.stop() @staticmethod def _make_logger(name): logger = logging.getLogger(name) logger.setLevel(logging.DEBUG) sh = logging.StreamHandler() sh.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s %(levelname)s\t- %(message)s', datefmt='%d/%m/%y %H:%M:%S') sh.setFormatter(formatter) logger.addHandler(sh) return logger def _notify_thingspeak(self, sensor_readings): self._logger.debug('Sending update...') fields = { TEMPRATURE_FIELD_INDEX: sensor_readings['temprature'], HUMIDITY_FIELD_INDEX: sensor_readings['humidity'] } fields_url_part = '&'.join( ['{}={}'.format(f, d) for f, d in fields.items()]) uri = '{}?api_key={}&{}'.format(BASE_URL, API_KEY, fields_url_part) agent = Agent(reactor) d = agent.request( bytes('GET', 'ascii'), bytes(uri, 'ascii'), None, None ) #Headers({'User-Agent': ['Twisted Web Client Example']}), None) def response(ctx): self._logger.debug('Update Sent') d.addCallback(response) def _notify_display(self, sensor_readings): self._display.write_line(self._format_sensor_readings(sensor_readings), SENSOR_DISPLAY_LINE) def _update_display_last_query(self): if not self._last_query: return self._display.write_line(timeago.format(self._last_query), TIME_AGO_DISPLAY_LINE) def _read_dht22(self): self._logger.debug('Started reading from DHT22') humidity, temp = Adafruit_DHT.read_retry(Adafruit_DHT.DHT22, DHT22_DATA_PIN) self._logger.debug('Read from DHT22') return humidity, temp def _query_sensors(self): sensors = {} humidity, temp = self._read_dht22() if humidity is not None: sensors['humidity'] = round(humidity, 2) if temp is not None: sensors['temprature'] = round(temp, 2) self._last_query = datetime.datetime.now() return sensors def _format_sensor_readings(self, sensor_readings): if sensor_readings['humidity'] is None or sensor_readings[ 'temprature'] is None: self._logger.error( 'humidity/temp received are incorrect ({}.{})'.format( humidity, temp)) return DEFAULT_DATA_DISPLAY text = 'T/H: {:.1f}c {:.1f}%'.format(sensor_readings['temprature'], sensor_readings['humidity']) return text def _query_sensors_and_notify(self): sensor_readings = self._query_sensors() text = self._format_sensor_readings(sensor_readings) self._logger.info(text) for notifier in self._notifiers.values(): reactor.callWhenRunning(notifier, sensor_readings) def run(self): reactor.run()
class Game(object): """ This class represents an individual game, and contains the main game logic. """ defaults = { "curses": True, # whether to use ncurses for map display "color": True, # whether to use color with ncurses "delay": 0.1, # seconds to sleep after each (ncurses) display update "connect": CONNECT, # the territory connection graph (see world.py) "areas": AREAS, # the territory->continent mapping, and values "cmap": MAP, # the ASCII art map to use "ckey": KEY, # the territority->char mapping key for the map "screen": None, # a curses.window (for use with the curses.wrapper function) "round": None, # the round number "wait": False, # whether to pause and wait for a keypress after each event "history": {}, # the win/loss history for each player, for multiple rounds "deal": False # deal out territories rather than let players choose } def __init__(self, **options): self.options = self.defaults.copy() self.options.update(options) self.world = World() self.world.load(self.options['areas'], self.options['connect']) self.players = {} self.turn = 0 self.turn_order = [] if self.options['curses']: self.display = CursesDisplay(self.options['screen'], self, self.options['cmap'], self.options['ckey'], self.options['color'], self.options['wait']) else: self.display = Display() def add_player(self, name, ai_class, **ai_kwargs): assert name not in self.players player = Player(name, self, ai_class, ai_kwargs) self.players[name] = player @property def player(self): """Property that returns the correct player object for this turn.""" return self.players[self.turn_order[self.turn % len(self.players)]] def aiwarn(self, *args): """Generate a warning message when an AI player tries to break the rules.""" logging.getLogger("pyrisk.player.%s" % self.player.ai.__class__.__name__).warn(*args) def event(self, msg, territory=None, player=None): """ Record any game action. `msg` is a tuple describing what happened. `territory` is a list of territory objects to be highlighted, if any `player` is a list of player names to be highlighted, if any Calling this method triggers the display to be updated, and any AI players that have implemented event() to be notified. """ self.display.update(msg, territory=territory, player=player) LOG.info([str(m) for m in msg]) for p in self.players.values(): p.ai.event(msg) def play(self): assert 2 <= len(self.players) <= 5 self.turn_order = list(self.players) random.shuffle(self.turn_order) for i, name in enumerate(self.turn_order): self.players[name].color = i + 1 self.players[name].ord = ord('\/-|+*'[i]) self.players[name].ai.start() self.event(("start",)) live_players = len(self.players) self.initial_placement() while live_players > 1: if self.player.alive: choices = self.player.ai.reinforce(self.player.reinforcements) assert sum(choices.values()) == self.player.reinforcements for tt, ff in choices.items(): t = self.world.territory(tt) f = int(ff) if t is None: self.aiwarn("reinforce invalid territory %s", tt) continue if t.owner != self.player: self.aiwarn("reinforce unowned territory %s", t.name) continue if f < 0: self.aiwarn("reinforce invalid count %s", f) continue t.forces += f self.event(("reinforce", self.player, t, f), territory=[t], player=[self.player.name]) for src, target, attack, move in self.player.ai.attack(): st = self.world.territory(src) tt = self.world.territory(target) if st is None: self.aiwarn("attack invalid src %s", src) continue if tt is None: self.aiwarn("attack invalid target %s", target) continue if st.owner != self.player: self.aiwarn("attack unowned src %s", st.name) continue if tt.owner == self.player: self.aiwarn("attack owned target %s", tt.name) continue if tt not in st.connect: self.aiwarn("attack unconnected %s %s", st.name, tt.name) continue initial_forces = (st.forces, tt.forces) opponent = tt.owner victory = self.combat(st, tt, attack, move) final_forces = (st.forces, tt.forces) self.event(("conquer" if victory else "defeat", self.player, opponent, st, tt, initial_forces, final_forces), territory=[st, tt], player=[self.player.name, tt.owner.name]) freemove = self.player.ai.freemove() if freemove: src, target, count = freemove st = self.world.territory(src) tt = self.world.territory(target) f = int(count) valid = True if st is None: self.aiwarn("freemove invalid src %s", src) valid = False if tt is None: self.aiwarn("freemove invalid target %s", target) valid = False if st.owner != self.player: self.aiwarn("freemove unowned src %s", st.name) valid = False if tt.owner != self.player: self.aiwarn("freemove unowned target %s", tt.name) valid = False if not 0 <= f < st.forces: self.aiwarn("freemove invalid count %s", f) valid = False if valid: st.forces -= count tt.forces += count self.event(("move", self.player, st, tt, count), territory=[st, tt], player=[self.player.name]) live_players = len([p for p in self.players.values() if p.alive]) self.turn += 1 winner = [p for p in self.players.values() if p.alive][0] self.event(("victory", winner), player=[self.player.name]) for p in self.players.values(): p.ai.end() return winner.name def combat(self, src, target, f_atk, f_move): n_atk = src.forces n_def = target.forces if f_atk is None: f_atk = lambda a, d: True if f_move is None: f_move = lambda a: a - 1 while n_atk > 1 and n_def > 0 and f_atk(n_atk, n_def): atk_dice = min(n_atk - 1, 3) atk_roll = sorted([random.randint(1, 6) for i in range(atk_dice)], reverse=True) def_dice = min(n_def, 2) def_roll = sorted([random.randint(1, 6) for i in range(def_dice)], reverse=True) for a, d in zip(atk_roll, def_roll): if a > d: n_def -= 1 else: n_atk -= 1 if n_def == 0: move = f_move(n_atk) min_move = min(n_atk - 1, 3) max_move = n_atk - 1 if move < min_move: self.aiwarn("combat invalid move request %s (%s-%s)", move, min_move, max_move) move = min_move if move > max_move: self.aiwarn("combat invalid move request %s (%s-%s)", move, min_move, max_move) move = max_move src.forces = n_atk - move target.forces = move target.owner = src.owner return True else: src.forces = n_atk target.forces = n_def return False def initial_placement(self): empty = list(self.world.territories.values()) available = 35 - 2 * len(self.players) remaining = {p: available for p in self.players} if self.options['deal']: random.shuffle(empty) while empty: t = empty.pop() t.forces += 1 remaining[self.player.name] -= 1 t.owner = self.player self.event(("deal", self.player, t), territory=[t], player=[self.player.name]) self.turn += 1 else: while empty: choice = self.player.ai.initial_placement(empty, remaining[self.player.name]) t = self.world.territory(choice) if t is None: self.aiwarn("invalid territory choice %s", choice) self.turn += 1 continue if t not in empty: self.aiwarn("initial invalid empty territory %s", t.name) self.turn += 1 continue t.forces += 1 t.owner = self.player remaining[self.player.name] -= 1 empty.remove(t) self.event(("claim", self.player, t), territory=[t], player=[self.player.name]) self.turn += 1 while sum(remaining.values()) > 0: if remaining[self.player.name] > 0: choice = self.player.ai.initial_placement(None, remaining[self.player.name]) t = self.world.territory(choice) if t is None: self.aiwarn("initial invalid territory %s", choice) self.turn += 1 continue if t.owner != self.player: self.aiwarn("initial unowned territory %s", t.name) self.turn += 1 continue t.forces += 1 remaining[self.player.name] -= 1 self.event(("reinforce", self.player, t, 1), territory=[t], player=[self.player.name]) self.turn += 1
# Give external devs a way to start stuff early try: import boot2 except: pass import ckcc import uasyncio.core as asyncio loop = asyncio.get_event_loop() print("---\nColdcard Wallet from Coinkite Inc. (c) 2020.\n") # Setup OLED and get something onto it. from display import Display dis = Display() dis.splash() # Setup membrane numpad (mark 2+) from mempad import MembraneNumpad numpad = MembraneNumpad(loop) # Serial Flash memory from sflash import SPIFlash sf = SPIFlash() # NV settings from nvstore import SettingsObject settings = SettingsObject(loop) # global ptr to HSM policy, if any (supported on Mk3 only)
import re from button import Button from tagreader import TagReader from player import Player from display import Display from os import listdir from os.path import isdir, join import RPi.GPIO as GPIO # Initialize display first to write Hello print("Initializing Display") d = Display() d.draw_text("Hallo!", 32) library_path = "/srv/library" GPIO.setmode(GPIO.BCM) print("Initializing Player") p = Player(24) def on_tag_discovered(tag): # Check if there is a album with this name try: selected_album = (join(library_path, f) for f in listdir(library_path) if isdir(join(library_path, f)) and bool(re.search(tag + "$", f, re.I))).next() p.play_album(selected_album) except StopIteration: d.draw_text(tag, 12)
#!/usr/bin/env python3 import cv2 import time from display import Display from extractor import Extractor import numpy as np W = 1920 / 2 H = 1020 / 2 F = 1 display = Display(W, H) K = np.array([[F, 0, W // 2], [0, F, H // 2], [0, 0, 1]]) fe = Extractor(K) def process_frame(img): # too much resolution so will have to resize img = cv2.resize(img, (W, H)) matches = fe.extract(img) print("%d matches" % (len(matches))) for pt1, pt2 in matches: u1, v1 = fe.denormalize(pt1) u2, v2 = fe.denormalize(pt2) cv2.circle(img, (u1, v1), color=(0, 255, 0), radius=3) cv2.line(img, (u1, v1), (u2, v2), color=(255, 0, 0)) display.paint(img)
class Tracker: def __init__(self): # Strava client to hold information for tracker. self.client = Client() # Time token expires at. self.token_expires_at_ = None # Client information. self.client_id = None self.client_secret = None # Time in seconds between refreshes. self.sleep_time_ = 300 # Number of target activities per week. self.target_ = 4 # Private display object. self.display_ = Display() # Activity tracking variables. self.start_date = datetime.datetime.utcnow().date() self.next_week = self.start_date + datetime.timedelta(weeks=1) self.week_streak = 0 self.num_activities = 0 # Filename of save file. self.save_file_ = 'streak.yaml' def set_expiration(self, token_expires_at): self.token_expires_at_ = token_expires_at def set_client_info(self, client_id, client_secret): self.client_id = client_id self.client_secret = client_secret def save_status(self): save_obj = {'start_date' : self.start_date, 'next_week' : self.next_week, 'week_streak' : self.week_streak, 'num_activities' : self.num_activities} with open(self.save_file_, 'wb') as save_file: pickle.dump(save_obj, save_file) def load_status(self): save_obj = None try: with open(self.save_file_, 'rb') as save_file: save_obj = pickle.load(save_file) self.start_date = save_obj['start_date'] self.next_week = save_obj['next_week'] self.week_streak = save_obj['week_streak'] self.num_activities = save_obj['num_activities'] except (OSError, IOError, EOFError) as e: print('Nothing in this save file, going to save defaults.') self.save_status() def update(self): self.save_status() self.display_.show(self.week_streak, self.target_ - self.num_activities, self.target_) def run(self): # Save start date/time # Ask Strava for activities since 1 week ago # If len(activities) >= goal increment streak # Check that token won't expire in 12 hours # If token needs refreshing, refresh it # Sleep for sleep_time self.load_status() self.update() while(True): # Refresh token if necessary. if time.time() > self.token_expires_at_: refresh_response = self.client.refresh_access_token(client_id=self.client_id, client_secret=self.client_secret, refresh_token=self.client.refresh_token) self.token_expires_at_ = refresh_response['expires_at'] print('Refreshing token, new one expires at {}' .format(str(refresh_response['expires_at']))) new_activities = len(list(self.client.get_activities(after = self.start_date.isoformat()))) # Handle null return from Strava servers. if not new_activities: new_activities = 0 print(new_activities) if new_activities != self.num_activities: print("New activities detected!") self.num_activities = new_activities self.update() for activity in self.client.get_activities(after = self.start_date.isoformat()): print("{0.name} {0.moving_time}".format(activity)) # Check if we've hit the target for this week. if self.num_activities >= self.target_: self.week_streak += 1 self.update() cur_date = datetime.datetime.utcnow().date() # Check if it's next week. if cur_date == self.next_week: # Check if we haven't hit our target and reset. if self.num_activities < self.target_: self.week_streak = 0 # Advance the date to a week from now. self.start_date = cur_date self.next_week = cur_date + datetime.timedelta(weeks=1) self.update() time.sleep(self.sleep_time_)
class Game_board: # constructeur def __init__(self): self.nb_maison_dispo = 32 self.nb_hotel_dispo = 12 self.dice = Dice() # instanciation des cartes self.carte_chance = Carte_chance() self.carte_communaute = Carte_communaute() # instanciation des cases propriété self.proprietes = [] for i in proprietes_data: self.proprietes.append(Propriete(i)) # for p in self.proprietes: p.fiche() # instanciation des cases gare self.gares = [] for i in gares_data: self.gares.append(Gare(i)) # for g in self.gares: g.fiche() # instanciation des cases compagnie self.compagnies = [] for i in compagnies_data: self.compagnies.append(Compagnie(i)) # for c in self.compagnies: c.fiche() # instanciation de la prison self.prison = Prison() # tableau des joueurs self.joueurs = [] # initialisation graphique du plateau self.display = Display() def init_game(self): print("************************************\n" + "* BIENVENUE A LA TABLE DE MONOPOLY *\n" + "************************************\n") j = Joueur() self.joueurs.append(j) j = Joueur() self.joueurs.append(j) print("Il y a", len(self.joueurs), "joueurs à la table\n") while len(self.joueurs) < 5 and input( "Souhaitez-vous ajouter un nouveau joueur (max = 5) (o/N) ? " ).lower() == "o": j = Joueur() self.joueurs.append(j) print("Il y a", len(self.joueurs), "joueurs à la table\n") print("\nDébut de la partie\n") # affichage des pions des joueurs sur le plateau self.display.display_players(self.joueurs) def play(self): for j in self.joueurs: j.fiche() if j.position == 40: #joueur en prison self.prison.libere(j, self.carte_chance, self.carte_communaute) if j.position != 40: self.case_arrivee(j) # le joueur a été libéré else: # si joueur n'est pas en prison self.go(j, self.dice.lancer(j)) self.case_arrivee(j) while j.nb_double > 0: # tant le joueur a fait un double, il rejoue print(j.nom, "rejoue") self.go(j, self.dice.lancer(j)) self.case_arrivee(j) # analyse de la case d'arrivée def case_arrivee(self, j): # joueur j if j.position == 0: # case départ = 0 j.cash += 200 print("Vous avez reçu 200 € !") elif j.position in [7, 22, 36]: self.carte_chance.tirer_carte(j) # carte chance if j.replay: j.replay = False self.case_arrivee(j) # en cas de carte de déplacement elif j.position in [2, 17, 33]: self.carte_communaute.tirer_carte( j, self.joueurs) # carte caisse de communauté if j.replay: j.replay = False self.case_arrivee(j) # en cas de carte de déplacement if j.retire_chance: j.retire_chance = False self.carte_chance.tirer_carte( j) # si ne paye pas l'amende et préfere tirer chance elif j.position in proprietes_data: # terrain p = Propriete(j.position) p.fiche() p.visite(j, self.joueurs) elif j.position in compagnies_data: # électricité/eau c = Compagnie(j.position) c.fiche() c.visite(j, self.joueurs) elif j.position in gares_data: # gare g = Gare(j.position) g.fiche() g.visite(j, self.joueurs) elif j.position in [0, 10, 20]: # case départ, simple visite, parc gratuit if j.position == 0: print("Case départ") elif j.position == 10: print("Simple visite") elif j.position == 20: print("Parc gratuit") elif j.position == 30: # allez en prison print("Allez directement en prison") j.position = 40 j.nb_double = 0 # cas du joueur qui arrive ici par un double => ne rejoue pas elif j.position == 4: # impôts print("Taxe sur le revenu: 200 €") j.payer(200) elif j.position == 38: # taxe luxe print("Taxe de luxe: 100 €") j.payer(100) else: # pour debug print("Erreur de case") exit() # déplacement du joueur j et maj graphique du plateau def go(self, j, dice): progress = dice # le joueur progresse de la valeur du lancé de dés self.display.update_board( j, progress, self.joueurs) # visualisation du déplacement sur le plateau j.position += progress # avance de la valeur de dice if j.position > 39: j.position -= 40 # case départ = 0 ############################################################################# ########################### FONCTIONS POUR DEBUG ########################### ############################################################################# def list_all(self): print("****************\nListing complet") for i in range(1, 40): print("\ncase:", i) if i in self.proprietes: p = Propriete(i) p.fiche() elif i in self.compagnies: c = Compagnie(i) c.fiche() elif i in self.gares: g = Gare(i) g.fiche() def list_proprietes(self): print("****************\nListing propriétés") for i in range(1, 40): if i in self.proprietes: print("\ncase:", i) p = Propriete(i) p.fiche() def list_gares(self): print("****************\nListing gares") for i in range(1, 40): if i in self.gares: print("\ncase:", i) g = Gare(i) g.fiche() def list_compagnies(self): print("****************\nListing compagnies") for i in range(1, 40): if i in self.compagnies: print("\ncase:", i) c = Compagnie(i) c.fiche() # listing des cartes chance def list_chance(self): print("****************\nListing cartes chance") # for i in range(len(self.carte_chance.jeu_carte)): print(self.carte_chance.jeu_carte.pop(len(self.carte_chance.jeu_carte)-1)[0]) for c in self.carte_chance.jeu_carte: print(self.carte_chance.jeu_carte[c]) # listing des cartes caisse de communauté def list_communaute(self): print("****************\nListing cartes caisse de communauté") # for i in range(len(self.carte_communaute.jeu_carte)): print(self.carte_communaute.jeu_carte.pop(len(self.carte_communaute.jeu_carte)-1)[0]) for c in self.carte_communaute.jeu_carte: print(self.carte_communaute.jeu_carte[c])
class App(object): """ The regression application. The application accepts input from the command line and visualizes results in a display window. noise E -- set standard deviation representing measurement noise. spacing O -- select spacing option (regular/random) sample N -- sample N points on the sine function. """ def __init__(self, root): """ Initializes the sine and standard display object and setup a loop to continuously process the user input provided via the command line. """ # construct two frames frame1 = tk.Frame(root) frame1.place(relx=0, rely=0, relheight=1, relwidth=0.75) frame2 = tk.Frame(root) frame2.place(relx=0.75, rely=0, relheight=1, relwidth=0.25) self.sine = Sine() self.display = Display(frame1) # Place scrollbar s = tk.Scrollbar(frame2) s.place(relx=0.95, rely=0, relwidth=0.05, relheight=0.5) # Place text box to display previous commands self.hist = tk.Text(frame2) self.hist.config(yscrollcommand=s.set) self.hist.place(relx=0, rely=0, relwidth=0.95, relheight=0.5) # entry box to display new commands self.cmd_var = tk.StringVar() cmd = tk.Entry(frame2, textvariable=self.cmd_var) cmd.bind('<Return>', self._execute_command) cmd.place(relx=0, rely=0.5, relwidth=1, relheight=0.2) # text box to display output messages self.out_var = tk.StringVar() out = tk.Entry(frame2, textvariable=self.out_var) out.place(relx=0, rely=0.7, relwidth=1, relheight=0.3) self.display.sine_function(self.sine.df_sine) self.root = root def _execute_command(self, event): """ Interpret command line arguments. args: command -- str, input string provided via command line. """ command = self.cmd_var.get() self.cmd_var.set('') if 'quit' in command: self.root.quit() # interpret command try: if 'noise' in command: self.sine.set_std(command.split()[1]) elif 'spacing' in command: self.sine.set_spacing(command.split()[1]) elif 'sample' in command: self.sine.training_data(command.split()[1]) self.display.training_data(self.sine.df_data) except Message as m: self.out_var.set(m.message) hist = self.hist.insert(tk.END, command + '\n')
default=300, help='Width of the frames in the video stream.') parser.add_argument('-ht', '--height', dest='height', type=int, default=200, help='Height of the frames in the video stream.') parser.add_argument('-ds', '--display', dest='display', type=int, default=0, help='Display the detected images using OpenCV. This reduces FPS') parser.add_argument('-num-w', '--num-workers', dest='num_workers', type=int, default=3, help='Number of workers.') parser.add_argument('-q-size', '--queue-size', dest='queue_size', type=int, default=5, help='Size of the queue.') args = parser.parse_args() input_q = Queue(maxsize=args.queue_size) output_q = Queue(maxsize=args.queue_size) display_q = Queue(maxsize=args.queue_size) d = Display() video_capture = WebcamVideoStream(src=args.video_source, width=args.width, height=args.height).start() cap_params = {} frame_processed = 0 cap_params['im_width'], cap_params['im_height'] = video_capture.size() cap_params['score_thresh'] = score_thresh # max number of hands we want to detect/track cap_params['num_hands_detect'] = args.num_hands print(cap_params, args)
class Main: def __init__(self): self.results = get_args() self.name = self.results.target # Check if requested target exists if not utils.is_target(self.name, neural=True): return if self.results.camera == 'pi': camera_provider = PICamera() logging.info('Using PI Camera provider') elif self.results.camera == 'realsense': logging.info('Using RealSense camera provider') camera_provider = RealSense() elif self.results.camera == 'cv': camera_provider = CVCamera(self.results.port) else: logging.error('Invalid camera provider, this shouldn\'t happen') sys.exit(1) self.display = Display(provider=camera_provider) if self.results.web: self.web = Web(self) self.web.start_thread() # Run web server if self.results.networktables: self.nt = nt_handler.NT(self.name) self.stop = False self.session = None def change_name(self, name): """ Changes the name and starts a new loop. :param name: """ if not utils.is_target(name, neural=True): return logging.info('Changing target to {}'.format(name)) self.name = name self.stop = True def loop(self): printed = False # Check if requested target exists if not utils.is_target(self.name, False, True): return logging.info('Starting loop with target {}'.format(self.name)) self.stop = False # We dynamically load classes in order to provide a modular base target = import_module('neural_targets.{}'.format( self.name)).Target(self) self.display.change_exposure(target.exposure) # Timer for FPS counter timer = time.time() avg = 0 while True: frame = self.display.get_frame() if frame is None: if not printed: logging.warning('Couldn\'t read from camera') printed = True continue else: printed = False # Get bounding boxes boxes = target.boxes(frame) # Draw on frame target.draw(frame, boxes) angle, distance, bounding_box = target.measurements(frame, boxes) # Show FPS avg = utils.calculate_fps(frame, time.time(), timer, avg) timer = time.time() # Web self.web.frame = frame # Display self.display.process_frame(frame, 'image', self.results.local) if self.results.networktables: if distance: self.nt.set_item('distance', distance) if angle: self.nt.set_item('angle', angle) if self.stop: # If stop signal was sent we call loop again to start with new name logging.warning('Restarting...') self.loop() break k = cv2.waitKey(1) & 0xFF # large wait time to remove freezing if k in (27, 113): logging.warning('Q pressed, stopping...') self.display.release() self.session.close() break
def run_display_information_job(self): print("Getting display information") self.display = Display() self.display.get_system_display()
def __init__(self): self.root = tk.Tk() self.windowManager = WindowManager(Globals.NumCols, Globals.NumRows) self.display = Display(self.root, self.windowManager) self.inputHandler = InputHandler(self.display.getWidget())
def main(): screen1 = Display(1200, 600, 20) screen1.create_display()
# Devices ## import timer from timer import Timer from dac import DAC from lcd import LCD from bp import BP from power import Power ############################################################################### # DISPLAY ########## # You shall modify pygame to True or False if you want or not to use pygame (True by default) # You shall modify screen if you want to change screen dimensions ([800, 600] by default) ############################################################################### dispatch_display = Display(pygame=True, screen=[560, 320]) ############################################################################### # SCHEDULER ########## # You shall modify speedCoeff only ############################################################################### scheduler = Scheduler(speedCoeff=1) ############################################################################### # REGISTERS ########## # Add registers like that : reg = Register("NAME") ############################################################################### ###############################################################################
def key_menu(key, count): if key == KEY_NEXT: Disp.key_next(count) elif key == KEY_PREV: Disp.key_prev(count) elif key == KEY_ENTER: if Disp.highlighted() != Disp.selected(): Disp.set_highlighted(Disp.selected()) Config.cur_program(Disp.highlighted()) # Config.save() else: Disp.key_enter()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--sentences', help='path to sentences file', type=str) args = parser.parse_args() sentences_file = args.sentences try: db = Db(FileIO.read(sentences_file)) except Exception: Display.error('Error occurred while processing sentences file.') sys.exit() wa = WordAssociation(FileIO.read_optional(WORD_ASSOCIATION_DEFAULT_FILE)) error_lines = db.get_error_lines() if len(error_lines) > 0: Display.error( 'Keyword was not properly marked in the following line(s):') for line in error_lines: Display.display(line) sys.exit() twc = db.get_total_word_count() kwc = db.get_known_word_count() Display.display_header(twc, kwc) try: error = False next_word = True k, v = None, None prompt = InputMapper.get_main_prompt() while True: if not error and next_word: k, v = db.get_next_key_value() disp = k associations = wa.get_associations_for_word(Db.strip_key(k)) if len(associations) > 0: disp = Db.mark_key(k, EmojiMapper.get(EmojiTypes.EYES)) Display.display(disp, True) error = False next_word = False inp = raw_input(prompt).lower() commands = InputMapper.get_commands(inp) word = Db.strip_key(k) for command in commands: if command == Command.KNOW_IT: db.mark(k, EmojiMapper.get(EmojiTypes.THUMBS_UP)) next_word = True elif command == Command.SKIP: db.unmark(k) next_word = True elif command == Command.OPEN_DICTIONARY: Display.info('Opening dictionary for ' + Display.bold_replace(word)) os.system('open dict://{}'.format(word)) elif command == Command.SHOW_CONTEXT: Display.display(v) elif command == Command.DISPLAY_ALL_WORDS: Display.display_all_words(db.get_data(), db.get_total_word_count(), db.get_known_word_count()) elif command == Command.ASSOCIATE: word_prompt = Display.get_association_prompt(word) associations = raw_input(word_prompt).split() associations = [w.lower() for w in associations] associations.append(word) wa.associate(associations) elif command == Command.DISPLAY_ASSOCIATED_WORDS: Display.display_associated_words(associations) elif command == Command.DISPLAY_ALL_ASSOCIATIONS: Display.display_all_associations(wa.get_all_associations(), wa.get_num_associations()) elif command == Command.CONFLICTING: Display.error('Conflicting command') error = True else: Display.error('Unknown command') error = True Display.new_line() except KeyboardInterrupt: pass finally: FileIO.write_db(sentences_file, db.get_data()) FileIO.write_associations(WORD_ASSOCIATION_DEFAULT_FILE, wa.get_all_associations())