class Map(QtGui.QFrame): msg2Statusbar = QtCore.pyqtSignal(str) changedStatus = QtCore.pyqtSignal(bool) MapWidth = 1024 MapHeight = 640 Speed = 100 NoAction = 0 PlaceBlockAction = 1 PlaceRobotAction = 2 PlaceTargetAction = 3 def __init__(self, parent): super(Map, self).__init__(parent) self.parent = parent self.initMap() def initMap(self): QtCore.qDebug('sim_map.Map.initMap') self.timer = QtCore.QBasicTimer() self.setFrameStyle(QtGui.QFrame.Panel | QtGui.QFrame.Raised) self.objects = [] self.setFocusPolicy(QtCore.Qt.StrongFocus) self.setFixedSize(Map.MapWidth, Map.MapHeight) self.isStarted = False self.isPaused = False self.clearMap() self.dragXstart = -1 self.dragYstart = -1 self.dragXend = -1 self.dragYend = -1 self.dragObject = None self.mouseActionType = Map.NoAction self.saveToImage = True self.mapChanged = False self.robot = None self.target = None self.vbox = QtGui.QVBoxLayout() self.setLayout(self.vbox) self.simStats = SimStats(self) def load(self, fname): print("[sim_map.Map.load]") with open(fname) as fp: fp.readline() line = fp.readline().strip().split() Map.MapWidth = int(line[0]) Map.MapHeight = int(line[1]) Map.Speed = int(line[2]) fp.readline() line = fp.readline().strip() nObjects = int(line) fp.readline() for i in range(nObjects): line = fp.readline().strip().split() x = int(line[0]) y = int(line[1]) w = int(line[2]) h = int(line[3]) print(line) self.objects.append(Rectangle(x, y, w, h)) self.setFixedSize(Map.MapWidth, Map.MapHeight) self.repaint() def save(self, fname): print("[sim_map.Map.save]") self.setChanged(False) with open(fname, 'w') as fp: fp.write('# MapWidth MapHeight Speed\n') fp.write(str(Map.MapWidth) + ' ' + str(Map.MapHeight) + ' ' + str(Map.Speed) + '\n') fp.write('# Number of objects\n') fp.write(str(len(self.objects)) + '\n') fp.write('# x y width height\n') for obj in self.objects: fp.write(str(obj) + '\n') def start(self): QtCore.qDebug('sim_map.Map.start') if self.isPaused: return self.isStarted = True self.clearMap() self.msg2Statusbar.emit(str(0)) self.timer.start(Map.Speed, self) def pause(self): QtCore.qDebug('sim_map.Map.pause') if not self.isStarted: return self.isPaused = not self.isPaused if self.isPaused: self.timer.stop() self.msg2Statusbar.emit("paused") else: self.timer.start(Map.Speed, self) self.msg2Statusbar.emit(str(0)) self.update() def mousePressEvent(self, QMouseEvent): x = QMouseEvent.x() y = QMouseEvent.y() if self.mouseActionType == Map.NoAction: self.dragXstart = x self.dragYstart = y self.dragObject = Rectangle() self.dragObject.updateDrag(self.dragXstart, self.dragYstart, self.dragXstart, self.dragYstart) self.mouseActionType = Map.PlaceBlockAction #TODO cleanup #print(QMouseEvent.pos()) elif self.mouseActionType == Map.PlaceRobotAction: self.robot = Robot(x, y, 0) self.setStatsWidget() def mouseMoveEvent(self, QMouseEvent): x = QMouseEvent.x() y = QMouseEvent.y() if self.mouseActionType == Map.PlaceBlockAction: self.dragXend = x self.dragYend = y self.dragObject.updateDrag(self.dragXstart, self.dragYstart, self.dragXend, self.dragYend) #TODO cleanup #print(QMouseEvent.pos()) self.repaint() elif self.mouseActionType == Map.PlaceRobotAction: ab = x - self.robot.posX mb = math.sqrt(math.pow(x - self.robot.posX, 2) + math.pow(y - self.robot.posY, 2)) if mb == 0: newTheta = 0 else: newTheta = math.acos(ab / mb) if y < self.robot.posY: newTheta = math.pi - newTheta + math.pi print('theta: %f' % newTheta) self.robot.setOrientation(newTheta) if self.target is not None: # I am computing the angle relative to Ox ax. x = self.target.x - self.robot.posX y = self.target.y - self.robot.posY ab = x mb = math.sqrt(x * x + y * y) if mb == 0: theta = 0 else: theta = math.acos(ab / mb) if self.target.y < self.robot.posY: theta = math.pi - theta + math.pi theta = theta - newTheta if theta < 0: theta = theta + 2 * math.pi self.robot.setTargetDirection(theta) self.repaint() def mouseReleaseEvent(self, QMouseEvent): x = QMouseEvent.x() y = QMouseEvent.y() if self.mouseActionType == Map.PlaceRobotAction: self.mouseActionType = Map.NoAction self.simStats.btPlaceRobot.setEnabled(False) ab = x - self.robot.posX mb = math.sqrt(math.pow(x - self.robot.posX, 2) + math.pow(y - self.robot.posY, 2)) if mb == 0: newTheta = 0 else: newTheta = math.acos(ab / mb) if y < self.robot.posY: newTheta = math.pi - newTheta + math.pi self.robot.setOrientation(newTheta) if self.target is not None: # I am computing the angle relative to Ox ax. x = self.target.x - self.robot.posX y = self.target.y - self.robot.posY ab = x mb = math.sqrt(x * x + y * y) if mb == 0: theta = 0 else: theta = math.acos(ab / mb) if self.target.y < self.robot.posY: theta = math.pi - theta + math.pi theta = theta - newTheta if theta < 0: theta = theta + 2 * math.pi self.robot.setTargetDirection(theta) self.repaint() elif self.mouseActionType == Map.PlaceTargetAction: self.target = Target(x, y) self.mouseActionType = Map.NoAction self.simStats.btPlaceTarget.setEnabled(False) self.simStats.btPlaceRobot.setEnabled(True) self.repaint() elif self.mouseActionType == Map.PlaceBlockAction: self.dragXend = x self.dragYend = y self.dragObject.updateDrag(self.dragXstart, self.dragYstart, self.dragXend, self.dragYend) self.objects.append(self.dragObject) self.dragObject = None self.saveToImage = True self.setChanged(True) self.mouseActionType = Map.NoAction #TODO #print(QMouseEvent.pos()) self.repaint() def paintEvent(self, event): rect = self.contentsRect() if self.saveToImage == True: ImageMap.image = QtGui.QImage(rect.right(), rect.bottom(), QtGui.QImage.Format_RGB32) imagePainter = QtGui.QPainter(ImageMap.image) self.draw(imagePainter) ImageMap.image.save('image.jpg') self.saveToImage = False painter = QtGui.QPainter(self) self.draw(painter) def draw(self, painter): rect = self.contentsRect() painter.setPen(QtGui.QColor(0xff0000)) #TODO #QtCore.qDebug('[sim_map.Map.paintEvent] %d %d %d %d' % (rect.top(), rect.left(), rect.bottom(), rect.right())) painter.fillRect(0, 0, rect.right(), rect.bottom(), QtGui.QColor(0xffffff)) for obj in self.objects: obj.draw(painter) if not self.dragObject is None: self.dragObject.draw(painter) if self.robot is not None and self.saveToImage != True: self.robot.draw(painter) if self.target is not None and self.saveToImage != True: self.target.draw(painter) def keyPressEvent(self, event): key = event.key() if key == QtCore.Qt.Key_S: self.start() return if not self.isStarted: super(Map, self).keyPressEvent(event) return if key == QtCore.Qt.Key_P: self.pause() return if self.isPaused: return elif key == QtCore.Qt.Key_Q: self.robot.increaseLeftMotorSpeed(10) elif key == QtCore.Qt.Key_A: self.robot.increaseLeftMotorSpeed(-10) elif key == QtCore.Qt.Key_E: self.robot.increaseRightMotorSpeed(10) elif key == QtCore.Qt.Key_D: self.robot.increaseRightMotorSpeed(-10) else: super(Map, self).keyPressEvent(event) def timerEvent(self, event): if event.timerId() == self.timer.timerId(): if self.robot is not None: self.robot.move() self.repaint() else: super(Map, self).timerEvent(event) def clearMap(self): self.objects = [] def changed(self): return self.mapChanged def setChanged(self, mapChanged): self.mapChanged = mapChanged self.changedStatus.emit(bool(self.mapChanged)) def getStatsWidget(self): widgets = [] widgets.append(self.simStats) if self.robot is not None: widgets.append(self.robot.getStatsWidget()) return widgets def setStatsWidget(self): widgets = [] widgets.append(self.simStats) if self.robot is not None: widgets.append(self.robot.getStatsWidget()) self.parent.setStatsWidgets(widgets) def placeRobot(self): self.mouseActionType = Map.PlaceRobotAction def placeTarget(self): self.mouseActionType = Map.PlaceTargetAction
class Env: SIZE = 500 RETURN_IMAGES = False MOVE_PENALTY = 1 ENEMY_PENALTY = 300 FOOD_REWARD = 50 #OBSERVATION_SPACE_VALUES = 8 ACTION_SPACE_SIZE = 5 def reset(self): self.player = Ballon("ballon", 50, 50, 1,1, 100, 1) self.food = Target(100,100,[100,100]) self.food.instantiate() while self.food.check(self.player.x, self.player.y): self.food.instantiate() self.startdpos = [self.player.loc[0] - self.food.x, self.player.loc[1] - self.food.y] self.startdis = np.sqrt((self.food.x- self.player.loc[0])**2 + (self.food.y-self.player.loc[1])**2) self.episode_step = 0 if self.RETURN_IMAGES: observation = np.array(self.get_image()) else: self.dposold = [self.food.x- self.player.loc[0], self.food.y-self.player.loc[1]] observation = [self.dposold[0]/1920, self.dposold[1]/1080, self.player.vel[0]/153, self.player.vel[1]/153, self.player.angvel/2.5, self.player.rot/(2*3.1415926535897932384623383)] return observation def step(self, action): self.episode_step += 1 self.player.action(action) self.player.setVelocity() self.player.move() self.player.boundries(1920, 1080) if self.RETURN_IMAGES: new_observation = np.array(self.get_image()) else: self.dpos = [self.food.x- self.player.loc[0], self.food.y-self.player.loc[1]] new_observation = [self.dposold[0]/1920, self.dposold[1]/1080, self.player.vel[0]/153, self.player.vel[1]/153, self.player.angvel/2.5, self.player.rot/(2*3.1415926535897932384623383)] if self.food.check(self.player.loc[0], self.player.loc[1]): reward = self.FOOD_REWARD elif self.episode_step >= 2500: reward = 100 - (np.sqrt((self.food.x - self.player.loc[0])**2 + (self.food.y-self.player.loc[1])**2)/self.startdis)*100 else: reward = -self.MOVE_PENALTY +(np.abs(self.dposold[0])-np.abs(self.dpos[0])) + (np.abs(self.dposold[1])-np.abs(self.dpos[1])) done = False if reward == self.FOOD_REWARD or self.episode_step >= 2500: done = True self.dposold[0] = self.dpos[0] self.dposold[1] = self.dpos[1] return new_observation, reward, done def render(self, screen): self.player.draw(screen) self.food.draw(screen)
force_left = .2 if event.key == pygame.K_a: force_left = .1 if event.key == pygame.K_z: force_left = -.1 else: force_right = 0 force_left = 0 screen.fill((200, 200, 200)) if (force_left >= 0 and force_right >= 0) or (force_left < 0 and force_right < 0): force_front = force_left + force_right - abs(force_left - force_right) elif (force_left < 0 and force_right == 0) or (force_right < 0 and force_left == 0): force_front = 0 else: force_front = force_left + force_right #+ abs(force_left - force_right) force_rot = force_left - force_right object.setVelocity() object.applyForce(input.calculateforward(object.rot, force_front), force_rot) object.move() object.boundries(1920, 1080) target.draw(screen) object.draw(screen) clock.tick(60) pygame.display.update() pygame.quit()
class Box(): def __init__(self, w, h): pygame.init() self.width = w self.height = h self.target = None self.font = pygame.font.SysFont('comicsansms', FONT_SIZE) self.font_intro = pygame.font.SysFont('comicsansms', 40) self.bg = pygame.image.load("img/bg.jpg") # 背景画像の取得 self.rect_bg = self.bg.get_rect() self.title = pygame.image.load("img/title.png") self.rect_title = self.title.get_rect() self.tutorial = pygame.image.load("img/tutorial.png") self.rect_tutorial = self.tutorial.get_rect() self.star_guide_image = pygame.image.load("img/fukidashi.png") self.cutin_image = [] # 百裂肉球 for i in range(25): cutin = pygame.image.load( "img/cutin/frame_{:02}_delay-0.1s.gif".format(i)) self.cutin_image.append(cutin) self.cutin_index = 0 self.deg = 0 def set(self): # 初期設定を一括して行う self.stage = STAGE_START self.screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Cat Fighter Z") self.clock = pygame.time.Clock() # 時計オブジェクト self.player = Player(self.screen, PLAYER_X, PLAYER_Y, 0, 0, STATE_STANDING) self.target = Target(self.screen, TARGET_X, TARGET_Y, 0, 0, STATE_STANDING) self.show_score() def show_score(self): h_scale = 2 self.screen.blit(self.font.render("HP", True, WHITE), [BOX_WIDTH - 40, 20]) show_health_bar(self.screen, self.player.hp / h_scale, PLAYER_MAX_HP / h_scale, (BOX_WIDTH - 150, 20)) self.screen.blit(self.font.render("MP", True, WHITE), [BOX_WIDTH - 40, 40]) show_magic_point(self.screen, int(self.player.mp), PLAYER_MAX_MP, (BOX_WIDTH - 130, 50)) self.screen.blit(self.font.render("HP", True, WHITE), [20, 20]) show_health_bar(self.screen, self.target.hp / h_scale, ENEMY_MAX_HP / h_scale, (50, 20)) self.screen.blit(self.font.render("MP", True, WHITE), [20, 40]) show_magic_point(self.screen, int(self.target.mp), ENEMY_MAX_MP, (70, 50)) def run(self): while (self.stage != STAGE_QUIT): if self.stage == STAGE_START: self.show_intro_screen() elif self.stage == STAGE_TUTORIAL: self.show_tutorial_screen() elif self.stage == STAGE_RUN: self.show_battle_screen() elif self.stage == STAGE_CLEAR: self.show_clear_screen() elif self.stage == STAGE_OVER: self.show_gameover_screen() elif self.stage == STAGE_CUTIN: self.show_cutin_screen() def intro_message(self): text = self.font_intro.render("PRESS SPACE", True, (0, 0, 0)) position = text.get_rect() position.center = (WIDTH / 2, 250) alpha = (math.cos(float(self.deg) / 180 * math.pi) + 1) / 2 * 255 text.set_alpha(alpha) self.screen.blit(text, position) self.deg = (self.deg + 5) % 360 def show_intro_screen(self): self.stage = STAGE_INTRO while (self.stage == STAGE_INTRO): for event in pygame.event.get(): if event.type == pygame.QUIT: self.stage = STAGE_QUIT if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: self.stage = STAGE_TUTORIAL self.clock.tick(FPS) # 毎秒の呼び出し回数に合わせて遅延 self.intro_message() pygame.display.flip() self.screen.fill((0, 0, 0)) self.screen.blit(self.title, self.rect_title) def show_tutorial_screen(self): while (self.stage == STAGE_TUTORIAL): for event in pygame.event.get(): if event.type == pygame.QUIT: self.stage = STAGE_QUIT if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: self.stage = STAGE_RUN self.clock.tick(FPS) # 毎秒の呼び出し回数に合わせて遅延 pygame.display.flip() self.screen.fill((0, 0, 0)) self.screen.blit(self.tutorial, self.rect_tutorial) def show_battle_screen(self): while (self.stage == STAGE_RUN): # メインループ if self.target.hp <= 0: # プレイヤーが勝った self.player.win() self.target.lose() self.stage = STAGE_CLEAR sleep(1) return if self.player.hp <= 0: # 敵が勝った self.player.lose() self.target.lose() self.stage = STAGE_OVER sleep(1) return enemy_direction = 1 if self.player.x < self.target.x else -1 for event in pygame.event.get(): # 「閉じる」ボタンを処理する if event.type == pygame.QUIT: print("finish animation") pygame.quit() return if event.type == pygame.KEYDOWN: # aキーで攻撃 if event.key == pygame.K_a: self.player.shot(enemy_direction) if event.key == pygame.K_s: self.player.punch(enemy_direction) self.clock.tick(FPS) # 毎秒の呼び出し回数に合わせて遅延 pressed_keys = pygame.key.get_pressed() # キー情報を取得 if pressed_keys[pygame.K_UP]: # 上でジャンプ self.player.jump(0, -15) if pressed_keys[pygame.K_RIGHT]: self.player.right() if pressed_keys[pygame.K_LEFT]: self.player.left() if self.player.mp == PLAYER_MAX_MP: # 百裂肉球を表示する position = self.star_guide_image.get_rect() position.center = (WIDTH / 4 * 3 + 20, 40) alpha = (math.cos(float(self.deg) / 180 * math.pi) + 1) * 255 self.star_guide_image.set_alpha(alpha) self.screen.blit(self.star_guide_image, position) self.deg = (self.deg + 3) % 360 if pressed_keys[pygame.K_z]: # 百裂肉球 self.player.mp = 0 self.target.hp -= 50 for i in range(4): surface = pygame.image.load("img/explosion_small.png") rect = surface.get_rect() rect.center = (random.randrange(BOX_WIDTH), random.randrange(BOX_HEIGHT)) effect = Effect(surface, rect, 100) self.player.effects.add(effect) surface = pygame.image.load("img/explosion_big.png") rect = surface.get_rect() rect.center = (random.randrange(BOX_WIDTH), random.randrange(BOX_HEIGHT)) effect = Effect(surface, rect, 100) self.player.effects.add(effect) self.stage = STAGE_CUTIN # 肉球の衝突判定 collided = pygame.sprite.spritecollideany(self.target, self.player.bullets) if collided != None: self.target.get_attacked('SHOT') self.player.bullets.remove(collided) # 近接猫パンチとターゲットの衝突判定 if self.player.nikukyu != None and pygame.sprite.collide_rect( self.target, self.player.nikukyu): self.target.get_attacked('PUNCH') # お互いの情報を伝え合う self.player.set_enemy(self.target) self.target.set_player(self.player) # オブジェクトのアップデート self.player.update() self.target.update() # 表示の更新 self.show_score() self.target.draw() self.player.draw() self.player.bullets.draw(self.screen) pygame.display.flip() # パドルとボールの描画を画面に反映 self.screen.blit(self.bg, self.rect_bg) # 背景画像 # self.screen.fill((0, 0, 0)) # 塗潰し:次の flip まで反映されない def show_cutin_screen(self): repeat_num = 2 fps_scale = 3 self.clock.tick(FPS) print(self.cutin_index) self.screen.blit( self.cutin_image[(self.cutin_index % (25 * fps_scale)) // fps_scale], self.cutin_image[(self.cutin_index % (25 * fps_scale)) // fps_scale].get_rect()) self.cutin_index += 1 pygame.display.flip() if self.cutin_index == 25 * fps_scale * repeat_num: self.cutin_index = 0 self.stage = STAGE_RUN def show_clear_screen(self): self.clock.tick(FPS) pygame.display.flip() self.screen.fill((0, 0, 0)) text = self.font_intro.render("CLEARED!!", True, (255, 255, 255)) position = text.get_rect() position.center = (WIDTH / 2, HEIGHT / 2) self.screen.blit(text, position) def show_gameover_screen(self): self.clock.tick(FPS) pygame.display.flip() self.screen.fill((0, 0, 0)) text = self.font_intro.render("GAME OVER!!", True, (255, 255, 255)) position = text.get_rect() position.center = (WIDTH / 2, HEIGHT / 2) self.screen.blit(text, position)
class Trainer(object): def __init__(self): ############### # load config # ############### with open('trainer_config.yaml') as f: CONFIG = yaml.load(f) self.exp_type = CONFIG['experiment-type'] self.playback_bool = CONFIG['playback-enabled'] self.subj_id = CONFIG['subject-id'] self.subj_dir = 'datasets/' + self.subj_id if self.exp_type == 'timed': fu.write_all_headers_timed(self) elif self.exp_type == 'block': fu.write_all_headers_block(self) ################# # set constants # ################# self.FRAME_RATE = 30 self.SCREEN_WIDTH, self.SCREEN_HEIGHT = 1024, 768 self.BG_COLOR_REG = 70,70,70 self.BG_COLOR_REG_2 = 110,110,110 self.BG_COLOR_REG_3 = 40,40,40 self.SUCCESS_COLOR = 70,170,70 self.INDICATOR_COLOR = 40,60,40 self.INDICATOR_COLOR_2 = 30,100,30 self.GOOD_MSG_COLOR = 160,255,160 self.BAD_MSG_COLOR = 255,160,160 self.A_MSG_COLOR = 160,160,255 self.B_MSG_COLOR = 230,230,160 self.SENSOR_INPUT_OFFSET = np.array([0.5*self.SCREEN_WIDTH, 0.5*self.SCREEN_HEIGHT]) self.NEWTONS_2_PIXEL = 200 self.BLOCK_TIME = CONFIG['block-length'] self.RESET_HOLD_TIME = 0.5 self.REACH_SUCCESS_TIME = 2. self.NOISE_VAR_GOOD = 0.025 if not self.playback_bool: self.NOISE_VAR_BAD = 10*self.NOISE_VAR_GOOD else: self.NOISE_VAR_BAD = self.NOISE_VAR_GOOD self.SAMPLE_PERIOD = 2. self.SAMPLE_FRAMES = self.SAMPLE_PERIOD*self.FRAME_RATE self.TRS_SHOW_UPDATE_RATE = 2 self.TR_LIST = (0.125, .25, 0.5, 1., 2., 4.) self.TRS_SAMPLES_DICT = dict((tr, tr/self.SAMPLE_PERIOD) for tr in self.TR_LIST) self.TRS_SUCCESS_DICT = dict((tr, self.REACH_SUCCESS_TIME/tr) for tr in self.TR_LIST) self.BUFFER_DIST = 0.075*self.SCREEN_HEIGHT self.START_DIST = self.BUFFER_DIST self.GAME_ORIGIN = (0.5*self.SCREEN_WIDTH-0.5*self.SCREEN_HEIGHT, self.SCREEN_HEIGHT) self.START_COORDS = np.array([self.GAME_ORIGIN[0]+self.BUFFER_DIST, self.GAME_ORIGIN[1]-self.BUFFER_DIST]) self.TARGET_DIST = (0.3*self.SCREEN_HEIGHT, 0.8*self.SCREEN_HEIGHT) self.ERROR_CUTOFF = self.TARGET_DIST[0] - self.START_DIST self.MIN_ERROR_METRIC = 0.1 self.SS_ERROR_METRIC = 0.9 self.MIN_SUCCESS_SCORE = 0.7 self.TARGET_RAD = (self.ERROR_CUTOFF* (1-(self.MIN_SUCCESS_SCORE-self.MIN_ERROR_METRIC) /(self.SS_ERROR_METRIC-self.MIN_ERROR_METRIC))) if SENSOR_ACTIVE: self.daq = Pydaq('Dev1/ai0:1', self.FRAME_RATE) self.VISIBLE_TRIALS = CONFIG['visible-trials'] self.INVISIBLE_TRIALS = CONFIG['invisible-trials'] self.NUM_TRIALS = self.VISIBLE_TRIALS self.TRIAL_TYPES = 8 #################################################### # start pygame and initialize default game objects # #################################################### pygame.init() pygame.mouse.set_visible(not pygame.mouse.set_visible) self.clock = pygame.time.Clock() if CONFIG['fullscreen']: self.screen = pygame.display.set_mode( (self.SCREEN_WIDTH, self.SCREEN_HEIGHT), pygame.FULLSCREEN) else: self.screen = pygame.display.set_mode( (self.SCREEN_WIDTH, self.SCREEN_HEIGHT)) ################################## # initialize custom game objects # ################################## self.cursor = Cursor(self.screen) self.target = Target(self.screen, self.FRAME_RATE, self.TARGET_RAD, self.ERROR_CUTOFF, self.MIN_ERROR_METRIC, self.SS_ERROR_METRIC, self.MIN_SUCCESS_SCORE, self.START_COORDS, self.TARGET_DIST) self.therm = Thermometer(self.screen, self.MIN_ERROR_METRIC, self.MIN_SUCCESS_SCORE, self.SS_ERROR_METRIC) self.INDIC_RAD_MAX = self.START_DIST-self.cursor.RAD-2 self.target.target_lims = self.TARGET_DIST self.timers = {} self.init_timers() self.set_tr(2.) self.trial_count = 0 self.trial_type_count = 1 self.next_dof = 1 self.set_dof(self.next_dof) self.next_ir = 'impulse' self.next_visible = True self.set_trial() ###################### # set game variables # ###################### self.screen_mid = np.array([0.5*self.screen.get_width(), 0.5*self.screen.get_height()]) self.bg_color = self.BG_COLOR_REG self.bg_color_alt = self.BG_COLOR_REG_2 self.bg_color_alt_2 = self.BG_COLOR_REG_3 self.indicator_color = self.INDICATOR_COLOR self.indicator_rad = 0*self.START_DIST self.success_color = self.SUCCESS_COLOR self.input_mode = 'mouse' self.input_pos = np.array([0.0,0.0]) self.training_mode = True ####################### # set block variables # ####################### self.NUM_BLOCK_TRIALS = CONFIG['num-block-trials'] self.next_target = 'new' self.first_feedback = CONFIG['first-trial-feedback'] self.first_noise = CONFIG['first-trial-noise'] self.next_feedback = self.first_feedback self.next_noise = self.first_noise self.set_noise() self.BLOCK_TRS = self.BLOCK_TIME/self.tr self.block_nfb_buffer = np.zeros(self.BLOCK_TRS) self.block_tr_count = 0 self.total_block_count = 0 self.trial_block_count = 0 ########################## # set playback variables # ########################## self.TIME_SHIFT = 6 self.PLAYBACK_TRS = self.BLOCK_TRS + self.TIME_SHIFT/self.tr self.EXTRA_TRS = 2 self.playback_buffer_length = (self.BLOCK_TIME + self.EXTRA_TRS)*self.FRAME_RATE self.move_counter = 0 self.reset_playback_buffers() def reset_playback_buffers(self): self.playback_counter = 0 self.playback_time_buffer = np.zeros(self.playback_buffer_length) self.playback_pos_buffer = np.zeros((2,self.playback_buffer_length)) self.playback_nfb_buffer = np.zeros(self.playback_buffer_length) self.playback_nfb_points = np.zeros(self.PLAYBACK_TRS) def get_pos(self): if self.input_mode=='mouse' or not(SENSOR_ACTIVE): return pygame.mouse.get_pos() else: f_out = self.daq.get_force() return (self.SENSOR_INPUT_OFFSET[0]+self.NEWTONS_2_PIXEL*f_out[0], self.SENSOR_INPUT_OFFSET[1]+self.NEWTONS_2_PIXEL*f_out[1]) def set_trial(self): self.set_dof(self.next_dof) self.target.set_fb_mode(self.next_ir) self.set_training_mode(self.next_visible) def set_noise(self): if self.next_noise == 'good': self.noise_var = self.NOISE_VAR_GOOD elif self.next_noise == 'bad': self.noise_var = self.NOISE_VAR_BAD def set_training_mode(self, bool_arg): self.training_mode = bool_arg def set_tr(self, tr): if tr == 0.125: self.tr = 0.125 self.timers['tr'] = self.timers['tr_8hz'] elif tr == 0.25: self.tr = 0.25 self.timers['tr'] = self.timers['tr_4hz'] elif tr == 0.5: self.tr = 0.5 self.timers['tr'] = self.timers['tr_2hz'] elif tr == 1: self.tr = 1. self.timers['tr'] = self.timers['tr_1hz'] elif tr == 2: self.tr = 2. self.timers['tr'] = self.timers['tr_p5hz'] elif tr == 4: self.tr = 4. self.timers['tr'] = self.timers['tr_p25hz'] def init_timers(self): self.timers['signal'] = Timer(self.SAMPLE_PERIOD) self.timers['tr_8hz'] = Timer(self.TR_LIST[0]) self.timers['tr_4hz'] = Timer(self.TR_LIST[1]) self.timers['tr_2hz'] = Timer(self.TR_LIST[2]) self.timers['tr_1hz'] = Timer(self.TR_LIST[3]) self.timers['tr_p5hz'] = Timer(self.TR_LIST[4]) self.timers['tr_p25hz'] = Timer(self.TR_LIST[5]) self.timers['tr'] = self.timers['tr_2hz'] self.timers['reach'] = Timer(0) self.timers['reach_hold'] = Timer(self.REACH_SUCCESS_TIME) self.timers['block'] = Timer(self.BLOCK_TIME) self.timers['reset_hold'] = Timer(self.RESET_HOLD_TIME) def reset_all_timers(self): for k,t in self.timers.iteritems(): t.reset() def check_input(self): for event in pygame.event.get(): if event.type == pygame.QUIT: self.quit() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: self.quit() elif event.key == pygame.K_0: self.daq.set_volts_zero() elif event.key == pygame.K_f: if self.dof == 1: self.set_dof(2) elif self.dof == 2: self.set_dof(1) elif event.key == pygame.K_b: self.target.set_new_target() elif event.key == pygame.K_v: self.training_mode = not(self.training_mode) elif event.key == pygame.K_c: self.target.set_fb_mode('hrf') elif event.key == pygame.K_x: self.target.set_fb_mode('impulse') elif event.key == pygame.K_m: if self.input_mode == 'mouse': self.input_mode = 'sensor' elif self.input_mode == 'sensor': self.input_mode = 'mouse' def run_timed(self): ########################################### # main loop for time-to-target experiment # ########################################### while True: time_passed = self.clock.tick_busy_loop(self.FRAME_RATE) self.check_input() self.input_pos = self.get_pos() self.cursor.update(self.input_pos) self.target.update(self.cursor.pos) if not(self.timers['reset_hold'].time_limit_hit): gr.check_in_start(self, time_passed) self.target.draw_bool = True elif not(self.cursor.has_left): gr.check_if_left(self) self.target.draw_bool = False elif self.training_mode: self.target.draw_bool = True else: self.target.draw_bool = False if self.cursor.has_left: gr.frame_based_updates_timed(self) self.timers['signal'].update(time_passed) self.timers['tr'].update(time_passed) if self.timers['signal'].time_limit_hit: gr.signal_based_updates(self) if self.timers['tr'].time_limit_hit: gr.tr_based_updates(self) self.draw_background() self.therm.draw(self.cursor.has_left, self.target.error_metric) self.target.draw() if (self.trial_count == 0 and not self.cursor.has_left): self.draw_instructions_timed() self.cursor.draw() pygame.display.flip() def run_block(self): ########################################### # main loop for block feedback experiment # ########################################### self.target.draw_bool = False if self.playback_bool: self.set_dof(2) else: self.set_dof(1) self.target.set_fb_mode('hrf') while True: time_passed = self.clock.tick_busy_loop(self.FRAME_RATE) self.check_input() self.input_pos = self.get_pos() self.cursor.update(self.input_pos) self.target.update(self.cursor.pos) if not(self.timers['reset_hold'].time_limit_hit): gr.check_in_start(self, time_passed) if self.next_target == 'new': self.target.draw_bool = True elif not(self.cursor.has_left): gr.check_if_left(self) self.target.draw_bool = False # debugging # self.target.draw_bool = True if self.cursor.has_left: gr.frame_based_updates_block(self) self.timers['signal'].update(time_passed) self.timers['tr'].update(time_passed) self.timers['block'].update(time_passed) if self.timers['signal'].time_limit_hit: gr.signal_based_updates(self) if self.timers['tr'].time_limit_hit: gr.tr_based_updates(self) if self.timers['block'].time_limit_hit: gr.block_based_updates(self) self.draw_background() therm_draw_bool = ((self.cursor.has_left and self.next_feedback == 'continuous') or (self.total_block_count > 0 and not self.cursor.has_left)) score = self.target.error_metric self.therm.draw(therm_draw_bool, score) self.target.draw() if not self.cursor.has_left: self.draw_instructions_block() else: self.therm.set_score_color('norm') self.cursor.draw() pygame.display.flip() def run_playback(self): while self.move_counter > 0: time_passed = self.clock.tick_busy_loop(self.FRAME_RATE) self.check_input() self.cursor.update(self.playback_pos_buffer[:, self.playback_counter]) self.indicator_rad = int(self.INDIC_RAD_MAX*( self.playback_time_buffer[self.playback_counter] /float(self.timers['block'].MAX_TIME))) self.draw_background() self.therm.draw(True, self.playback_nfb_buffer[self.playback_counter]) # debugging # self.target.draw() self.cursor.draw() pygame.display.flip() self.move_counter -= 1 self.playback_counter += 1 def set_dof(self, dof): self.dof = dof self.cursor.set_dof(dof) self.target.set_dof(dof) def draw_background(self): self.screen.fill(self.bg_color_alt_2) gr.cap_indicator_rad(self) self.draw_play_area() if self.indicator_rad > 0: self.draw_indicator() def draw_instructions_block(self): if self.next_target == 'new': top_msg = 'New target' top_color = self.GOOD_MSG_COLOR else: top_msg = 'Same target' top_color = self.BAD_MSG_COLOR if self.next_feedback == 'continuous': mid_msg = 'Continuous feedback' mid_color = self.A_MSG_COLOR else: mid_msg = 'Intermittent feedback' mid_color = self.B_MSG_COLOR if self.next_noise == 'good': btm_msg = 'Good signal' btm_color = self.A_MSG_COLOR else: btm_msg = 'Bad signal' btm_color = self.B_MSG_COLOR gg.draw_msg(self.screen, top_msg, color=top_color, center=(self.screen_mid[0], self.screen_mid[1]-75)) gg.draw_msg(self.screen, mid_msg, color=mid_color, center=(self.screen_mid[0], self.screen_mid[1])) if not self.playback_bool: gg.draw_msg(self.screen, btm_msg, color=btm_color, center=(self.screen_mid[0], self.screen_mid[1]+75)) def draw_instructions_timed(self): if self.next_visible: top_msg = 'Target visible' top_color = self.GOOD_MSG_COLOR else: top_msg = 'Target invisible' top_color = self.BAD_MSG_COLOR if self.next_ir == 'impulse': btm_msg = 'Instant feedback' btm_color = self.GOOD_MSG_COLOR else: btm_msg = 'Delayed feedback' btm_color = self.BAD_MSG_COLOR gg.draw_msg(self.screen, top_msg, color=top_color, center=(self.screen_mid[0], self.screen_mid[1]-50)) gg.draw_msg(self.screen, btm_msg, color=btm_color, center=(self.screen_mid[0], self.screen_mid[1]+50)) def draw_play_area(self): if self.dof == 1: gg.draw_center_rect(self.screen, self.SCREEN_HEIGHT, self.SCREEN_HEIGHT, self.bg_color, self.screen_mid[0], self.screen_mid[1]) gg.draw_center_rect(self.screen, self.TARGET_DIST[1]-self.TARGET_DIST[0], self.SCREEN_HEIGHT, self.bg_color_alt, (self.TARGET_DIST[0] +0.5*(self.TARGET_DIST[1] -self.TARGET_DIST[0]) + self.START_COORDS[0]), self.screen_mid[1]) gg.draw_center_rect(self.screen, 2*(self.START_DIST-self.cursor.RAD), self.SCREEN_HEIGHT, self.bg_color_alt_2, self.START_COORDS[0], self.screen_mid[1]) elif self.dof == 2: gg.draw_center_rect(self.screen, self.SCREEN_HEIGHT, self.SCREEN_HEIGHT, self.bg_color, self.screen_mid[0], self.screen_mid[1]) gg.draw_filled_aacircle(self.screen, self.TARGET_DIST[1], self.bg_color_alt, self.START_COORDS[0], self.START_COORDS[1]) gg.draw_filled_aacircle(self.screen, self.TARGET_DIST[0], self.bg_color, self.START_COORDS[0], self.START_COORDS[1]) gg.draw_center_rect(self.screen, self.SCREEN_HEIGHT, 2*self.BUFFER_DIST, self.bg_color, self.screen_mid[0], self.GAME_ORIGIN[1]) gg.draw_center_rect(self.screen, 2*self.BUFFER_DIST, self.SCREEN_HEIGHT, self.bg_color, self.GAME_ORIGIN[0], self.screen_mid[1]) gg.draw_filled_aacircle(self.screen, self.START_DIST-self.cursor.RAD, self.bg_color_alt_2, self.START_COORDS[0], self.START_COORDS[1]) def draw_indicator(self): if self.dof == 1: gg.draw_center_rect(self.screen, 2*self.indicator_rad, self.SCREEN_HEIGHT, self.indicator_color, self.START_COORDS[0], self.screen_mid[1]) elif self.dof == 2: gg.draw_filled_aacircle(self.screen, self.indicator_rad, self.indicator_color, self.START_COORDS[0], self.START_COORDS[1]) def quit(self): sys.exit()
# Creature wins if it is closest to target for i in range(len(creatures)): distance = math.sqrt(abs(creatures[i].get_loc()[1] - target.get_loc()[1]) ** 2 + abs(creatures[i].get_loc()[0] - target.get_loc()[0]) ** 2) if distance < best_distance: best_distance = distance best = i # Breed for i in range(len(creatures)): if i != best: creatures[i].breedwith(creatures[best]) # Draw the target target.draw() dislpay_instructions() # Update and draw creature for i in range(len(creatures)): creatures[i].update() # show only the winner or the entire population if show_best: creatures[best].draw() else: for i in range(len(creatures)): creatures[i].draw() # Event handling