def upload_game_results(self, exponat_name, user_id, score=None, level=None, additional_data=None, callback=None, timeout=0.5): """Uploads data about game to server. ``additional_data`` can be arbitrary piece of data (in a dict form) that is attached to the result and its pickled form is stored in the database. """ logger.info('upload_game_results') address, port = self.st.server_url() try: conn = httplib.HTTPConnection(address, port, timeout=timeout) conn.request('POST', '/upload-game-results/', json.dumps({ 'exponat_name':exponat_name, 'user_id':user_id, 'score':score, 'level':level, 'additional_data':additional_data})) res = conn.getresponse() if res.status != 200:# vim: set expandtab: logger.error('Server response is not 200 OK: %s'%str(res) + str(res.status) + ' ' + str(res.reason)) conn.close() else: data = json.loads(res.read()) conn.close() if 'error' in data: logger.error(data['error']) else: if callback is not None: callback() except Exception as e: logger.error(str(e))
def get_max_score(self, exponat_name, exponat_level, callback=None, timeout=0.5): """Returns best daily score. If none exists, returns None. """ exponat_name = str(exponat_name) exponat_level = str(exponat_level) address, port = self.st.server_url() try: conn = httplib.HTTPConnection(address, port, timeout=timeout) logger.info(exponat_name + ',' + exponat_level) conn.request('GET', '/get-max-score/%s/%s/' % (exponat_name, exponat_level,)) res = conn.getresponse() if res.status != 200: logger.error('Server response is not 200 OK: %s'%str(res) + str(res.status) + ' ' + str(res.reason)) conn.close() else: text = res.read() logger.info(text) data = json.loads(text) conn.close() if 'error' in data: logger.error(data['error']) else: if callback is not None: callback() return data['max_score'] except Exception as e: logger.error(str(e))
def end_game(self): """ default end_game, i.e.: uploads game results, get max score from the server (this could change because of update) and show appropriate html screen """ logger.info(str(self.user_id)) self.env.upload_game_results(exponat_name=self.st.exhibit.name, user_id=self.user_id, score=self.score, level=self.st.level.name, timeout=self.st.url_timeout) self.update_max_score() self.html('html_score')
def end_game(self): BaseExhibit.__reset__(self) #BaseExhibit.end_game(self) logger.info(str(self.user_id)) self.env.upload_game_results(exponat_name=self.st.exhibit.name, user_id=self.user_id, score=self.score, level=self.st.level.name, timeout=10) self.html('html_score') ## end of BaseExhibit.end_game(self) self.seven_flicker(self.score, "%d", callback=self.reset_game)
def run(expo_num, level_name, mode): game_str = "game%s" % expo_num game_settings_str = "Game%sSettings" % expo_num _temp = __import__("pkg.exponates", globals(), locals(), [game_str]) Exhibit = getattr(_temp, game_str).Exhibit _temp = __import__("pkg.settings", globals(), locals(), [game_settings_str]) Settings = getattr(_temp, game_settings_str) invoker = Invoker() settings = Settings(mode) level = None for l in settings.exhibit.levels: if l.name == level_name: level = l if level is None: level = settings.exhibit.levels[0] # inject level-specific settings into settings object for key, val in level.params.items(): setattr(settings, key, val) # set test exhibit to selected level if expo_num == "Test" and level_name != "default": io_settings_str = "Game%sSettings" % level_name _temp = __import__("pkg.settings", globals(), locals(), [io_settings_str]) IOSettings = getattr(_temp, io_settings_str) io_settings = IOSettings(mode) settings.key_map = io_settings.key_map settings.light_map = io_settings.light_map settings.seven_length = io_settings.seven_length logger.info("start_expo.py, before localizing settings") try: from pkg.local_settings import localize_settings except Exception as e: logger.warn("no local settings") if "localize_settings" in locals(): try: localize_settings(settings) logger.info("localizing settings") except Exception as e: logger.error("failed to load local setings") logger.error(e) if mode == "emulator": env = Emulator(invoker, settings) else: from pkg.rpi_env import RpiEnv env = RpiEnv(invoker, settings) exhibit = Exhibit(invoker, env, settings) invoker.start() env.run()
def midi_success_accord(self): _akord = [0, 12] akord = [self.st.base + 40 + x for x in _akord] for t in akord: alsaseq.output(noteonevent(1, t, 120)) logger.info("midi_success, 1.faza") time.sleep(2) for t in akord: try: alsaseq.output(noteoffevent(1, t, 120)) except Exception as e: logger.error("midi_success: " + str(e)) logger.info("midi_success, posledna faza")
def end_game(self): self.mute = True self.idle = True self.timer = None #BaseExhibit.end_game(self) logger.info("dlzka wav: "+str(len(self.make_wav(self.record)))) self.env.upload_game_results(exponat_name=self.st.exhibit.name, user_id=self.user_id, score=self.score, level=self.st.level.name, timeout=self.st.url_timeout, additional_data={ 'record':base64.b64encode(self.make_wav(self.record)), }) #end of BaseExhibit.end_game(self) self.update_max_score() self.reset_game() self.qr_register() self.mute = False
def _start(): logger.info(self.st.script_command) with Popen(self.env, [self.st.script_command, str(self.st.sound_card_index)], shell=False, stdout=subprocess.PIPE) as child: if not(self.recorder is None): self.recorder.start() while True: out = child.stdout.read(150) if out == '' and child.poll() != None: break reg = r'(\d{1,3})\%' ans = re.findall(reg, out) if len(ans) != 0: try: self.fire_event(int(ans[0])) except Exception as e: logger.error(e)
def play_tone(self): logger.info(str(self.env.finishing_list)) if self.sound: logger.info(str(self.sound)) self.sound.early_exit() logger.info(str(self.st.sound_card_index)) self.sound = Popen(self.env, ["audio_playing/play_tone.sh", str(self.st.sound_card_index), str(self.tones[self.tone])], shell=False) logger.info(["audio_playing/play_tone.sh", str(self.st.sound_card_index), str(self.tones[self.tone])]) self.seven_print(self.tones[self.tone], "%d")
def run(self, info=""): """At the moment of the load of the environment, game_load event gets fired. Exponate can listen to this event and do some initializations. """ #tick schedules recursive sequence of ticks with fixed time-period - #needed for urwid responsiveness def tick(): self.loop.set_alarm_in(0.1, strip_params(tick)) tick() #start game when main_loop is created self.urwid_invoke(self.game_load.fire_event) self.urwid_invoke(self.refresh_keys) if self.st.web_screen: self.start_gtk_thread() # Loop is specific attribute for Emulator environment; because of # urwid, loop.run() must be called in the main thread after all #initialization. self.loop.run() logger.info('urwid main-loop exited')
def _start(): try: logger.info('waiting while sound pipe is created') sleep(4) f = open(self.st.pipe_source, 'rb') buffer = [] sizebuf=0 while True: out = f.read(2000) if len(out)>0: logger.info("chunk length: " + str(len(out))) buffer.append(out) sizebuf+=len(out) if sizebuf > self.st.buffer_size: sizebuf=0 self.fire_event(''.join(buffer)) buffer = [] except Exception as e: logger.error(e)
def __handle_keypress__(self, letter): if letter=='esc': logger.info('exiting program (escape pressed)') BaseEnv.__exit__(self) if self.st.web_screen: self.main_window.destroy() gob.idle_add(gtk.main_quit) raise urwid.ExitMainLoop() self.invoker.__exit__() sys.exit() elif hasattr(self.qr,'key2user_id') and letter in self.qr.key2user_id.keys(): self.qr.fire_event(letter) else: for key in self.keyboard.keys: if key.key_object==letter: key.pressed=not key.pressed updown='down' if key.pressed else 'up' key.fire_event(updown) self.refresh_keys()
def __init__(self, invoker, env, settings): BaseExhibit.__init__(self, invoker, env, settings) self.env.game_load.listen_once(self.reset_game) self.env.game_load.listen_once(self.qr_register) try: logger.info(os.system("pgrep timidity")) logger.info(os.system("pkill timidity")) logger.info(os.system("timidity -iA -Os -B5,12 &")) #logger.info(os.system("timidity -iA -Os")) time.sleep(2) #essential for good connection alsaseq.client( 'Simple', 1, 1, True ) alsaseq.connectto( 1, 128, 0 ) alsaseq.start() logger.info("timidity is ok. (i hope)") except Exception as e: logger.error("timidity" + str(e)) self.st.max_tone_amount = 3 self.tones_playing = []
def recorder(self, sample): logger.info('recorder, idle=' + str(self.idle)) if self.idle: pass else: self.record += sample
def __init__(self, invoker, settings=None): """ `invoker` - same as exhibit's invoker `key_map` - maps logical key label to physical adress (i.e. keyboard button or expander pin adress) `light_map` - maps logical light labels to physical adress (similar to key_map) `snd_path` - root path to sound samplse `seven_length` - length of seven-segment display, may not be set if exhibit does not have one """ # clean up - kill all processes that shouldn't be running - maybe they weren't closed # properly during the last run kia = ['barcode', 'zbarcam', 'vol_pipe','arecord', 'play_tone', 'aplay', 'play', 'picocom'] for k in kia: try: os.system("pkill --signal CONT " + k) except: pass try: os.system("pkill --signal KILL "+ k) except: pass self.st=settings self.invoker=invoker self.key_map=settings.key_map self.light_map=settings.light_map self.keyboard = Keyboard(invoker, settings.key_map) self.seven_length=settings.seven_length self.light_labels=list(settings.light_map.keys()) self.lights=OrderedDict((label, 0) for label in self.light_labels) self.snd_path=settings.snd_path self.finishing_list = [] self.qr=self.st.qr_factory(invoker, settings, self) self.qr.start() self.game_load=EventProducer(invoker) try: os.system("./audio_playing/force_analogue_audio.sh") except Exception as e: logger.error("forec_analog" + str(e)) if self.st.enable_soundworker: self.samples={} sample_file_names=[os.path.join(root, filename) for root, dirnames, filenames in os.walk(self.snd_path) if dirnames==[] for filename in filenames] for filename in sample_file_names: with open(filename) as fyle: self.samples[os.path.relpath(filename, self.snd_path)]=fyle.read() logger.info("setting sound devices by pyalsaaudio") try: card = self.st.sound_card card_control = self.st.sound_card_control if not (card in alsaaudio.cards()): logger.error("sound card %s not found "%card) logger.error(str(alsaaudio.cards())) else: self.st.sound_card_index = alsaaudio.cards().index(card) mixer = alsaaudio.Mixer(cardindex=self.st.sound_card_index, control=card_control) mixer.setvolume(self.st.volume) mixer = alsaaudio.Mixer(cardindex=self.st.sound_card_index, control=self.st.sound_card_control_mic) mixer.setvolume(self.st.record_sensitivity, 0, "capture") mixer.setvolume(self.st.record_sensitivity, 1, "capture") except Exception as e: logger.error(e) logger.info("setting sound devices is finished.") if self.st.enable_soundworker: self.sound_executor=SoundExecutor(self.samples, self.st)
def __init__(self, invoker, env, settings): BaseExhibit.__init__(self, invoker=invoker, env=env, settings=settings) logger.info("hura, BaseExhibit.__init__ skoncil.") self.env.game_load.listen_once(self.mega_reset_game)
def begin_round(self): for p in self.players: logger.info('tu'+str(p.io.pyramid_label)) self.env.light(p.io.pyramid_label, 1) self.env.keyboard.listen_once(self.update_scores, key_down) self.run_reset_timer(self.reset_game)
def res(self, *args, **kwargs): if self.st.ignore_server: logger.info('ignoring communication with server %s'%str(fn.__name__)) else: return fn(self, *args, **kwargs)