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)
