def initialize(standard_screen):
globals.STDSCR = standard_screen
globals.MAIN = MainMenu()
globals.INTERFACES.append(globals.MAIN)
globals.MAP = GameMap()
globals.INTERFACES.append(globals.MAP)
globals.INVENTORY = Inventory()
globals.INTERFACES.append(globals.INVENTORY)
globals.PAUSE = PauseMenu()
globals.INTERFACES.append(globals.PAUSE)
globals.STORY = StoryScreen()
globals.INTERFACES.append(globals.STORY)
globals.CONTROLS_MAP = Controls(Controls.Type.game_map)
globals.INTERFACES.append(globals.CONTROLS_MAP)
globals.CONTROLS_INVENTORY = Controls(Controls.Type.inventory)
globals.INTERFACES.append(globals.CONTROLS_INVENTORY)
globals.CREDITS = Credits()
globals.INTERFACES.append(globals.CREDITS)
globals.NEW_GAME = NewGameDialog()
globals.INTERFACES.append(globals.NEW_GAME)
globals.QUIT_GAME = EndGameDialog()
globals.INTERFACES.append(globals.QUIT_GAME)
globals.SAVE_GAME = SaveGameDialog()
globals.INTERFACES.append(globals.SAVE_GAME)
globals.MONSTER = MonsterDialog()
globals.INTERFACES.append(globals.MONSTER)
globals.ITEM = ItemDialog()
globals.INTERFACES.append(globals.ITEM)
globals.GAME_OVER = GameOverDialog()
globals.INTERFACES.append(globals.GAME_OVER)
globals.LADDER = LadderDialog()
globals.INTERFACES.append(globals.LADDER)
def __init__(self):
self.clock = None
self.show_path = False
self.game = Game()
self.surface = pygame.display.set_mode(cfg.WINDOW_SIZE)
self.players_alg = [
Algorithm.PLAYER, Algorithm.PLAYER, Algorithm.DIJKSTRA,
Algorithm.DFS
]
# Controllers initialization
self.control_list_select1 = [("Key1", 0)]
self.control_list_select2 = [("Key2", 1)]
pygame.joystick.init()
self.num_of_gamepads = pygame.joystick.get_count()
self.controllers = [
Controls(pygame.K_UP, pygame.K_DOWN, pygame.K_LEFT, pygame.K_RIGHT,
pygame.K_RCTRL),
Controls(pygame.K_w, pygame.K_s, pygame.K_a, pygame.K_d,
pygame.K_LCTRL)
]
for i in range(self.num_of_gamepads):
gamepad = pygame.joystick.Joystick(i)
gamepad.init()
self.controllers.append(gamepad)
if i % 2 == 0:
self.control_list_select1.append((f"Joy{i+1}", i + 2))
else:
self.control_list_select2.append((f"Joy{i+1}", i + 2))
self.player_controls = [self.controllers[0], self.controllers[1]]
def handle_event(self, slack_event):
event = slack_event['event']
event_type = event['type']
if 'user' not in event:
return 'OK'
user = event['user']
if user == self.config.bot_id:
return 'OK' # Dont do anything about own messages
channel = event['channel']
if 'text' in event:
text = event['text']
print('in handle_event')
print('event_type = ' + event_type + ' channel = ' + channel + ' user = '******' text = ' + text)
print('---------------')
# Reply to request
AT_BOT = '<@' + self.config.bot_id + '>'
command = text
if True:
if text.startswith(AT_BOT):
command = text.split(AT_BOT)[1].strip().lower()
# if command.startswith('quote') or command.startswith('q ') or command.startswith('Q ') or command.startswith('Quote'):
sym_or_name = ''
if command.lower().startswith('help') == False:
toks = command.split(' ')
if len(toks) <= 1:
sym_or_name = command.strip().upper()
else:
tok1 = toks[0]
tok2 = toks[1]
if tok1.lower().startswith('q'):
sym_or_name = tok2.upper()
user_command = StockQuote(name="stock_quote", intent="get_stock_quote", params={}, raw=command,
urls={})
user_command.set_param('company-trie', Bot.company_trie)
user_command.set_param('symbol-trie', Bot.symbol_trie)
user_command.set_param('selected', sym_or_name)
val = Bot.symbol_trie.get(sym_or_name)
if val is not None:
self.postToSlack(channel, user_command.execute(), {})
else:
controls = Controls()
Bot.user_commands[channel+user] = user_command
controls.message_attachments_company_name_options[0]['actions'][0]['name'] = sym_or_name
message = 'Hmm, I don\'t know that stock symbol.\n Please use the search box below'
self.postToSlack(channel, message, controls.message_attachments_company_name_options)
else:
# Fallback to saying hello!
user_command = Hello(name="hello", intent="say_hello", params={}, raw=command, urls={})
self.postToSlack(channel, user_command.execute(), {})
return 'OK'
class MainWindow(QMainWindow):
width, height = 800, 480
def __init__(self, title, version):
super().__init__()
self.about_window = AboutWindow(title, version)
self.language_doc_window = LanguageDocWindow(title, version)
self.help_window = HelpWindow(title, version)
self.viewer = Viewer(self) # Rendered commands appear here
self.editor = Editor(self) # Commands are written here
self.controls = Controls(self)
self.move(200, 200)
self.setFixedSize(MainWindow.width, MainWindow.height)
self.setWindowTitle(title)
self.show()
def paintEvent(self, event):
try:
painter = QPainter(self)
self.controls.update_mouse_positional_label(self)
finally:
painter.end()
def create_widgets(self):
if globals.debug > 1: print("gui.create_widgets")
self.menubar = MenuBar(self.window, self)
self.interactiveplot = InteractivePlot(
self,
relief='sunken',
bd=1,
)
# Wait until the plot becomes visible to proceed
self.update_idletasks()
self.update()
self.plotcontrols = PlotControls(
self,
self.interactiveplot.canvas,
bg='white',
relief='sunken',
bd=1,
)
self.controls = Controls(
self,
width=2 * self.dpi, # pixels = inches * dpi
bd=1,
relief='sunken',
padx=5,
pady=5,
)
self.message_label = tk.Label(self,
textvariable=self.message_text,
bg='white')
def on_key_press(self, key: int, modifiers: int):
"""
check for key presses, set the respective instance variable to true.
:param key: the last key on the keyboard that the user pressed
:param modifiers: n/a
:return: n/a
"""
Controls.handle_key_presses(self, key, modifiers)
def temp_run():
temp_signals = {
'green': False,
'red': False,
'blue': False,
'stop': False,
'metal': False,
'maxTime': False,
'finish': False,
'path': '/home/pi/Filakov/',
'pltCnt': 1,
'imgCnt': 1
}
C = Controls("/dev/ttyACM0")
if not C.started:
debug_print(
"Controls of the motors are not started. Aborting program...")
return
time.sleep(3)
cam = cv2.VideoCapture(0)
time.sleep(1)
if not cam.isOpened():
debug_print("Camera is not opened. Aborting program...")
return
T_metal = threading.Thread(target=metalCheck, args=(
C,
temp_signals,
))
T_cam = threading.Thread(target=cameraLoop, args=(
cam,
temp_signals,
))
T_metal.start()
T_cam.start()
# calibrateCamera(C, temp_signals)
# if temp_signals['stop']:
# return
#
# C.Lights(1)
safeMove(C, 2, 'M', -90, temp_signals)
while True:
time.sleep(.5)
if temp_signals['stop']:
temp_signals['finish'] = True
break
T_cam.join()
T_metal.join()
# C.Lights(0)
C.Close()
def main():
root = Tk()
root.title("Simple 3-D Renderer :: Noah Ansel (nba38)")
display = Display(root)
controls = Controls(root, display)
controls.grid(row = 0, column = 0, sticky = N+W)
display.grid(row = 0, column = 1, sticky = N+W+E+S)
root.mainloop()
def on_key_release(self, key: int, modifiers: int):
"""
check for the last key to have been released, set the respective
instance variable to false.
:param key: the last key on the keyboard that the user let go of
:param modifiers: n/a
:return: n/a
"""
if self.player.in_water:
# the controls in water should only register when the key is released, unlike regular controls
Controls.handle_water_controls(self)
Controls.handle_key_release(self, key, modifiers)
class GameFSM(FSM):
def enterStartMenu(self):
self.menu = StartMenu()
def exitStartMenu(self):
self.menu.destroy()
del self.menu
def enterTrain(self):
self.train = TrainingMode()
def exitTrain(self):
self.train.destroy()
del self.train
def enterBattle(self):
self.battle = BattleMode()
def exitBattle(self):
if self.battle.popupText:
self.battle.popupText.detachNode()
self.battle.popupText = None
self.battle.destroy()
del self.battle
def enterControls(self):
self.controls = Controls()
def exitControls(self):
self.controls.destroy()
del self.controls
def enterSave(self):
self.save = Save()
def exitSave(self):
self.save.destroy()
del self.save
def enterLoad(self):
self.load = Load()
def exitLoad(self):
self.load.destroy()
del self.load
def enterStats(self):
self.stats = Stats()
def exitStats(self):
self.stats.destroy()
del self.stats
def __init__(self, resolution=Dimensions(1001, 601), calcThread=None):
# Declare constants
# General
self.fpsLimit = 60
self.simRunning = False
self.calcThread = calcThread
# Section sizes
self.control_width = 200
# Key presses
self.L_SHIFT = 1
self.R_SHIFT = 2
self.L_CTRL = 64
self.R_CTRL = 128
self.L_ALT = 256
self.R_ALT = 512
# Declare variables
self.populationLimit = 3
self.populationMin = 2
self.generation = 0
# Declare mouse event flags
self.processMouse = False
self.multiCellDrag = False
self.multiCellDragState = True
self.mouseHeld = False
self.mouseRepeatDelayed = False
self.mouseClickTime = 0
# Initialize pygame window
pygame.init()
self.window = pygame.display.set_mode(resolution, pygame.RESIZABLE)
pygame.display.set_caption("Conway's Game of Life")
# Create clock to limit FPS
self.fpsClock = pygame.time.Clock()
# Enable key and mouse hold repeating and set limits
pygame.key.set_repeat(500, 75)
self.mouseRepeat = (500, 75)
# Create the initial grid
self.grid = Grid(
Dimensions(self.window.get_rect().width - self.control_width,
self.window.get_rect().height), Position(0, 0))
# Create control section
self.controls = Controls(
Dimensions(self.control_width,
self.window.get_rect().height),
Position(self.grid.width, 0), self)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--player", help="player 1-6", type=int, default=1)
args = parser.parse_args()
config = Config(CONFIG_FILE, args.player)
comms_config = {
'rx_ip': config.client_ip,
'rx_port': config.client_port,
'tx_ip': config.sim_ip,
'tx_port': config.sim_port
}
print("Rx at {}:{}".format(comms_config["rx_ip"], comms_config["rx_port"]))
print("Tx to {}:{}".format(comms_config["tx_ip"], comms_config["tx_port"]))
commands_mutex = Lock()
# Launch comms in background thread
comms = CommsThread(comms_config, False, commands_mutex)
comms.daemon = True
comms.start()
# Launch perception, motion planning, and controls in main thread
sweep_builder = SweepBuilder()
perception = Perception(config)
planning = Planning(config)
controls = Controls(config)
visualize = Visualize(config)
try:
while True:
vehicle_state = sweep_builder.run(comms.get_vehicle_states())
if vehicle_state is not None:
t1 = time.time()
world_state = perception.run(vehicle_state)
plan = planning.run(world_state)
vehicle_commands = controls.run(plan)
t2 = time.time()
freq = 1 / (t2 - t1)
print(f"Running at {freq} Hz")
vehicle_commands['draw'] = visualize.run(world_state, plan)
with commands_mutex:
# hold the lock to prevent the Comms thread from
# sending the commands dict while we're modifying it
comms.vehicle_commands.update(vehicle_commands)
except KeyboardInterrupt:
pass
def __init__(self):
pygame.init()
self.outputs = Outputs()
self.stream = Stream(channels=1,
sample_rate=60 * 10**3,
sample_size=2**11)
self.mouse_frequency = 0.0
# visual params
self.background_color = pygame.Color(50, 50, 50)
self.colorA = pygame.Color("#ff0000")
self.colorB = pygame.Color("#0000ff")
self.num_bars = self.outputs.get_divisor()
# surface params
self.height = 1000
self.dimensions = numpy.array([self.outputs.get_width(), self.height])
self.surface_flags = pygame.HWSURFACE | pygame.DOUBLEBUF
self.surface = pygame.display.set_mode(self.dimensions,
self.surface_flags)
self.time_surface = pygame.Surface(self.dimensions //
numpy.array([1, 2]))
self.freq_surface = pygame.Surface(self.dimensions //
numpy.array([1, 2]))
self.control_surface = pygame.Surface(self.dimensions // 2)
self.control_surface.set_colorkey(self.background_color)
self.controls = Controls(self.control_surface)
self.sliders = {
'pull':
Slider(self.control_surface,
pygame.Rect(300, 46, 100, 10),
10,
15,
value=0.5),
'smooth':
Slider(self.control_surface,
pygame.Rect(300, 66, 100, 10),
10,
15,
value=0.5)
}
# smoothing history array
self.t_history = numpy.full(self.num_bars, 0.5)
self.f_history = numpy.full(self.num_bars, 0.0)
def __init__(self, verbose=True, path=False, width=WIDTH, height=HEIGHT):
self.verbose = verbose
self.logger = Logerer()
self.controls = Controls(verbose=self.verbose)
self.path = self.controls.path if not path else path
self.log("Game started in " + self.path)
self.levels = {}
self.current_level = (0, 0)
self.width = width
self.height = height
self.size = self.width, self.height
self.slow_clock = 90
self.screen = pygame.display.set_mode(
(self.width, self.height), pygame.RESIZABLE)
self.npcs_loaded = False
def __init__(self, interface):
gtk.Window.__init__(self)
self.set_title("mogbar3000")
#Create child widgets
self.statusbar = gtk.Statusbar()
self.controls = Controls(interface)
self.notebook = gtk.Notebook()
self.notebook.set_scrollable(True)
#Add children to VBox
self.box = gtk.VBox()
self.box.pack_start(self.controls, False, False, 0)
self.box.pack_start(self.notebook, True, True, 0)
self.box.pack_start(self.statusbar, False, False, 0)
self.add(self.box)
self.connect('delete_event', gtk.main_quit)
def create_playlist(tracks, name):
self.notebook.append_page(Playlist(interface), name)
interface.create_playlist = create_playlist
def add_tracks(tracks):
cur = self.notebook.get_current_page()
if cur == None: return
cur.store.append()
#done loading
self.show_all()
def __init__(self, window=None, objects=(), controllers=()):
# Create a font for score
self.font = font.load('Arial', 18)
# pyglet.font.Text object to display the score
self.score = font.Text(self.font, x=10, y=10, color=(1, 1, 1, 1))
self.control = Controls(window)
self.bind_objects(*objects)
self.bind_controllers(*controllers)
self.score_right = 0
self.score_left = 0
self.draw_score()
self.height = window.width
self.width = window.height
# should this not be handled within the object?
# map effects to different objects in the game
effects_map = {"fire": None}
def __init__(self, nop):
rows, columns = self.get_terminal_dimensions()
self.screen = {'rows': rows, 'columns': columns}
if not self.multi_player_support(nop):
print("Sorry " + str(nop) +
" is not supported at present screen aspect ratio.")
return
self.initialise_screen()
self.num_players = nop
self.players = []
self.maps = []
self.gameplay_settings = self.configure_gameplay_settings()
# os.system('tput civis')
# print("the ratio is ", columns / nop)
self.welcome_screen()
for num_id in range(nop):
self.maps.append(
level1_map.Level1Map(num_id, self.screen['rows'],
int(self.screen['columns'] / nop - 1)))
self.players.append(
Player(self.maps[-1].initial_player_position, config.PLAYER,
num_id, self.maps[-1]))
self.controls = Controls()
# self.maps[0].view_map()
# self.print_screen()
# exit(1)
if ROOT:
for player_id in range(self.num_players):
inp_thread = Thread(target=self.get_input_for_player,
args=(player_id, ))
inp_thread.daemon = True
inp_thread.start()
time_thread = Thread(target=self.decrease_time,
args=(player_id, ))
time_thread.daemon = True
time_thread.start()
control_input_thread = Thread(target=self.get_input_for_control)
control_input_thread.daemon = True
control_input_thread.start()
else:
time_thread = Thread(target=self.decrease_time, args=(0, ))
time_thread.daemon = True
time_thread.start()
all_input_thread = Thread(target=self.game_input)
all_input_thread.daemon = True
all_input_thread.start()
msc.play_music_for_action('Player at start')
while True:
try:
if config.stop.is_set() or config.timeout.is_set():
break
sleep(0.1)
[self.make_updates(x) for x in range(self.num_players)]
self.updates()
except KeyboardInterrupt:
break
self.exit()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.connect("delete-event", Gtk.main_quit)
root_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.board = Board()
self.controls = Controls()
self.console = Gtk.Label("Input angle, initial velocity and fire!")
self.controls.reset_btn.connect("clicked", self.__on_reset_clicked)
self.controls.fire_btn.connect("clicked", self.__on_fire_clicked)
root_box.pack_start(self.board, False, False, 0)
root_box.pack_end(self.controls, False, False, 10)
root_box.pack_end(self.console, False, False, 10)
self.add(root_box)
def appStarted(self):
# Citation: this is a modified version of image from user BENL at link
# https://www.chiefdelphi.com/t/top-down-orthographic-view-of-frcs-2019-playing-field/335397/9
self._fieldImage = self.loadImage("2019-field-blue.png")
self.fieldImageScaled = ImageTk.PhotoImage(self._fieldImage)
# Citation: from cleanpng.com, contributor: georgen
url = "https://icon2.cleanpng.com/20180417/bxw/kisspng-steve-harvey-still-trippin-act-like-a-lady-thin-steve-jobs-5ad626cde40c49.3709911715239840779341.jpg"
self._robotImage = self.scaleImage(self.loadImage(url), 0.6)
self._WAYPOINT_RADIUS = 30
self.setAppDims()
self.resetUserInputs()
self.FIELD_REAL_WIDTH = 8.23 # meters
self.FIELD_REAL_HEIGHT = 9 # 16.46
self.timerDelay = 30 # milliseconds
self.robot = RobotModel(1.0, 1.0, 0.0)
self.leftVoltage, self.rightVoltage = 0.0, 0.0
self.simTime = 0.0
self.ODOMETRY_UPDATE_RATE = 100
odometryThread = threading.Thread(target=self.odometryPeriodic,
daemon=True)
odometryThread.start()
self.waypoints = []
self.controls = Controls(self.waypoints, self.robot)
self.CONTROLS_UPDATE_RATE = 100
controlThread = threading.Thread(target=self.controlsPeriodic,
daemon=True)
controlThread.start()
self.logger = Logger()
self.logger.registerLoggerDict(self.robot.logDict, "robot")
self.logger.registerLoggerDict(self.controls.logDict, "controls")
yAxes = [
self.logger.dict["robot.heading"], self.logger.dict["robot.vel"],
self.logger.dict["controls.ffSpeed"]
]
self.graph = StackedTimeGraph(self.logger.time, yAxes,
(self.fieldImageWidth, self.width),
(self.height, 0))
def appStarted(self):
self._fieldImage = self.loadImage("2019-field-blue.png")
self.fieldImageScaled = ImageTk.PhotoImage(self._fieldImage)
self.setAppDims()
self.FIELD_REAL_WIDTH = 8.23 # meters
self.FIELD_REAL_HEIGHT = 9 # 16.46
self.robot = RobotModel(1.0, 1.0, 0.0)
self._robotImage = self.scaleImage(self.loadImage("steve.jpg"), 0.6)
self.leftVoltage, self.rightVoltage = 0.0, 0.0
self.ODOMETRY_UPDATE_RATE = 100
odometryThread = threading.Thread(target=self.odometryPeriodic,
daemon=True)
odometryThread.start()
self.logger = {}
self.waypoints = []
self.waypointRadius = 30
self.selectedWaypoint = None
self.rotatingWaypoint = False
self.lastClickTime = 0
self.DOUBLE_CLICK_TIME = 0.2
self.timerDelay = 50 # milliseconds
self.timer = 0
self.releaseDelay = 0.1
self.inputKeys = {
"Up": KeyLatch(self.releaseDelay),
"Down": KeyLatch(self.releaseDelay),
"Right": KeyLatch(self.releaseDelay),
"Left": KeyLatch(self.releaseDelay)
}
self.autoDriving = False
self.autoDrivingStart = False
self.controls = Controls(self.waypoints, self.robot)
self.CONTROLS_UPDATE_RATE = 100
controlThread = threading.Thread(target=self.controlsPeriodic,
daemon=True)
controlThread.start()
class Game:
def __init__(self, screen):
self.screen = screen
self.assets = Assets()
self.gameplay = GamePlay(self)
self.clock = pygame.time.Clock()
self.controls = Controls()
def run(self):
while True:
self.controls.update()
if self.controls.ctrl_exit:
sys.exit(0)
ticks = self.clock.tick_busy_loop(30)
self.gameplay.update(ticks)
self.screen.fill((0, 0, 0))
self.gameplay.draw()
pygame.display.flip()
def __init__(self):
self.snake = Snake()
self.controls = Controls()
self.textFont = pygame.font.Font(config.FONT, 13)
self.game_over = False
self.textOffset = (3, 3)
self.scoreText = Text(
self.textFont,
"Your Score: {:}".format(self.snake.snake_length - 1),
config.BLACK,
tX=self.textOffset[0],
tY=self.textOffset[0])
self.spawnTime = 50 # In frames
self.foodSmall = Food(
(config.DIS_WIDTH,
config.DIS_HEIGHT - self.scoreText.tH - self.textOffset[1]), 2)
self.foodBig = Food(
(config.DIS_WIDTH,
config.DIS_HEIGHT - self.scoreText.tH - self.textOffset[1]),
3,
self.spawnTime,
0.5,
config.GREEN,
blink_rate=2)
self.foodBig.turn_idle()
self.cursorPos = 0
self.eatSound = pygame.mixer.Sound("sounds/eat.wav")
self.eatBigSound = pygame.mixer.Sound("sounds/eatBig_2.wav")
self.selectSound = pygame.mixer.Sound("sounds/select.wav")
self.nextScene = self
self.screen_shake = 0
self.menuScene = None
self.pauseMenu = Menu(self.textFont, ('P A U S E', config.WHITE),
('Continue', config.WHITE),
('Exit', config.WHITE))
self.gameOverMenu = Menu(self.textFont,
('G A M E O V E R', config.RED),
('Retry', config.WHITE),
('Exit', config.WHITE))
def setUp(self):
config = Mock()
config.drive_kp = 40
config.drive_ki = 1
config.drive_kd = 1
config.heading_error_threshold = 0.2
config.max_forward_speed = 512
config.max_intake_speed = 512
config.max_outtake_speed = 512
self.controls = Controls(config)
self.plan_state = {
'pose': ((0, 0), 0),
'trajectory': None,
'tube_mode': 'NONE',
'direction': 0,
'field_outtake': 0,
'flail': False,
'goal': None,
}
self.vehicle_commands = {}
def __init__(self, title, version):
super().__init__()
self.about_window = AboutWindow(title, version)
self.language_doc_window = LanguageDocWindow(title, version)
self.help_window = HelpWindow(title, version)
self.viewer = Viewer(self) # Rendered commands appear here
self.editor = Editor(self) # Commands are written here
self.controls = Controls(self)
self.move(200, 200)
self.setFixedSize(MainWindow.width, MainWindow.height)
self.setWindowTitle(title)
self.show()
def main():
pygame.init()
pygame.font.init()
screen = pygame.display.set_mode(DISPLAY, FLAGS, DEPTH)
pygame.display.set_caption("Use arrows to move!")
timer = pygame.time.Clock()
up = down = left = right = running = False
bg = Surface((16,16))
bg.convert()
bg.fill(Color("#FFFFFF"))
entities = pygame.sprite.Group()
x = y = 0
start_level = Level(30, 30)
controls = Controls(start_level)
while 1:
timer.tick(60)
for e in pygame.event.get():
if e.type == QUIT: raise SystemExit, "QUIT"
controls.process_event(e)
start_level.update(screen)
pygame.display.update()
class GroundStation():
def __init__(self, ip):
self.sender = Sender(ip)
self.receiver = Receiver() # thread that sends data
self.receiver.start() # thread that receives data
self.overlay = Overlay(self.receiver, self.sender) # overlay thread
self.video = Video() # video thread
self.controls = Controls(self.video) # controls thread
self.controls.start()
self.sender.set_controls(self.controls)
self.overlay.set_controls(self.controls)
self.video.run()
self.sender.start()
self.video.connect('configure_event', self.on_configure_event) # move master -> move dog
self.video.connect('destroy', lambda w: Gtk.main_quit()) # close master -> end program
def on_configure_event(self, *args):
x, y = self.video.get_position()
sx, sy = self.video.get_size()
tx = self.video.get_style().xthickness
self.overlay.move(x+tx, y+30)
self.overlay.resize(sx, sy)
def __init__(self, ip):
self.sender = Sender(ip)
self.receiver = Receiver() # thread that sends data
self.receiver.start() # thread that receives data
self.overlay = Overlay(self.receiver, self.sender) # overlay thread
self.video = Video() # video thread
self.controls = Controls(self.video) # controls thread
self.controls.start()
self.sender.set_controls(self.controls)
self.overlay.set_controls(self.controls)
self.video.run()
self.sender.start()
self.video.connect('configure_event', self.on_configure_event) # move master -> move dog
self.video.connect('destroy', lambda w: Gtk.main_quit()) # close master -> end program
def createObjects(self):
self.intake_motor = ctre.TalonSRX(10)
self.intake_arm_motor = PIDSparkMax(7)
self.shooter_motor = PIDSparkMax(16)
self.shooter_feeder_motor = ctre.TalonSRX(19)
self.drivetrain_motorr1 = CANSparkMax(5, MotorType.kBrushless)
self.drivetrain_motorr2 = CANSparkMax(8, MotorType.kBrushless)
self.drivetrain_motorl1 = CANSparkMax(17, MotorType.kBrushless)
self.drivetrain_motorl2 = CANSparkMax(13, MotorType.kBrushless)
self.joystick_left = wpilib.Joystick(0)
self.joystick_right = wpilib.Joystick(1)
self.controls = Controls(self.joystick_left, self.joystick_right)
def __init__(self, window=None, objects=(), controllers=()):
#Create a font for score
self.font = font.load('Arial', 18)
#pyglet.font.Text object to display the score
self.score = font.Text(self.font, x = 10, y=10, color=(1, 1, 1, 1))
self.control = Controls(window)
self.bind_objects(*objects)
self.bind_controllers(*controllers)
self.score_right = 0
self.score_left = 0
self.draw_score()
self.height = window.width
self.width = window.height
#should this not be handled within the object?
#map effects to different objects in the game
effects_map = { "fire": None}
def __init__(self, verbose=False, path=path):
self.levels = {}
self.home = os.environ['HOME']
self.path = path if path else os.environ['PWD']
self.game = pygame.init()
self.game_exit = False
self.current_level = "0-0"
self.levels_loaded = False
self.main_character_loaded = False
self.clock = pygame.time.Clock()
self.verbose = verbose
self.width = 0
self.height = 0
self.scalar = 70
self.screen = None
self.controls = Controls(path=path)
self.game_locations = {}
def __init__(self, qubic, controller, *args, **kwargs):
super().__init__(*args, **kwargs)
taille = len(qubic)
self.qubic = qubic
qubic.add_observers(self)
self.settings = _VueQubicSettings()
target = (taille / 2 - .5, 0, taille / 2 - .5)
self.qamera = self.settings.qamera_type(target)
self.components.append(self.qamera)
self.board = _Board(qubic, controller)
self.components.append(self.board)
controls_type = Controls.get_controls(self.settings.control_method)
self.controls = controls_type(qubic, self, controller)
self.components.append(self.controls)
self.pions = [[[None for _ in range(taille)] for _ in range(taille)]
for _ in range(taille)]
self.components.append(Lights())
def main():
app = QtWidgets.QApplication(sys.argv)
main_view = MainView(app)
controls = Controls()
main_view.subscribe_controls(controls)
metrics_engine = MetricsEngine()
metrics_engine.subscribe_view(main_view)
metrics_engine.load_metrics()
controls.subscribe_view(main_view)
image_handler = ImageHandler()
image_handler.subscribe_view(main_view)
modifications_provider = ModificationsProvider()
modifications_provider.subscribe_image_handler(image_handler)
controls.subscribe_image_handler(image_handler)
controls.subscribe_modifications_provider(modifications_provider)
image_handler.subscribe_metrics_engine(metrics_engine)
main_view.show()
sys.exit(app.exec_())
def __init__(self, screen: Surface, map_: str, heroes: int, monsters: int,
items: int):
""" Создаёт игру
:param heroes: колличество героев в игре. Если players_count=0, то создаст читера.
"""
self.start_time = datetime.now()
self.screen = screen
# map
self.map: Map = self._init_map(map_) # карта
self.maps: Group = Group(self.map)
# sprites
self.characters: Group = Group() # спрайты с героями и монстрами
self.heroes: Group = self._init_heroes(heroes) # спрайты с героями
self.monsters: Group = self._init_monsters(
monsters) # спрайты с монстрами
self.items: Group = self._init_items(items) # спрайты с вещами
self._start_turn()
self.dashboard = Dashboard(self) # приборная панель
self.backpack: Backpack = Backpack(self) # рюкзак
self.controls: Controls = Controls(self) # help
self.monsters_killed = 0
def test_controls(self):
'''Fake some key ups and key downs then check that changes control booleans'''
self.screen = pygame.display.set_mode((50, 50), pygame.RESIZABLE)
test_controls = Controls(verbose=False)
test_controls.path = test_controls.path.replace(
'static', 'test/static')
events = [pygame.event.Event(pygame.KEYDOWN, key=control, mod=4096)
for control in test_controls.control_lookup]
test_controls.get_events(events, self.screen, 50, 50)
for key in test_controls.buttons:
self.assertTrue(test_controls.buttons[key])
events = [pygame.event.Event(pygame.KEYUP, key=control, mod=4096)
for control in test_controls.control_lookup]
test_controls.get_events(events, self.screen, 50, 50)
for key in test_controls.buttons:
self.assertFalse(test_controls.buttons[key])
def __init__(self, resolution = Dimensions(1001, 601), calcThread=None):
# Declare constants
# General
self.fpsLimit = 60
self.simRunning = False
self.calcThread = calcThread
# Section sizes
self.control_width = 200
# Key presses
self.L_SHIFT = 1
self.R_SHIFT = 2
self.L_CTRL = 64
self.R_CTRL = 128
self.L_ALT = 256
self.R_ALT = 512
# Declare variables
self.populationLimit = 3
self.populationMin = 2
self.generation = 0
# Initialize pygame window
pygame.init()
self.window = pygame.display.set_mode(resolution, pygame.RESIZABLE)
pygame.display.set_caption("Conway's Game of Life")
# Create clock to limit FPS
self.fpsClock = pygame.time.Clock()
# Enable key hold repeating and set limits
pygame.key.set_repeat(500,75)
# Create the initial grid
self.grid = Grid(Dimensions(self.window.get_rect().width - self.control_width, self.window.get_rect().height), Position(0, 0))
# Create control section
self.controls = Controls(Dimensions(self.control_width, self.window.get_rect().height),
Position(self.grid.rect.width, 0), self)
def test_controls(self):
'''Fake some key ups and key downs then check that changes control booleans'''
self.screen = pygame.display.set_mode((50, 50), pygame.RESIZABLE)
test_controls = Controls(verbose=False)
test_controls.path = test_controls.path.replace(
'static', 'test/static')
events = [
pygame.event.Event(pygame.KEYDOWN, key=control, mod=4096)
for control in test_controls.control_lookup
]
test_controls.get_events(events, self.screen, 50, 50)
for key in test_controls.buttons:
self.assertTrue(test_controls.buttons[key])
events = [
pygame.event.Event(pygame.KEYUP, key=control, mod=4096)
for control in test_controls.control_lookup
]
test_controls.get_events(events, self.screen, 50, 50)
for key in test_controls.buttons:
self.assertFalse(test_controls.buttons[key])
class MainWindow(Gtk.Window):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.connect("delete-event", Gtk.main_quit)
root_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.board = Board()
self.controls = Controls()
self.console = Gtk.Label("Input angle, initial velocity and fire!")
self.controls.reset_btn.connect("clicked", self.__on_reset_clicked)
self.controls.fire_btn.connect("clicked", self.__on_fire_clicked)
root_box.pack_start(self.board, False, False, 0)
root_box.pack_end(self.controls, False, False, 10)
root_box.pack_end(self.console, False, False, 10)
self.add(root_box)
def __on_reset_clicked(self, button):
self.board.reset()
self.controls.angle_control.set_text('')
self.controls.velocity_control.set_text('')
self.console.set_text("Input angle, initial velocity and fire!")
def __on_fire_clicked(self, button):
try:
angle, velocity = self.controls.get_angle_and_velocity()
if not 0 <= angle <= 90:
raise ValueError("angle must be between 0 and 90")
hit = self.board.fire(angle, velocity)
msg = "HIT!" if hit else "Missed"
self.console.set_text(msg)
except ValueError as e:
self.console.set_text("Wrong values: %s" % e)
class Interface():
# Constructor
def __init__(self, resolution = Dimensions(1001, 601), calcThread=None):
# Declare constants
# General
self.fpsLimit = 60
self.simRunning = False
self.calcThread = calcThread
# Section sizes
self.control_width = 200
# Key presses
self.L_SHIFT = 1
self.R_SHIFT = 2
self.L_CTRL = 64
self.R_CTRL = 128
self.L_ALT = 256
self.R_ALT = 512
# Declare variables
self.populationLimit = 3
self.populationMin = 2
self.generation = 0
# Initialize pygame window
pygame.init()
self.window = pygame.display.set_mode(resolution, pygame.RESIZABLE)
pygame.display.set_caption("Conway's Game of Life")
# Create clock to limit FPS
self.fpsClock = pygame.time.Clock()
# Enable key hold repeating and set limits
pygame.key.set_repeat(500,75)
# Create the initial grid
self.grid = Grid(Dimensions(self.window.get_rect().width - self.control_width, self.window.get_rect().height), Position(0, 0))
# Create control section
self.controls = Controls(Dimensions(self.control_width, self.window.get_rect().height),
Position(self.grid.rect.width, 0), self)
def setCalcThread(self,calcThread):
self.calcThread = calcThread
self.controls.updateSpeedDisplay(self.calcThread.speed)
def update(self):
# Process any mouse/keyboard events
if not self.processEvents():
return False
# Draw objects
self.draw()
# Update window
pygame.display.update()
# Limit FPS
self.fpsClock.tick(self.fpsLimit)
return True
def processEvents(self):
click_pos=(-1,-1)
# Get pygame events to see if/what key is pressed
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
return False
elif event.type == MOUSEBUTTONDOWN:
if event.button == 1:
self.controls.collidepoint(pygame.mouse.get_pos())
self.grid.collidepoint(pygame.mouse.get_pos())
elif event.type == KEYDOWN:
mods = pygame.key.get_mods()# Get modifier keys
if event.key == K_LEFT:
if mods == self.L_SHIFT:
self.popLimitDown()
elif mods == self.L_CTRL:
self.popMinDown()
else:
self.speedDown()
elif event.key == K_RIGHT:
if mods == self.L_SHIFT:
self.popLimitUp()
elif mods == self.L_CTRL:
self.popMinUp()
else:
self.speedUp()
elif event.key == K_SPACE:
self.pause()
elif event.key == K_RETURN:
self.stepForward()
else:
pass
elif event.type == VIDEORESIZE:
self.resize(event.dict['size'])
else:
pass
return True
def draw(self):
# Set background as white
self.window.fill(pygame.Color("white"))
# Draw grid
self.grid.draw(self.window)
# Draw control interface
self.controls.draw(self.window)
def resize(self, size):
# Resize window
self.window = pygame.display.set_mode(size, pygame.RESIZABLE)
# Resize grid
if (self.window.get_rect().width < self.control_width):
# Grid size is less than zero, so set it to 2x2 pixels instead
# (which should create a single cell).
# It will get covered by the controls, anyway.
# If grid is 0x0 and the calcThread starts, it will crash
self.grid.resize(Dimensions(2, 2), Position(0, 0))
else:
self.grid.resize(Dimensions(self.window.get_rect().width - self.control_width, self.window.get_rect().height), Position(0, 0))
# Resize controls
self.controls.resize(Dimensions(self.control_width, self.window.get_rect().height), Position(self.grid.rect.width, 0))
def reset(self):
self.__init__(Dimensions(self.window.get_rect().width, self.window.get_rect().height), self.calcThread)
self.calcThread.__init__(self)
def pause(self):
self.simRunning = not(self.simRunning)
self.controls.updateStatusDisplay(self.simRunning)
def speedUp(self):
self.calcThread.speed += 1
self.controls.updateSpeedDisplay(self.calcThread.speed)
def speedDown(self):
if (self.calcThread.speed > 1):
self.calcThread.speed -= 1
self.controls.updateSpeedDisplay(self.calcThread.speed)
def popLimitUp(self):
if self.populationLimit < 8:
self.populationLimit += 1
self.controls.updatePopLimitDisplay(self.populationLimit)
def popLimitDown(self):
if self.populationLimit > 1:
self.populationLimit -= 1
self.controls.updatePopLimitDisplay(self.populationLimit)
def popMinUp(self):
if self.populationMin < 8:
self.populationMin += 1
self.controls.updatePopMinDisplay(self.populationMin)
def popMinDown(self):
if self.populationMin > 1:
self.populationMin -= 1
self.controls.updatePopMinDisplay(self.populationMin)
def stepForward(self):
if self.simRunning:
self.pause()
self.calcThread.calc()
def on_update(self, delta_time: float):
"""
Update the positions and statuses of all game objects
If paused, do nothing
:param delta_time: Time since the last update
"""
if not self.game_over or not self.paused:
self.physics_engine.step()
# handle background music
self.play_music()
if self.screen_wipe_rect: # when the game is transitioning to a new level/restarting a level
self.screen_wipe_rect.center_x += self.screen_wipe_rect.change_x
self.screen_wipe_rect.center_y = self.view_bottom + (SCREEN_HEIGHT / 2)
# handle loading level here, after screen is covered in blue wipe
if (self.screen_wipe_rect.center_x > SCREEN_WIDTH) and (self.update_level):
self.load_level(self.level)
self.update_level = False # lower flag when level begins to load
if self.screen_wipe_rect.center_x > SCREEN_WIDTH * 2:
self.screen_wipe_rect = None
# Update everything
self.player_list.update()
self.all_sprites.update()
self.enemies_list.update()
self.moving_platforms_list.update()
self.cannons_list.update()
Controls.handle_control_actions(self)
if self.player.in_water:
Controls.handle_water_physics(self)
self.process_damage()
self.track_moving_sprites(delta_time)
self.cannon_toggle()
self.in_water_physics()
if ar.check_for_collision_with_list(self.player, self.keys_list) and not self.update_level:
current_key = ar.check_for_collision_with_list(self.player, self.keys_list)[0]
if self.key_colors[current_key] == WHITE:
# this if statement is redundant so that we don't immediately enter the else statement below
if self.hidden_platform_list:
self.orb_off_sound.play(volume=0.2)
for platform in self.hidden_platform_list:
self.physics_engine.remove_sprite(platform)
self.hidden_platform_list = None
self.player.color = WHITE
else:
if not self.hidden_platform_list:
self.orb_touched_sound.play(volume=0.2)
self.load_layer("Hidden Platforms", self.key_colors[current_key])
self.player.color = self.key_colors[current_key]
# if player gets to the right edge of the level, go to next level
if self.player.right >= self.end_of_map:
self.update_level = True # raise this flag to properly restart level
self.level += 1 # switch to next level
self.screen_wipe_rect = Transition()
self.screen_wipe_rect.setup()
self.player_teleported = True
self.physics_engine.set_horizontal_velocity(self.player, 0)
self.physics_engine.set_position(self.player, self.player.spawnpoint)
# if the player hits the bottom of the level, player dies and respawns at the start of the level
if self.player.bottom <= 0:
self.update_level = True # raise this flag to properly restart level
self.screen_wipe_rect = Transition()
self.screen_wipe_rect.setup()
self.player_teleported = True
self.physics_engine.set_horizontal_velocity(self.player, 0)
self.physics_engine.set_position(self.player, self.player.spawnpoint)
if self.physics_engine.is_on_ground(self.player) and self.player.jumping:
self.player.jumping = False
# track if we need to change the view port
changed = False
# Scroll left
left_bndry = self.view_left + VIEWPORT_LEFT_MARGIN
if self.player.left < left_bndry and self.player.left > VIEWPORT_LEFT_MARGIN:
self.view_left -= left_bndry - self.player.left
changed = True
# Scroll right
right_bndry = self.view_left + SCREEN_WIDTH - VIEWPORT_RIGHT_MARGIN
if self.player.right > right_bndry and (self.player.right < (self.end_of_map - VIEWPORT_RIGHT_MARGIN)):
self.view_left += self.player.right - right_bndry
changed = True
# Scroll up
top_bndry = self.view_bottom + SCREEN_HEIGHT - VIEWPORT_MARGIN_TOP
if self.player.top > top_bndry and (self.player.top < (self.top_of_map - VIEWPORT_MARGIN_TOP)):
self.view_bottom += self.player.top - top_bndry
changed = True
# Scroll down
bottom_bndry = self.view_bottom + VIEWPORT_MARGIN_BOTTOM
if self.player.bottom < bottom_bndry and self.player.bottom > VIEWPORT_MARGIN_BOTTOM:
self.view_bottom -= bottom_bndry - self.player.bottom
changed = True
# If we need to scroll, go ahead and do it.
# also change viewport when player has teleported (when switching levels, respawning, etc)
if changed:
self.view_left = int(self.view_left)
self.view_bottom = int(self.view_bottom)
ar.set_viewport(self.view_left,
SCREEN_WIDTH + self.view_left,
self.view_bottom,
SCREEN_HEIGHT + self.view_bottom)
if self.player_teleported and self.screen_wipe_rect.center_x > SCREEN_WIDTH:
self.view_left = 0
self.view_bottom = 0
ar.set_viewport(self.view_left,
SCREEN_WIDTH + self.view_left,
self.view_bottom,
SCREEN_HEIGHT + self.view_bottom)
self.player_teleported = False
import time
import argparse
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description="Scan some film")
parser.add_argument('-f', '--format', help="the output format. (jpg, tif, png)", required="true",
type=str)
parser.add_argument('-o', '--output', help="Path of Output Directory.", required="true")
args = vars(parser.parse_args())
format = args['format']
output = args['output']
controls = Controls()
controls.microstep('sixteenth')
controls.motor_setup()
controls.backlight_on()
capture = FrameCapture(output, format, low_res=(270, 512), hi_res=(1080, 2048))
detector = PerfDetector(gauge='16mm')
while True:
for step in range(0, 50):
time.sleep(0.004)
controls.motor_forward()
frame = capture.capture_low_res()
if detector.detect_perfs(frame) is True:
capture.capture_hi_res_async()
capture.clear_buffer()
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.player = None
self._alert = None
self._playlist_jobject = None
self.set_title(_('Jukebox Activity'))
self.max_participants = 1
self._toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
activity_toolbar = activity_button.page
self._toolbar_box.toolbar.insert(activity_button, 0)
self.title_entry = activity_toolbar.title
self._view_toolbar = ViewToolbar()
self._view_toolbar.connect('go-fullscreen',
self.__go_fullscreen_cb)
self._view_toolbar.connect('toggle-playlist',
self.__toggle_playlist_cb)
view_toolbar_button = ToolbarButton(
page=self._view_toolbar,
icon_name='toolbar-view')
self._view_toolbar.show()
self._toolbar_box.toolbar.insert(view_toolbar_button, -1)
view_toolbar_button.show()
self._control_toolbar = Gtk.Toolbar()
self._control_toolbar_button = ToolbarButton(
page=self._control_toolbar,
icon_name='media-playback-start')
self._control_toolbar.show()
self._toolbar_box.toolbar.insert(self._control_toolbar_button, -1)
self._control_toolbar_button.hide()
self.set_toolbar_box(self._toolbar_box)
self._toolbar_box.show_all()
self.connect('key_press_event', self.__key_press_event_cb)
self.connect('playlist-finished', self.__playlist_finished_cb)
# We want to be notified when the activity gets the focus or
# loses it. When it is not active, we don't need to keep
# reproducing the video
self.connect('notify::active', self.__notify_active_cb)
self._video_canvas = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
self._playlist_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.playlist_widget = PlayList()
self.playlist_widget.connect('play-index', self.__play_index_cb)
self.playlist_widget.connect('missing-tracks',
self.__missing_tracks_cb)
self.playlist_widget.set_size_request(
Gdk.Screen.width() * PLAYLIST_WIDTH_PROP, 0)
self.playlist_widget.show()
self._playlist_box.pack_start(self.playlist_widget, expand=True,
fill=True, padding=0)
self._playlist_toolbar = Gtk.Toolbar()
move_up = ToolButton("go-up")
move_up.set_tooltip(_("Move up"))
move_up.connect("clicked", self._move_up_cb)
self._playlist_toolbar.insert(move_up, 0)
move_down = ToolButton("go-down")
move_down.set_tooltip(_("Move down"))
move_down.connect("clicked", self._move_down_cb)
self._playlist_toolbar.insert(move_down, 1)
self._playlist_box.pack_end(self._playlist_toolbar, False, False, 0)
self._video_canvas.pack_start(self._playlist_box, False, False, 0)
# Create the player just once
logging.debug('Instantiating GstPlayer')
self.player = GstPlayer()
self.player.connect('eos', self.__player_eos_cb)
self.player.connect('error', self.__player_error_cb)
self.player.connect('play', self.__player_play_cb)
self.control = Controls(self, self._toolbar_box.toolbar,
self._control_toolbar)
self._separator = Gtk.SeparatorToolItem()
self._separator.props.draw = False
self._separator.set_expand(True)
self._separator.show()
self._toolbar_box.toolbar.insert(self._separator, -1)
self._stop = StopButton(self)
self._toolbar_box.toolbar.insert(self._stop, -1)
self._empty_widget = Gtk.Label(label="")
self._empty_widget.show()
self.videowidget = VideoWidget()
self.set_canvas(self._video_canvas)
self._init_view_area()
self.show_all()
# need hide the playlist by default
self._playlist_box.hide()
self._configure_cb()
self.player.init_view_area(self.videowidget)
self._volume_monitor = Gio.VolumeMonitor.get()
self._volume_monitor.connect('mount-added', self.__mount_added_cb)
self._volume_monitor.connect('mount-removed', self.__mount_removed_cb)
if handle.object_id is None:
# The activity was launched from scratch. We need to show
# the Empty Widget
self.playlist_widget.hide()
emptypanel.show(self, 'activity-jukebox',
_('No media'), _('Choose media files'),
self.control.show_picker_cb)
self.control.check_if_next_prev()
Gdk.Screen.get_default().connect('size-changed', self._configure_cb)
class JukeboxActivity(activity.Activity):
__gsignals__ = {
'playlist-finished': (GObject.SignalFlags.RUN_FIRST, None, []), }
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.player = None
self._alert = None
self._playlist_jobject = None
self.set_title(_('Jukebox Activity'))
self.max_participants = 1
self._toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
activity_toolbar = activity_button.page
self._toolbar_box.toolbar.insert(activity_button, 0)
self.title_entry = activity_toolbar.title
self._view_toolbar = ViewToolbar()
self._view_toolbar.connect('go-fullscreen',
self.__go_fullscreen_cb)
self._view_toolbar.connect('toggle-playlist',
self.__toggle_playlist_cb)
view_toolbar_button = ToolbarButton(
page=self._view_toolbar,
icon_name='toolbar-view')
self._view_toolbar.show()
self._toolbar_box.toolbar.insert(view_toolbar_button, -1)
view_toolbar_button.show()
self._control_toolbar = Gtk.Toolbar()
self._control_toolbar_button = ToolbarButton(
page=self._control_toolbar,
icon_name='media-playback-start')
self._control_toolbar.show()
self._toolbar_box.toolbar.insert(self._control_toolbar_button, -1)
self._control_toolbar_button.hide()
self.set_toolbar_box(self._toolbar_box)
self._toolbar_box.show_all()
self.connect('key_press_event', self.__key_press_event_cb)
self.connect('playlist-finished', self.__playlist_finished_cb)
# We want to be notified when the activity gets the focus or
# loses it. When it is not active, we don't need to keep
# reproducing the video
self.connect('notify::active', self.__notify_active_cb)
self._video_canvas = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
self._playlist_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.playlist_widget = PlayList()
self.playlist_widget.connect('play-index', self.__play_index_cb)
self.playlist_widget.connect('missing-tracks',
self.__missing_tracks_cb)
self.playlist_widget.set_size_request(
Gdk.Screen.width() * PLAYLIST_WIDTH_PROP, 0)
self.playlist_widget.show()
self._playlist_box.pack_start(self.playlist_widget, expand=True,
fill=True, padding=0)
self._playlist_toolbar = Gtk.Toolbar()
move_up = ToolButton("go-up")
move_up.set_tooltip(_("Move up"))
move_up.connect("clicked", self._move_up_cb)
self._playlist_toolbar.insert(move_up, 0)
move_down = ToolButton("go-down")
move_down.set_tooltip(_("Move down"))
move_down.connect("clicked", self._move_down_cb)
self._playlist_toolbar.insert(move_down, 1)
self._playlist_box.pack_end(self._playlist_toolbar, False, False, 0)
self._video_canvas.pack_start(self._playlist_box, False, False, 0)
# Create the player just once
logging.debug('Instantiating GstPlayer')
self.player = GstPlayer()
self.player.connect('eos', self.__player_eos_cb)
self.player.connect('error', self.__player_error_cb)
self.player.connect('play', self.__player_play_cb)
self.control = Controls(self, self._toolbar_box.toolbar,
self._control_toolbar)
self._separator = Gtk.SeparatorToolItem()
self._separator.props.draw = False
self._separator.set_expand(True)
self._separator.show()
self._toolbar_box.toolbar.insert(self._separator, -1)
self._stop = StopButton(self)
self._toolbar_box.toolbar.insert(self._stop, -1)
self._empty_widget = Gtk.Label(label="")
self._empty_widget.show()
self.videowidget = VideoWidget()
self.set_canvas(self._video_canvas)
self._init_view_area()
self.show_all()
# need hide the playlist by default
self._playlist_box.hide()
self._configure_cb()
self.player.init_view_area(self.videowidget)
self._volume_monitor = Gio.VolumeMonitor.get()
self._volume_monitor.connect('mount-added', self.__mount_added_cb)
self._volume_monitor.connect('mount-removed', self.__mount_removed_cb)
if handle.object_id is None:
# The activity was launched from scratch. We need to show
# the Empty Widget
self.playlist_widget.hide()
emptypanel.show(self, 'activity-jukebox',
_('No media'), _('Choose media files'),
self.control.show_picker_cb)
self.control.check_if_next_prev()
Gdk.Screen.get_default().connect('size-changed', self._configure_cb)
def _move_up_cb(self, button):
self.playlist_widget.move_up()
def _move_down_cb(self, button):
self.playlist_widget.move_down()
def _configure_cb(self, event=None):
self._toolbar_box.toolbar.remove(self._stop)
self._toolbar_box.toolbar.remove(self._separator)
if Gdk.Screen.width() < Gdk.Screen.height():
self._control_toolbar_button.show()
self._control_toolbar_button.set_expanded(True)
self.control.update_layout(landscape=False)
self._toolbar_box.toolbar.insert(self._separator, -1)
else:
self._control_toolbar_button.set_expanded(False)
self._control_toolbar_button.hide()
self.control.update_layout(landscape=True)
self._toolbar_box.toolbar.insert(self._stop, -1)
def __notify_active_cb(self, widget, event):
"""Sugar notify us that the activity is becoming active or inactive.
When we are inactive, we stop the player if it is reproducing
a video.
"""
logging.debug('JukeboxActivity notify::active signal received')
if self.player.player.props.current_uri is not None and \
self.player.playing_video():
if not self.player.is_playing() and self.props.active:
self.player.play()
if self.player.is_playing() and not self.props.active:
self.player.pause()
def _init_view_area(self):
"""
Use a notebook with two pages, one empty an another
with the videowidget
"""
self.view_area = Gtk.Notebook()
self.view_area.set_show_tabs(False)
self.view_area.append_page(self._empty_widget, None)
self.view_area.append_page(self.videowidget, None)
self._video_canvas.pack_end(self.view_area, expand=True,
fill=True, padding=0)
def _switch_canvas(self, show_video):
"""Show or hide the video visualization in the canvas.
When hidden, the canvas is filled with an empty widget to
ensure redrawing.
"""
if show_video:
self.view_area.set_current_page(1)
else:
self.view_area.set_current_page(0)
self._video_canvas.queue_draw()
def __key_press_event_cb(self, widget, event):
keyname = Gdk.keyval_name(event.keyval)
logging.info("Keyname Press: %s, time: %s", keyname, event.time)
if self.title_entry.has_focus():
return False
if keyname == "space":
self.control._button_clicked_cb(None)
return True
def __playlist_finished_cb(self, widget):
self._switch_canvas(show_video=False)
self._view_toolbar._show_playlist.set_active(True)
self.unfullscreen()
# Select the first stream to be played when Play button will
# be pressed
self.playlist_widget.set_current_playing(0)
self.control.check_if_next_prev()
def songchange(self, direction):
current_playing = self.playlist_widget.get_current_playing()
if direction == 'prev' and current_playing > 0:
self.play_index(current_playing - 1)
elif direction == 'next' and \
current_playing < len(self.playlist_widget._items) - 1:
self.play_index(current_playing + 1)
else:
self.emit('playlist-finished')
def play_index(self, index):
# README: this line is no more necessary because of the
# .playing_video() method
# self._switch_canvas(show_video=True)
self.playlist_widget.set_current_playing(index)
path = self.playlist_widget._items[index]['path']
if self.playlist_widget.check_available_media(path):
if self.playlist_widget.is_from_journal(path):
path = self.playlist_widget.get_path_from_journal(path)
self.control.check_if_next_prev()
self.player.set_uri(path)
self.player.play()
else:
self.songchange('next')
def __play_index_cb(self, widget, index, path):
# README: this line is no more necessary because of the
# .playing_video() method
# self._switch_canvas(show_video=True)
self.playlist_widget.set_current_playing(index)
if self.playlist_widget.is_from_journal(path):
path = self.playlist_widget.get_path_from_journal(path)
self.control.check_if_next_prev()
self.player.set_uri(path)
self.player.play()
def __player_eos_cb(self, widget):
self.songchange('next')
def _show_error_alert(self, title, msg=None):
self._alert = ErrorAlert()
self._alert.props.title = title
if msg is not None:
self._alert.props.msg = msg
self.add_alert(self._alert)
self._alert.connect('response', self._alert_cancel_cb)
self._alert.show()
def __mount_added_cb(self, volume_monitor, device):
logging.debug('Mountpoint added. Checking...')
self.remove_alert(self._alert)
self.playlist_widget.update()
def __mount_removed_cb(self, volume_monitor, device):
logging.debug('Mountpoint removed. Checking...')
self.remove_alert(self._alert)
self.playlist_widget.update()
def __missing_tracks_cb(self, widget, tracks):
self._show_missing_tracks_alert(tracks)
def _show_missing_tracks_alert(self, tracks):
self._alert = Alert()
title = _('%s tracks not found.') % len(tracks)
self._alert.props.title = title
icon = Icon(icon_name='dialog-cancel')
self._alert.add_button(Gtk.ResponseType.CANCEL, _('Dismiss'), icon)
icon.show()
icon = Icon(icon_name='dialog-ok')
self._alert.add_button(Gtk.ResponseType.APPLY, _('Details'), icon)
icon.show()
self.add_alert(self._alert)
self._alert.connect(
'response', self.__missing_tracks_alert_response_cb, tracks)
def __missing_tracks_alert_response_cb(self, alert, response_id, tracks):
if response_id == Gtk.ResponseType.APPLY:
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
vbox.props.valign = Gtk.Align.CENTER
label = Gtk.Label(label='')
label.set_markup(_('<b>Missing tracks</b>'))
vbox.pack_start(label, False, False, 15)
for track in tracks:
label = Gtk.Label(label=track['path'])
vbox.add(label)
_missing_tracks = Gtk.ScrolledWindow()
_missing_tracks.add_with_viewport(vbox)
_missing_tracks.show_all()
self.view_area.append_page(_missing_tracks, None)
self.view_area.set_current_page(2)
self.remove_alert(alert)
def _alert_cancel_cb(self, alert, response_id):
self.remove_alert(alert)
def __player_play_cb(self, widget):
# Do not show the visualization widget if we are playing just
# an audio stream
def callback():
if self.player.playing_video():
self._switch_canvas(True)
else:
self._switch_canvas(False)
return False
# HACK: we need a timeout here because gstreamer returns
# n-video = 0 if we call it immediately
GObject.timeout_add(1000, callback)
def __player_error_cb(self, widget, message, detail):
self.player.stop()
self.control.set_disabled()
logging.error('ERROR MESSAGE: %s', message)
logging.error('ERROR DETAIL: %s', detail)
file_path = self.playlist_widget._items[
self.playlist_widget.get_current_playing()]['path']
mimetype = mime.get_for_file(file_path)
title = _('Error')
msg = _('This "%s" file can\'t be played') % mimetype
self._switch_canvas(False)
self._show_error_alert(title, msg)
def can_close(self):
# We need to put the Gst.State in NULL so gstreamer can
# cleanup the pipeline
self.player.stop()
return True
def read_file(self, file_path):
"""Load a file from the datastore on activity start."""
logging.debug('JukeBoxAtivity.read_file: %s', file_path)
title = self.metadata['title']
self.playlist_widget.load_file(file_path, title)
self._view_toolbar._show_playlist.set_active(True)
def write_file(self, file_path):
def write_playlist_to_file(file_path):
"""Open the file at file_path and write the playlist.
It is saved in audio/x-mpegurl format.
"""
list_file = open(file_path, 'w')
for uri in self.playlist_widget._items:
list_file.write('#EXTINF:%s\n' % uri['title'])
list_file.write('%s\n' % uri['path'])
list_file.close()
if not self.metadata['mime_type']:
self.metadata['mime_type'] = 'audio/x-mpegurl'
if self.metadata['mime_type'] == 'audio/x-mpegurl':
write_playlist_to_file(file_path)
else:
if self._playlist_jobject is None:
self._playlist_jobject = \
self.playlist_widget.create_playlist_jobject()
# Add the playlist to the playlist jobject description.
# This is only done if the activity was not started from a
# playlist or from scratch:
description = ''
for uri in self.playlist_widget._items:
description += '%s\n' % uri['title']
self._playlist_jobject.metadata['description'] = description
write_playlist_to_file(self._playlist_jobject.file_path)
datastore.write(self._playlist_jobject)
def __go_fullscreen_cb(self, toolbar):
self.fullscreen()
def __toggle_playlist_cb(self, toolbar):
if self._view_toolbar._show_playlist.get_active():
self._playlist_box.show_all()
else:
self._playlist_box.hide()
self._video_canvas.queue_draw()
def __init__(self, parent, title):
wx.Frame.__init__(self, parent, title=title)
# Splitters and Panels
self.controls_map_splitter = wx.SplitterWindow(self)
self.controls_map_splitter.SetMinimumPaneSize(300)
controls_panel = wx.Panel(self.controls_map_splitter)
map_panel = wx.Panel(self.controls_map_splitter)
self.graphs_messages_splitter = wx.SplitterWindow(controls_panel)
self.graphs_messages_splitter.SetMinimumPaneSize(50)
graphs_panel = wx.Panel(self.graphs_messages_splitter)
messages_panel = wx.Panel(self.graphs_messages_splitter)
# World graphic
self._graphics = worldmap.WorldMap(map_panel)
self.graphics_sizer = wx.BoxSizer(wx.VERTICAL)
self.graphics_sizer.Add(self._graphics, 1, wx.EXPAND)
map_panel.SetSizerAndFit(self.graphics_sizer)
# Controls panel
self.controls = Controls(controls_panel, (300, 250), self)
# Info panel
self.info = Info(controls_panel, (300, 250))
# Graph canvas
self.graphs = graphs.Graphs(graphs_panel, (300, 300))
# Messages panel
self.messages = Messages(messages_panel, (600, 200))
self.interface_sizer = wx.BoxSizer(wx.VERTICAL)
self.controls_info_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.controls_info_sizer.Add(self.info, 0, wx.EXPAND)
self.controls_info_sizer.Add((20, -1), proportion=0) # Padding
self.controls_info_sizer.Add(self.controls, 1, wx.EXPAND)
self.messages_sizer = wx.BoxSizer(wx.VERTICAL)
self.messages_sizer.Add(self.messages, 1, wx.EXPAND)
messages_panel.SetSizerAndFit(self.messages_sizer)
self.graphs_sizer = wx.BoxSizer(wx.VERTICAL)
self.graphs_sizer.Add(self.graphs, 1, wx.EXPAND)
graphs_panel.SetSizerAndFit(self.graphs_sizer)
self.interface_sizer.Add(self.controls_info_sizer, 0, wx.EXPAND)
self.interface_sizer.Add(self.graphs_messages_splitter, 1, wx.EXPAND)
controls_panel.SetSizerAndFit(self.interface_sizer)
self.graphs_messages_splitter.SplitHorizontally(
messages_panel,
graphs_panel
)
self.controls_map_splitter.SplitVertically(controls_panel, map_panel)
# Set up event handler for any worker thread results
EVT_RESULT(self, self.OnResult)
EVT_STOP(self, self.OnStop)
# Set up close event so timer is properly stopped
wx.EVT_CLOSE(self, self.OnClose)
self.reset_gui()
self.Show()
if(not os.path.exists("maps/%d-%d-%d.png" % (zoom,i,j))):
page = urllib2.urlopen("http://a.tile.openstreetmap.org/%d/%d/%d.png" % (zoom,i,j))
file = open("maps/%d-%d-%d.png" % (zoom,i,j),"wb")
data = page.read()
file.write(data)
file.flush()
file.close()
images.append(ImageTk.PhotoImage(file="maps/%d-%d-%d.png" % (zoom,i,j)))
canvas.create_image((i - tile_ref[0] + r + 1) * 256,(j - tile_ref[1] + r + 1) * 256,image=images[-1])
print (float(i - tile_ref[0] + r) / ((r *2) +1 ) * 100)
helicopter = HelicopterSprite(canvas,"images/helicopter/red/helicopter",(r*256)+256+250,(r*256)+256+250,0,60)
controls = Controls(top)
event = controls.get_event()
canvas.xview_moveto(0.5)
canvas.yview_moveto(0.5)
prev_time = time.time()
while(play):
event = controls.get_event()
while(event != None):
helicopter.process_event(event)
if(event == 9):
play = False
class Game(object):
def __init__(self, verbose=False, path=path):
self.levels = {}
self.home = os.environ['HOME']
self.path = path if path else os.environ['PWD']
self.game = pygame.init()
self.game_exit = False
self.current_level = "0-0"
self.levels_loaded = False
self.main_character_loaded = False
self.clock = pygame.time.Clock()
self.verbose = verbose
self.width = 0
self.height = 0
self.scalar = 70
self.screen = None
self.controls = Controls(path=path)
self.game_locations = {}
def load_levels(self):
print self.path
for path, directory, levels in os.walk(self.path + "/assets/levels/"):
for level in levels:
match = re.match("(.*)\.lvl", level)
if match:
level_name = match.group(1)
file_name = path + match.group(0)
with open(file_name, "r") as level_content:
self.levels[level_name] = Level(level_name, level_content.read(
), clock=self.clock, scalar=self.scalar, verbose=self.verbose)
self.width = self.levels[level_name].block_width * self.scalar if self.levels[
level_name].block_width * self.scalar > self.width else self.width
self.height = self.levels[level_name].block_height * self.scalar if self.levels[
level_name].block_height * self.scalar > self.height else self.height
self.levels_loaded = True
def log(self, message):
pprint(message) if self.verbose else None
def load_characters(self):
self.main_character = Character(
"dave", screen=self.screen, scalar=self.scalar, clock=self.clock)
self.main_character_loaded = True
def valid_level(self, level):
return True if self.levels.get(level, False) else False
def go_direction(self, vector, direction, limit1, limit2, oldlimit1, oldlimit2):
vectors = self.current_level.split('-')
vectors[vector] = str(int(vectors[vector]) + direction)
new_level = vectors[0] + '-' + vectors[1]
if self.valid_level(new_level):
self.current_level = vectors[0] + '-' + vectors[1]
self.main_character.log('entered ' + self.current_level)
self.main_character.old_position[vector] = limit1
self.main_character.position[vector] = limit2
else:
self.main_character.old_position[vector] = oldlimit1
self.main_character.position[vector] = oldlimit2
def go_right(self):
self.go_direction(0, 1, -1, 0, self.levels[
self.current_level].block_width - 1, self.levels[self.current_level].block_width - 1)
def go_left(self):
self.go_direction(0, -1, self.levels[self.current_level].block_width, self.levels[
self.current_level].block_width - 1, 0, 0)
def go_up(self):
self.go_direction(1, 1, self.levels[self.current_level].block_height, self.levels[
self.current_level].block_height - 1, 0, 0)
def go_down(self):
self.go_direction(1, -1, -1, 0, self.levels[
self.current_level].block_height - 1, self.levels[self.current_level].block_height - 1)
def save_screen(self):
pygame.image.save(self.screen, self.home + '/current_screen.jpg')
def main_loop(self):
if not self.levels_loaded:
self.load_levels()
if not self.main_character_loaded:
self.load_characters()
count = 0
self.screen = pygame.display.set_mode((self.width, self.height), pygame.RESIZABLE)
while not self.game_exit:
try:
self.main_character.blocks.remove(tuple(self.main_character.position))
except KeyError:
pass
events = pygame.event.get()
self.last_level = self.current_level
self.levels[self.current_level].draw_level()
self.main_character.blocks = self.levels[self.current_level].blocks
self.main_character.water_blocks = self.levels[
self.current_level].water_blocks
self.controls.get_events(events, self.screen, self.levels[self.current_level], self.main_character)
self.main_character.check_movement()
self.main_character.draw_character()
self.levels[self.current_level].draw_foreground()
pygame.display.update()
self.levels[self.current_level].slow_clock()
self.clock.tick(60)
if self.main_character.position[0] > self.levels[self.current_level].block_width - 1:
self.go_right()
if self.main_character.position[0] < 0:
self.go_left()
if self.main_character.position[1] < 0:
self.go_up()
if self.main_character.position[1] > self.levels[self.current_level].block_height - 1:
self.go_down()
self.main_character.blocks.add(tuple(self.main_character.position))
def run():
signals = {
'green': False,
'red': False,
'blue': False,
'stop': False,
'metal': False,
'maxTime': False,
'finish': False,
'path': '/home/pi/Filakov/',
'pltCnt': 1,
'imgCnt': 1
}
start = time.time()
# Make directory for the pictures
directory = datetime.datetime.today().strftime('%Y-%m-%d_%H-%M-%S')
signals['path'] += directory + '/'
try:
os.makedirs(signals['path'])
except Exception as e:
debug_print(str(e))
debug_print('Folder for pictures was not created. Aborting program...')
return
global output_file
output_file = open(signals['path'] + 'log.txt', 'w', encoding='utf-8')
C = Controls("/dev/ttyACM0", output_file)
if not C.started:
debug_print(
"Controls of the motors are not started. Aborting program...")
output_file.close()
return
cam = cv2.VideoCapture(0)
time.sleep(1)
if not cam.isOpened():
debug_print("Camera is not opened. Aborting program...")
output_file.close()
return
# Run the process
T_metal = threading.Thread(target=metalCheck, args=(
C,
signals,
))
T_cam = threading.Thread(target=cameraLoop, args=(
cam,
signals,
))
T_metal.start()
T_cam.start()
# Canvas down
C.Move(3, 'M', 250, wait=True)
C.Lights(1)
# Camera calibration
# C.Move(2, 'M', 180, wait = True)
# calibrateCamera(C, signals)
# if signals['stop']:
# stopRoutine(C, signals)
# return
C.Move(2, 'M', 180, wait=True)
# debug_print('Camera calibrated successfully.')
# First iteration of plant imaging
plantIter(C, cam, '-', signals)
if signals['stop']:
stopRoutine(C, signals)
signals['finish'] = True
T_cam.join()
T_metal.join()
output_file.close()
return
# Second iteration of plant imaging
debug_print('Preparing plant imaging on the other side.')
C.Move(2, 'M', -180, wait=True)
plantIter(C, cam, '+', signals)
if signals['stop']:
stopRoutine(C, signals)
signals['finish'] = True
T_cam.join()
T_metal.join()
output_file.close()
return
# Finishing routine
debug_print('Vertical motor returning to home position.')
C.Move(1, 'H', wait=True)
debug_print('Job done: ' + str(time.time() - start) + ' secs')
signals['finish'] = True
T_cam.join()
T_metal.join()
C.Lights(0)
# Canvas up
C.Move(3, 'M', -250, wait=True)
C.Close()
uploadCloudFolder(signals['path'])
output_file.close()
sendDoneMail(signals['path'] + 'log.txt')
class Window(wx.Frame):
def __init__(self, parent, title):
wx.Frame.__init__(self, parent, title=title)
# Splitters and Panels
self.controls_map_splitter = wx.SplitterWindow(self)
self.controls_map_splitter.SetMinimumPaneSize(300)
controls_panel = wx.Panel(self.controls_map_splitter)
map_panel = wx.Panel(self.controls_map_splitter)
self.graphs_messages_splitter = wx.SplitterWindow(controls_panel)
self.graphs_messages_splitter.SetMinimumPaneSize(50)
graphs_panel = wx.Panel(self.graphs_messages_splitter)
messages_panel = wx.Panel(self.graphs_messages_splitter)
# World graphic
self._graphics = worldmap.WorldMap(map_panel)
self.graphics_sizer = wx.BoxSizer(wx.VERTICAL)
self.graphics_sizer.Add(self._graphics, 1, wx.EXPAND)
map_panel.SetSizerAndFit(self.graphics_sizer)
# Controls panel
self.controls = Controls(controls_panel, (300, 250), self)
# Info panel
self.info = Info(controls_panel, (300, 250))
# Graph canvas
self.graphs = graphs.Graphs(graphs_panel, (300, 300))
# Messages panel
self.messages = Messages(messages_panel, (600, 200))
self.interface_sizer = wx.BoxSizer(wx.VERTICAL)
self.controls_info_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.controls_info_sizer.Add(self.info, 0, wx.EXPAND)
self.controls_info_sizer.Add((20, -1), proportion=0) # Padding
self.controls_info_sizer.Add(self.controls, 1, wx.EXPAND)
self.messages_sizer = wx.BoxSizer(wx.VERTICAL)
self.messages_sizer.Add(self.messages, 1, wx.EXPAND)
messages_panel.SetSizerAndFit(self.messages_sizer)
self.graphs_sizer = wx.BoxSizer(wx.VERTICAL)
self.graphs_sizer.Add(self.graphs, 1, wx.EXPAND)
graphs_panel.SetSizerAndFit(self.graphs_sizer)
self.interface_sizer.Add(self.controls_info_sizer, 0, wx.EXPAND)
self.interface_sizer.Add(self.graphs_messages_splitter, 1, wx.EXPAND)
controls_panel.SetSizerAndFit(self.interface_sizer)
self.graphs_messages_splitter.SplitHorizontally(
messages_panel,
graphs_panel
)
self.controls_map_splitter.SplitVertically(controls_panel, map_panel)
# Set up event handler for any worker thread results
EVT_RESULT(self, self.OnResult)
EVT_STOP(self, self.OnStop)
# Set up close event so timer is properly stopped
wx.EVT_CLOSE(self, self.OnClose)
self.reset_gui()
self.Show()
def reset_gui(self):
self.controls.reset_buttons()
self.messages.clear()
self.graphs.reset_data()
# Event Methods
def OnStart(self, event):
self.controls.set_buttons_ready()
self._simulation = simulation.Simulation()
self._simulation.setup_config(self.controls.get_config_filename())
self.simulation_info = self._simulation.initialize()
if not self.simulation_info.interface_config.print_messages:
self.messages.deactivate()
self._graphics.num_max_complaints = \
self.simulation_info.num_max_complaints
self.rounds = 0
self.steps = 0
self.next_phase = "COASTPLAN"
self.prev_phase = None
self.worker = None
def run(self, rounds, steps):
assert rounds >= 0, "Rounds has to be a positive integer."
assert steps >= 0, "Steps has to be a positive integer."
assert steps > 0 or rounds > 0, "Rounds or steps needs to be positive."
self.controls.set_status(rounds, steps)
self.controls.set_buttons_processing()
self.rounds = rounds
self.steps = steps
if self.worker is None:
self.prev_phase = self.next_phase
self.info.set_current_phase(self.next_phase)
self.worker = WorkerThread(self._simulation, self)
def OnResult(self, event):
if not event.source is self.worker: # ongoing simulation was aborted
return
self.worker = None
self.simulation_info.map.grid = util.update_map(
self.simulation_info.map.grid, event.result.map.grid
)
self.next_phase = event.result.next_phase
handle_statistics(self.graphs, event.result.round, event.result.data)
self._graphics.set_map(self.simulation_info.map)
if event.result.phase == "HEARING":
self._graphics.add_votes(event.result.complaints)
self._graphics.update()
for m in event.result.messages:
self.messages.add(str(m))
newr = self.prev_phase == "LEARNING" and self.next_phase == "COASTPLAN"
if newr:
self._graphics.reset_votes()
if newr and self.rounds > 0:
self.rounds -= 1
elif self.rounds == 0:
self.steps -= 1
if self.rounds > 0 or self.steps > 0:
self.run(self.rounds, self.steps)
else:
self.controls.set_buttons_ready()
def OnStop(self, event):
self.reset_gui()
self._simulation = None
self.worker = None
self.simulation_info = None
def OnClose(self, event):
# TODO: Fix
self.Destroy()
class game_system(object):
"""game system controls when objects in the system get updated"""
objects = ()
controllers = ()
def __init__(self, window=None, objects=(), controllers=()):
#Create a font for score
self.font = font.load('Arial', 18)
#pyglet.font.Text object to display the score
self.score = font.Text(self.font, x = 10, y=10, color=(1, 1, 1, 1))
self.control = Controls(window)
self.bind_objects(*objects)
self.bind_controllers(*controllers)
self.score_right = 0
self.score_left = 0
self.draw_score()
self.height = window.width
self.width = window.height
#should this not be handled within the object?
#map effects to different objects in the game
effects_map = { "fire": None}
def draw_score(self):
self.score.text = ("left: %d right: %d") % (self.score_left, self.score_right)
self.score.draw()
def bind_controllers(self, *controllers):
"""Bind one or more controllers"""
self.controllers += controllers
def bind_objects(self, *objects):
"""Bind one or more objects"""
self.control.bind_keys(objects)
self.objects += objects
def add(self, object):
"""Add an object to the list of objects that get traveresed when update is called"""
self.objects += object
def __iter__(self):
"""Iterate the particles in the group"""
# Make a copy of the particle set in case the group is
# modified during iteration
return iter(set(self.objects))#used to be particles
def __len__(self):
"""Return the number of particles in the group"""
return len(self.objects)
def send(self, message):
#send the message to correct object
for object in self.objects:
if object.name == message.to:
object.move(message.content)
#Check to see if score has occured
if message.to == "score":
print "score message"
self.update_score(message.content)
def update_score(self, message):
if message == "right:score":
self.score_right += 1
if message == "left:score":
self.score_left += 1
#draw the score
self.draw_score()
#reset ball because its gone outside of the screen
for object in self.objects:
if object.name =="ball":
object.reset_ball(self.height/2, self.width/2)
def update(self, time_delta):
"""Update all sprites in the system. time_delta is the
time since the last update (in arbitrary time units).
This method can be conveniently scheduled using the Pyglet
scheduler method: pyglet.clock.schedule_interval
"""
self.control.update(self, time_delta)
for object in self.objects:
object.update(time_delta)
#object.sprite.last_position = object.sprite.position
#object.sprite.last_velocity = object.sprite.velocity
#for group in self:
for controller in self.controllers:
controller(time_delta, self)
def draw(self):
"""Draw all the sprites in the system using their renderers.
This method is convenient to call from you Pyglet window's
on_draw handler to redraw particles when needed.
"""
glPushAttrib(GL_ALL_ATTRIB_BITS)
self.draw_score()
for sprite in self:
sprite.draw()
glPopAttrib()
