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)
