Permalink
Cannot retrieve contributors at this time
| import psmove | |
| import common, colors, joust, webui | |
| import yaml | |
| import time, random, json, os, os.path, sys, glob | |
| from piaudio import Music, DummyMusic, Audio, InitAudio | |
| from enum import Enum | |
| from multiprocessing import Process, Value, Array, Queue, Manager, freeze_support | |
| from games import ffa, zombie, commander, swapper, tournament, speed_bomb, fight_club | |
| from sys import platform | |
| if platform == "linux" or platform == "linux2": | |
| import jm_dbus | |
| import pair | |
| elif "win" in platform: | |
| import win_jm_dbus as jm_dbus | |
| import win_pair as pair | |
| import controller_process | |
| import update | |
| TEAM_NUM = len(colors.team_color_list) | |
| #TEAM_COLORS = colors.generate_colors(TEAM_NUM) | |
| SENSITIVITY_MODES = 5 | |
| RANDOM_TEAM_SIZES = 6 | |
| class Opts(Enum): | |
| alive = 0 | |
| selection = 1 | |
| holding = 2 | |
| team = 3 | |
| game_mode = 4 | |
| random_start = 5 | |
| class Alive(Enum): | |
| on = 0 | |
| off = 1 | |
| class Selections(Enum): | |
| nothing = 0 | |
| change_mode_forward = 1 | |
| change_mode_backward = 2 | |
| add_game = 3 | |
| change_sensitivity = 4 | |
| change_instructions = 5 | |
| show_battery = 6 | |
| update = 7 | |
| admin = 8 | |
| change_setting_control = 9 | |
| start_game = 10 | |
| force_start_game = 11 | |
| class Holding(Enum): | |
| not_holding = 0 | |
| holding = 1 | |
| class Sensitivity(Enum): | |
| ultra_slow = 0 | |
| slow = 1 | |
| mid = 2 | |
| fast = 3 | |
| ultra_fast = 4 | |
| def track_move(serial, move_num, move, move_opts, force_color, battery, dead_count, restart, menu, kill_proc): | |
| move.set_leds(0,0,0) | |
| move.update_leds() | |
| random_color = random.random() | |
| force_start_timer = 0 | |
| while True: | |
| if(restart.value ==1 or menu.value == 0 or kill_proc.value): | |
| return | |
| time.sleep(0.01) | |
| if move.poll(): | |
| game_mode = common.Games(move_opts[Opts.game_mode.value]) | |
| move_button = common.Button(move.get_buttons()) | |
| if move_opts[Opts.alive.value] == Alive.off.value: | |
| if move_button == common.Button.SYNC: | |
| move_opts[Opts.alive.value] = Alive.on.value | |
| dead_count.value = dead_count.value - 1 | |
| time.sleep(0.1) | |
| else: | |
| if move_button == common.Button.SHAPES: | |
| move_opts[Opts.selection.value] = Selections.admin.value | |
| move_opts[Opts.holding.value] = Holding.holding.value | |
| if move_button == common.Button.UPDATE: | |
| move_opts[Opts.selection.value] = Selections.update.value | |
| move_opts[Opts.holding.value] = Holding.holding.value | |
| #show battery level | |
| if battery.value == 1: | |
| battery_level = move.get_battery() | |
| #granted a charging move should be dead | |
| #so it won't light up anyway | |
| if battery_level == psmove.Batt_CHARGING: | |
| move.set_leds(*colors.Colors.White20.value) | |
| elif battery_level == psmove.Batt_CHARGING_DONE: | |
| move.set_leds(*colors.Colors.White.value) | |
| elif battery_level == psmove.Batt_MAX: | |
| move.set_leds(*colors.Colors.Green.value) | |
| elif battery_level == psmove.Batt_80Percent: | |
| move.set_leds(*colors.Colors.Turquoise.value) | |
| elif battery_level == psmove.Batt_60Percent: | |
| move.set_leds(*colors.Colors.Blue.value) | |
| elif battery_level == psmove.Batt_40Percent: | |
| move.set_leds(*colors.Colors.Yellow.value) | |
| else : # under 40% - you should charge it! | |
| move.set_leds(*colors.Colors.Red.value) | |
| #custom team mode is the only game mode that | |
| #can't be added to con mode | |
| elif game_mode == common.Games.JoustTeams: | |
| if move_opts[Opts.team.value] >= TEAM_NUM: | |
| move_opts[Opts.team.value] = 3 | |
| move.set_leds(*colors.team_color_list[move_opts[Opts.team.value]].value) | |
| #set leds to forced color | |
| elif sum(force_color) != 0: | |
| move.set_leds(*force_color) | |
| elif game_mode == common.Games.JoustFFA: | |
| move.set_leds(*colors.Colors.Orange.value) | |
| elif game_mode == common.Games.JoustRandomTeams: | |
| color = time.time()/10%1 | |
| color = colors.hsv2rgb(color, 1, 1) | |
| move.set_leds(*color) | |
| elif game_mode == common.Games.Traitor: | |
| if move_num%4 == 2 and time.time()/3%1 < .15: | |
| move.set_leds(*colors.Colors.Red80.value) | |
| else: | |
| color = 1 - time.time()/10%1 | |
| color = colors.hsv2rgb(color, 1, 1) | |
| move.set_leds(*color) | |
| elif game_mode == common.Games.WereJoust: | |
| if move_num <= 0: | |
| move.set_leds(*colors.Colors.Blue40.value) | |
| else: | |
| move.set_leds(*colors.Colors.Yellow.value) | |
| elif game_mode == common.Games.Zombies: | |
| move.set_leds(*colors.Colors.Zombie.value) | |
| elif game_mode == common.Games.Commander: | |
| if move_num % 2 == 0: | |
| move.set_leds(*colors.Colors.Orange.value) | |
| else: | |
| move.set_leds(*colors.Colors.Blue.value) | |
| elif game_mode == common.Games.Swapper: | |
| if (time.time()/5 + random_color)%1 > 0.5: | |
| move.set_leds(*colors.Colors.Magenta.value) | |
| else: | |
| move.set_leds(*colors.Colors.Green.value) | |
| elif game_mode == common.Games.FightClub: | |
| move.set_leds(*colors.Colors.Green80.value) | |
| elif game_mode == common.Games.NonStop: | |
| move.set_leds(*colors.Colors.Turquoise.value) | |
| elif game_mode == common.Games.Tournament: | |
| if move_num <= 0: | |
| color = time.time()/10%1 | |
| color = colors.hsv2rgb(color, 1, 1) | |
| move.set_leds(*color) | |
| else: | |
| move.set_leds(*colors.Colors.Blue40.value) | |
| elif game_mode == common.Games.Ninja: | |
| if move_num <= 0: | |
| move.set_leds(random.randrange(100, 200),0,0) | |
| else: | |
| move.set_leds(*colors.Colors.Red60.value) | |
| elif game_mode == common.Games.Random: | |
| move.set_leds(0,0,255) | |
| if move_opts[Opts.holding.value] == Holding.not_holding.value: | |
| if move.get_trigger() > 100: | |
| move_opts[Opts.selection.value] = Selections.start_game.value | |
| move_opts[Opts.holding.value] = Holding.holding.value | |
| force_start_timer = time.time() | |
| #Change game mode backwards | |
| if move_button == common.Button.SELECT: | |
| move_opts[Opts.selection.value] = Selections.change_mode_backward.value | |
| move_opts[Opts.holding.value] = Holding.holding.value | |
| #Change game mode forwards | |
| if move_button == common.Button.START: | |
| move_opts[Opts.selection.value] = Selections.change_mode_forward.value | |
| move_opts[Opts.holding.value] = Holding.holding.value | |
| #as an admin controller add or remove game from convention mode | |
| if move_button == common.Button.CROSS: | |
| move_opts[Opts.selection.value] = Selections.add_game.value | |
| move_opts[Opts.holding.value] = Holding.holding.value | |
| #as an admin controller change sensitivity of controllers | |
| if move_button == common.Button.CIRCLE: | |
| move_opts[Opts.selection.value] = Selections.change_sensitivity.value | |
| move_opts[Opts.holding.value] = Holding.holding.value | |
| #as an admin controller change if instructions play | |
| if move_button == common.Button.SQUARE: | |
| move_opts[Opts.selection.value] = Selections.change_instructions.value | |
| move_opts[Opts.holding.value] = Holding.holding.value | |
| #as an admin show battery level of controllers | |
| if move_button == common.Button.TRIANGLE: | |
| move_opts[Opts.selection.value] = Selections.show_battery.value | |
| move_opts[Opts.holding.value] = Holding.holding.value | |
| if move_button == common.Button.MIDDLE: | |
| #allow players to increase their own team | |
| move_opts[Opts.selection.value] = Selections.change_setting_control.value | |
| if game_mode == common.Games.JoustTeams: | |
| move_opts[Opts.team.value] = (move_opts[Opts.team.value] + 1) % TEAM_NUM | |
| move_opts[Opts.holding.value] = Holding.holding.value | |
| if (move_opts[Opts.selection.value] == Selections.start_game.value and \ | |
| move_opts[Opts.holding.value] == Holding.holding.value and \ | |
| time.time()-force_start_timer >2): | |
| move_opts[Opts.selection.value] = Selections.force_start_game.value | |
| if move_opts[Opts.random_start.value] == Alive.off.value: | |
| move.set_leds(255,255,255) | |
| if move_opts[Opts.holding.value] == Holding.holding.value and move_button == common.Button.NONE and move.get_trigger() <= 100: | |
| move_opts[Opts.holding.value] = Holding.not_holding.value | |
| move.update_leds() | |
| class Menu(): | |
| def __init__(self): | |
| self.command_queue = Queue() | |
| self.joust_manager = Manager() | |
| self.ns = self.joust_manager.Namespace() | |
| self.web_proc = Process(target=webui.start_web, args=(self.command_queue,self.ns)) | |
| self.web_proc.start() | |
| self.ns.status = dict() | |
| self.ns.settings = dict() | |
| self.ns.battery_status = dict() | |
| self.command_from_web = '' | |
| self.initialize_settings() | |
| self.update_settings_file() | |
| self.admin_options = ["random_team_size","force_all_start"] | |
| self.admin_control_option = 0 | |
| #check for update | |
| if platform == "linux" or platform == "linux2": | |
| self.big_update = update.check_for_update(self.ns.settings['menu_voice']) | |
| self.git_hash = update.run_command("git rev-parse HEAD")[:7] | |
| else: | |
| self.git_hash = "0000000" | |
| #defined outside of ns.settings as it's a purely dev option | |
| self.experimental = False | |
| self.move_count = psmove.count_connected() | |
| self.dead_count = Value('i', 0) | |
| self.moves = [psmove.PSMove(x) for x in range(psmove.count_connected())] | |
| self.admin_move = None | |
| #move controllers that have been taken out of play | |
| #I think we can probably get rid of this since out_moves are just turning off the controller now | |
| #needs testing | |
| self.out_moves = {} | |
| self.random_added = [] | |
| self.rand_game_list = [] | |
| self.show_battery = Value('i', 0) | |
| #only allow one move to be paired at a time | |
| self.pair_one_move = True | |
| self.tracked_moves = {} | |
| self.force_color = {} | |
| self.paired_moves = [] | |
| self.move_opts = {} | |
| self.teams = {} | |
| self.game_mode = common.Games[self.ns.settings['current_game']] | |
| self.old_game_mode = self.game_mode | |
| self.pair = pair.Pair() | |
| self.menu = Value('i', 1) | |
| self.controller_game_mode = Value('i',1) | |
| self.restart = Value('i',0) | |
| self.controller_teams = {} | |
| self.controller_colors = {} | |
| self.dead_moves = {} | |
| self.music_speed= Value('d', 0) | |
| self.werewolf_reveal = Value('i', 2) | |
| self.show_team_colors = Value('i', 0) | |
| self.red_on_kill = Value('i', 0) | |
| self.zombie_opts = {} | |
| self.commander_intro = Value('i',1) | |
| self.commander_move_opts = {} | |
| self.commander_powers = [Value('d', 0.0), Value('d', 0.0)] | |
| self.commander_overdrive = [Value('i', 0), Value('i', 0)] | |
| self.five_controller_opts = {} | |
| self.swapper_team_colors = Array('i',[0]*6) | |
| self.fight_club_colors = {} | |
| self.invincible_moves = {} | |
| self.num_teams = Value('i',1) | |
| self.bomb_color = Array('i', [0] * 3) | |
| self.game_start = Value('i', 0) | |
| self.false_colors = {} | |
| self.was_faked = {} | |
| self.rumble = {} | |
| self.kill_controller_proc = {} | |
| self.controller_sensitivity = Array('d', [0] *10) | |
| self.dead_invince = Value('b', False) | |
| self.i = 0 | |
| #load audio now so it converts before the game begins | |
| self.menu_music = Music("menu") | |
| self.joust_music = Music("joust") | |
| self.zombie_music = Music("zombie") | |
| self.commander_music = Music("commander") | |
| self.choose_new_music() | |
| def choose_new_music(self): | |
| self.joust_music.load_audio("audio/Joust/music/*") | |
| self.zombie_music.load_audio("audio/Zombie/music/*") | |
| self.commander_music.load_audio("audio/Commander/music/*") | |
| def check_for_new_moves(self): | |
| self.enable_bt_scanning(True) | |
| #need to start tracking of new moves in here | |
| if psmove.count_connected() != self.move_count: | |
| self.moves = [psmove.PSMove(x) for x in range(psmove.count_connected())] | |
| self.move_count = len(self.moves) | |
| #doesn't work | |
| #self.alive_count = len([move.get_serial() for move in self.moves if self.move_opts[move.get_serial()][Opts.alive.value] == Alive.on.value]) | |
| def enable_bt_scanning(self, on=True): | |
| if platform == "linux" or platform == "linux2": | |
| bt_hcis = list(jm_dbus.get_hci_dict().keys()) | |
| for hci in bt_hcis: | |
| if jm_dbus.enable_adapter(hci): | |
| self.pair.update_adapters() | |
| if on: | |
| jm_dbus.enable_pairable(hci) | |
| else: | |
| jm_dbus.disable_pairable(hci) | |
| def pair_usb_move(self, move): | |
| move_serial = move.get_serial() | |
| if move_serial not in self.tracked_moves: | |
| if move.connection_type == psmove.Conn_USB: | |
| if move_serial not in self.paired_moves: | |
| self.pair.pair_move(move) | |
| move.set_leds(255,255,255) | |
| move.update_leds() | |
| self.paired_moves.append(move_serial) | |
| self.pair_one_move = False | |
| def pair_move(self, move, move_num): | |
| move_serial = move.get_serial() | |
| if move_serial not in self.tracked_moves: | |
| color = Array('i', [0] * 3) | |
| opts = Array('i', [0] * 6) | |
| if move_serial in self.teams: | |
| opts[Opts.team.value] = self.teams[move_serial] | |
| else: | |
| #initialize to team Yellow | |
| opts[Opts.team.value] = 3 | |
| if move_serial in self.out_moves: | |
| opts[Opts.alive.value] = self.out_moves[move_serial] | |
| opts[Opts.game_mode.value] = self.game_mode.value | |
| #now start tracking the move controller | |
| team = Value('i',0) | |
| team_color_enum = Array('i',[0]*3) | |
| dead_move = Value( 'i',0) | |
| zombie_opt = Array('i', [0, 0, 0, 1, 0, 1, 1]) | |
| five_controller_opt = Array('i',[0]*5) | |
| commander_move_opt = Array('i', [0] * 5) | |
| invincibility = Value('b', True) | |
| fight_club_color = Value('i', 0) | |
| false_color = Value('i', 0) | |
| faked = Value('i', 0) | |
| rumble = Value('i', 0) | |
| kill_proc = Value('b', False) | |
| proc = Process(target= controller_process.main_track_move, args=(self.menu, self.restart, move_serial, move_num, opts, color, self.show_battery, \ | |
| self.dead_count, self.controller_game_mode, team, team_color_enum, self.controller_sensitivity, dead_move, \ | |
| self.music_speed, self.werewolf_reveal, self.show_team_colors, self.red_on_kill,zombie_opt,\ | |
| self.commander_intro, commander_move_opt, self.commander_powers, self.commander_overdrive,\ | |
| five_controller_opt, self.swapper_team_colors, invincibility, fight_club_color, self.num_teams,\ | |
| self.bomb_color,self.game_start,false_color, faked, rumble, self.dead_invince, kill_proc)) | |
| proc.start() | |
| self.move_opts[move_serial] = opts | |
| self.tracked_moves[move_serial] = proc | |
| self.force_color[move_serial] = color | |
| self.controller_teams[move_serial] = team | |
| self.controller_colors[move_serial] = team_color_enum | |
| self.dead_moves[move_serial] = dead_move | |
| self.zombie_opts[move_serial] = zombie_opt | |
| self.commander_move_opts[move_serial] = commander_move_opt | |
| self.five_controller_opts[move_serial] = five_controller_opt | |
| self.fight_club_colors[move_serial] = fight_club_color | |
| self.invincible_moves[move_serial] = invincibility | |
| self.false_colors[move_serial] = false_color | |
| self.was_faked[move_serial] = faked | |
| self.rumble[move_serial] = rumble | |
| self.kill_controller_proc[move_serial] = kill_proc | |
| self.out_moves[move.get_serial()] = Alive.on.value | |
| def remove_controller(self, move_serial): | |
| self.kill_controller_proc[move_serial].value = True | |
| self.tracked_moves[move_serial].join() | |
| self.tracked_moves[move_serial].terminate() | |
| del self.move_opts[move_serial] | |
| #del self.tracked_moves[move_serial] | |
| del self.force_color[move_serial] | |
| del self.controller_teams[move_serial] | |
| del self.controller_colors[move_serial] | |
| del self.dead_moves[move_serial] | |
| del self.zombie_opts[move_serial] | |
| del self.commander_move_opts[move_serial] | |
| del self.five_controller_opts[move_serial] | |
| del self.fight_club_colors[move_serial] | |
| del self.invincible_moves[move_serial] | |
| del self.false_colors[move_serial] | |
| del self.was_faked[move_serial] | |
| del self.rumble[move_serial] | |
| del self.kill_controller_proc[move_serial] | |
| def game_mode_announcement(self): | |
| if self.game_mode == common.Games.JoustFFA: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu Joust FFA.wav').start_effect() | |
| if self.game_mode == common.Games.JoustTeams: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu Joust Teams.wav').start_effect() | |
| if self.game_mode == common.Games.JoustRandomTeams: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu Joust Random Teams.wav').start_effect() | |
| if self.game_mode == common.Games.Traitor: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu Traitor.wav').start_effect() | |
| if self.game_mode == common.Games.WereJoust: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu Werewolves.wav').start_effect() | |
| if self.game_mode == common.Games.Zombies: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu Zombies.wav').start_effect() | |
| if self.game_mode == common.Games.Commander: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu Commander.wav').start_effect() | |
| if self.game_mode == common.Games.Swapper: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu Swapper.wav').start_effect() | |
| if self.game_mode == common.Games.Tournament: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu Tournament.wav').start_effect() | |
| if self.game_mode == common.Games.Ninja: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu ninjabomb.wav').start_effect() | |
| if self.game_mode == common.Games.Random: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu Random.wav').start_effect() | |
| if self.game_mode == common.Games.FightClub: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu FightClub.wav').start_effect() | |
| if self.game_mode == common.Games.NonStop: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/menu NonStopJoust.wav').start_effect() | |
| def check_game_trigger(self): | |
| for move, move_opt in self.move_opts.items(): | |
| if move != self.admin_move: | |
| if move_opt[Opts.selection.value] == Selections.start_game.value: | |
| move_opt[Opts.random_start.value] = Alive.off.value | |
| move_opt[Opts.selection.value] = Selections.nothing.value | |
| else: | |
| if (move_opt[Opts.selection.value] == Selections.start_game.value and \ | |
| move_opt[Opts.holding.value] == Holding.not_holding.value): | |
| #turn admin back to regular player | |
| self.force_color[self.admin_move][0] = 0 | |
| self.force_color[self.admin_move][1] = 0 | |
| self.force_color[self.admin_move][2] = 0 | |
| self.admin_move = None | |
| move_opt[Opts.selection.value] = Selections.nothing.value | |
| def check_change_mode(self): | |
| change_mode = False | |
| change_forward = True | |
| for move, move_opt in self.move_opts.items(): | |
| if move != self.admin_move: | |
| if move_opt[Opts.selection.value] == Selections.change_mode_forward.value: | |
| #change the game mode if allowed | |
| if self.ns.settings['move_can_be_admin']: | |
| change_mode = True | |
| change_forward = True | |
| move_opt[Opts.selection.value] = Selections.nothing.value | |
| if move_opt[Opts.selection.value] == Selections.change_mode_backward.value: | |
| #change the game mode if allowed | |
| if self.ns.settings['move_can_be_admin']: | |
| change_mode = True | |
| change_forward = False | |
| move_opt[Opts.selection.value] = Selections.nothing.value | |
| if self.command_from_web == 'changemode': | |
| self.command_from_web = '' | |
| change_mode = True | |
| if change_mode: | |
| if change_forward: | |
| self.game_mode = self.game_mode.next() | |
| else: | |
| self.game_mode = self.game_mode.previous() | |
| self.update_setting('current_game',self.game_mode.name) | |
| self.reset_controller_game_state() | |
| if not self.ns.settings['play_audio']: | |
| if self.game_mode == common.Games.Commander: | |
| self.game_mode = self.game_mode.next() | |
| if self.game_mode == common.Games.WereJoust: | |
| self.game_mode = self.game_mode.next() | |
| for opt in self.move_opts.values(): | |
| opt[Opts.game_mode.value] = self.game_mode.value | |
| if self.ns.settings['play_audio']: | |
| self.game_mode_announcement() | |
| def check_new_admin(self): | |
| for move, move_opt in self.move_opts.items(): | |
| if move_opt[Opts.selection.value] == Selections.admin.value: | |
| #remove previous admin, and set new one | |
| if self.ns.settings['move_can_be_admin']: | |
| #set the old admin_move to have no colors | |
| if self.admin_move: | |
| self.force_color[self.admin_move][0] = 0 | |
| self.force_color[self.admin_move][1] = 0 | |
| self.force_color[self.admin_move][2] = 0 | |
| self.admin_move = move | |
| move_opt[Opts.selection.value] = Selections.nothing.value | |
| #all controllers need to opt-in again in order fo the game to start | |
| def reset_controller_game_state(self): | |
| for move_opt in self.move_opts.values(): | |
| #on means off here | |
| move_opt[Opts.random_start.value] = Alive.on.value | |
| for serial in self.move_opts.keys(): | |
| for i in range(3): | |
| self.force_color[serial][i] = 0 | |
| self.random_added = [] | |
| def check_update(self): | |
| for move, move_opt in self.move_opts.items(): | |
| if move_opt[Opts.selection.value] == Selections.update.value: | |
| if self.big_update: | |
| update.big_update(self.ns.settings['menu_voice']) | |
| self.big_update = False | |
| def game_loop(self): | |
| self.play_menu_music = True | |
| while True: | |
| if self.play_menu_music: | |
| self.play_menu_music = False | |
| self.menu_music.load_audio("audio/Menu/music/*") | |
| self.menu_music.start_audio_loop() | |
| self.i=self.i+1 | |
| if "linux" in platform: | |
| if not self.pair_one_move and "0" in os.popen('lsusb | grep "PlayStation Move motion controller" | wc -l').read(): | |
| self.pair_one_move = True | |
| self.paired_moves = [] | |
| else: | |
| if not self.pair_one_move: | |
| self.pair_one_move = True | |
| self.paired_moves = [] | |
| if self.pair_one_move: | |
| #check if there are any controllers that were shut off | |
| if psmove.count_connected() > len(self.tracked_moves): | |
| for move_num, move in enumerate(self.moves): | |
| if move.connection_type == psmove.Conn_USB and self.pair_one_move: | |
| self.pair_usb_move(move) | |
| elif move.connection_type != psmove.Conn_USB: | |
| self.pair_move(move, move_num) | |
| elif(len(self.tracked_moves) > len(self.moves)): | |
| connected_serials = [x.get_serial() for x in self.moves] | |
| tracked_serials = self.tracked_moves.keys() | |
| keys_to_kill = [] | |
| for serial in tracked_serials: | |
| if serial not in connected_serials: | |
| #self.kill_controller_proc[serial].value = True | |
| #check to see if the controller has not been removed already | |
| if serial in self.move_opts.keys(): | |
| self.remove_controller(serial) | |
| #self.tracked_moves[serial].join() | |
| #self.tracked_moves[serial].terminate() | |
| keys_to_kill.append(serial) | |
| for key in keys_to_kill: | |
| del self.tracked_moves[key] | |
| if key == self.admin_move: | |
| self.admin_move = None | |
| self.check_for_new_moves() | |
| if len(self.tracked_moves) > 0: | |
| self.check_new_admin() | |
| self.check_change_mode() | |
| self.check_game_trigger() | |
| self.check_admin_controls() | |
| self.check_start_game() | |
| self.check_update() | |
| self.check_command_queue() | |
| self.update_status('menu') | |
| def check_admin_controls(self): | |
| show_bat = False | |
| for move_opt in self.move_opts.values(): | |
| if move_opt[Opts.selection.value] == Selections.show_battery.value and move_opt[Opts.holding.value] == Holding.holding.value: | |
| show_bat = True | |
| if show_bat: | |
| self.show_battery.value = 1 | |
| else: | |
| self.show_battery.value = 0 | |
| if not self.ns.settings['move_can_be_admin'] and self.admin_move != None: | |
| self.force_color[self.admin_move][0] = 0 | |
| self.force_color[self.admin_move][1] = 0 | |
| self.force_color[self.admin_move][2] = 0 | |
| self.admin_move = None | |
| if self.admin_move: | |
| #you can't add custom teams mode to con mode, don't set colors | |
| admin_opt = self.move_opts[self.admin_move] | |
| if admin_opt[Opts.selection.value] == Selections.force_start_game.value: | |
| admin_opt[Opts.random_start.value] = Alive.off.value | |
| self.start_game() | |
| return; | |
| #change game settings | |
| if admin_opt[Opts.selection.value] == Selections.change_setting_control.value: | |
| admin_opt[Opts.selection.value] = Selections.nothing.value | |
| self.admin_control_option = (self.admin_control_option + 1) % len(self.admin_options) | |
| if(self.admin_options[self.admin_control_option] == 'random_team_size'): | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/adminop_random_team_size.wav').start_effect() | |
| elif(self.admin_options[self.admin_control_option] == 'force_all_start'): | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/adminop_force_all_start.wav').start_effect() | |
| if admin_opt[Opts.selection.value] == Selections.change_mode_forward.value: | |
| admin_opt[Opts.selection.value] = Selections.nothing.value | |
| if(self.admin_options[self.admin_control_option] == 'random_team_size'): | |
| self.update_setting('random_team_size', (self.ns.settings['random_team_size'] + 1) % (RANDOM_TEAM_SIZES+1)) | |
| if (self.ns.settings['random_team_size'] < 2): | |
| self.update_setting('random_team_size', 2) | |
| Audio('audio/Menu/vox/{}/adminop_{}.wav'.format(self.ns.settings['menu_voice'],self.ns.settings['random_team_size'])).start_effect() | |
| elif(self.admin_options[self.admin_control_option] == 'force_all_start'): | |
| self.update_setting('force_all_start', not self.ns.settings['force_all_start'] ) | |
| Audio('audio/Menu/vox/{}/adminop_{}.wav'.format(self.ns.settings['menu_voice'],self.ns.settings['force_all_start'])).start_effect() | |
| if admin_opt[Opts.selection.value] == Selections.change_mode_backward.value: | |
| admin_opt[Opts.selection.value] = Selections.nothing.value | |
| if(self.admin_options[self.admin_control_option] == 'random_team_size'): | |
| self.update_setting('random_team_size', (self.ns.settings['random_team_size'] - 1)) | |
| if (self.ns.settings['random_team_size'] < 2): | |
| self.update_setting('random_team_size', RANDOM_TEAM_SIZES) | |
| Audio('audio/Menu/vox/{}/adminop_{}.wav'.format(self.ns.settings['menu_voice'],self.ns.settings['random_team_size'])).start_effect() | |
| elif(self.admin_options[self.admin_control_option] == 'force_all_start'): | |
| self.update_setting('force_all_start', not self.ns.settings['force_all_start'] ) | |
| Audio('audio/Menu/vox/{}/adminop_{}.wav'.format(self.ns.settings['menu_voice'],self.ns.settings['force_all_start'])).start_effect() | |
| #to play instructions or not | |
| if admin_opt[Opts.selection.value] == Selections.change_instructions.value: | |
| admin_opt[Opts.selection.value] = Selections.nothing.value | |
| self.update_setting('play_instructions', not self.ns.settings['play_instructions']) | |
| if self.ns.settings['play_audio']: | |
| if self.ns.settings['play_instructions']: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/instructions_on.wav').start_effect() | |
| else: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/instructions_off.wav').start_effect() | |
| #change sensitivity | |
| if admin_opt[Opts.selection.value] == Selections.change_sensitivity.value: | |
| admin_opt[Opts.selection.value] = Selections.nothing.value | |
| self.update_setting('sensitivity', (self.ns.settings['sensitivity'] + 1) % SENSITIVITY_MODES) | |
| if self.ns.settings['play_audio']: | |
| if self.ns.settings['sensitivity'] == Sensitivity.ultra_slow.value: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/ultra_high.wav').start_effect() | |
| elif self.ns.settings['sensitivity'] == Sensitivity.slow.value: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/high.wav').start_effect() | |
| elif self.ns.settings['sensitivity'] == Sensitivity.mid.value: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/medium.wav').start_effect() | |
| elif self.ns.settings['sensitivity'] == Sensitivity.fast.value: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/low.wav').start_effect() | |
| elif self.ns.settings['sensitivity'] == Sensitivity.ultra_fast.value: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/ultra_low.wav').start_effect() | |
| #no admin colors in con custom teams mode | |
| if self.game_mode == common.Games.JoustTeams or self.game_mode == common.Games.Random: | |
| self.force_color[self.admin_move][0] = 0 | |
| self.force_color[self.admin_move][1] = 0 | |
| self.force_color[self.admin_move][2] = 0 | |
| else: | |
| #if game is in con mode, admin is green, otherwise admin is red | |
| if self.game_mode.name in self.ns.settings['random_modes']: | |
| self.force_color[self.admin_move][0] = 0 | |
| self.force_color[self.admin_move][1] = 200 | |
| else: | |
| self.force_color[self.admin_move][0] = 200 | |
| self.force_color[self.admin_move][1] = 0 | |
| #add or remove game from con mode | |
| if admin_opt[Opts.selection.value] == Selections.add_game.value: | |
| admin_opt[Opts.selection.value] = Selections.nothing.value | |
| if self.game_mode.name not in self.ns.settings['random_modes']: | |
| temp_random_modes = self.ns.settings['random_modes'] | |
| temp_random_modes.append(self.game_mode.name) | |
| self.update_setting('random_modes',temp_random_modes) | |
| if self.ns.settings['play_audio']: | |
| Audio('audio/Menu/sounds/game_on.wav').start_effect() | |
| elif len(self.ns.settings['random_modes']) > 1: | |
| temp_random_modes = self.ns.settings['random_modes'] | |
| temp_random_modes.remove(self.game_mode.name) | |
| self.update_setting('random_modes',temp_random_modes) | |
| if self.ns.settings['play_audio']: | |
| Audio('audio/Menu/sounds/game_off.wav').start_effect() | |
| else: | |
| if self.ns.settings['play_audio']: | |
| Audio('audio/Menu/sounds/game_err.wav').start_effect() | |
| self.update_settings_file() | |
| def initialize_settings(self): | |
| #default settings | |
| temp_settings = ({ | |
| 'sensitivity': Sensitivity.mid.value, | |
| 'play_instructions': True, | |
| #we store the name, not the enum, so the webui can process it more easily | |
| 'random_modes': [common.Games.JoustFFA.name,common.Games.JoustRandomTeams.name,common.Games.WereJoust.name,common.Games.Swapper.name], | |
| 'current_game': common.Games.JoustFFA.name, | |
| 'play_audio': True, | |
| 'menu_voice': 'ivy', | |
| 'move_can_be_admin': True, | |
| 'enforce_minimum': True, | |
| 'red_on_kill': True, | |
| 'random_teams': True, | |
| 'color_lock': False, | |
| 'random_team_size': 4, | |
| 'force_all_start':False, | |
| 'color_lock_choices':{ | |
| 2: ['Magenta','Green'], | |
| 3: ['Orange','Turquoise','Purple'], | |
| 4: ['Yellow','Green','Blue','Purple'] | |
| } | |
| }) | |
| try: | |
| #if anything fails during the settings file load, ignore file and stick with defaults | |
| with open(common.SETTINGSFILE,'r') as yaml_file: | |
| file_settings = yaml.load(yaml_file) | |
| temp_colors = file_settings['color_lock_choices'] | |
| for key in temp_colors.keys(): | |
| colorset = temp_colors[key] | |
| if len(colorset) != len(set(colorset)): | |
| temp_colors[key] = temp_settings['color_lock_choices'][key] | |
| for setting in file_settings.keys(): | |
| if setting not in common.REQUIRED_SETTINGS: | |
| file_settings.pop(setting) | |
| for game in [common.Games.JoustTeams,common.Games.Random]: | |
| if game.name in file_settings['random_modes']: | |
| file_settings['random_modes'].remove(game.name) | |
| for game in file_settings['random_modes']: | |
| if game not in [game.name for game in common.Games]: | |
| file_settings['random_modes'].remove(game) | |
| if file_settings['random_modes'] == []: | |
| file_settings['random_modes'] = [common.Games.JoustFFA.name] | |
| temp_settings.update(file_settings) | |
| temp_settings['color_lock_choices'] = temp_colors | |
| except: | |
| print("we found an exception when loading the settings!") | |
| #force these settings | |
| temp_settings.update({ | |
| 'play_audio': True, | |
| 'move_can_be_admin': True, | |
| 'enforce_minimum': True | |
| }) | |
| self.ns.settings = temp_settings | |
| def update_settings_file(self): | |
| with open(common.SETTINGSFILE,'w') as yaml_file: | |
| yaml.dump(self.ns.settings,yaml_file) | |
| #option to make file editable by non-root | |
| #let's leave it as root only, people shouldn't | |
| #mess with the config file for now | |
| if platform == "linux" or platform == "linux2": | |
| os.system('chmod 666 %s' % common.SETTINGSFILE) | |
| def update_setting(self,key,val): | |
| temp_settings = self.ns.settings | |
| temp_settings[key] = val | |
| self.ns.settings = temp_settings | |
| self.update_settings_file() | |
| def check_command_queue(self): | |
| if not(self.command_queue.empty()): | |
| package = self.command_queue.get() | |
| command = package['command'] | |
| if command == 'admin_update': | |
| self.web_admin_update(package['admin_info']) | |
| else: | |
| self.command_from_web = command | |
| def update_status(self,game_status): | |
| self.ns.status ={ | |
| 'game_status' : game_status, | |
| 'game_mode' : self.game_mode.pretty_name, | |
| 'move_count' : self.move_count, | |
| 'alive_count' : self.move_count - self.dead_count.value, | |
| 'ticker': self.i, | |
| 'git_hash': self.git_hash | |
| } | |
| battery_status = {} | |
| for move in self.moves: | |
| move.poll() | |
| battery_status[move.get_serial()] = move.get_battery() | |
| self.ns.battery_status = battery_status | |
| self.ns.out_moves = self.out_moves | |
| def stop_tracking_moves(self): | |
| for proc in self.tracked_moves.values(): | |
| proc.terminate() | |
| proc.join() | |
| def check_start_game(self): | |
| #if self.game_mode == common.Games.Random: | |
| start_game = True | |
| for serial in self.move_opts.keys(): | |
| #on means off here | |
| if self.out_moves[serial] == Alive.on.value and self.move_opts[serial][Opts.random_start.value] == Alive.on.value: | |
| start_game = False | |
| if self.move_opts[serial][Opts.random_start.value] == Alive.off.value and serial not in self.random_added: | |
| self.random_added.append(serial) | |
| if self.ns.settings['play_audio']: | |
| Audio('audio/Joust/sounds/start.wav').start_effect() | |
| if start_game: | |
| print("starting game") | |
| if self.game_mode == common.Games.Random: | |
| self.start_game(random_mode=True) | |
| else: | |
| self.start_game() | |
| #else: | |
| # if self.ns.settings['move_can_be_admin']: | |
| # for move_opt in self.move_opts.values(): | |
| # if move_opt[Opts.selection.value] == Selections.start_game.value: | |
| # self.start_game() | |
| if self.command_from_web == 'startgame': | |
| self.command_from_web = '' | |
| self.start_game() | |
| def play_random_instructions(self): | |
| if self.game_mode == common.Games.JoustFFA: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/FFA-instructions.wav').start_effect_and_wait() | |
| if self.game_mode == common.Games.JoustRandomTeams: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/Teams-instructions.wav').start_effect_and_wait() | |
| if self.game_mode == common.Games.Traitor: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/Traitor-instructions.wav').start_effect_and_wait() | |
| if self.game_mode == common.Games.WereJoust: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/werewolf-instructions.wav').start_effect_and_wait() | |
| if self.game_mode == common.Games.Zombies: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/zombie-instructions.wav').start_effect_and_wait() | |
| if self.game_mode == common.Games.Commander: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/commander-instructions.wav').start_effect_and_wait() | |
| if self.game_mode == common.Games.Ninja: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/Ninjabomb-instructions.wav').start_effect_and_wait() | |
| if self.game_mode == common.Games.Swapper: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/Swapper-instructions.wav').start_effect_and_wait() | |
| if self.game_mode == common.Games.Tournament: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/Tournament-instructions.wav').start_effect_and_wait() | |
| if self.game_mode == common.Games.FightClub: | |
| if self.ns.settings['menu_voice'] == 'aaron': | |
| os.popen('espeak -ven -p 70 -a 200 "Two players fight, the winner must defend their title, the player with the highest score wins') | |
| else: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/Fightclub-instructions.wav').start_effect_and_wait() | |
| time.sleep(5) | |
| def start_game(self, random_mode=False): | |
| self.enable_bt_scanning(False) | |
| time.sleep(1) | |
| if(not self.ns.settings['force_all_start']): | |
| #start with only controllers that have pushed trigger | |
| self.teams = {serial: self.move_opts[serial][Opts.team.value] for serial in self.tracked_moves.keys() if self.out_moves[serial] == Alive.on.value} | |
| game_moves = [move.get_serial() for move in self.moves if self.out_moves[move.get_serial()] == Alive.on.value and (self.move_opts[move.get_serial()])[Opts.random_start.value] == Alive.off.value ] | |
| else: | |
| #start with all controllers (even ones who have not pushed trigger) | |
| self.teams = {serial: self.move_opts[serial][Opts.team.value] for serial in self.tracked_moves.keys() if self.out_moves[serial] == Alive.on.value} | |
| game_moves = [move.get_serial() for move in self.moves if self.out_moves[move.get_serial()] == Alive.on.value] | |
| if len(game_moves) < self.game_mode.minimum_players and self.ns.settings['enforce_minimum']: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/notenoughplayers.wav').start_effect() | |
| self.reset_controller_game_state() | |
| return | |
| for move in [move.get_serial() for move in self.moves if move.get_serial() not in game_moves]: | |
| print("we are removing controller: {}".format(move)) | |
| self.remove_controller(move) | |
| try: | |
| self.menu_music.stop_audio() | |
| except: | |
| pass | |
| self.menu.value = 0 | |
| self.restart.value =1 | |
| self.update_status('starting') | |
| self.sensitivity = self.ns.settings['sensitivity'] | |
| self.controller_sensitivity[0] = common.SLOW_MAX[self.sensitivity] | |
| self.controller_sensitivity[1] = common.SLOW_WARNING[self.sensitivity] | |
| self.controller_sensitivity[2] = common.FAST_MAX[self.sensitivity] | |
| self.controller_sensitivity[3] = common.FAST_WARNING[self.sensitivity] | |
| self.controller_sensitivity[4] = common.WERE_SLOW_MAX[self.sensitivity] | |
| self.controller_sensitivity[5] = common.WERE_SLOW_WARNING[self.sensitivity] | |
| self.controller_sensitivity[6] = common.WERE_FAST_MAX[self.sensitivity] | |
| self.controller_sensitivity[7] = common.WERE_FAST_WARNING[self.sensitivity] | |
| self.controller_sensitivity[8] = common.ZOMBIE_MAX[self.sensitivity] | |
| self.controller_sensitivity[9] = common.ZOMBIE_WARNING[self.sensitivity] | |
| if random_mode: | |
| good_random_modes = [game for game in common.Games if game.name in self.ns.settings['random_modes']] | |
| good_random_modes = [common.Games[game] for game in self.ns.settings['random_modes']] | |
| if self.ns.settings['enforce_minimum']: | |
| good_random_modes = [game for game in good_random_modes if game.minimum_players <= len(game_moves)] | |
| if len(good_random_modes) == 0: | |
| selected_game = common.Games.JoustFFA #force Joust FFA | |
| elif len(good_random_modes) == 1: | |
| selected_game = good_random_modes[0] | |
| else: | |
| if len(self.rand_game_list) >= len(good_random_modes): | |
| #empty rand game list, append old game, to not play it twice | |
| self.rand_game_list = [self.old_game_mode] | |
| selected_game = random.choice(good_random_modes) | |
| while selected_game in self.rand_game_list: | |
| selected_game = random.choice(good_random_modes) | |
| self.old_game_mode = selected_game | |
| self.rand_game_list.append(selected_game) | |
| self.game_mode = selected_game | |
| self.controller_game_mode.value = self.game_mode.value | |
| if self.ns.settings['play_instructions'] and self.ns.settings['play_audio']: | |
| self.play_random_instructions() | |
| if self.game_mode == common.Games.Zombies: | |
| zombie.Zombie(game_moves, self.command_queue, self.ns, self.zombie_music, self.restart, self.zombie_opts) | |
| elif self.game_mode == common.Games.Commander: | |
| commander.Commander(game_moves, self.command_queue, self.ns, self.commander_music, self.dead_moves, self.commander_intro, self.commander_move_opts, \ | |
| self.commander_powers, self.commander_overdrive, self.music_speed, self.force_color, self.restart, self.controller_teams) | |
| elif self.game_mode == common.Games.Ninja: | |
| speed_bomb.Bomb(game_moves, self.command_queue, self.ns, self.commander_music, self.bomb_color, self.game_start, self.five_controller_opts, self.dead_moves, self.force_color, self.false_colors, self.was_faked, self.rumble, self.music_speed,self.restart) | |
| elif self.game_mode == common.Games.Swapper: | |
| swapper.Swapper(game_moves, self.command_queue, self.ns, self.joust_music, \ | |
| self.swapper_team_colors, self.dead_moves, self.music_speed, self.force_color, self.five_controller_opts, self.controller_teams, self.restart) | |
| elif self.game_mode == common.Games.FightClub: | |
| if random.randint(0,1)==1: | |
| fight_music = self.commander_music | |
| else: | |
| fight_music = self.joust_music | |
| fight_club.Fight_club(game_moves, self.command_queue, self.ns, fight_music, self.show_team_colors, self.music_speed, self.dead_moves, self.force_color, self.invincible_moves, self.fight_club_colors, self.restart) | |
| elif self.game_mode == common.Games.Tournament: | |
| tournament.Tournament(game_moves, self.command_queue, self.ns, self.joust_music, self.show_team_colors, self.music_speed, self.controller_teams, self.dead_moves, self.force_color, self.invincible_moves, self.num_teams, self.restart) | |
| else: | |
| if self.game_mode == common.Games.JoustFFA and self.experimental: | |
| print("Playing EXPERIMENTAL FFA Mode.") | |
| moves = [ common.get_move(serial, num) for num, serial in enumerate(game_moves) ] | |
| game = ffa.FreeForAll(moves, self.joust_music) | |
| game.run_loop() | |
| else: | |
| #may need to put in moves that have selected to not be in the game | |
| joust.Joust(game_moves, self.command_queue, self.ns, self.joust_music, self.teams, self.game_mode, self.controller_teams, self.controller_colors, self.dead_moves, self.force_color,self.music_speed,self.werewolf_reveal, self.show_team_colors, self.red_on_kill, self.restart,self.ns.settings['random_team_size']) | |
| if random_mode: | |
| self.game_mode = common.Games.Random | |
| if self.ns.settings['play_instructions']: | |
| if self.ns.settings['play_audio']: | |
| Audio('audio/Menu/vox/' + self.ns.settings['menu_voice'] + '/tradeoff2.wav').start_effect_and_wait() | |
| self.play_menu_music = True | |
| #reset music | |
| self.choose_new_music() | |
| #turn off admin mode so someone can't accidentally press a button | |
| self.admin_move = None | |
| self.random_added = [] | |
| self.reset_controller_game_state() | |
| self.menu.value = 1 | |
| self.restart.value =0 | |
| self.reset_controller_game_state() | |
| self.retrack_removed_controllers(game_moves) | |
| def retrack_removed_controllers(self, game_moves): | |
| self.check_for_new_moves() | |
| for move_serial in [move.get_serial() for move in self.moves if move.get_serial() not in game_moves]: | |
| #This allows joustmania to re-find the removed controller | |
| if move_serial in self.tracked_moves.keys(): | |
| del self.tracked_moves[move_serial] | |
| if __name__ == "__main__": | |
| if "win" in platform: | |
| freeze_support() | |
| InitAudio() | |
| piparty = Menu() | |
| piparty.game_loop() |