class Mainmenu():
"""Class that represents the main menu"""
def __init__(self, window):
"""Constructor"""
self.window = window
pygame.font.init()
self.buttonFont = pygame.font.Font("emulogic.ttf", 15) #Prepare fonts
self.tutorialFont = pygame.font.Font("emulogic.ttf", 10)
self.titleFont = pygame.font.Font("emulogic.ttf", 25)
self.title = self.titleFont.render("Megaman Battles", False, (0, 0, 0))
self.playButton = Button(
self.buttonFont.render("Play Game (2P)", False, (0, 0, 0)),
self.window, 400, 150, 1) #Initialize player button
self.tutorialButton = Button(
self.buttonFont.render("Read Tutorial", False, (0, 0, 0)),
self.window, 400, 300, 2) #Initialize tutorial button
self.buttons = [self.playButton,
self.tutorialButton] #List to hold buttons
self.buttonIndex = 0 #Index to see which button is chosen.
self.cursor = Cursor(self.buttons[self.buttonIndex].x + 256,
self.buttons[self.buttonIndex].y,
self.window) #Initialize cursor
self.running = True
def draw(self):
"""Draw main menu"""
self.window.blit(bg, (0, 0)) #Draw background first
self.window.blit(self.title, (350, 50)) #Draw title
self.playButton.draw() #Draw buttons
self.tutorialButton.draw()
self.cursor.draw() #Draw cursor
pygame.display.update() #Update display
def run(self):
"""Run the main menu"""
while self.running:
pygame.time.delay(125) #Delay to not take multiple inputs at once
self.cursor.move(
self.buttons[self.buttonIndex].y) #Move the cursor
for event in pygame.event.get(): #Loop to check for user exit.
if event.type == pygame.QUIT:
return 3
keys = pygame.key.get_pressed() #Get keys
if keys[pygame.K_DOWN]: #If they pressed down
if self.buttonIndex + 1 == len(
self.buttons): #If the index exceeds the list length
self.buttonIndex = 0 #Move the cursor to the first button
else:
self.buttonIndex += 1 #Move the cursor down.
if keys[pygame.K_UP]: #If up is pressed
if self.buttonIndex - 1 == -1: #If the index is less than 0
self.buttonIndex = len(
self.buttons) - 1 #Move the cursor to the last button
else:
self.buttonIndex -= 1 #Move the cursor up
if keys[pygame.K_RETURN]: #If Enter is pressed
return self.buttons[self.buttonIndex].getDecision(
) #Return decision stored in selected button
self.draw() #Draw
def tutorial(self):
run = True
texts = [
self.tutorialFont.render("There are two players in this game.",
False, (0, 0, 0)),
self.tutorialFont.render(
"Player one is on the left and player two is on the right.",
False, (0, 0, 0)),
self.tutorialFont.render(
"Player one uses WASD to move and space to shoot.", False,
(0, 0, 0)),
self.tutorialFont.render(
"Player two uses IJKL and Backslash (the button above enter) to shoot.",
False, (0, 0, 0)),
self.tutorialFont.render(
"Both players cannot cross the middle of the arena.", False,
(0, 0, 0)),
self.tutorialFont.render("Good luck and Have Fun! Press", False,
(0, 0, 0)),
self.tutorialFont.render("Enter to go back to the main menu.",
False, (0, 0, 0))
] #Tutorial text split into lines
self.window.blit(bg, (0, 0)) #Blit background once.
i = 0
for text in texts: #Blit each line of text
self.window.blit(text, (200, i))
i += 30
pygame.display.update() #Update display
while run: #Main loop
pygame.time.delay(100) #Delay
for event in pygame.event.get(): #Loop to check for user exit.
if event.type == pygame.QUIT:
run = False
keys = pygame.key.get_pressed()
if keys[pygame.K_RETURN]: #If enter is pressed, exit
run = False
class Game(object):
def __init__(self):
###############
# load config #
###############
with open('config.yaml') as f:
CONFIG = yaml.load(f)
with open('mvc.yaml') as f:
MVC = yaml.load(f)
self.subj_id = CONFIG['subject-id']
self.subj_dir = 'datasets/' + self.subj_id
self.loc = CONFIG['location']
#################
# set constants #
#################
if self.loc == 'lab':
self.FRAME_RATE = 120
elif self.loc == 'scanner':
self.FRAME_RATE = 60
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.FAIL_COLOR = 170,70,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.REG_FIXATION_COLOR = 200,200,200
self.GOOD_FIXATION_COLOR = self.SUCCESS_COLOR
self.BAD_FIXATION_COLOR = 240,140,140
self.BAD_SCORE_COLOR = 200,100,100
self.GOOD_SCORE_COLOR = 100,200,100
self.HIGHLIGHT_SCORE_COLOR = 20,255,20
self.NORM_SCORE_COLOR = 180,180,100
self.SENSOR_INPUT_OFFSET = np.array([0.5*self.SCREEN_WIDTH,
0.75*self.SCREEN_HEIGHT])
self.BORDER_COLOR_DICT = {'incomplete':(50,0,0),
'ready':(0,0,50),
'complete':(0,50,0),
'disconnected':(50,0,0),
'idle':(50,50,50),
'rai':(0,50,0),
'rfi':(0,50,0),
'loc':(0,50,0),
'nfb':(0,50,0)}
self.BG_COLOR_DICT = {'incomplete':(100,0,0),
'ready':(0,0,100),
'complete':(0,100,0),
'disconnected':(100,0,0),
'idle':(100,100,100),
'rai':(0,100,0),
'rfi':(0,100,0),
'loc':(0,100,0),
'nfb':(0,100,0)}
# dict entry for current timer set to use
self.PRE_REST_TIME = {'trial':0}
self.INTRO_TIME = {'trial':0}
self.FEEDBACK_TIME = {'trial':0}
self.ACTIVE_TIME = {'trial':0}
self.TRIALS = {'trial':0}
self.TRIAL_TIME = {'trial':0}
self.INTRO_TRIGGER_TIME = {'trial':0}
self.ACTIVE_TRIGGER_TIME = {'trial':0}
self.FEEDBACK_TRIGGER_TIME = {'trial':0}
# self-paced times
self.PRE_REST_TIME['s_p'] = 3
self.INTRO_TIME['s_p'] = 1
self.FEEDBACK_TIME['s_p'] = 2
self.ACTIVE_TIME['s_p'] = -1
self.TRIALS['s_p'] = 5
self.TRIAL_TIME['s_p'] = (self.PRE_REST_TIME['s_p'] + self.INTRO_TIME['s_p']
+ self.FEEDBACK_TIME['s_p'])
self.INTRO_TRIGGER_TIME['s_p'] = self.PRE_REST_TIME['s_p']
self.ACTIVE_TRIGGER_TIME['s_p'] = self.PRE_REST_TIME['s_p'] + self.INTRO_TIME['s_p']
self.FEEDBACK_TRIGGER_TIME['s_p'] = -1
self.TRIAL_TYPES = 9
self.trial_type_count = 0
# localizer times
# 40 seconds per trial
# 480s per run
self.PRE_REST_TIME['loc'] = 17
self.INTRO_TIME['loc'] = 1
self.ACTIVE_TIME['loc'] = 20
self.FEEDBACK_TIME['loc'] = 2
self.TRIALS['loc'] = 12
# neurofeedback times
# 60 seconds per trial
# 480s per run
self.PRE_REST_TIME['nfb'] = 27
self.INTRO_TIME['nfb'] = 1
self.ACTIVE_TIME['nfb'] = 30
self.FEEDBACK_TIME['nfb'] = 2
self.TRIALS['nfb'] = 8
self.NFB_INFO_TIME = 0.5
self.NFB_INFO_HEIGHT = 28
self.MVC_TIME = 19
self.INTRO_TRIGGER_TIME['loc'] = self.PRE_REST_TIME['loc']
self.ACTIVE_TRIGGER_TIME['loc'] = self.PRE_REST_TIME['loc'] + self.INTRO_TIME['loc']
self.FEEDBACK_TRIGGER_TIME['loc'] = self.ACTIVE_TRIGGER_TIME['loc'] + self.ACTIVE_TIME['loc']
self.INTRO_TRIGGER_TIME['nfb'] = self.PRE_REST_TIME['nfb']
self.ACTIVE_TRIGGER_TIME['nfb'] = self.PRE_REST_TIME['nfb'] + self.INTRO_TIME['nfb']
self.FEEDBACK_TRIGGER_TIME['nfb'] = self.ACTIVE_TRIGGER_TIME['nfb'] + self.ACTIVE_TIME['nfb']
self.CONTROL_TRIGGER_TIME = 1000*int(0.5*self.INTRO_TRIGGER_TIME['nfb'])
self.BASELINE_CALC_SHIFT = self.PRE_REST_TIME['nfb']-10
self.TRIAL_TIME['loc'] = (self.PRE_REST_TIME['loc'] + self.INTRO_TIME['loc']
+ self.ACTIVE_TIME['loc'] + self.FEEDBACK_TIME['loc'])
self.TRIAL_TIME['nfb'] = (self.PRE_REST_TIME['nfb'] + self.INTRO_TIME['nfb']
+ self.ACTIVE_TIME['nfb'] + self.FEEDBACK_TIME['nfb'])
#####################
# control variables #
#####################
self.TR = 1.
self.ADD_CONTROL_TRS = 5
self.TF_CONTROL = self.ACTIVE_TIME['nfb']+self.ADD_CONTROL_TRS
self.N_ACTIVE_TIME = self.ACTIVE_TIME['nfb']/self.TR+1
self.N_CONTROL_STEPS = self.TF_CONTROL/self.TR+1
self.CONTROL_MVC_MIN = 0.1
self.CONTROL_MVC_MAX = 0.4
self.u_vec = np.zeros((1,self.N_CONTROL_STEPS))
self.y_vec = np.zeros(self.N_CONTROL_STEPS)
gc.set_system(self)
##########################
# force sensor variables #
##########################
self.MVC_IN_PIXEL = 900
self.MVC_MIN = 0#0.05
self.ANGLE_ADD_DEG = 20
self.ANGLE_ADD = np.deg2rad(self.ANGLE_ADD_DEG)
self.ANGLE_MULT = 1+2*self.ANGLE_ADD/np.pi
self.set_mvc(MVC['mvc'])
self.DAQ_LPF_CUTOFF = 8
self.DAQ_LPF_ORDER = 3
self.CALIBRATE_BOOL = False # False or True
if self.CALIBRATE_BOOL:
fu.write_cal_header(self)
if SENSOR_ACTIVE:
if self.CALIBRATE_BOOL:
self.daq = Pydaq('Dev3/ai0:2', self.FRAME_RATE,
lp_filt_freq=14,
lp_filt_order=3,
force_params='force_params_cal.txt')
else:
self.daq = Pydaq('Dev3/ai0:1', self.FRAME_RATE,
lp_filt_freq=self.DAQ_LPF_CUTOFF,
lp_filt_order=self.DAQ_LPF_ORDER,
force_params='force_params_lab.txt')
self.scanner_daq = Pydaq('Dev1/ai2:3', self.FRAME_RATE,
lp_filt_freq=self.DAQ_LPF_CUTOFF,
lp_filt_order=self.DAQ_LPF_ORDER,
force_params='force_params_scanner.txt')
########################
# networking variables #
########################
IP = CONFIG['server-ip']
PORT = CONFIG['server-port']
self.SERVER_TARGET = 'http://{ip}:{port}/'.format(ip=IP,
port=PORT)
self.requests_running_bool = mp.Value('i', 1)
self.last_volume_received = mp.Value('i', 0)
self.pool = mp.Pool()
self.insta_mode = 'disconnected' # idle, rai, rfi, loc, nfb
self.roi_name = 'm1_left_a'
self.next_run_msg = ''
self.insta_complete = OrderedDict()
self.insta_complete['roi'] = 'incomplete'
self.insta_complete['rai'] = 'incomplete'
self.insta_complete['rfi'] = 'incomplete'
self.insta_complete['warp2rfi'] = 'incomplete'
self.insta_complete['glm'] = 'incomplete'
self.insta_complete['loc'] = 'incomplete'
self.raw_betas = {'active':0.,
'force':0.,
'complexity':0.,
'constant':0.}
self.psc_betas = {'active':0.5,
'force':1.5,
'complexity':1.0}
self.MAX_CONTROL = 3
self.MIN_CONTROL = 0.5
self.PSC_TARGET_LIST = [1.5,1.5,1.5,1.5]
self.RUN_TYPE_LIST = CONFIG['run-type-list']
self.NFB_TRS = int(self.TRIAL_TIME['nfb']
*self.TRIALS['nfb']/self.TR)
self.bold_rois_array = []
self.bold_rois_array.append(mp.Array('d',self.NFB_TRS))
self.REQUEST_WAIT_TIME = 0.1
self.requests_process = mp.Process(target = gn.requests_loop,
args = (self.SERVER_TARGET,
self.REQUEST_WAIT_TIME,
self.requests_running_bool,
self.last_volume_received,
self.bold_rois_array,))
####################################################
# 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_RAD = 75
self.FIXATION_WIDTH = 1.5*self.CURSOR_RAD
self.FIXATION_HEIGHT = 8
self.cursor = Cursor(self.screen, self.CURSOR_RAD)
self.timers = {}
self.init_timers()
self.TARGET_SUCCESS_TIME = .15
self.TARGET_MIN_TIME = .5
self.TARGET_RAD_MIN = -25
self.TARGET_RAD_MAX = 45
#####################
# target lists here #
#####################
# function to generate x length, all same mvc,
# all same phase
# and do {20s length} x {.1, .2, .4} x {0, 180}
self.MVC_LIST = []
self.PHASE_LIST = []
self.MVC_LIST.append(np.array([.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1,.1]))
self.MVC_LIST.append(np.array([.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2,.2]))
self.MVC_LIST.append(np.array([.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4,.4]))
self.PHASE_LIST.append(np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]))
self.PHASE_LIST.append(np.array([180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180]))
self.TRAINING_TARGET_LOC_LIST = []
self.loc_target_order = [0,3,1,4,2,5,1,4,0,5,3,2]
for mvc in self.MVC_LIST:
for phase in self.PHASE_LIST:
self.TRAINING_TARGET_LOC_LIST.append(self.gen_target_list(mvc,phase))
self.next_mvc_list = []
self.next_phase_list = []
self.next_target_loc_list = []
# auto-generate 1, 1.5, and 2 psc from dummy data
for psc_target in (1.,1.5,2.):
new_targets = self.gen_control_targets(psc_target)
self.TRAINING_TARGET_LOC_LIST.append(new_targets)
self.SAMPLE_MVC_LIST = np.array([.4,.1,.2,.1,.2,.4])
self.SAMPLE_PHASE_LIST = np.array([0,0,0,180,180,180])
self.SAMPLE_TARGET_LOC_LIST = self.gen_target_list(self.SAMPLE_MVC_LIST,
self.SAMPLE_PHASE_LIST)
self.set_targets(self.SAMPLE_TARGET_LOC_LIST)
######################
# 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_3
self.fixation_color = self.REG_FIXATION_COLOR
self.input_mode = 'mouse'
self.input_pos = np.array([0.0,0.0])
self.input_force = np.array([0.0,0.0])
self.cal_force = 0.
self.debug_bool = False
self.nfb_info_bool = False
self.run_mode = 'idle' # idle, mvc, trials
self.run_type = 's_p'
self.self_paced_bool = True
self.controller_active_bool = False
self.controller_calc_bool = False
self.nfb_run_count = 0
self.calc_score_bool = False
self.trial_time_array = np.array(())
self.set_timer_mode('s_p')
self.current_score = 0
self.score_color = self.GOOD_SCORE_COLOR
self.score_fixation_status = 'norm'
self.max_rec_mvc_both = 0
self.max_rec_mvc_x = 0
self.max_rec_mvc_y = 0
self.MVC_DISPLAY_CEIL = 100.
def gen_target_list(self, mvc_list, phase_list):
mvc_list = np.ravel(mvc_list)
phase_list = np.ravel(phase_list)
target_list = np.zeros((2,2*len(mvc_list)))
for idx in range(len(mvc_list)):
if phase_list[idx] == 0:
target_list[0][2*idx] = 0
target_list[1][2*idx] = -self.MVC_IN_PIXEL*mvc_list[idx]
target_list[0][2*idx+1] = 0
target_list[1][2*idx+1] = -self.MVC_IN_PIXEL*self.MVC_MIN
elif phase_list[idx] == 180:
target_list[0][2*idx] = self.MVC_IN_PIXEL*mvc_list[idx]
target_list[1][2*idx] = -self.MVC_IN_PIXEL*self.MVC_MIN
target_list[0][2*idx+1] = -self.MVC_IN_PIXEL*mvc_list[idx]
target_list[1][2*idx+1] = -self.MVC_IN_PIXEL*self.MVC_MIN
return np.transpose(target_list)
def set_mvc(self, mvc):
self.newtons_2_pixel_both = self.MVC_IN_PIXEL/(.5*mvc['both'])
self.newtons_2_pixel_x = self.MVC_IN_PIXEL/(mvc['x'])
self.newtons_2_pixel_y = self.MVC_IN_PIXEL/(mvc['y'])
def set_targets(self, target_list):
self.targets = []
# set targets
for target_loc in target_list:
target_rad = (self.TARGET_RAD_MAX -
(self.TARGET_RAD_MAX - self.TARGET_RAD_MIN)
* np.sqrt(target_loc[0]**2 + target_loc[1]**2)
/float(self.MVC_IN_PIXEL))
self.targets.append(Target(self.screen,
target_loc,
self.SENSOR_INPUT_OFFSET,
target_rad,
self.CURSOR_RAD,
self.TARGET_SUCCESS_TIME,
self.TARGET_MIN_TIME))
# link targets
self.current_target = self.targets[0]
self.targets[0].prev_target = None
self.targets[-1].next_target = None
for idx in range(len(self.targets)-1):
self.targets[idx].next_target = self.targets[idx+1]
self.targets[idx+1].prev_target = self.targets[idx]
def get_pos(self):
if self.input_mode=='mouse' or not(SENSOR_ACTIVE):
return pygame.mouse.get_pos()
else:
if self.loc == 'lab':
f_in_x, f_in_y = self.daq.get_force()
elif self.loc == 'scanner':
f_in_x, f_in_y = self.scanner_daq.get_force()
self.input_force = f_in_x, f_in_y
f_mag = max(f_in_x, f_in_y)
f_ang = np.arctan2(f_in_x, f_in_y)
f_out_x = f_mag*np.cos(2*self.ANGLE_MULT*f_ang-self.ANGLE_ADD)
f_out_y = f_mag*np.sin(2*self.ANGLE_MULT*f_ang-self.ANGLE_ADD)
ang_blend = (f_ang-.25*np.pi)/(.25*np.pi)
ang_blend_both = (max(0,(1-abs(ang_blend)))
*self.newtons_2_pixel_both)
if ang_blend < 0:
ang_blend_side = abs(ang_blend)*self.newtons_2_pixel_y
else:
ang_blend_side = abs(ang_blend)*self.newtons_2_pixel_x
newtons_2_pixel = ang_blend_both + ang_blend_side
pos_x = (self.SENSOR_INPUT_OFFSET[0]
+newtons_2_pixel*f_out_x)
pos_y = (self.SENSOR_INPUT_OFFSET[1]
-newtons_2_pixel*f_out_y)
return (pos_x,
pos_y)
def init_timers(self):
self.timers['loc'] = Timer(self.TRIAL_TIME['loc'],
self.TRIALS['loc'])
self.timers['nfb'] = Timer(self.TRIAL_TIME['nfb'],
self.TRIALS['nfb'])
self.timers['s_p'] = Timer(self.TRIAL_TIME['s_p'],
self.TRIALS['s_p'])
self.timers['trial'] = self.timers['loc']
self.timers['move'] = Timer(sys.maxint)
self.timers['mvc'] = Timer(self.MVC_TIME)
self.timers['nfb_info'] = Timer(self.NFB_INFO_TIME)
def set_timer_mode(self, mode):
self.timers['trial'] = self.timers[mode]
self.PRE_REST_TIME['trial'] = self.PRE_REST_TIME[mode]*1000
self.INTRO_TIME['trial'] = self.INTRO_TIME[mode]*1000
self.FEEDBACK_TIME['trial'] = self.FEEDBACK_TIME[mode]*1000
self.ACTIVE_TIME['trial'] = self.ACTIVE_TIME[mode]*1000
self.TRIALS['trial'] = self.TRIALS[mode]*1000
self.TRIAL_TIME['trial'] = self.TRIAL_TIME[mode]*1000
self.INTRO_TRIGGER_TIME['trial'] = self.INTRO_TRIGGER_TIME[mode]*1000
self.ACTIVE_TRIGGER_TIME['trial'] = self.ACTIVE_TRIGGER_TIME[mode]*1000
self.FEEDBACK_TRIGGER_TIME['trial'] = self.FEEDBACK_TRIGGER_TIME[mode]*1000
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:
if self.loc == 'lab':
self.daq.set_volts_zero()
elif self.loc == 'scanner':
self.scanner_daq.set_volts_zero()
elif event.key == pygame.K_m:
if self.input_mode == 'mouse':
self.input_mode = 'sensor'
elif self.input_mode == 'sensor':
self.input_mode = 'mouse'
elif event.key == pygame.K_d:
self.debug_bool = not self.debug_bool
elif event.key == pygame.K_s:
self.nfb_info_bool = not self.nfb_info_bool
elif event.key == pygame.K_SPACE:
self.run_type = 's_p'
gr.reset_for_next_run(self)
self.run_mode = 'trials'
elif event.key == pygame.K_7:
self.run_mode = 'mvc'
elif event.key == pygame.K_8:
gn.set_mode('loc', self.SERVER_TARGET)
self.run_type = 'loc'
self.next_run_msg = 'Ready for Localizer'
elif event.key == pygame.K_9:
gn.set_mode('nfb', self.SERVER_TARGET)
self.run_type = 'nfb'
self.next_run_msg = ('Ready for Run '
+ str(game.nfb_run_count + 1) + ' of 4')
elif event.key == pygame.K_5:
if ((self.run_type == 'loc'
or self.run_type == 'nfb')
and self.run_mode == 'idle'):
self.run_mode = 'trials'
self.next_run_msg = ''
gr.reset_for_next_run(self)
# control of insta_server
elif event.key == pygame.K_g:
gn.set_mode('idle', self.SERVER_TARGET)
elif event.key == pygame.K_h:
gn.set_mode('rai', self.SERVER_TARGET)
elif event.key == pygame.K_j:
gn.set_mode('rfi', self.SERVER_TARGET)
elif event.key == pygame.K_k:
gn.set_mode('loc', self.SERVER_TARGET)
elif event.key == pygame.K_l:
gn.set_mode('nfb', self.SERVER_TARGET)
# testing controls
# elif event.key == pygame.K_z:
# # figure out when/where to calculate this (add trigger)
# # need baseline calculation
# # and y_vec calculation
# psc_target = 2.
# # self.pool.apply_async(func = gc.calc_control,
# # args = (self,
# # psc_target,
# # self.u_vec,
# # self.y_vec),
# # callback = self.update_control_targets)
# u_vec = gc.calc_control(self,
# psc_target,
# self.u_vec,
# self.y_vec)
# self.update_control_targets(u_vec)
def run(self):
fu.write_trial_s_p_header(self)
fu.write_control_file(self)
fu.write_all_headers_timed(self)
self.requests_process.start()
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)
if self.current_target != None:
self.cursor.update_warn(time_passed,
not(self.current_target.success))
else:
self.cursor.update_warn(time_passed,
False)
self.draw_background()
if self.run_mode == 'trials':
gr.frame_based_updates(game, time_passed)
if self.debug_bool:
self.draw_debug(time_passed)
if self.nfb_info_bool:
self.draw_nfb_info(time_passed)
if self.run_mode == 'mvc':
gr.run_mvc(self, time_passed)
else:
self.cursor.draw()
pygame.display.flip()
def draw_targets(self):
current_bool = self.current_target != None
if current_bool:
next_bool = self.current_target.next_target != None
else:
next_bool = False
if next_bool:
next_next_bool = self.current_target.next_target.next_target != None
else:
next_next_bool = False
if next_next_bool:
self.current_target.next_target.next_target.draw(draw_type='next_next')
if next_bool:
self.current_target.next_target.draw(draw_type='next')
if current_bool:
self.current_target.draw(draw_type='current')
def draw_debug(self, time_passed):
fr = 1000/float(time_passed)
fr_msg = 'frame rate: ' + str(fr)
x_v_msg = 'x force: ' + str(self.input_force[0])
y_v_msg = 'y force: ' + str(self.input_force[1])
betas_active_msg = 'active beta: ' + str(self.psc_betas['active'])
betas_force_msg = 'force beta: ' + str(self.psc_betas['force'])
betas_complexity_msg = 'complexity beta: ' + str(self.psc_betas['complexity'])
lvr_msg = 'last vol: ' + str(self.last_volume_received.value)
gg.draw_msg(self.screen, fr_msg,
loc='left', pos=(10,33), size=28)
gg.draw_msg(self.screen, x_v_msg,
loc='left', pos=(10,66), size=28)
gg.draw_msg(self.screen, y_v_msg,
loc='left', pos=(10,99), size=28)
gg.draw_msg(self.screen, betas_active_msg,
loc='left', pos=(10,132), size=28)
gg.draw_msg(self.screen, betas_force_msg,
loc='left', pos=(10,165), size=28)
gg.draw_msg(self.screen, betas_complexity_msg,
loc='left', pos=(10,198), size=28)
gg.draw_msg(self.screen, lvr_msg,
loc='left', pos=(10,231), size=28)
if self.CALIBRATE_BOOL:
self.cal_force = self.daq.force_transform_cal(
self.daq.get_volts_cal())
z_v_msg = 'z lbs: ' + str(self.cal_force)
gg.draw_msg(self.screen, z_v_msg,
loc='left', pos=(10,231), size=28)
fu.cal_record(self, self.f_cal)
def draw_nfb_info(self, time_passed):
self.timers['nfb_info'].update(time_passed)
if self.timers['nfb_info'].time_limit_hit:
self.pool.apply_async(func = gn.get_complete,
args = (self.SERVER_TARGET,
self.insta_complete),
callback = self.update_complete)
self.pool.apply_async(func = gn.get_mode,
args = (self.SERVER_TARGET,),
callback = self.update_mode)
self.pool.apply_async(func = gn.get_betas,
args = (self.SERVER_TARGET,
self.roi_name,
self.raw_betas),
callback = self.update_betas)
self.timers['nfb_info'].time_limit_hit = False
self.timers['nfb_info'].count = 0
# show insta_mode and insta_complete
list_count = 0
for k,v in self.insta_complete.iteritems():
gg.draw_info_rect(self.screen, k + ': ' + v,
(255,255,255),self.BORDER_COLOR_DICT[v],
self.BG_COLOR_DICT[v],350,
self.NFB_INFO_HEIGHT,200,
50 + list_count*(8+self.NFB_INFO_HEIGHT))
list_count += 1
gg.draw_info_rect(self.screen, 'mode: ' + self.insta_mode,
(255,255,255),self.BORDER_COLOR_DICT[self.insta_mode],
self.BG_COLOR_DICT[self.insta_mode],350,
self.NFB_INFO_HEIGHT,200,
65 + list_count*(8+self.NFB_INFO_HEIGHT),
border_size=12)
def update_complete(self, insta_complete):
self.insta_complete = insta_complete
def update_betas(self, raw_betas):
self.raw_betas = raw_betas
if self.raw_betas['constant'] != 0:
for k,v in self.psc_betas.iteritems():
self.psc_betas[k] = 100*self.raw_betas[k]/self.raw_betas['constant']
gc.set_control_limits(self, self.psc_betas)
def update_control_targets(self, u_vec):
self.u_vec = self.u_vec + u_vec
u_vec_reduced = np.ravel(self.u_vec)
u_vec_reduced = u_vec_reduced[0:self.N_ACTIVE_TIME]
self.next_mvc_list, self.next_phase_list = gc.betas_to_mvc_phase(self,
self.psc_betas,
u_vec_reduced)
self.next_target_loc_list = self.gen_target_list(self.next_mvc_list,
self.next_phase_list)
self.set_targets(self.next_target_loc_list)
def calc_y_psc(self):
trial_num = self.timers['trial'].count-1
begin_rest_idx = trial_num*self.TRIAL_TIME['nfb'] + self.BASELINE_CALC_SHIFT
end_rest_idx = begin_rest_idx + self.PRE_REST_TIME['nfb'] - self.BASELINE_CALC_SHIFT + self.INTRO_TIME['nfb']
begin_move_idx = end_rest_idx
end_move_idx = begin_move_idx + self.ACTIVE_TIME['nfb'] + 1
rest_mean = 10e-9+np.mean(self.bold_rois_array[0][begin_rest_idx:end_rest_idx])
y_vec_psc = (100*(self.bold_rois_array[0][begin_move_idx:end_move_idx]-rest_mean)
/rest_mean)
self.y_vec[0:self.N_ACTIVE_TIME] = y_vec_psc[0:self.N_ACTIVE_TIME]
self.y_vec[self.N_ACTIVE_TIME:] = np.mean(y_vec_psc[self.N_ACTIVE_TIME
- self.ADD_CONTROL_TRS
:self.N_ACTIVE_TIME])
def gen_control_targets(self, psc_target):
u_vec = gc.calc_control(self, psc_target)
u_vec_reduced = u_vec[0:self.N_ACTIVE_TIME]
mvc_list, phase_list = gc.betas_to_mvc_phase(self,
self.psc_betas,
u_vec_reduced)
return self.gen_target_list(mvc_list,
phase_list)
def update_mode(self, mode):
self.insta_mode = mode
def increment_target(self):
self.current_target = self.current_target.next_target
def draw_background(self):
self.screen.fill(self.bg_color)
if self.run_mode == 'idle' and self.loc == 'lab':
instr_msg = ('Press Space for Run ' + str(self.trial_type_count+1)
+ ' of ' + str(self.TRIAL_TYPES))
gg.draw_msg(self.screen, instr_msg,
loc='center', pos=(.5*self.SCREEN_WIDTH,
.5*self.SCREEN_HEIGHT), size=48)
if self.next_run_msg != '':
gg.draw_msg(self.screen, self.next_run_msg,
loc='center', pos=(.5*self.SCREEN_WIDTH,
.4*self.SCREEN_HEIGHT), size=48)
def quit(self):
self.requests_running_bool.value = 0
self.requests_process.join()
sys.exit()
while 1:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
sys.exit()
elif event.key == pygame.K_z:
trooper.action()
elif event.key == pygame.K_UP:
cursor.update('up')
elif event.key == pygame.K_DOWN:
cursor.update('down')
elif event.key == pygame.K_LEFT:
cursor.update('left')
elif event.key == pygame.K_RIGHT:
cursor.update('right')
cursor_x, cursor_y = cursor.get_location()
trooper.update( cursor_x, cursor_y )
background.draw()
trooper.draw()
cursor.draw()
pygame.display.flip()
moveflag = 0
clock.tick(FPS)
tmpPlayerUnit.active = True
# setup enemies
activeEnemyUnits = []
for unit in currentMap.enemyUnits:
activeEnemyUnits.append(unit)
else:
screen.fill((0,0,0))
currentMap.draw(screen, xCamera, yCamera)
mainCursor.draw(screen)
for unit in playerUnits:
unit.draw(screen, tileSize, xCamera, yCamera)
for enemy in currentMap.enemyUnits:
enemy.draw(screen, tileSize, xCamera, yCamera)
myMapUnitUI.draw(screen, font)
if currentState == states.selectingAttack:
myBattleForcast.draw(screen, font, currentUnit, unitsInRange[attackUnitIndex])
elif currentState == states.selectingItems:
currentUnit.inventory.draw(screen, font)
elif currentState == states.selectingWeapon:
currentUnit.inventory.draw(screen, font)
elif currentState == states.selectingAction:
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()
class Scene(object):
image = None
def __init__(self, _engine):
super(Scene, self).__init__()
self._ais = []
self._engine = _engine
self._resx, self._resy = _engine.getResolution()
self.surface = pygame.Surface((self._resx, self._resy))
drawText(self.surface, "Wczytywanie mapy...", 48, (255, 255, 255),
(self._resx / 2, self._resy / 2))
self._map = Map(_engine)
self._hub = Hub(_engine, self._map)
self._cursor = Cursor(_engine, self._map)
self._ais.append(AI(_engine, self._map, _engine.players[0], 0))
self._ais.append(AI(_engine, self._map, _engine.players[1], 1))
def screenUpdated(self):
self._resx, self._resy = self._engine.getResolution()
self.surface = pygame.transform.smoothscale(self.surface,
(self._resx, self._resy))
self._map.screenUpdated()
self._hub.screenUpdated()
self._cursor.screenUpdated()
def show(self):
try:
while self._engine.tick():
for event in pygame.event.get():
if event.type == QUIT:
self._engine.quit()
elif event.type == KEYUP:
if event.key == K_ESCAPE:
raise Pause()
elif event.key == K_TAB:
for n, tank in enumerate(
self._engine.players[0]['tanks']):
if tank.focus:
tank.setFocus(False)
n = (n + 1) % len(
self._engine.players[0]['tanks'])
self._engine.players[0]['tanks'][
n].setFocus(True)
break
if self._engine.state & engine.STATE_FAIL:
self.surface.fill((0, 0, 0))
drawText(self.surface, "Game Over", 50, (140, 0, 0),
(self._resx / 2, self._resy / 2))
self._engine.show(self.surface)
continue
if self._engine.state & engine.STATE_WIN:
self.surface.fill((0, 0, 0))
drawText(self.surface, "Gratulacje!", 50, (0, 140, 0),
(self._resx / 2, self._resy / 2))
self._engine.show(self.surface)
continue
if self._engine.timeLeft() == (0, 0):
if self._engine.players[0]['score'] > self._engine.players[
1]['score']:
raise GameWin()
raise GameOver()
if not len(self._engine.players[0]['tanks']):
raise GameOver()
if not len(self._engine.players[1]['tanks']):
raise GameWin()
for tank in self._engine.players[0]['tanks']:
if tank.focus: break
else:
self._engine.players[0]['tanks'][0].setFocus(True)
keys = pygame.key.get_pressed()
if keys[K_LEFT]:
self._map.move(map.DIRECTION_LEFT)
if keys[K_RIGHT]:
self._map.move(map.DIRECTION_RIGHT)
if keys[K_UP]:
self._map.move(map.DIRECTION_UP)
if keys[K_DOWN]:
self._map.move(map.DIRECTION_DOWN)
for ai in self._ais:
ai.update()
self._map.update()
self._hub.update()
self._cursor.update()
self._map.draw(self.surface)
self._hub.draw(self.surface)
self._cursor.draw(self.surface)
self._engine.show(self.surface)
except Pause:
self._engine.state ^= engine.STATE_GAME | engine.STATE_MENU
except GameOver:
self._engine.state |= engine.STATE_FAIL
except GameWin:
self._engine.state |= engine.STATE_WIN
class Scene(object): image = None def __init__(self, _engine): super(Scene, self).__init__() self._ais = [] self._engine = _engine self._resx, self._resy = _engine.getResolution() self.surface = pygame.Surface((self._resx, self._resy)) drawText(self.surface, "Wczytywanie mapy...", 48, (255, 255, 255), (self._resx / 2, self._resy / 2)) self._map = Map(_engine) self._hub = Hub(_engine, self._map) self._cursor = Cursor(_engine, self._map) self._ais.append(AI(_engine, self._map, _engine.players[0], 0)) self._ais.append(AI(_engine, self._map, _engine.players[1], 1)) def screenUpdated(self): self._resx, self._resy = self._engine.getResolution() self.surface = pygame.transform.smoothscale(self.surface, (self._resx, self._resy)) self._map.screenUpdated() self._hub.screenUpdated() self._cursor.screenUpdated() def show(self): try: while self._engine.tick(): for event in pygame.event.get(): if event.type == QUIT: self._engine.quit() elif event.type == KEYUP: if event.key == K_ESCAPE: raise Pause() elif event.key == K_TAB: for n, tank in enumerate(self._engine.players[0]['tanks']): if tank.focus: tank.setFocus(False) n = (n + 1) % len(self._engine.players[0]['tanks']) self._engine.players[0]['tanks'][n].setFocus(True) break if self._engine.state & engine.STATE_FAIL: self.surface.fill((0, 0, 0)) drawText(self.surface, "Game Over", 50, (140, 0, 0), (self._resx / 2, self._resy / 2)) self._engine.show(self.surface) continue if self._engine.state & engine.STATE_WIN: self.surface.fill((0, 0, 0)) drawText(self.surface, "Gratulacje!", 50, (0, 140, 0), (self._resx / 2, self._resy / 2)) self._engine.show(self.surface) continue if self._engine.timeLeft() == (0, 0): if self._engine.players[0]['score'] > self._engine.players[1]['score']: raise GameWin() raise GameOver() if not len(self._engine.players[0]['tanks']): raise GameOver() if not len(self._engine.players[1]['tanks']): raise GameWin() for tank in self._engine.players[0]['tanks']: if tank.focus: break else: self._engine.players[0]['tanks'][0].setFocus(True) keys = pygame.key.get_pressed() if keys[K_LEFT]: self._map.move(map.DIRECTION_LEFT) if keys[K_RIGHT]: self._map.move(map.DIRECTION_RIGHT) if keys[K_UP]: self._map.move(map.DIRECTION_UP) if keys[K_DOWN]: self._map.move(map.DIRECTION_DOWN) for ai in self._ais: ai.update() self._map.update() self._hub.update() self._cursor.update() self._map.draw(self.surface) self._hub.draw(self.surface) self._cursor.draw(self.surface) self._engine.show(self.surface) except Pause: self._engine.state ^= engine.STATE_GAME | engine.STATE_MENU except GameOver: self._engine.state |= engine.STATE_FAIL except GameWin: self._engine.state |= engine.STATE_WIN
