def __init__(self, labyrinth_ctrl, guard_ctrl, game_engine):
Controller.__init__(self, game_engine, labyrinth_ctrl)
Collider.__init__(self, game_engine)
self._guard_ctrl = guard_ctrl
self._model = HeroModel(self, labyrinth_ctrl)
self._view = HeroView(self, self._model, game_engine)
self._view.show_objects_collected([])
def test_controllerAttr(self):
"""
Test the attributes are set correctly
"""
controller = TrafficLightController("WEST")
self.assertEqual(controller.getName(), "WEST")
self.assertTrue(controller.getTL() != None)
def __init__(self, parentWindow, controller, save, profileNumber):
self.__controller = Controller()
self.__builder = Gtk.Builder()
self.__controller = controller
self.__save = save
self.__parentWindow = parentWindow
self.__profileNumber = profileNumber
self.__parentWindow = parentWindow
self.__builder.add_from_file(
'views/UploadSaveDialog/UploadSaveDialog.glade')
self.__window = self.__builder.get_object("uploadSaveWindow")
self.__builder.get_object("saveNameLabel").set_text('" {} "'.format(
save.getName()))
self.__builder.get_object("profileNameLabel").set_text(
'"Profile {}: {}"'.format(
self.__profileNumber + 1,
self.__controller.getProfilesList()[self.__profileNumber][1]))
# Handles:
self.__builder.get_object("noButton").connect("clicked",
self.__noButtonHandle)
self.__builder.get_object("yesButton").connect("clicked",
self.__yesButtonHandle)
self.__window.connect("key-press-event", self.on_key_press_event)
class GameState:
def __init__(self):
self.controller = Controller(self)
self.side = PlayerSide(self)
self.map = Map(self)
self.gui = GameStateGUI(self)
def handleEvents(self,events):
self.controller.handleEvents(events)
def tick(self):
self.map.tick()
self.side.tick()
def blit(self,screen):
screen.fill((0,0,0))
self.map.blit(screen)
self.side.blit(screen)
self.gui.blit(screen)
if self.controller.action[0] == PLACEOBJECT:
screen.blit(R.IMAGES[R.buildings[self.controller.action[1]]["image"]],(pygame.mouse.get_pos()[0]/20*20+self.map.offset[0]%20,
pygame.mouse.get_pos()[1]/20*20+self.map.offset[1]%20))
def test_otherInitWait(self):
"""
Makes sure waits are set right on init
"""
controller = TrafficLightController("TEST")
self.assertEqual(controller.GetRightWait(), 0, msg="Right wait")
self.assertEqual(controller.GetOtherWait(), 0, msg="Other wait")
def test_controller_start():
import sys
app = QApplication(sys.argv)
app_event_loop = QEventLoop(app)
asyncio.set_event_loop(app_event_loop)
w = Controller()
w.show()
def get(initials):
team = TeamsModel.find_by_initials(initials)
if team: #Verifica se possui conteúdo
team = team[0]
return Controller.format_response(team.to_dict(), status_code=200)
else:
return Controller.format_response(errors=15, status_code=404)
def test_phaseStop(self):
"""
test the phase stop function
"""
controller = TrafficLightController("TEST")
tl = controller.getTL()
controller.phaseStop()
self.assertEqual(tl.whatsOn(), [True, True, False, False, False, False])
def test_dualWaitIncrement(self):
"""
Test the method handling incrementing both waits
"""
controller = TrafficLightController("TEST")
controller.IncrementBothWaits()
self.assertEqual(controller.GetRightWait(), 1, msg="Right wait")
self.assertEqual(controller.GetOtherWait(), 1, msg="Other wait")
def __init__(self, args):
Controller.__init__(self)
try:
port = int(args)
except ValueError:
port = 6666
self.server = Server("0.0.0.0", port)
self.server.start()
def create():
current_user = Controller.authenticated_user()
data = request.get_json()
tournament = TournamentsModel(data['name'], data['description'],
data['start_date'], data['end_date'],
current_user.login)
tournament.insert()
return Controller.format_response(status_code=201)
def test_partialRightCycle(self):
"""
Test a part of our right cycle
"""
controller = TrafficLightController("TEST")
tl = controller.getTL()
controller.trafficLight.switchOff()
controller.trafficLight.redOn()
controller.trafficLight.tgreenOn()
self.assertEqual(tl.whatsOn(), [True, False, False, False, False, True])
def test_partialOtherCycleTwo(self):
"""
Test the other part of our other cycle
"""
controller = TrafficLightController("TEST")
tl = controller.getTL()
controller.trafficLight.switchOff()
controller.trafficLight.orangeOn()
controller.trafficLight.tredOn()
self.assertEqual(tl.whatsOn(), [False, True, True, False, False, False])
def main():
player1 = Player()
player2 = Player()
field = Field()
view = View()
cont = Controller(player1, player2, field, view)
play_again = True
while play_again:
cont.game_loop()
play_again = cont.play_again()
def sign_in():
data = request.get_json()
user = UsersModel.find_by_login(data['login'])
if user and Controller.bycrpt.check_password_hash(
user[0].password, data['password']):
access_token = create_access_token(identity=user[0].login)
return Controller.format_response({'token': access_token},
status_code=200)
return Controller.format_response(errors=11, status_code=401)
def test_partialBrokenCycle(self):
"""
Test the broken cycle logic, minus timings
"""
controller = TrafficLightController("TEST")
tl = controller.getTL()
controller.trafficLight.switchOff()
self.assertEqual(tl.whatsOn(), [False, False, False, False, False, False])
controller.trafficLight.orangeOn()
controller.trafficLight.torangeOn()
self.assertEqual(tl.whatsOn(), [False, False, True, True, False, False])
def test_sensorAllGo(self):
controller = TrafficLightController("MOCK")
tl = controller.getTL()
tl.switchOff()
tl.greenOn()
tl.tgreenOn()
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
lane = [car1, car2, car3, car3]
simulator.sensor(controller, lane)
self.assertEqual(lane, [car2, car3, car3])
def put(login):
data = request.get_json()
logged_user = Controller.authenticated_user()
if logged_user.login == login:
for field in ('name', 'email', 'birthday', 'password', 'country',
'state', 'city', 'neighborhood', 'street', 'number',
'complement'):
if field in data:
setattr(logged_user, field, data[field])
logged_user.update()
return Controller.format_response(status_code=200)
return Controller.format_response(errors=10, status_code=400)
def delete(initials
): #TESTAR averiguar se o usuário autenticado é o dono do time
team = TeamsModel.find_by_initials(initials)
current_user = Controller.authenticated_user()
if not current_user.login == team.owner_login:
return Controller.format_response(errors=13, status_code=403)
if team:
team = team[0]
team.delete()
return Controller.format_response(status_code=200)
else:
return Controller.format_response(status_code=404)
def __init__(self,parentWindow,profileNumber):
self.__controller = Controller()
self.__builder = Gtk.Builder()
self.__profileNumber = profileNumber
self.__parentWindow = parentWindow
self.__builder.add_from_file('views/NewSaveDialog/NewSaveDialog.glade')
self.__window = self.__builder.get_object("newSaveWindow")
self.__builder.get_object("descriptionTextArea").set_wrap_mode(Pango.WrapMode.WORD_CHAR)
# Handles:
self.__builder.get_object("cancelButton").connect("clicked", self.__cancelButtonHandle)
self.__builder.get_object("confirmButton").connect("clicked", self.__confirmButtonHandle)
self.__window.connect("key-press-event",self.on_key_press_event)
def delete_by_code(code):
tournament = TournamentsModel.find_by_cod_tournament(int(code))
if tournament:
tournament = tournament[0]
current_user = Controller.authenticated_user()
if not current_user.login == tournament.owner_login:
return Controller.format_response(errors=13, status_code=403)
tournament.delete_by_code()
return Controller.format_response(status_code=200)
else:
return Controller.format_response(status_code=404)
def test_sensorStraightOrange(self):
"""
Test straight orange lights
"""
controller = TrafficLightController("MOCK")
tl = controller.getTL()
tl.switchOff()
tl.tredOn()
tl.orangeOn()
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
lane = [car1, car2, car3, car3]
simulator.sensor(controller, lane)
self.assertEqual(lane, [car2, car3])
def _check_files_format(*args, **kwargs):
mainController = Controller()
configFound, wrongFiles = mainController.check_files_format()
if not configFound:
sys_print(u'检测到你不在印象笔记主目录中，或配置文件损坏', 'warn')
elif mainController.available:
if wrongFiles and not DEBUG:
for fileName, status in wrongFiles:
if status == 1:
sys_print(u'检测到错误放置的内容：' + fileName.decode('utf8'),
'warn')
elif status == 2:
sys_print(u'检测到内容过大的文件：' + fileName.decode('utf8'),
'warn')
elif status == 3:
sys_print(u'检测到意义不明的文件：' + fileName.decode('utf8'),
'warn')
sys_print(u'请确保单条笔记有md或html的正文且不大于%s字节' %
mainController.ls.maxUpload)
sys_print(u'请确保没有文件夹格式的附件，或名为.DS_Store的笔记及笔记本。')
else:
return fn(mainController, *args, **kwargs)
elif mainController.ls.get_credential():
u, p = mainController.ls.get_credential().split('|')
_, _, sandbox, is_international, expire_time, _, _ = mainController.ls.get_config(
)
token = TokenFetcher(is_international, u, p).fetch_token()
if token:
mainController.log_in(token=token,
isSpecialToken=True,
sandbox=sandbox,
isInternational=is_international,
expireTime=expire_time)
if mainController.available:
mainController.ls.update_config(
token=token,
isSpecialToken=True,
sandbox=sandbox,
isInternational=is_international,
expireTime=expire_time)
sys_print(u'刷新token成功')
return fn(mainController, *args, **kwargs)
else:
sys_print(u'刷新token失败')
else:
sys_print(u'获取token失败，请检查用户名密码')
else:
sys_print(u'尚未初始化', 'warn')
def sign_up():
data = request.get_json()
password = Controller.bycrpt.generate_password_hash(
data['password']).decode('utf-8')
if UsersModel.find_by_login(data['login']):
return Controller.format_response(errors=9, status_code=400)
if UsersModel.find_by_email(data['email']):
return Controller.format_response(errors=10, status_code=400)
user = UsersModel(data['login'], data['name'], data['email'],
data['birthday'], password)
user.insert()
return Controller.format_response(status_code=201)
def view_members(cod_tournament, initials):
tournament = TournamentsModel.find_by_cod_tournament(int(code))
team = TeamsModel.find_by_initials(initials)
if tournament and team:
pass #falta
else:
return Controller.format_response(status_code=404)
def index():
all_teams = TeamsModel.get_all()
search_keyword = request.args.get('search')
if search_keyword:
k = search_keyword.lower()
all_teams = [
t for t in all_teams if k in t.to_dict()['initials'].lower()
or k in t.to_dict()['name'].lower()
]
result = []
for team in all_teams:
result.append(team.to_dict())
# Somente retornar erro se for uma pesquisa por palavra chave e não for encontrado nada
if search_keyword and not result:
return Controller.format_response(errors=16, status_code=404)
return Controller.format_response(result, status_code=200)
class UploadSaveDialog:
def __init__(self, parentWindow, controller, save, profileNumber):
self.__controller = Controller()
self.__builder = Gtk.Builder()
self.__controller = controller
self.__save = save
self.__parentWindow = parentWindow
self.__profileNumber = profileNumber
self.__parentWindow = parentWindow
self.__builder.add_from_file(
'views/UploadSaveDialog/UploadSaveDialog.glade')
self.__window = self.__builder.get_object("uploadSaveWindow")
self.__builder.get_object("saveNameLabel").set_text('" {} "'.format(
save.getName()))
self.__builder.get_object("profileNameLabel").set_text(
'"Profile {}: {}"'.format(
self.__profileNumber + 1,
self.__controller.getProfilesList()[self.__profileNumber][1]))
# Handles:
self.__builder.get_object("noButton").connect("clicked",
self.__noButtonHandle)
self.__builder.get_object("yesButton").connect("clicked",
self.__yesButtonHandle)
self.__window.connect("key-press-event", self.on_key_press_event)
def run(self):
self.__window.show_all()
def __noButtonHandle(self, arg):
self.__window.destroy()
pass
def __yesButtonHandle(self, arg):
# self.__controller.uplaodSave(self.__save)
self.__builder.get_object("progressBar").pulse()
self.__controller.uploadSave(self.__save, self.__profileNumber)
self.__window.destroy()
self.__parentWindow.refresh()
def on_key_press_event(self, widget, event):
if event.keyval == 65307:
self.__noButtonHandle(None)
if event.keyval == 65293:
self.__yesButtonHandle(None)
class ModifySaveDialog:
def __init__(self, parentWindow, controller, save):
self.__controller = Controller()
self.__builder = Gtk.Builder()
self.__controller = controller
self.__save = save
self.__parentWindow = parentWindow
self.__parentWindow = parentWindow
self.__builder.add_from_file('views/ModifySaveDialog/ModifySaveDialog.glade')
self.__window = self.__builder.get_object("modifySaveWindow")
self.__builder.get_object("saveNameLabel").set_text('" {} "'.format(save.getName()))
self.__builder.get_object("nameEntry").set_text(save.getName())
self.__builder.get_object("descriptionTextArea").get_buffer().set_text(save.getDescription())
self.__builder.get_object("descriptionTextArea").set_wrap_mode(Pango.WrapMode.WORD_CHAR)
self.__window.connect("key-press-event",self.on_key_press_event)
# Handles:
self.__builder.get_object("cancelButton").connect("clicked", self.__cancelButtonHandle)
self.__builder.get_object("confirmButton").connect("clicked", self.__confirmButtonHandle)
def __cancelButtonHandle(self, arg):
self.__window.destroy()
def __confirmButtonHandle(self, args):
name = self.__builder.get_object("nameEntry").get_text()
buffer = self.__builder.get_object("descriptionTextArea").get_buffer()
description = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter(), True)
progressBar = self.__builder.get_object("progressBar")
progressBar.pulse()
self.__controller.modifySave(self.__save, name,description)
self.__parentWindow.refresh()
self.__window.destroy()
def on_key_press_event(self, widget, event):
if event.keyval == 65307:
self.__cancelButtonHandle(None)
if event.keyval == 65293:
self.__confirmButtonHandle(None)
def run(self):
self.__window.show_all()
def nav_loop():
robot = UgvPlatform()
#robot.setColorLut('lut_file.lut')
#robot.initImu('accelcal.txt', 'magcal.txt')
mpu_valid = -1
print "waiting for GPS fix"
gps_service = GpsService()
current_pos = gps_service.getPosition()
while not current_pos.valid:
time.sleep(1)
current_pos = gps_service.getPosition()
print current_pos.valid
while mpu_valid < 0:
time.sleep(1.0)
mpu_valid = mpu9150.mpuInit(1, 10, 4)
print mpu_valid
mpu9150.setMagCal('./magcal.txt')
mpu9150.setAccCal('./accelcal.txt')
#time.sleep(4)
wp = StaticWayPointProvider()
controller = Controller()
threads.append(controller)
#gps_service.start()
robot.setSteeringFailSafe(0.0)
robot.setSpeedFailSafe(ESC_ARM_ANGLE)
robot.resetWatchdog()
robot.setSteeringAngle(0.0)
robot.setSpeed(0)
while True:
robot.resetWatchdog()
target_pos = wp.getCurrentWayPoint()
sensors = populateSensorMap(robot, gps_service)
current_pos = sensors[Controller.gps_key]
imu_sample = sensors[Controller.imu_key]
if imu_sample[0] < 0:
time.sleep(0.05)
continue
#print "lat : "+str(current_pos.lat)+" lon :"+str(current_pos.lon)+"imu:"+str(imu_sample)
# continue
cmd = controller.getCommand(sensors)
if cmd == None:
break
print str(cmd)
if cmd.has_key(Controller.next_waypoint_key
) and cmd[Controller.next_waypoint_key] != None and cmd[
Controller.next_waypoint_key] == 1:
wp.getNextWaypoint()
else:
robot.setSteeringAngle(cmd[Controller.steering_key])
robot.setSpeed(cmd[Controller.speed_key])
time.sleep(0.100)
robot.setSteeringAngle(0.0)
robot.setSpeed(0)
print "Shutdown ESC then quit programm (for safety reason)"
while True:
time.sleep(1)
def test_lightsBrokenLogic(self):
"""
Tests lightsAreBroken works as intended
"""
simulator.lightsAreBroken = True
controller = TrafficLightController("TEST")
tl = controller.getTL()
tl.switchOff()
tl.greenOn()
tl.tgreenOn()
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
lane = [car1, car2, car3, car3]
simulator.sensor(controller, lane)
self.assertEqual(lane, [car1, car2, car3, car3])
# Reset the variable so as not to break anything
simulator.lightsAreBroken = False
def _check_files_format(*args, **kwargs):
mainController = Controller()
configFound, wrongFiles = mainController.check_files_format()
if not configFound:
sys_print(u'检测到你不在印象笔记主目录中，或配置文件损坏', 'warn')
elif mainController.available:
if wrongFiles:
for fileName, status in wrongFiles:
if status == 1:
sys_print(u'检测到错误放置的内容：'+fileName.decode('utf8'), 'warn')
elif status == 2:
sys_print(u'检测到内容过大的文件：'+fileName.decode('utf8'), 'warn')
elif status == 3:
sys_print(u'检测到意义不明的文件：'+fileName.decode('utf8'), 'warn')
sys_print(u'请确保单条笔记有md或html的正文且不大于%s字节，笔记中没有文件夹格式的附件。'%mainController.ls.maxUpload, 'info')
else:
return fn(mainController, *args, **kwargs)
else:
sys_print(u'尚未登录', 'warn')
if not os.path.exists(SONGS_PATH):
os.mkdir(SONGS_PATH)
if __name__ == "__main__":
ensure_data_dir()
app = QApplication(sys.argv)
app.setQuitOnLastWindowClosed(True)
app.setWindowIcon(QIcon(WINDOW_ICON))
app.setApplicationName("FeelUOwn")
app_event_loop = QEventLoop(app)
asyncio.set_event_loop(app_event_loop)
qss = QSS_PATH
with open(qss, "r") as qssfile:
app.setStyleSheet(qssfile.read())
if MODE != DEBUG:
f_handler = open(LOGFILE, "w")
sys.stdout = f_handler
sys.stderr = f_handler
w = Controller()
w.move(QApplication.primaryScreen().geometry().center() - w.rect().center())
w.show()
app_event_loop.run_forever()
sys.exit()
def __init__(self):
self.controller = Controller(self)
self.side = PlayerSide(self)
self.map = Map(self)
self.gui = GameStateGUI(self)
def __init__(self, display): self._display = display Controller.__init__(self)
os.mkdir(SONGS_PATH)
if __name__ == "__main__":
ensure_data_dir()
app = QApplication(sys.argv)
app.setQuitOnLastWindowClosed(True)
app.setWindowIcon(QIcon(WINDOW_ICON))
app.setApplicationName("FeelUOwn")
app_event_loop = QEventLoop(app)
asyncio.set_event_loop(app_event_loop)
qss = QSS_PATH
with open(qss, "r") as qssfile:
app.setStyleSheet(qssfile.read())
if MODE != DEBUG:
f_handler = open(LOGFILE, 'w')
sys.stdout = f_handler
sys.stderr = f_handler
w = Controller()
w.move((QApplication.desktop().width() - w.width())/2,
(QApplication.desktop().height() - w.height())/2)
w.show()
app_event_loop.run_forever()
sys.exit()
#!/usr/bin/env python
import sys
import time
import socket
from controllers import Controller
try:
CONTROLLER = Controller()
except socket.error, msg:
print "Clipp daemon is not running."
sys.exit(1)
try:
while CONTROLLER.running:
CONTROLLER.wait_for_key_and_process()
time.sleep(0.01)
finally:
pass
CONTROLLER.close()
