def _event_polling(self, task): event_name = "" value = None for ev in pygame.event.get(): if ev.type is pygame.JOYBUTTONDOWN or ev.type is pygame.JOYBUTTONUP: event_name = 'joystick%d-button%d' % (ev.joy, ev.button) value = ev.type is pygame.JOYBUTTONDOWN elif ev.type is pygame.JOYAXISMOTION: event_name = 'joystick%d-axis%d' % (ev.joy, ev.axis) value = ev.value in_game_name = self.events_dict.get(event_name, None) if in_game_name is not None: t0 = self.gameEngine.get_time(round_result=False) if event_name in self.times: dt = t0 - self.times[event_name] else: dt = 10. self.times[event_name] = t0 if dt > self.firewall_time: # if it is a switch, we just reverse its value if in_game_name.startswith("s_"): value = not self._hardware_state(in_game_name) self.tasks[event_name] = self.gameEngine.task_mgr.do_method_later(1.1 * self.firewall_time, self._process_event, name=event_name, extraArgs=[in_game_name, value]) else: # firewall ! if self.tasks[event_name] is not None: if self.gameEngine.params("show_buttons_ghosts"): Logger.warning("possible ghost from", event_name) self.tasks[event_name].remove() return task.cont
def play(self, name, loop=False, volume=None): if name in self._sounds: sound = self._sounds[name] # avoid playing the same sound many times if name == self._last_played and sound.status() == sound.PLAYING: return if loop: sound.setLoop(True) if volume is not None: sound.setVolume(volume) if name in self._protected_sounds or ( self.gameEngine.params("voice_sound_do_not_overlap") and ("voice" in name or "human" in name)): self._queue.append(sound) self._last_played = name if not self._is_playing: self._start_next() else: self._last_played = name sound.play() elif name == "bips": self.play_bips() else: Logger.warning("Sound", name, "does not exists.")
def check_constrained_led(self, event_name, value): if event_name in self.controlled_leds: if value: Logger.info("setting led", event_name, "on") self.set_led_on(self.controlled_leds[event_name]) else: Logger.info("setting led", event_name, "off") self.set_led_off(self.controlled_leds[event_name])
def __init__(self, gameEngine): self.task_mgr = gameEngine.task_mgr self.gameEngine = gameEngine ports = list(serial.tools.list_ports.comports()) self.board = None for p in ports: Logger.info(p, p[2], 'description :', p.description) if "ttyACM0" in p.description: self.board = serial.Serial(p[0], 9600, timeout=5) if self.board is None: Logger.warning("no arduino connected !") else: if self.board.isOpen(): Logger.info("port is open. Closing it") self.board.close() Logger.info("opening the port") self.board.open() time.sleep(1.0) self.all_off()
def update_hard_state(self, state_key, value, silent=False): """ Update a hardware state of the shuttle and tells the game that the shuttle is updated. This can only append if the variable 'listen_to_hardware' is set to True. In this case, the game checks if a leds corresponds to this new hardware states and switch it on/off. If the hardware states correspnds to a software one, the corresponding software state is automatically updated. @param state_key: must be one of the strings defined in self.game_states @param value: the new value (int, float, bool or string depending on the state_key) @param silent: if True, no automatic sound is played. Otherwise, the game searches for a sound corresponding to the new state of the soft_state and plays it. @return: True if the state exists. False otherwise """ if state_key == "b_admin": self.hard_states[state_key] = value # always listen to it self.scenario.update_shuttle_state() # only do it if the key exists and if we listen to hardware and if the value is different from the previous one (to avoid spamminf of joysticks_axis = 0.0 elif state_key in self.hard_states and self.get_soft_state( "listen_to_hardware") and value != self.hard_states[state_key]: Logger.print("(hard_state): ", state_key, ':', value, color='yellow') self.hard_states[state_key] = value # check if it is associated to one led self.hardware.check_constrained_led(state_key, value) # maybe it plays an automatic sound if not silent: if value: self.sound_manager.play(state_key + "_on") else: self.sound_manager.play(state_key + "_off") self.scenario.update_shuttle_state() # particular cases: if state_key == "b_freq_moins" and value: self.update_soft_state("freq_comm", self.get_soft_state("freq_comm") - self.params("freq_comm_increment"), silent=silent) elif state_key == "b_freq_plus" and value: self.update_soft_state("freq_comm", self.get_soft_state("freq_comm") + self.params("freq_comm_increment"), silent=silent) elif state_key == "b_stop_shuttle" and value: self.shuttle.stop() elif state_key == "j_sp_orientation_h": if value > 0 and self.get_soft_state("offset_ps_x") < 10: self.update_soft_state("offset_ps_x", self.get_soft_state("offset_ps_x") + 1, silent=silent) elif value < 0 and self.get_soft_state("offset_ps_x") > -10: self.update_soft_state("offset_ps_x", self.get_soft_state("offset_ps_x") - 1, silent=silent) elif state_key == "j_sp_orientation_v": if value > 0 and self.get_soft_state("offset_ps_y") < 10: self.update_soft_state("offset_ps_y", self.get_soft_state("offset_ps_y") + 1, silent=silent) elif value < 0 and self.get_soft_state("offset_ps_y") > -10: self.update_soft_state("offset_ps_y", self.get_soft_state("offset_ps_y") - 1, silent=silent) elif state_key[:-1] == 's_pilote_automatique': other = 's_pilote_automatique1' if state_key[ -1] == '2' else 's_pilote_automatique2' if value and self.get_hard_state(other): self.update_soft_state("pilote_automatique", True, silent=silent) elif not value and not self.get_hard_state(other): self.update_soft_state("pilote_automatique", False, silent=silent) else: # now check if it controls a software value self.update_soft_state(state_key.split('_', 1)[1], value) return True return False
def update_soft_state(self, state_key, value, force_power=False, silent=False): """ Update a software state of the shuttle and tells the game that the shuttle is updated. If this acton requires some power, the engine checks if this action can be performed and update the shuttle power. Depending on the name of state, some action are performed and the shuttle is correctly updated. @param state_key: must be one of the strings defined in self.game_states @param value: the new value (int, float, bool or string depending on the state_key) @param force_power: If this action consumes some power, set is to True to ignore the power limits. @param silent: if True, no automatic sound is played. Otherwise, the game searches for a sound corresponding to the new state of the soft_state and plays it. @return: True if the state exists. False otherwise """ if state_key in self.soft_states: if (not self.params("use_power") or force_power or not value or ( value and self.params("use_power") and self.power.can_be_switched_on(state_key))) and \ self.soft_states[state_key] != value: # first, there may be some conditions if state_key in [ "correction_roulis", "correction_direction", "correction_stabilisation" ] and value and not self.soft_states["pilote_automatique"]: return True if state_key.startswith("batterie") and not state_key.endswith( 's') and not self.soft_states["batteries"]: self.sound_manager.play("batterie_wrong") return True if state_key.startswith( "moteur") and value and self.get_soft_state( "collision_occurred"): self.sound_manager.play("engine_fails") return True # now we switch it on Logger.print("(soft_state): ", state_key, ':', value, color='yellow') old_value = self.soft_states[state_key] self.soft_states[state_key] = value # check if it is associated to one led self.hardware.check_constrained_led(state_key, value) # maybe it changes the energy and maybe it plays an automatic sound if not value: if not silent: self.sound_manager.play(state_key + "_off") self.power.switch_off(state_key) else: if not silent: self.sound_manager.play(state_key + "_on") self.power.switch_on(state_key) # check for control_screen: self.control_screen.event("update_state", key=state_key) # particular actions ? if state_key == "offset_ps_x" or state_key == "offset_ps_y": self.update_soft_state( "sp_power", round( self.get_soft_state("sp_max_power") / sqrt(1 + self.get_soft_state("offset_ps_x")**2 + self.get_soft_state("offset_ps_y")**2), 3)) if self.get_soft_state( "offset_ps_x") == self.get_soft_state( "offset_ps_y") == 0: self.sound_manager.play("sp_nominal") self.hardware.set_led_on("l_ps_nominal") else: self.hardware.set_led_off("l_ps_nominal") elif state_key == "sp_power": power = self.get_soft_state("main_power") self.update_soft_state("main_power", power + value - old_value) elif state_key == "pilote_automatique" and not value: self.soft_states["full_pilote_automatique"] = False # switch corrections off for c in [ "correction_roulis", "correction_direction", "correction_stabilisation" ]: self.update_soft_state(c, False) elif state_key in [ "correction_roulis", "correction_direction", "correction_stabilisation" ]: on = True for c in [ "correction_roulis", "correction_direction", "correction_stabilisation" ]: if not self.get_soft_state(c): on = False break self.soft_states["full_pilote_automatique"] = on elif state_key.startswith("moteur") and value: self.sound_manager.play("engine_starts") elif state_key == "pilote_automatique_failed" and value: # removing it in a few frames self.taskMgr.doMethodLater( 0.1, self.update_soft_state, name="paf_end", extraArgs=["pilote_automatique_failed", False]) # and tell the game that there have been a update self.scenario.update_shuttle_state() # this may append if the task is automatically fulfilled with f1. if state_key == "pilote_automatique_failed" and value: self.soft_states["pilote_automatique_failed"] = False Logger.print("(soft_state): ", state_key, ':', False, color='yellow') else: if state_key.startswith('moteur') and value: self.sound_manager.play("engine_fails") elif value and not self.power.can_be_switched_on(state_key): self.sound_manager.play("voice_energy_denied") if state_key == "pilote_automatique": # sets the failed to True and immediately after to False. self.soft_states["pilote_automatique_failed"] = True Logger.print("(soft_state): ", state_key, ':', True, color='yellow') self.scenario.update_shuttle_state() self.soft_states["pilote_automatique_failed"] = False Logger.print("(soft_state): ", state_key, ':', False, color='yellow') return True return False
def simulate_input(self, event_code, value): if event_code in self.events_dict: messenger.send(self.events_dict[event_code], [value]) else: Logger.warning(event_code, "is not in the event list !")
def set_led_off(self, led_name): for key in self.events_dict: if self.events_dict[key] == led_name: self.arduino.led_off(key) return Logger.info(led_name, "not found in self.event_dict")