def cancel_looping_task(self):
if self.looping_task is not None:
logger.debug('Cancelling looping task')
try:
self.looping_task.cancel()
except Exception as e:
logger.warning("Could not cancel looping task (reason={})".format(e))
def on_disconnect(self, air_duct):
logger.debug("{} is not connected to any air source".format(air_duct))
if self.status != "playing":
logger.debug("Game is not started yet: nothing to do")
return
if self.sequence_cursor != -1: # Game is running
air_duct.fan.off()
if self.success_sequence[
self.sequence_cursor]["air_duct"] != air_duct.name:
# It was not necessary to disconnect this air duct: considering as an error
# TODO: reactivate this rule
logger.debug(
"Should be considered an error but ignoring for now")
# self.sequence_cursor = -1
# self.bad_move_failure_animation()
else: # Game is not running
if all([
ad.connected_source is None
for ad in self.air_ducts.values()
]):
logger.debug("All air ducts are disconnected")
self.restart_round()
else:
logger.debug("Some air ducts remain connected")
self.display_connected_air_ducts_before_restart()
def onMessage(self, payload, isBinary):
if isBinary:
logger.warning(
"Binary message received ({} bytes): ignoring".format(
len(payload)))
return
try:
unicode_message = payload.decode('utf8')
except UnicodeDecodeError:
logger.exception("Cannot decode {}: ignoring".format(payload))
return
try:
message = json.loads(unicode_message)
except json.JSONDecodeError:
logger.exception(
"Cannot load {}: ignoring".format(unicode_message))
return
ok, warning = self.validate_message(message)
if not ok:
logger.info("Received {}".format(message))
logger.warning(warning)
logger.info("Ignoring")
else:
logger.debug("Received {}".format(message))
self.log_message(message, to_server=False)
self.factory.process_event(message[P.EVENT])
def difficulty(self, value):
if value not in self.difficulties:
logger.warning("Difficulty {} not in {}: skipping".format(
value, ", ".join(self.difficulties)))
else:
logger.debug("Setting difficulty to {}".format(value))
self._difficulty = value
def cancel_release_task(self):
logger.debug('Cancelling release task')
try:
self.release_task.cancel()
except Exception as e:
logger.warning(
"Could not cancel release task (reason={})".format(e))
def send_event(self, event):
message = {
P.MESSAGE_TYPE: P.MESSAGE_TYPE_EVENT,
P.EVENT: event,
}
logger.debug("Sending message to the server: {}".format(message))
self.send_json(message)
def send_json(self, dict_):
unicode_json = json.dumps(dict_, ensure_ascii=False)
bytes_ = unicode_json.encode("utf8")
logger.debug("Sending {}".format(dict_))
self.log_message(dict_, to_server=False)
self.sendMessage(bytes_)
def status(self, value):
if value not in self.STATUSES:
logger.warning("Status {} not in {}: skipping".format(
value, ", ".join(self.STATUSES)))
return
if value == self.status:
logger.debug("Status is already {}: skipping".format(value))
return
logger.debug("Setting status to {}".format(value))
self._status = value
if self._status == "inactive":
self.skip_skippable_animations()
if self.unskippable_animation_task and self.unskippable_animation_task.active(
):
self.unskippable_animation_task.cancel()
self.on_inactive()
elif self._status == "playing":
self.skip_skippable_animations()
if self.unskippable_animation_task and self.unskippable_animation_task.active(
):
self.unskippable_animation_task.cancel()
self.on_playing()
elif self._status == "success":
self.on_success()
def _on_chopstick_unplug(self):
logger.debug("Executing letter {} chopstick unplug reaction".format(
self.letters.index(self)))
reaction = self.unplug_reactions.get(self.difficulty,
self.reaction_do_nothing)
reaction()
self.check_success()
def _toggle(self, color, activate):
if activate:
logger.debug("Activating {}".format(self))
else:
logger.debug("Deactivating {}".format(self))
self.on_toggle(color, activate)
def status(self, value):
if value not in self.STATUSES:
logger.warning("Status {} not in {}: skipping".format(
value, ", ".join(self.STATUSES)))
return
if value == self.status:
logger.debug("Status is already {}: skipping".format(value))
return
logger.debug("Setting status to {}".format(value))
self._status = value
for task_name, task in self.tasks.items():
if task.active():
task.cancel()
self.tasks = {}
if self._status == "chaos":
self.on_chaos()
elif self._status == "mute":
self.on_mute()
elif self._status == "playing":
self.on_playing()
elif self._status == "success":
self.on_success()
def display_connected_air_ducts_before_restart(self):
logger.debug("Displaying connected air ducts in red before restart")
for ad_name, ad in self.air_ducts.items():
if ad.connected_source is None:
ad.set_color("black")
else:
ad.set_color("red")
def new_player(self):
super(VLCLoopingChapterVideoPlayer, self).new_player()
logger.debug('Setting time={} because current chapter is {}'.format(
self.current_chapter['t_start'], self.current_chapter_id))
# callLater because VLC seems to need some delay
reactor.callLater(
0.01, self.player.set_time,
int(self.current_chapter['t_start'] * 1000))
def send_log(self, level, content):
message = {
P.MESSAGE_TYPE: P.MESSAGE_TYPE_LOG,
P.LOG_LEVEL: level,
P.LOG_CONTENT: content,
}
logger.debug("Sending message to the server: {}".format(message))
self.send_json(message)
def reaction_toggle_blue_orange(self):
if self.led_color == "blue":
self.led_color = "orange"
elif self.led_color == "orange":
self.led_color = "blue"
else:
logger.debug("Letter {} color is {}: nothing to do".format(
self.letters.index(self), self.led_color))
def new_player(self):
super(VLCDynamicSlidesPlayer, self).new_player()
logger.debug('Setting time={} because current slide is chapter id={}'.format(
self.current_chapter['start'], self.slides[self.current_slide_index]))
# callLater because VLC seems to need some delay
reactor.callLater(
0.01, self.player.set_time,
int(self.current_chapter['start'] * 1000))
def send_i_am_node(self):
message = {
P.MESSAGE_TYPE: P.MESSAGE_TYPE_I_AM,
P.I_AM_CLIENT_TYPE: P.CLIENT_NODE,
P.I_AM_NAME: self.name,
P.I_AM_CHANNEL: self.channel,
}
logger.debug("Declaring as a node")
self.send_json(message)
def led_color(self, value):
self._led_color = value
logger.debug("Letter {}: {}".format(self.letters.index(self), value))
# Get GRB values of given colors from settings
red = self.colors.get(value, {}).get("r", 0)
green = self.colors.get(value, {}).get("g", 0)
blue = self.colors.get(value, {}).get("b", 0)
Letter.led_strip[self.led_index] = (red, green, blue)
def cancel_tasks(self):
logger.debug("Cancelling tasks")
if self.led_task and self.led_task.active():
logger.info("Cancelling led task")
self.led_task.cancel()
if self.stop_motor_task and self.stop_motor_task.active():
logger.info("Cancelling stop motor task")
self.stop_motor_task.cancel()
def on_chopstick_unplug(self):
logger.debug("Letter {} chopstick unplugged".format(
self.letters.index(self)))
if self.delayed_reaction_task and self.delayed_reaction_task.active():
logger.debug("Canceling previous reaction task")
self.delayed_reaction_task.cancel()
else:
self.delayed_reaction_task = callLater(0.2,
self._on_chopstick_unplug)
def next_slide(self):
self.current_slide_index = (self.current_slide_index + 1) % len(self.slides)
time_before_slide = self.current_chapter['end'] - self.current_chapter['start']
self.schedule_slide_task(time_before_slide)
logger.debug('Setting player time to {} because current slide is chapter id={}'.format(
self.current_chapter['start'], self.slides[self.current_slide_index]))
self.player.set_time(int(self.current_chapter['start']) * 1000)
self.service.notify_slide(self.current_slide_index)
def set_chapter(self, chapter_id):
self.current_chapter_id = chapter_id
self.cancel_looping_task()
if self.player is not None:
logger.debug('Setting time={} because current chapter is {}'.format(
self.current_chapter['t_start'], self.current_chapter_id))
self.player.set_time(int(self.current_chapter['t_start'] * 1000))
if self.current_state == MediaPlayerMixin.STATE_PLAYING:
time_before_loop = self.current_chapter['loop_b'] - self.current_chapter['t_start']
self.schedule_looping_task(time_before_loop)
def new_success_sequence(self):
logger.debug("Loading a new success sequence (try counter={})".format(
self.try_counters[self.round]))
round_sequences = self.difficulties[self.difficulty][self.round]
sequence_index = (self.try_counters[self.round] -
1) % len(round_sequences)
self.success_sequence = round_sequences[sequence_index]
logger.info("The new success sequence is {}".format(
self.success_sequence))
def set_slide(self, slide_index, chapter_id):
self.current_slide_index = slide_index
self.slides[self.current_slide_index] = chapter_id
self.cancel_slide_task()
if self.player is not None:
logger.debug('Setting time={} because current slide is {}'.format(
self.current_chapter['start'], self.slides[self.current_slide_index]))
self.player.set_time(int(self.current_chapter['start'] * 1000))
self.service.notify_slide(slide_index)
if self.current_state == MediaPlayerMixin.STATE_PLAYING:
time_before_slide = self.current_chapter['end'] - self.current_chapter['start']
self.schedule_slide_task(time_before_slide)
def bad_move_failure_animation(self):
logger.debug("Running bad move failure animation")
self.skip_skippable_animations()
for ad in self.air_ducts.values():
ad.fan.off()
def wait_and_display_connected_air_ducts_before_restart():
self.animation_tasks["wait"] = callLater(
0.3, self.display_connected_air_ducts_before_restart)
self.animation_tasks["blink1"] = callLater(
0,
self.fluid_to_color,
self.air_ducts["ad2"].led_index,
"red",
0.35,
"blink1",
self.fluid_to_color,
self.air_ducts["ad2"].led_index,
"black",
0.35,
"blink1",
)
self.animation_tasks["blink2"] = callLater(
0.3,
self.fluid_to_color,
self.air_ducts["ad1"].led_index,
"red",
0.35,
"blink2",
self.fluid_to_color,
self.air_ducts["ad1"].led_index,
"black",
0.35,
"blink2",
)
self.animation_tasks["blink3"] = callLater(
0.6,
self.fluid_to_color,
self.air_ducts["ad0"].led_index,
"red",
0.35,
"blink3",
self.fluid_to_color,
self.air_ducts["ad0"].led_index,
"black",
0.35,
"blink3",
wait_and_display_connected_air_ducts_before_restart,
)
def buildProtocol(self, addr):
logger.debug('Connected')
self.resetDelay()
logger.debug("Building protocol")
self.protocol = JustSockClientProtocol(
self,
self.name,
self.channel
)
return self.protocol
def on_cell_activation(self):
if self.is_activated:
logger.debug(
"Color {} is already activated: skipping".format(self))
return
# Hide oscillations
if self.deactivation_task and self.deactivation_task.active():
logger.debug("Canceling {} deactivation".format(self))
self.deactivation_task.cancel()
self.is_activated = True
self.toggle()
def pause(self):
if self.current_state == MediaPlayerMixin.STATE_NOT_STARTED:
logger.debug('Player has not been started yet')
logger.debug('Nothing to do')
elif self.current_state == MediaPlayerMixin.STATE_PLAYING:
logger.debug('Player is already playing')
self._pause()
self.current_state = MediaPlayerMixin.STATE_PAUSED
elif self.current_state == MediaPlayerMixin.STATE_PAUSED:
logger.debug('Player is paused and had already been started')
logger.debug('Nothing to do')
else:
pass
def process_event(self, event):
logger.debug("Processing event '{}'".format(event))
if type(event) is not dict:
logger.error("Unknown event: skipping")
return
category = self.get_category(event)
method = self.get_method_from_category(category)
self.check_arguments(event, method)
self.pop_superfluous_fields(event, method)
method(**event)
def step4():
if self.round < 2:
logger.debug("Going to next round".format(self.round))
self.round += 1
if all([
ad.connected_source is None
for ad in self.air_ducts.values()
]):
self.restart_round()
else:
self.display_connected_air_ducts_before_restart()
else:
logger.debug("All rounds have been completed: victory!")
self.success_animation(step5)
