def __init__(self): Thread.__init__(self) self.video = VideoModule(0, 1) self.nav = Navigation("ru") self.speech = SpeechClass("ru") self.running = True self.audio = Display(lang="ru")
def __init__(self, parent=None): QtGui.QWidget.__init__(self) self.parent = parent self.setWindowTitle('imrenderin') ## Widgets self.menu_bar = MenuBar(self) self.menu_bar.setFixedHeight(25) self.status_bar = StatusBar(self) self.status_bar.setFixedHeight(35) ## Redirect stdout,stderr to dialog self.console = ConsoleDialog(sys.stdout) sys.stdout = self.console sys.stderr = self.console ## UI Elements self.display = Display(self) self.controls = DefaultUI(self, self.display) ## Layout vbox = QtGui.QVBoxLayout(self) vbox.addWidget(self.menu_bar) vbox.addWidget(self.controls) vbox.addWidget(self.status_bar) vbox.setSpacing(2) vbox.setContentsMargins(2, 2, 2, 2) self.setLayout(vbox) self.setMinimumWidth(200) self.setMinimumHeight(150) self.resize(_width, _height)
def __init__(self): self.sta_if = WLAN(STA_IF) self.settings = Settings().load() self.credentials = Credentials().load() self.wifi = WifiManager(b"%s-%s" % (PUBLIC_NAME, self.settings.net_id)) self.mdns = mDnsServer(PUBLIC_NAME.lower(), self.settings.net_id) routes = { b"/": b"./index.html", b"/index.html": b"./index.html", b"/scripts.js": b"./scripts.js", b"/style.css": b"./style.css", b"/favicon.ico": self.favicon, b"/connect": self.connect, b"/settings/values": self.settings_values, b"/settings/net": self.settings_net, b"/settings/group": self.settings_group, } self.http = HttpServer(routes) print("> HTTP server up and running") self.display = Display() self.ntp = NtpTime() self.previous_hour1 = self.previous_hour2 = -1 self.previous_minute1 = self.previous_minute2 = -1 self.previous_second2 = self.previous_count = -1 self.loop = get_event_loop() self.loop.create_task(self.check_wifi()) self.loop.create_task(self.update_time()) self.loop.run_forever() self.loop.close()
def main(self): """ Main controller of everything, likeyado """ displayOn = True self.d = Display(self.b, self.AIList, [None, None, None]) while displayOn: players = self.d.mainMenu() currentSet = True while currentSet: self.playGame(players) inExit = True while inExit: choice = self.d.playAgain() if choice == "Play Again": inExit = False # tally up who won and display that somehow elif choice == "Switch Players": inExit = False currentSet = False elif choice == "View Replay": self.viewReplay(players) elif choice == "Quit": inExit, currentSet, displayOn = (False, ) * 3 pygame.quit() quit(0)
def __init__(self): #Prompt for size of board. Minimal size should be 3. validInt = False while self.size < 3: if validInt: self.disp.warning("INVALID SIZE. Size should >= 3. ") try: self.size = int(raw_input("Enter board size n: ")) validInt = True except KeyboardInterrupt: raise except: self.disp.warning( "INVALID INPUT. Please enter a valid integer. ") validInt = False self.board = np.zeros((self.size, self.size), np.int8) #Prompt for players' name. self.XPlayer = raw_input("Enter name for player 1: ") self.OPlayer = raw_input("Enter name for player 2: ") #Enter full screen after getting required infomation. self.disp = Display(self.size)
class Game(): """ Classe qui gère le jeu. C'est en quelque sorte le "modèle". Il récupère les informations du controleurs, met à jour les données. """ def __init__(self, map_path="map_00.map"): pygame.init() self.game_map = Map() self.game_map.load(map_path) self.display = Display(self, self.game_map.screen_width, self.game_map.screen_height) self.controller = Controller(self) self.player = Player(self) #gestion des FPS self.fps = 30 self.clock = pygame.time.Clock() def tick(self): """Fonction appellée à chaque tout de boucle""" dt = self.clock.tick(self.fps) #On évite d'aller trop vite self.controller.tick() self.player.tick(dt) self.display.tick() def quit(self): pygame.quit()
def __init__(self): self.settings = Settings() self.credentials = Credentials() self.display = Display() self.networkManager = NetworkManager() self.previous_hour1 = self.previous_hour2 = -1 self.previous_minute1 = self.previous_minute2 = -1 self.previous_second2 = self.previous_count = -1 self.loop = get_event_loop() rst_cause = reset_cause() if rst_cause in [PWRON_RESET, SOFT_RESET]: self.power_on_reset_wkfl() elif rst_cause in [HARD_RESET]: self.hard_reset_wkfl() elif rst_cause == DEEPSLEEP_RESET: self.deepsleep_reset_wkfl() else: self.other_reset_wkfl() self.loop.run_forever() self.loop.close()
def display_last_followers_informations(): while True: followers = get_followers_from_file() display = Display(followers) display.show() print(followers) sleep(1)
class Application(object): # A hub room object hub_room_ = None # Display display_ = None # Initialises internal variables def __init__(self): print("Application: initialised") # Main programme loop def run(self): print("Application: running") self.display_ = Display() self.hub_room_.register_observer(self.display_) self.display_.mainloop() # SHould be run in its own thread def hub_room_thread(self): self.hub_room_ = HubRoom(hub_room_config, unoccupied_config, occupied_config) self.hub_room_.start_monitoring() try: while 1: sleep(0.1) except KeyboardInterrupt: self.hub_room_.stop_monitoring() print("Application: stopped")
def __init__(self): self.ImgFolder = 'download' # original images folder self.ImgPoolFolder = 'mosaic_img_pool' # processed images pool folder self.ResultsFolder = 'results_images' # mosaic images folder self.ImgPoolSize = (50, 50) # resized shape self.ImgLabel = [] self.Show = Display()
def yesno ( prompt = "Yes or no?", value = "yes" ): if value == "yes": answer = "[YES] no" selected = True elif value == "no": answer = "yes [NO]" selected = False else: raise ValueError("Incorrect value " + value) display = Display() display.message(prompt + "\n" + answer) while True: if display.button_select(): display.clear() return(selected) elif display.button_left() or display.button_right(): if selected: answer = "yes [NO]" selected = False else: answer = "[YES] no" selected = True display.message(prompt + "\n" + answer)
def draw(self): self.colorize() #print("Size of Body: ", len(self.body)) self.state = [] for b in self.body: pos = b.get_pos() self.state.append( Display.Pixel(x=pos[0, 0], y=pos[0, 1], r=b.r, g=b.g, b=b.b)) #print("Size of Apples: ", len(self.apples)) for a in self.apples: pos = a.get_pos() self.state.append( Display.Pixel(x=pos[0, 0], y=pos[0, 1], r=a.r, g=a.g, b=a.b)) self.callback(self.state)
class Game: display = None def __init__(self, n, m, g, nhp, abdepth, display=True): self.n, self.m, self.g = n, m, g self.agents = [ ArtificialAgent(i, n, m, abdepth) if nhp > i else HumanAgent(i) for i in range(1, -1, -1) ] if display: self.display = Display(n, m, g) self.display.startupdateloop() self.state = State(n, m, g) def play(self): done = False while not done: for agent in self.agents: move = agent.play(self.state) self.state.add(move) self.display.addmove(move) if self.state.finished(): print('done') done = True break
def __init__(self): self.frm_buttons = tk.Frame() self.display = Display() self.btns = self.createButtons() self.placeButtons()
def __init__(self, env, maxGraph): self.graph = maxGraph self.env = env self.ancestorStack = [] self.display = False self.displayManager = Display(env)
def main(): startscreen() while True: choice = input_screen() d = Display(choice, screen, s, big, med) d.run() endscreen(d.get_results())
def __init__(self): Display.__init__( self , hostname = "demeter" , name = "mitsubishi_tv" , resolution = (1920, 1080) , displaystrings = [":0.0"] , size = (1.44, 0.81) , transformation = avango.gua.make_trans_mat(0.0,1.3,0.0) , stereomode = "CHECKERBOARD" )
def display(self): # Graphs a plotly line graph p = Parser(self.data_f) profile = Operations.integrate(size=(self.size), center=self.center, data=self.subtracted_data) Display.plot1d(com=self.center, difference=self.subtracted_data, profile=profile, pixel_size=(self.size[0], self.size[1]))
def __init__(self): Display.__init__( self , hostname = "medusa" , name = "small_powerwall" , resolution = (1920, 1200) , displaystrings = [":0.0", ":0.1"] , size = (3.0, 1.98) , transformation = avango.gua.make_trans_mat(0, 1.42, 0) , stereomode = "SIDE_BY_SIDE" )
def __init__(self): Display.__init__( self , hostname = "apollo" , name = "samsung_tv" , resolution = (1920, 1080) , displaystrings = [":0.0"] , size = (1.235, 0.695) , transformation = avango.gua.make_trans_mat(0.0,1.6,0.0) * avango.gua.make_rot_mat(-40.0,1,0,0) , stereomode = "CHECKERBOARD" )
def __init__(self, n, m, g, nhp, abdepth, display=True): self.n, self.m, self.g = n, m, g self.agents = [ ArtificialAgent(i, n, m, abdepth) if nhp > i else HumanAgent(i) for i in range(1, -1, -1) ] if display: self.display = Display(n, m, g) self.display.startupdateloop() self.state = State(n, m, g)
def display(self): # Graphs a plotly line graph p = Parser(self.data_f) profile = Operations.integrate(size=(self.size), center=self.center, data = self.subtracted_data) Display.plot1d(com=self.center, difference=self.subtracted_data, profile=profile, pixel_size=(self.size[0], self.size[1]))
def rgbtocolor(rgbs): color = "" for rgb in rgbs.split(): if not rgb: continue if rgb.isdigit(): color += Display.rgb_to_ansi(*map(int, rgb[ : 3]), color != "") else: c = Display.color[rgb] color += Display.flipansi(c) if color != "" else c return color
def display(self): # Graphs a plotly line graph try: p = Parser(self.data_f) profile = Operations.integrate(size=(self.size), center=(self.center[2], self.center[3]), data=self.subtracted_data) Display.plot1d(com=(self.center[2], self.center[3]), difference=self.subtracted_data.values, profile=profile, pixel_size=(self.size[0], self.size[1])) except: raise ValueError("Not enough data.")
def play(self): """The main game loop, alternating shots until someone wins""" print("Play starts") print("1)User Ship Are in Grey color") print("2)Red Block represents hit") print("3)Black Block represents Miss") while not self.gameover: if self.player_shot(): self.ai_shot() self.display.show(self.ai_board, self.player_board) self.display.show_text("Click to guess:") Display.flip()
def __init__(self): self.logger = logging.getLogger() self.logger.setLevel(logging.INFO) self.logger.addHandler(SystemdHandler()) self.logger.info("Starting up. Alarm status is normal.") self.alarm_status = "normal" self.alarm_last_fire = datetime.datetime(1970, 1, 1, 0, 0, 0) self.display = Display(self.logger) self.alarm_manager = AlarmManager(self.logger) self.time_keeper = TimeKeeper(self.logger) self.weather_manager = WeatherManager(self.logger)
def __init__( self, **kwargs ): # observer, basket, drop_threshold, drop_height, wave_count, min_speed, max_speed): for (k, v) in kwargs.items(): setattr(self, k, v) self.display = Display(self.window_width, self.window_height, self.surface_width, self.surface_height, self.basket_width) self.user = User() self.basket = None self.eggSet = None
def __init__(self, enable_opengl_transformation : bool = False, parent = None): super().__init__(parent) p = self.palette() p.setColor(QtGui.QPalette.Background, QtCore.Qt.white) self.setPalette(p) self.setLayout(QtGui.QHBoxLayout()) display = Display(self) display.setData([Nexus(i['mobility']) for i in bench_mark], enable_opengl_transformation) self.layout().addWidget(display, 5) imputsLayout = QtGui.QVBoxLayout() self.layout().addLayout(imputsLayout) for i in range(0,len(bench_mark)): le = QtGui.QLineEdit(self) lo = QtGui.QHBoxLayout() lo.addWidget(QtGui.QLabel("Закон движения в закреплении звена #{}".format(i + 1), self)) lo.addWidget(le) """ if (bench_mark[i]['polynom'] == 1): le.setText("{}*t + {}".format(randint(1,100),0)) elif (bench_mark[i]['polynom'] == 2): le.setText("{}*t**2+{}*t + {}".format(randint(1,100),randint(1,100),0)) elif (bench_mark[i]['polynom'] == 3): le.setText("{}*t**3+{}*t**2+{}*t + {}".format(randint(1,100),randint(1,100),randint(1,100),0)) """ if (i == 0): le.setText("720*t") elif (i == 1): le.setText("540*t*t") elif (i == 2): le.setText("1-(t*2-1)**2") elif (i == 3): le.setText("t*900") display.data[i].setFunction(le.text()) le.textEdited.connect(display.data[i].setFunction) le.textEdited.connect(display.repaint) imputsLayout.addLayout(lo) lo = QtGui.QHBoxLayout() lo.addWidget(QtGui.QLabel("Время", self)) dial = QtGui.QSlider(self) dial.setMinimum(0.0) dial.setOrientation(QtCore.Qt.Horizontal) dial.setMaximum(1000.0) valDisplay = QtGui.QLabel(self) valDisplay.set_value = lambda s: valDisplay.setText("{:0<#5}".format(s / dial.maximum())) valDisplay.set_value(0.0) dial.valueChanged.connect(valDisplay.set_value) dial.valueChanged.connect(lambda s: display.set_t(s / dial.maximum())) lo.addWidget(dial) lo.addWidget(valDisplay) imputsLayout.addLayout(lo) imputsLayout.addStretch(10)
def display(self): """ Graphs a plotly/matplotlib line graph of radial profile """ p = Parser(self.data_f) profile = Operations.integrate(size=(self.size), center=(self.center[2], self.center[3]), data=self.subtracted_data) Display.plot1d(com=(self.center[2], self.center[3]), difference=self.subtracted_data.values, profile=profile, pixel_size=(self.size[0], self.size[1]))
def display2d(self): # Graphs a plotly contour plot of the subtracted data # If there's no subtracted data, will graph data file all_data= Data.get_data(self.p_data) pixel_size_x, pixel_size_y = self.size units = Operations.get_axes_units(all_data[0].shape, pixel_size=[pixel_size_y, pixel_size_x]) try: Display.plot2d(data=self.subtracted_data, parameters=all_data, center=self.center, units=units) except: Display.plot2d(data=self.center_data, parameters=all_data, center=self.center, units=units)
def display2d(self): # Graphs a plotly heatmap and/or a matplotlib image of the subtracted data # If there's no subtracted data, will graph center file pixel_size_x, pixel_size_y = self.size try: Display.plot2d(data=self.subtracted_data, parameters=(self.size[0], self.size[1], self.translation), center=(self.center[0], self.center[1])) except: Display.plot2d(data=self.center_data, parameters=(self.size[0], self.size[1], self.translation), center=(self.center[0], self.center[1]))
def __init__(self): pygame.init() pygame.display.set_caption("Car tutorial") width = 720 height = 720 self.radius = 10 self.screen = pygame.display.set_mode((width, height)) self.clock = pygame.time.Clock() self.ticks = 60 self.exit = False self.lap = 2 * math.pi * self.radius self.numberCars = 60 self.display = Display() self.showAnimation = False
class World: endGame = False def __init__(self): self.__initObjects() self.state = StateWorld(StateWorld.GAME) def __initObjects(self): self.Generaltimer = MyTimer() self.map = Map() self.player = Magian(55, 105) self.portalZombies = PointRespawnZombies(950, 500) self.portalSpiders = PointRespawnSpider(950, 100) self.portalWin = PortalWin() self.pointesOfRespawn = [self.portalZombies, self.portalSpiders] self.display = Display(self.map, self.player, self.pointesOfRespawn, self.Generaltimer, self.portalWin) self.waweAlgoritm = WaweAlgorithm(self.player, self.display.getEntities(), self.map) self.checkObject = CheckObjects(self.player, self.display.getEntities(), self.map, self.pointesOfRespawn, self.portalWin, self.Generaltimer, self.waweAlgoritm) def checkPointOfRespawn(self): for pointResp in self.pointesOfRespawn: pointResp.process() def checkGame(self): if (self.Generaltimer.getTimeLivePortal() == 0) or (not self.player.isLive()): self.state.setState(StateWorld.MEAT) elif self.portalWin.isInput(): self.state.setState(StateWorld.WIN) def stateGame(self): self.checkGame() self.checkPointOfRespawn() self.checkObject.checkObjects() self.display.draw() def stateMeat(self): if not self.endGame: self.display.drawMeat() self.endGame = True def stateWin(self): if not self.endGame: self.display.drawWin() self.endGame = True def timerStart(self): self.Generaltimer.start() def getState(self): return self.state.getState() def getPlayer(self): return self.player
def __init__(self, width=800, height=600, title='Main Game'): self.display = Display(width, height, title) self.isGameRunning = False #self.stars = Stars3D(1000, 1, 0.001) #self.stars.initStars() self.player = Player(5, 5, 45) self.min_dist = 999999999 self.start_time = 0 self.end_time = 0 self.delta_time = 0 self.frames = 0 self.fps = 0
def __init__(self,name, data): Display.__init__(self,name, data) ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) filename=open("./Login.txt") user=filename.read().split() ssh.connect('wopr.csl.mtu.edu',username=user[0],password=user[1]) stdin, stdout, stderr = ssh.exec_command("top -bn1 | grep \"Cpu(s)\" | sed \"s/.*, *\([0-9.]*\)%* id.*/\1/\" | awk '{print 100 - $1\"%\"}'") stdoutData = stdout.read() self.addElement(Container("Container", 0)) self.addElement(Label("Label", 1, "CPU Usage")) self.addElement(PercentBar("PercentageBar", 2, 10)) self.addElement(Value("Value", 3, stdoutData))
def test_display_grayscale_2(self): pygame.init() d = Display(200, 200, 20, 20, 3) b = Basket(d) b.basket_x = 15 b.cell_width = 5 pygame.event.get() d.update(b, None) pygame.event.get() a = d.get_surface_grayscale_array() self.assertTrue(a[399] == 1) self.assertTrue(a[398] == 1) self.assertTrue(a[397] == 1) self.assertTrue(a[396] == 1) self.assertTrue(a[395] == 1)
def __init__(self, startScore, aliens, player, width, height, size): self.score = startScore self.display = Display() self.shotEngine = ShotEngine(width, height) self.ticks = 0 self.player = player self.aliens = aliens self.specialAlien = AliveEntity(0, 0, 0, 0, 0, "img/shot.png", 0, width, height) #dummy assignment self.specialAlien.consider = False self.running = True self.aliensExist = True self.screen = pygame.display.set_mode(size) self.width = width self.height = height
class Customer(object): def __init__(self, customer_name, speed, queue_to_join): #print customer_name + ' enters La Victoria', customer_name self.customer_name = customer_name self.speed = speed self.queue_to_join = queue_to_join self.display = Display() self.absoluteName = customer_name.split(".")[2] self.display._print_info(self.absoluteName + ' enters La Victoria') #set customer likings/preferences def speak(self, to_person, what): #print 'speaking to ', to_person self.display._print_conversation(self.absoluteName, what['message']) respont_to_person = Pyro4.Proxy(to_person) respont_to_person.listen('customer', self.customer_name, what) respont_to_person._pyroRelease() @Pyro4.expose def listen(self, from_person, name, message): #print "MESSSAGE RECEIVED" json_message = message #json.loads(message) message_type = json_message['messageType'] json_message['fromName'] = name #print 'message', json_message self.display._print_conversation(from_person, json_message['message']) self.request_queue.put(json_message) #print 'enqueued' def join_queue(self): #print 'Customer joining the cashier queue ', self.customer_name self.display._print_info(self.absoluteName + ' joins the queue') self.queue_to_join.register(self.customer_name) def ativate_customer(self): def activate(): """register to the nameserver""" myIp = str(socket.gethostbyname(socket.gethostname())) self.daemon=Pyro4.Daemon(myIp) ns=Pyro4.locateNS()#(host = "PYRO:Pyro.NameServer") uri=self.daemon.register(self) ns.register(self.customer_name, uri) """Create queue and thread for listening to requests""" self.request_queue = Queue.Queue(); self.request_processor = RequestProcessor(self, self.speed) self.request_processor.start() """Join cashier queue""" self.join_queue(); self.daemon.requestLoop() self.display._print_info(self.absoluteName + ' leaves La Victoria') #print 'SHUTTTING DOWN Daemon' self.active_thread = Thread(target=activate) self.active_thread.start()
class Interface: """ class for handling all interface elements """ def __init__(self): """ init function for components (display,panels,cursor) """ self.display = Display(None) self.canvas = self.display.get_canvas() self.menuPanels = pygame.sprite.Group() self.populate() self.cursor = Cursor() def click(self,mousex,mousey): """ function for chosing what panel is clicked """ self.cursor.move(mousex,mousey) menuPanel = pygame.sprite.spritecollideany(self.cursor,self.menuPanels) if menuPanel is not None: return menuPanel.click(self.cursor) def populate(self): """ init function for adding predefined panels """ pass def update(self,*args,**kwargs): """ update function for updating panels and drawing """ pArgs = [] # input args mapped to output args self.menuPanels.update(pArgs) self.menuPanels.draw(self.canvas) self.display.update()
def draw(self, draw_number): # Draws Cards from the Deck and onto the Display. deck, cards = self.deck.draw(draw_number) return self.copy( display=Display.add(self.display, cards), deck=deck, )
def __init__(self, map_path="map_00.map"): pygame.init() self.game_map = Map() self.game_map.load(map_path) self.display = Display(self, self.game_map.screen_width, self.game_map.screen_height) self.controller = Controller(self) self.player = Player(self) #gestion des FPS self.fps = 30 self.clock = pygame.time.Clock()
def play_once(params, screen): """ Play a single round until gameover """ game, display, logger = Game(), Display(), Logger("log.txt") screen.locate_game() game.start(screen.get()) params["dino_height"] = game.get_dinossaur_height() agent = Agent(params) logger.log_start(params) while True: img = screen.get() state = game.get_state(img) action, time = agent.step(state) game.act(action, time) display.show_image(img, game, state) if (game.gameover()): break key = cv2.waitKey(1) & 0xFF if key == ord('q'): # Quit cv2.destroyAllWindows() exit(0) elif key == ord('s'): # Relocate the game if any error occurs screen.locate_game() logger.log_score(game.score)
def update(self): if self.skipupdate: return Display.filldisplay() self.filedisplay.applyfile(self.file) self.infodisplay.applyfile(self.infofile) self.cmddisplay.applyfile(self.cmdfile) display = Display.cursor(False) display += Display.outputdisplay() display += self.currentdisplay.outputcursor() display += Display.cursor(True) sys.stdout.write(display) sys.stdout.flush()
def __init__(self): """ Inicialización del juego. """ self.wii = WiiNunchuck() self.snake = Snake(3) self.display = Display() self.direction = self.snake.direction self.food = None
def __init__(self, customer_name, speed, queue_to_join): #print customer_name + ' enters La Victoria', customer_name self.customer_name = customer_name self.speed = speed self.queue_to_join = queue_to_join self.display = Display() self.absoluteName = customer_name.split(".")[2] self.display._print_info(self.absoluteName + ' enters La Victoria')
def __init__(self,name, data): # Get ready for the next program file. Display.__init__(self,name, data) self.ssh = paramiko.SSHClient() self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) filename=open("./Login.txt") user=filename.read().split() # Connect to the wopr server on campus. Any server can be accessed this way as long as login information is available and an SSH link can be established. self.ssh.connect('wopr.csl.mtu.edu',username=user[0],password=user[1], timeout=1000) # Check if we reached the server self.addElement(Label("Label0", 4, "Able to connect successfully!", "green")) stdin1, stdout1, stderr1 = self.ssh.exec_command("top -bn1 | grep \"Cpu(s)\" | sed \"s/.*, *\([0-9.]*\)%* id.*/\1/\"") print(stdout1.read()) stdoutData1 = stdout1.read() stdin2, stdout2, stderr2 = self.ssh.exec_command("grep MemTotal /proc/meminfo | awk '{print $2}") stdoutData2 = stdout2.read() stdin3, stdout3, stderr3 = self.ssh.exec_command("df | awk \'{print $1}\'") stdoutData3 = stdout3.readlines() stdin4, stdout4, stderr4 = self.ssh.exec_command("df | awk \'{print $5}\' | sed 's/%//'") stdoutData4 = stdout4.readlines() stdin5, stdout5, stderr5 = self.ssh.exec_command("grep Active /proc/meminfo | awk '{print $2}") stdoutData5 = stdout5.readline() # Create all of the elements. self.addElement(Container("Container", 0)) self.addElement(Label("Label1", 1, "CPU Usage (%)")) self.addElement(PercentBar("PercentageBar", 2, stdoutData1)) self.addElement(Label("Label2", 2, "Free Memory (%)")) self.addElement(PercentBar("PercentageBar2", 4, stdoutData2.decode("UTF-8"))) self.addElement(Label("Label3", 3, "Maximum Memory (kB)")) self.addElement(Label("Label4", 4, stdoutData2.decode("UTF-8"))) self.addElement(Label("Label5", 5, "Storage (kB):")) count=0 for line in stdoutData3: labelName = "Label" + str(count+6) self.addElement(Label(labelName, 4, line)) labelName = "PercentageBar" + str(count) self.addElement(PercentBar(labelName, 5, stdoutData4[int(count)])) count = count + 1
def __init__(self, backend): # load the views self.load_views() self.load_controllers() self.backend = backend self.display = Display(self) self._keymap["esc"] = ["self._controller.exit", "self.backend.exit"]
def __init__(self): """ init function for components (display,panels,cursor) """ self.display = Display(None) self.canvas = self.display.get_canvas() self.menuPanels = pygame.sprite.Group() self.populate() self.cursor = Cursor()
class World: endGame = False def __init__(self): self.__initObjects() self.state = StateWorld(StateWorld.GAME) def __initObjects(self): self.Generaltimer = MyTimer() self.map = Map() self.player = Magian(55, 105) self.portalZombies = PointRespawnZombies(950, 500) self.portalSpiders = PointRespawnSpider(950, 100) self.portalWin = PortalWin() self.pointesOfRespawn = [self.portalZombies, self.portalSpiders] self.display = Display(self.map, self.player, self.pointesOfRespawn, self.Generaltimer, self.portalWin) self.waweAlgoritm = WaweAlgorithm(self.player, self.display.getEntities(), self.map) self.checkObject = CheckObjects(self.player, self.display.getEntities(), self.map, self.pointesOfRespawn,self.portalWin, self.Generaltimer, self.waweAlgoritm) def checkPointOfRespawn(self): for pointResp in self.pointesOfRespawn: pointResp.process() def checkGame(self): if (self.Generaltimer.getTimeLivePortal() == 0) or (not self.player.isLive()): self.state.setState(StateWorld.MEAT) elif self.portalWin.isInput(): self.state.setState(StateWorld.WIN) def stateGame(self): self.checkGame() self.checkPointOfRespawn() self.checkObject.checkObjects() self.display.draw() def stateMeat(self): if not self.endGame: self.display.drawMeat() self.endGame = True def stateWin(self): if not self.endGame: self.display.drawWin() self.endGame = True def timerStart(self): self.Generaltimer.start() def getState(self): return self.state.getState() def getPlayer(self): return self.player
def __initObjects(self): self.Generaltimer = MyTimer() self.map = Map() self.player = Magian(55, 105) self.portalZombies = PointRespawnZombies(950, 500) self.portalSpiders = PointRespawnSpider(950, 100) self.portalWin = PortalWin() self.pointesOfRespawn = [self.portalZombies, self.portalSpiders] self.display = Display(self.map, self.player, self.pointesOfRespawn, self.Generaltimer, self.portalWin) self.waweAlgoritm = WaweAlgorithm(self.player, self.display.getEntities(), self.map) self.checkObject = CheckObjects(self.player, self.display.getEntities(), self.map, self.pointesOfRespawn,self.portalWin, self.Generaltimer, self.waweAlgoritm)
def __init__(self): Display.__init__( self , hostname = "medusa" , name = "touch_table_3D" , resolution = (1400, 1050) , displaystrings = [":0.0", ":0.1", ":0.2"] , shutter_timings = [ [(100, 200, 2900, 3000), (8400, 8500, 11400, 11500)], [(2600, 2700, 5700, 5800), (11000, 11100, 14600, 14700)], [(6000, 6100, 8200, 8300), (14300, 14400, 15900, 16000)] ] , shutter_values = [ [(20, 80, 40, 10), (2, 8, 4, 1)], [(20, 80, 40, 10), (2, 8, 4, 1)], [(20, 80, 40, 10), (2, 8, 4, 1)] ] , size = (1.27, 0.93) , transformation = #avango.gua.make_trans_mat(-1.56, 0.953, 2.28) * \ #avango.gua.make_rot_mat(90, 0, 1, 0) * \ avango.gua.make_rot_mat(90.0, -1,0, 0) , max_viewing_distance = 1.0 , stereomode = "SIDE_BY_SIDE" )
def __init__(self): Display.__init__( self , hostname = "kerberos" , name = "large_powerwall" , resolution = (1920, 1200) , displaystrings = [":0.0", ":0.1", ":0.2", ":0.3"] #, displaystrings = [":0.0", ":0.1", ":0.2", ":0.3", ":0.4", "0.5"] #, shutter_timings = [ [(0,2400), (100,2500)], # [(3000,4600),(3100,4700)], # [(5700,8175), (5800,8275)], # [(8200,10700), (8300,10800)], # [(11400,12900), (11500,13000)], # [(14000,15800), (14100,15900)] # ] , shutter_timings = [ [(0,8175), (100,8275)], [(8200,10700), (8300,10800)], [(11400,12900), (11500,13000)], [(14000,15800), (14100,15900)] ] #, shutter_values = [ [(22,44), (88,11)], # [(22,44), (88,11)], # [(22,44), (88,11)], # [(22,44), (88,11)], # [(22,44), (88,11)], # [(22,44), (88,11)] # ] , shutter_values = [ [(22,44), (88,11)], [(22,44), (88,11)], [(22,44), (88,11)], [(22,44), (88,11)] ] , size = (4.16, 2.6) , transformation = avango.gua.make_trans_mat(0, 1.57, 0) , max_viewing_distance = 5.0 , stereomode = "SIDE_BY_SIDE" )
def init(): rest = None if (USE_REST): print('Start REST server') rest = RESTThread() rest.start() bin = None if (USE_BINLOG): bin = BinaryFileController(2) bin.start() acc = Accelerometer(0.250, bin) acc.start() log = None if (USE_TEXTLOG): log = FileController(20) log.start() dsp = Display(acc, log, rest) dsp.start() print('at sleep') time.sleep(60*30) acc.stopit() acc.join() print("Accelorometer stopped") dsp.stopit() dsp.join() print("Display stopped") if (USE_BINLOG): bin.stopit() bin.join() print("BinLogger stopped") if (USE_TEXTLOG): log.stopit() log.join() print("FileController stopped") if (USE_REST): rest.stopit() rest.join() print("REST server stopped") time.sleep(2) print("End")
def _init(self): log.info('Initializing...') # TODO: Rewrite ugly test display system try: self._display = Display() self._display.symbols("Init", b"\xff\x00\x00") except: log.error("Unable to setup display") self._runProcesses(Remote) self._runProcesses(Jack) self._runProcesses(Guitarix) self._runProcesses(Bluetooth) self._runProcesses(Button) log.info('Initialization done')
def text (prompt = "Enter text...", value = ""): maxlen = 16 if len(value) > maxlen: raise ValueError("Value too long") display = Display() letters = letter_choices() answer = [] column = 0 if value: for i in range(0, len(value)): answer.append(value[i]) else: for i in range (0, maxlen): answer.append(' ') display.message( prompt + "\n" + string.join(answer, '') ) display.move_cursor(col = column, row = 1) display.blink_cursor() while True: if display.button_select(): return( string.join(answer, '') ) elif display.button_left(): if column > 0: column -= 1 display.move_cursor(col = column, row = 1) elif display.button_right(): if column < 15: column += 1 display.move_cursor(col = column, row = 1) elif display.button_up(): letter = answer[column] index = letters.index(letter) if index < (len(letters) - 1): index += 1 else: index = 0 answer[column] = letters[index] display.message( prompt + "\n" + string.join(answer, '') ) display.move_cursor(col = column, row = 1) elif display.button_down(): letter = answer[column] index = letters.index(letter) if index > 0: index -= 1 else: index = len(letters) - 1 answer[column] = letters[index] display.message( prompt + "\n" + string.join(answer, '') ) display.move_cursor(col = column, row = 1)
def __init__(self, name, data): Display.__init__(self, name, data) self.addElement(Label("playerLabel", 0, "Players online: ")) self.addElement(Value("players", 2, '?')) self.addElement(Label("uptimelable", 4, "Uptime: ")) self.addElement(Value("uptime", 5,'?'))
def main(): """This is the main function called when the program starts. It initializes everything it needs, then runs in a loop until exited. """ display = Display() background = display.drawBackground() display.drawPitch(background) display.centreTitleOnBackground(background) # Prepare Game Objects # clock = pygame.time.Clock() clock = pygw.clock() WM = WorldModel() ball = Ball() blue1 = Agent(BLUE1_START_POS, 1, BLUE_START_ANGLE, WM) blue2 = Agent(BLUE2_START_POS, 2, BLUE_START_ANGLE, WM) red1 = Agent(RED1_START_POS, 3, RED_START_ANGLE, WM) red2 = Agent(RED2_START_POS, 4, RED_START_ANGLE, WM) ball.setName("ball") blue1.setName("blue1") blue2.setName("blue2") red1.setName("red1") red2.setName("red2") # ballSprite = pygame.sprite.RenderPlain(ball) ballSprite = pygw.renderplainsprite(ball) blue1Sprite = pygw.renderplainsprite(blue1) blue2Sprite = pygw.renderplainsprite(blue2) red1Sprite = pygw.renderplainsprite(red1) red2Sprite = pygw.renderplainsprite(red2) frame = 0 going = True # Main game loop while going: clock.tick(FPS) if frame >= 30: frame = 0 else: frame += 1 allData = [ball, blue1, blue2, red1, red2] if (frame % WORLD_MODEL_UPDATE) == 0: WM.update_info(allData) #Update Sprites ballSprite.update() blue1Sprite.update() blue2Sprite.update() red1Sprite.update() red2Sprite.update() #Draw Everything display.drawEverything(background, ballSprite, blue1Sprite, blue2Sprite, red1Sprite, red2Sprite) display.updateFeaturesOnScreen(frame, ball, blue1, blue2, red1, red2) #Check for kicks ball.setPushValue(0) if blue1.kicking or blue2.kicking or red1.kicking or red2.kicking: ball.setPushValue(1) ball.setPushSpeed(5) if blue1.kicking: ball.setPushOrientation(blue1.angle) elif blue2.kicking: ball.setPushOrientation(blue2.angle) elif red1.kicking: ball.setPushOrientation(red1.angle) elif red2.kicking: ball.setPushOrientation(red2.angle) # # ball.setPushValue(0) # # if ball.speed == 0: # ball.setPushValue(1) # ball.setPushOrientation(np.random.randint(0, 360)) # ball.setPushSpeed(5) # pygame.display.flip() pygw.updatefulldisplay() # for event in pygame.event.get(): for event in pygw.getIOevent(): if event.type == pygw.QUIT or event.type == pygw.KEYDOWN and event.key == pygw.K_ESCAPE: going = False print('User quit the game') # pygame.quit() pygw.quitgame() sys.exit()
class Program(object): """ TODO: Mejorar el tiempo de refresco de pantalla """ # Condición que un hilo debe revisar para terminar su ejecución keep_playing = True def __init__(self): """ Inicialización del juego. """ self.wii = WiiNunchuck() self.snake = Snake(3) self.display = Display() self.direction = self.snake.direction self.food = None def read_control(self): """ Mientras el juego siga activo, lee el control de Wii y mueve la serpiente o termina el juego. """ while (self.keep_playing): self.wii.read_data() self.change_direction() if self.wii.data.button_c is True: print "Boton C" self.game_over(None) sleep(0.01) def change_direction(self): """ Interpreta la dirección del joystick para cambiar la dirección en la que avanza la serpiente. """ if self.wii.data.joystick_y < 70: #Down arrow self.direction = "DOWN" elif self.wii.data.joystick_y > 180: #Up arrow self.direction = "UP" if self.wii.data.joystick_x < 70: #Up arrow self.direction = "LEFT" elif self.wii.data.joystick_x > 180: #Up arrow self.direction = "RIGHT" def update_snake(self): """ Mientras el juego siga activo, actualiza la posición de la serpiente moviéndola hacia adelante cada 0.2 seg y verifica colisiones.""" while(self.keep_playing): self.snake.move(self.direction) self.check_collisions() sleep(0.2) def check_collisions(self): """ Revisar si la cabeza de la serpiente colisionó con el resto del cuerpo o con comida """ for p in self.snake.body[2:]: if ( self.snake.body[0].x == p.x and self.snake.body[0].y == p.y ): self.game_over(-1) if self.food is not None: if ( self.snake.body[0].x == self.food.place.x and self.snake.body[0].y == self.food.place.y ): self.snake.eat() self.food = None def make_food(self): """ Mientras el juego siga activo, actualiza la posición del objeto de comida cada 3 seg. """ while(self.keep_playing): self.food = Food() sleep(3) def update_screen(self): """ Mientras el juego siga activo, refresca la pantalla con la posición de la serpiente y de la comida """ while(self.keep_playing): array_points = list(self.snake.body) if self.food is not None: array_points.append(self.food.place) self.display.show(array_points) def game_over(self, end_code): """ Controla cómo terminará el juego. Al perder, espera 3 seg y luego saldrá. Args: end_code: Un número entero negativo usado para saber por qué terminó el juego. """ if end_code is -1: print "You lost." print "End of game!" self.keep_playing = False sleep(3)
def longtext (prompt = "Enter text...", value = ""): display = Display() letters = letter_choices() # possible character values cursor_column = 0 # the column where the cursor is at answer_column = 0 # the current column somewhere in the answer display_column = 0 # the column to start displaying at # initialize the answer answer = [] if value: for i in range(0, len(value)): answer.append(value[i]) else: answer.append(' ') display.message( prompt + "\n" + string.join(answer, '')[display_column:16] ) display.move_cursor(col = cursor_column, row = 1) display.blink_cursor() while True: if display.button_select(): return( string.join(answer, '').strip() ) elif display.button_left(): logging.debug("left") logging.debug( "before start column = " + str(display_column) ) logging.debug( "before answer column = " + str(answer_column) ) logging.debug( "before cursor column = " + str(cursor_column) ) if cursor_column > 0: logging.debug( "decrementing cursor column and moving cursor" ) cursor_column -= 1 display.move_cursor(col = cursor_column, row = 1) answer_column -= 1 elif answer_column > 0: logging.debug( "decrementing answer and start column and scrolling display" ) answer_column -= 1 display_column -= 1 display.message( prompt + "\n" + string.join(answer, '')[display_column:display_column+16] ) display.move_cursor(col = cursor_column, row = 1) else: logging.debug( "not moving any cursors, already at start of display and of answer" ) logging.debug( "after start column = " + str(display_column) ) logging.debug( "after answer column = " + str(answer_column) ) logging.debug( "after cursor column = " + str(cursor_column) ) elif display.button_right(): logging.debug( "right" ) logging.debug( "before start column = " + str(display_column) ) logging.debug( "before answer column = " + str(answer_column) ) logging.debug( "before cursor column = " + str(cursor_column) ) answer_column += 1 if answer_column == len(answer): logging.debug( "appending space" ) answer.append(' ') if cursor_column < 15: logging.debug( "incrementing cursor column and moving cursor" ) cursor_column += 1 display.move_cursor(col = cursor_column, row = 1) else: logging.debug( "incrementing start column and scrolling answer" ) display_column += 1 display.message( prompt + "\n" + string.join(answer, '')[display_column:display_column+16] ) display.move_cursor(col = cursor_column, row = 1) logging.debug( "after start column = " + str(display_column) ) logging.debug( "after answer column = " + str(answer_column) ) logging.debug( "after cursor column = " + str(cursor_column) ) elif display.button_up(): letter = answer[answer_column] index = letters.index(letter) if index < (len(letters) - 1): index += 1 else: index = 0 answer[answer_column] = letters[index] display.message( prompt + "\n" + string.join(answer, '')[display_column:display_column+16] ) display.move_cursor(col = cursor_column, row = 1) elif display.button_down(): letter = answer[answer_column] index = letters.index(letter) if index > 0: index -= 1 else: index = len(letters) - 1 answer[answer_column] = letters[index] display.message( prompt + "\n" + string.join(answer, '')[display_column:display_column+16] ) display.move_cursor(col = cursor_column, row = 1)
class Controller: _view = None _controller = None _views = {} _controllers = {} _keymap = { } # global non-overridable keys _previous_view_name = "" # view name _previous_focus = "" # focus id on previous screen def __init__(self, backend): # load the views self.load_views() self.load_controllers() self.backend = backend self.display = Display(self) self._keymap["esc"] = ["self._controller.exit", "self.backend.exit"] def back_view(self): """ Returns to the last view """ if not self._previous_view_name: return # can't do it focus = self._previous_focus self.change_view(self._previous_view_name) self.controller().set_focus(focus) self.controller().populate() def change_view(self, view, params=()): """ Will change the view """ # does the view we want exist? if not view in self._views: raise ControllerException("Can't find view named %s" % view) if self._view != None: # sets previouses. self._previous_view_name = self._view.get_name() self._previous_focus = self.controller().get_focus() if self._previous_focus == None: self._previous_focus = "" # view exists. if None != self._view: self._view.__del__() self.display.clear() if params: self._view = self._views[view].View(self.display, params) else: self._view = self._views[view].View(self.display) self._controller = self._controllers[view].Controller(self) def controller(self): """ Returns the current view GC, if none, returns self """ if self._controller: return self._controller return self def handle_input(self, key): """ This is the glue between handling purely view input (e.g. adding a letter on the screen) and speaking to the backend when an input is made that requires change on the backend """ # for now just pass it across it to display if type(key) in [tuple]: return # we don't support mouse if self._view: if key in self._keymap: # global override. for call in self._keymap[key]: getattr(self, call)() else: # okay now hand it off to the specific GC self._controller.handle_input(key) def load_views(self): """ This will load the views """ for view in glob("Views/*.py"): name = self.path_to_name(view) self._views[name] = load_source(name, view) def load_controllers(self): """ Loads the GC's """ for controller in glob("GraphicsControllers/*.py"): name = self.path_to_name(controller) self._controllers[name] = load_source(name, controller) def run(self): self.display.run() def path_to_name(self, path): """ This will take a path convert to a name """ base_name = os.path.basename(path) name = os.path.splitext(base_name)[0] return name def update(self, screen): """ This will update the screen """ # ensure the screens clear self._view.clear() self._view.update(screen)