def __init__(self, parent=None):
super(MainWindow, self).__init__()
QtWidgets.QMainWindow.__init__(self)
#Importando el archivo .css
instructions = Instructions()
with open("MainWindow.css") as f:
self.setStyleSheet(f.read())
self.setupUi(self)
self.setWindowIcon(QIcon("logo.png"))
self.instructions = QLabelClickable("Instrucciones...")
self.instructions.clicked.connect(lambda: instructions.show())
self.layout.addWidget(self.instructions)
#Lo que va a aparecer en cada QPlainText cuando esté vacío
self.array = ""
self.roads = ""
self.edge_labels = {}
self.characters.setTabStopWidth(
self.characters.fontMetrics().width(" ") * 10)
self.characters.setPlaceholderText(
"Ingrese vértices, aristas y caracteristicas.")
self.root_node.setPlaceholderText("Nodo Origen")
self.last_node.setPlaceholderText("Nodo Destino")
self.load_file.clicked.connect(self.loadFile)
self.create_map.clicked.connect(self.passToOpen)
self.create_table.clicked.connect(self.openTable)
#self.converter()
self.setFocus()
def main():
#global donePlaying
#global titleScreen
#global howToPlay
#global mainGame
#global gameOver
#global creditScreen
#global startMenu
#global menu
#global clearSprites
while Globals.donePlaying != True:
print Globals.donePlaying
if Globals.titleScreen == True:
Title.title()
elif Globals.howToPlay == True:
Instructions.instructions()
elif Globals.mainGame == True:
Game.game()
elif Globals.pauseMenu == True:
PauseMenu.pausemenu()
elif Globals.gameOver == True:
GameOver.gameover()
elif Globals.creditScreen == True:
Credits.credits()
elif Globals.winScreen == True:
Win.win()
def evalToRegInstr(self, p, reg):
try:
isInitialized = self.identifier.declaration.initialized
if isInitialized == False:
raise Exception("Variable '%s' is not initialized" % self.identifier.pidentifier)
if isinstance(self.identifier, ArrayAccess):
return Instructions.LOAD_ARRAY_VALUE_TO_REGISTER(p, self.identifier, reg)
return Instructions.LOAD_IDENTIFIER_VALUE_TO_REGISTER(p, self.identifier, reg)
except Exception as err:
raise Exception(str(err) + " at line %i" % self.lineNumber)
def evalToRegInstr(self, p, reg):
if self.operator == '+':
return Instructions.PLUS(p, self.left, self.right, reg)
if self.operator == '-':
return Instructions.MINUS(p, self.left, self.right, reg)
if self.operator == '*':
return Instructions.TIMES(p, self.left, self.right, reg)
if self.operator == '/':
return Instructions.DIVIDE(p, self.left, self.right, reg)
if self.operator == '%':
return Instructions.MODULO(p, self.left, self.right, reg)
else:
raise Exception("Operator '%s' not defined" % self.operator)
def memAddressToReg(self, p, reg1, reg2):
declaration = self.declaration
if not declaration.isArray():
raise Exception("'%s' is not an Array" % declaration.pidentifier)
memoryId = MemoryManager.getBlockId(self.pidentifier)
arrRangeFrom = declaration.rangeFrom
arrRangeTo = declaration.rangeTo
offset = self.index - arrRangeFrom
if offset < 0 :
raise Exception("Array out of bounds. Given %i, but range is (%i:%i)" % (self.index, arrRangeFrom, arrRangeTo))
Instructions.setRegisterConst(p, reg2, offset)
Instructions.setRegisterConst(p, reg1, memoryId)
Instructions.ADD(p, reg1, reg2)
def p_unset(p):
'unset : R_UNSET S_L_PAR register S_R_PAR S_SEMICOLON'
node_index = inc()
dot.node(node_index, 'unset()')
dot.edge(node_index, p[3].node_index)
p[0] = Instructions.Unset(node_index, p[3])
p[0].lineno = p.slice[1].lineno
def p_print(p):
'print : R_PRINT S_L_PAR operand S_R_PAR S_SEMICOLON'
node_index = inc()
dot.node(node_index, 'print()')
dot.edge(node_index, p[3].node_index)
p[0] = Instructions.Print(node_index, p[3])
p[0].lineno = p.slice[1].lineno
def p_main(p):
'''main : R_MAIN S_COLON list_instr
| R_MAIN error list_instr'''
node_index = inc()
dot.node(node_index, 'main')
dot.edge(node_index, p[3].node_index)
p[0] = Instructions.Main(node_index, p[3].instructions_list)
def p_label(p):
'''label : LABEL_NAME S_COLON list_instr
| LABEL_NAME error list_instr'''
node_index = inc()
dot.node(node_index, p.slice[1].value)
dot.edge(node_index, p[3].node_index)
p[0] = Instructions.Label(node_index, p[1], p[3].instructions_list)
def listen(self):
instructions = Instructions.Instructions("instructions_pl.txt",
"instrukcje gry")
try:
self.move_ = ''
os.system('python run_sarmata.py')
f = open("result.txt", "r")
self.message_ = f.read()
if self.message_ == "otwórz instrukcje" or self.message_ == "pokaż instrukcje":
instructions.show_instructions()
elif self.message_ == "poddaję się" or self.message_ == "poddaj się" \
or self.message_ == "zakończ grę" or self.message_ == "koniec gry":
sys.exit(1)
elif self.message_ == "repeat":
winsound.PlaySound("repeat_pl.wav", winsound.SND_FILENAME)
self.listen()
elif self.message_ == "pokaż dostępne ruchy" or self.message_ == "pokaż możliwe ruchy":
winsound.PlaySound("ask_of_figure_pl.wav",
winsound.SND_FILENAME)
self.checking_ = True
self.listen()
elif self.checking_:
self.move_ = self.converter_.convert_pos(c=self.message_)
else:
self.move_ = self.converter_.convert(c=self.message_)
f.close()
except:
if self.message_ == "poddaję się" or self.message_ == "poddaj się" \
or self.message_ == "zakończ grę" or self.message_ == "koniec gry" or self.message_ == "koniec":
sys.exit(1)
def __init__(self):
self.instructions_ = Instructions.Instructions("instructions_pl.txt",
"Instrukcje gry")
self.instructions_.show_instructions()
self.chess_engine_ = ChessEngine.ChessEngine(True)
self.gui_ = GUI.GUI()
self.converter_ = ChessConverter.ChessConverter()
def test_modificationGrid(self):
instructionList = ["switch", 1, 1, 2, 2]
inputInstruction = Instructions.Instruction(instructionList)
inputGrid = {
(0, 0): False,
(0, 1): False,
(0, 2): False,
(1, 0): False,
(1, 1): False,
(1, 2): False,
(2, 0): False,
(2, 1): False,
(2, 2): False
}
outputGrid = {
(0, 0): False,
(0, 1): False,
(0, 2): False,
(1, 0): False,
(1, 1): True,
(1, 2): True,
(2, 0): False,
(2, 1): True,
(2, 2): True
}
self.assertEqual(
Modification.modificationGrid(inputInstruction, inputGrid),
outputGrid)
def p_if(p):
'if : R_IF S_L_PAR expression S_R_PAR goto'
node_index = inc()
dot.node(node_index, 'if')
dot.edge(node_index, p[3].node_index)
dot.edge(node_index, p[5].node_index)
p[0] = Instructions.If(node_index, p[3], p[5])
p[0].lineno = p.slice[1].lineno
def p_assignation(p):
'''assignation : register S_EQUAL expression S_SEMICOLON'''
node_index = inc()
dot.node(node_index, '=')
dot.edge(node_index, p[1].node_index)
dot.edge(node_index, p[3].node_index)
p[0] = Instructions.Assignation(node_index, p[1], p[3])
p[0].lineno = p[1].lineno
def p_goto(p):
'goto : R_GOTO LABEL_NAME S_SEMICOLON'
node_index = inc()
dot.node(node_index, 'goto')
node_lbl_index = inc()
dot.node(node_lbl_index, p.slice[2].value)
dot.edge(node_index, node_lbl_index)
p[0] = Instructions.GoTo(node_index, p.slice[2].value)
p[0].lineno = p.slice[1].lineno
def toAssembly(lines):
commands = []
for line, lineno in lines:
try:
cmd = Instructions.new(line)
commands.append(cmd)
except SyntaxError as ex:
ex.lineno = lineno
raise ex
return commands
def sumLED(gridSize, theSource): #int, str
theGrid = Grid.Grid(gridSize).grid
theSource = urllib.request.urlopen(theSource)
for line in theSource:
theLine = str(line, 'utf-8')
#formatting
theLine = Instructions.instructionFormat(theLine)
#test
if not Instructions.instructionValidTypes(theLine):
pass
else:
theLine = Instructions.instructionValidRange(theLine, gridSize)
if not Instructions.instructionValidOrder(theLine):
pass
else:
theLine = Instructions.Instruction(theLine)
theGrid = Modification.modificationGrid(theLine, theGrid)
gridSum = sum(theGrid.values())
return gridSum
def DecodeCode(self):
newCode = []
for line in self.Code:
for directive, value in self.Directives.iteritems():
extracted = [piece for piece in re.split("\[|\]| |,|\t|\+", line.String)] # Split the instruction by spaces, commas, and brackets
if directive in extracted:
line.String = line.String.replace(directive, value)
if line.String.strip().endswith(':'):
Common.Error(line, "Label must be on the same line as an instruction")
self.Instructions.append(Instructions.DecodeLine(line))
newCode.append(line)
self.Code = newCode
def p_list_instr_p_instr(p):
'list_instr_p : instr list_instr_p'
node_index = inc()
instructions = [p[1]] + p[2].instructions_list
dot.node(node_index, 'instruction')
dot.edge(node_index, p[1].node_index)
p[0] = Instructions.InstructionsList(node_index, instructions)
try:
'para vincular la posible lista de instrucciones'
dot.edge(node_index, p[2].node_index)
except AttributeError:
'''es la última instrucción por lo que list_instr_p produce epsilon
def p_list_label(p):
'list_label : label list_label_p'
node_index = inc()
dot.node(node_index, 'label_list')
labels = [p[1]] + p[2].list_label
dot.edge(node_index, p[1].node_index)
p[0] = Instructions.LabelList(node_index, labels)
try:
'para vincular la posible lista de labels'
dot.edge(node_index, p[2].node_index)
except AttributeError:
'''es la última instrucción por lo que list_label_p produce epsilon
def event(self, event):
if event.type == PG.MOUSEBUTTONDOWN:
if self.selected[0]:
G.Globals.STATE = StoryBoard.StoryBoard(
"story_texts/intro.txt", self.images)
if self.selected[1]:
G.Globals.STATE = Instructions.Instructions()
if self.selected[2]:
G.Globals.STATE = Options.Options()
if self.selected[3]:
G.Globals.STATE = Score.Score()
if self.selected[4]:
G.Globals.RUNNING = False
def test_Instruction(self):
self.assertEqual(
Instructions.Instruction(["switch", 1, 2, 3, 4]).instruction,
["switch", 1, 2, 3, 4])
self.assertEqual(
Instructions.Instruction(["switch", 1, 2, 3, 4]).command, "switch")
self.assertEqual(
Instructions.Instruction(["switch", 1, 2, 3, 4]).start, (1, 2))
self.assertEqual(
Instructions.Instruction(["switch", 1, 2, 3, 4]).end, (3, 4))
self.assertEqual(
Instructions.Instruction(["switch", 1, 2, 3, 4]).x1, 1)
self.assertEqual(
Instructions.Instruction(["switch", 1, 2, 3, 4]).y1, 2)
self.assertEqual(
Instructions.Instruction(["switch", 1, 2, 3, 4]).x2, 3)
self.assertEqual(
Instructions.Instruction(["switch", 1, 2, 3, 4]).y2, 4)
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.SetBackgroundColour("#f0f0f0")
#-------------------------------------------------------------------
self.stbx1 = Instructions.My_StaticBox(self)
self.stbx2 = ArgumentOne.My_StaticBox(self)
self.stbx3 = ArgumentTwo.My_StaticBox(self)
self.stbx4 = ArgumentThree.My_StaticBox(self)
self.stbx5 = ArgumentFour.My_StaticBox(self)
self.stbx6 = ArgumentFive.My_StaticBox(self)
self.stbx7 = Eflags.My_StaticBox(self)
stbx1Sizer = wx.BoxSizer(wx.HORIZONTAL)
stbx2Sizer = wx.BoxSizer(wx.HORIZONTAL)
stbx3Sizer = wx.BoxSizer(wx.HORIZONTAL)
stbx4Sizer = wx.BoxSizer(wx.HORIZONTAL)
stbx1Sizer.Add(self.stbx1, 1, wx.EXPAND | wx.ALL, 0)
stbx2Sizer.Add(self.stbx2, 1, wx.EXPAND | wx.ALL, 0)
stbx2Sizer.Add(self.stbx3, 1, wx.EXPAND | wx.ALL, 0)
stbx3Sizer.Add(self.stbx4, 1, wx.EXPAND | wx.ALL, 0)
stbx3Sizer.Add(self.stbx5, 1, wx.EXPAND | wx.ALL, 0)
stbx4Sizer.Add(self.stbx6, 1, wx.EXPAND | wx.ALL, 0)
stbx4Sizer.Add(self.stbx7, 1, wx.EXPAND | wx.ALL, 0)
#----------
stbxSizer = wx.BoxSizer(wx.VERTICAL)
stbxSizer.Add(stbx1Sizer, 1, wx.EXPAND | wx.ALL, 0)
stbxSizer.Add(stbx2Sizer, 1, wx.EXPAND | wx.ALL, 0)
stbxSizer.Add(stbx3Sizer, 1, wx.EXPAND | wx.ALL, 0)
stbxSizer.Add(stbx4Sizer, 1, wx.EXPAND | wx.ALL, 0)
#----------
self.SetAutoLayout(True)
self.SetSizer(stbxSizer)
stbxSizer.Fit(self)
def generateCode(self, p):
if self.operator == '>':
return Instructions.CONDITION_GT(p, self.left, self.right)
if self.operator == '>=':
return Instructions.CONDITION_GEQ(p, self.left, self.right)
if self.operator == '<':
return Instructions.CONDITION_LT(p, self.left, self.right)
if self.operator == '<=':
return Instructions.CONDITION_LEQ(p, self.left, self.right)
if self.operator == '=':
return Instructions.CONDITION_EQ(p, self.left, self.right)
if self.operator == '!=':
return Instructions.CONDITION_NEQ(p, self.left, self.right)
else:
raise Exception("Undefined CONDITION operator '%s'" %
self.operator)
def memAddressToReg(self, p, reg1, reg2):
declaration = self.declaration
if not declaration.isArray():
raise Exception("'%s' is not an Array" % declaration.pidentifier)
memoryId = declaration.memoryId
arrRangeFrom = declaration.rangeFrom
arrRangeTo = declaration.rangeTo
indexIdentifier = Identifier(self.index)
# tab(5:15) [memoryId:memoryId+10]
# a := 7
# tab(a)
Instructions.LOAD_IDENTIFIER_VALUE_TO_REGISTER(p, indexIdentifier, reg2) # reg2 = a.value
Instructions.setRegisterConst(p, reg1, arrRangeFrom) # reg1 = arrRangeFrom
Instructions.SUB(p, reg2, reg1) # reg2 = reg2 - reg1 // offset
Instructions.setRegisterConst(p, reg1, memoryId) # reg1 = memoryId
Instructions.ADD(p, reg1, reg2) # reg1 = reg1 + reg2 // memid + offset
def test_modificationEntry(self):
self.assertEqual(
Modification.modificationEntry(
Instructions.Instruction(["on", 1, 2, 3, 4]), True), True)
self.assertEqual(
Modification.modificationEntry(
Instructions.Instruction(["off", 1, 2, 3, 4]), True), False)
self.assertEqual(
Modification.modificationEntry(
Instructions.Instruction(["on", 1, 2, 3, 4]), False), True)
self.assertEqual(
Modification.modificationEntry(
Instructions.Instruction(["off", 1, 2, 3, 4]), False), False)
self.assertEqual(
Modification.modificationEntry(
Instructions.Instruction(["switch", 1, 2, 3, 4]), True), False)
self.assertEqual(
Modification.modificationEntry(
Instructions.Instruction(["switch", 1, 2, 3, 4]), False), True)
def main():
global mode, usr, syst,svc,abt,und,irq,fiq, abtRegister, usrRegister, svcRegister, fiqRegister,irqRegister,undRegister,systRegister
global ADC, ADD, AND, BIC, CMN, CMP, EOR, MOV, MVN,ORR, RSB, RSC, SBC, SUB, TEQ, TST, ADC, ADD, AND, BIC, CMN, CMP, EOR, MOV, MVN,ORR, RSB, RSC, SBC, SUB, TEQ, TST,COND
global MRS, MSR , BX, CLZ, BLX2, BLX1,LDR, LDRB
global LDRBT,LDRH,LDRSB,LDRSH,LDRT,STR,STRB,STRBT,STRH,STRTMLA,MUL,SMLAL,SMULL,UMLAL,UMULL, LDM1, LDM2, LDM3, STM1, STM2
global LR,PC,CPSR,SPSR
addMode = 0
usr = 0
syst = 1
svc = 2
abt = 3
und = 4
irq = 5
fiq = 6
mode = usr
LR = 14
PC = 15
CPSR = 16
SPSR = 17
## will add ability to pass in file name as arguement.
#filename = 'code/template.machine'
#filename = 'code/instTests/adc/adc.test'
# inits our regs
register = regInit()
# inits our memory
# sets the registers up
register = setMode(mode, usr, register)
# ganks a binary, converts to hex
#g = g[0].strip("\n")
# print()
# print(g)
Memory, register[PC] = elf.loadfile(sys.stdin.readlines()[0].strip("\n"))
#print(hex(entry))
#print(Memory)
ADC, ADD, AND, BIC, CMN, CMP, EOR, MOV, MVN,ORR, RSB, RSC, SBC, SUB, TEQ, TST = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16
# Misc Insts, Branching.
MRS, MSR , BX, CLZ, BLX2, BLX1, BBL = 17,18,19,20,21,22,48
# Multiplies:
MLA,MUL,SMLAL,SMULL,UMLAL,UMULL = 23,24,25,26,27,28
## load/store mults:
LDM1, LDM2, LDM3, STM1, STM2 = 29,30,31,32,33
# extra load/store instructions:
LDR, LDRB, LDRBT,LDRH,LDRSB,LDRSH,LDRT,STR,STRB,STRBT,STRH,STRT= 34,35,36,37,38,39,40,41,42,43,44,45
DP32BitImmediate = 0
DPImmediateShift= 1
DPRegShift = 2
MLSImmOffIndex = 3
MLSRegOffIndex = 4
LSImmOffIndex = 5
LSRegOffIndex = 6
LSScaleRegOffIndex = 7
LSMultiple = 8
UND = 96
IRREL = 10
UNPRED = 99
BKPT = 98
SWI = 97
PC = 15
CPSR = 16
SPSR = 17
COND = 0
#barrelShifter = BarrellShifter()
#register[PC] = 0x8054
while True: # represents the main loop
for i in range(16):
print("R[{0}] :".format(i),hex(register[i]))
word = fetch(Memory, register)
addMode = BarrellShifter.determineMode(word)
inst = Instructions.parseInstruction(word)
register[PC] = register[PC] +4
instStr = setInstString(inst)
if inst == BKPT or inst == SWI:
handleException(word,inst,addMode)
else:
if addMode == DP32BitImmediate or addMode == DPImmediateShift or addMode == DPRegShift:
shifter_operand, shifter_carry_out, register = BarrellShifter.do_data_proc(word,addMode,inst,register)
register = Instructions.do_dp(shifter_operand,shifter_carry_out,register,inst,word)
elif addMode == MLSImmOffIndex or addMode == MLSRegOffIndex:
address,register = BarrellShifter.do_misc_l_s(word,addMode,inst,register)
register, Memory = Instructions.do_LS(address,Memory,register,inst,word)
elif addMode == LSMultiple:
start_address,end_address,register = BarrellShifter.do_l_s_mult(word,addMode,inst,register)
Memory, register = Instructions.do_LSM(start_address,end_address,Memory,register,inst,word)
elif addMode == LSImmOffIndex or addMode == LSRegOffIndex or addMode == LSScaleRegOffIndex:
address, register = BarrellShifter.do_l_s(word,addMode,inst,register)
register, Memory = Instructions.do_LS(address,Memory,register,inst,word)
elif inst >22 and inst <29:
register = Instructions.do_multiplies(Memory,register,word,inst,addMode)
else:
register = Instructions.do_misc(Memory,register,word,inst,addMode)
print("Word: ", bin(word),". Add Mode: ", addMode, "Inst: ", instStr)
def RUN():
global SignalValue
FPSclock = pygame.time.Clock()
FPSclock.tick(FPS)
StimList = LoadStim(LanuageNumber)
BaseStim = LoadBaseStim(LanuageNumber)
mRT = []
mAcc = []
while True:
[ConsentScreen(i) for i in range(2)]
[Instructions(i) for i in range(28)]
for block in range(Blocks):
RT = []
Acc = []
RspList = []
AngleList = []
CndList = []
MouseList = []
SignalContrast = []
ContrastListN = []
MovementOnset = []
TimeInMotion = []
for trial, contrastN in cnd_list_contrasts(Trials,blockN=block):
if trial == 111:
nRT = np.asarray(RT); nAcc = np.asarray(Acc)
mRT.append( np.mean( np.abs( nRT[nRT > -Max_Stim_Time] ) ) / 1000 ) # Mean RT excluding Timeouts
mAcc.append( np.mean( nAcc ) * 100 )
SaveDict = OrderedDict()
SaveDict['NativeLangNumber'] = [NativeNumber] * len(RT)
SaveDict['LanuageNumber'] = [LanuageNumber] * len(RT)
SaveDict['SessionNumber'] = [SessionNumber] * len(RT)
SaveDict['Block'] = [block]*len(RT)
SaveDict['TrialNum'] = list(range(1,len(RT)+1))
SaveDict['ConditionNumber'] = CndList
SaveDict['Response'] = RspList
SaveDict['Accuracy'] = Acc
SaveDict['RT'] = RT
SaveDict['MovementOnsetTime'] = MovementOnset
SaveDict['TimeInMotion'] = TimeInMotion
SaveDict['SignalContrast'] = SignalContrast
SaveDict['SignalContrastNumber'] = ContrastListN
SaveDict['StimDisplayTime'] = [Stim_Display_Time] * len(RT)
SaveDict['MaskTime'] = [Mask_Time] * len(RT)
SaveDict['MaxResponseTime'] = [Max_Stim_Time] * len(RT)
SaveDict['MousePositionXY'] = MouseList
SaveDict['MouseAngle'] = AngleList
SaveDict['WheelOrder'] = [WheelOrder] * len(RT)
SaveDict['NoiseMuSigma'] = zip([NoiseMu], [NoiseSigma]) * len(RT)
SaveDict['ParticipantID'] = [ParticipantID]*len(RT)
SaveDict['LanuageTested'] = [PartPrefix] * len(RT)
SaveDict['SessionTested'] = [SessionLetter] * len(RT)
SaveDict['NativeLanuage'] = [NativeLanuage] * len(RT)
SaveDict['Date'] = [Date] * len(RT)
SaveDict['ResponseDevice'] = [Device] * len(RT)
Save(block, SaveDict)
Feedback( block, mRT, mAcc )
if block == 0:
SignalValue = int(round(np.mean(SignalContrast[-30:]))) # Changed to -30 rather than -20 during piloting
ConstantSignalValue = SignalValue
else:
if block > 0:
# 3-x-1 Design
SignalValue = range(ConstantSignalValue-NContrastLevels+2, ConstantSignalValue+2)[contrastN]
else:
contrastN = 0
pre_trial_screen()
DrawNoisyStim( trial, BaseStim, Signal=SignalValue, mu=NoiseMu, sigma=NoiseSigma, UPDATE=True )
wait_time(Stim_Display_Time) # Non-Response Interval
DisplayMask(MaskD, FigSize)
wait_time(Mask_Time) # Mask Display
DrawWheel(LoadedStimList=StimList) # RTI begins
if JOYSTICK == []:
Signal = MouseResponse( trial, block, InnerRadius, RT, Acc, RspList, AngleList, MouseList, Signal=SignalValue, MouseStart=MovementOnset, MotionRT=TimeInMotion )
else:
JoystickResponse( trial, block, InnerRadius, RT, Acc, RspList, AngleList, MouseList )
CndList.append( trial )
SignalContrast.append(SignalValue)
ContrastListN.append( contrastN )
SignalValue = Signal
def menu():
pygame.init()
Rect = screen.get_rect()
pygame.mouse.set_visible(True)
top = (367, 311)
second = (367, 363)
third = (367, 413)
bottom = (367, 465)
x_left = 367
x_right = 657
selection = ''
playsound = False
running = True
mus_pause = False
#images
selectionbar_file_name = os.path.join("img","selection_outline.png")
outline = pygame.image.load(selectionbar_file_name)
icon_img = os.path.join("img", "icon.png")
icon = pygame.image.load(icon_img)
pygame.display.set_icon(icon)
# Create background
returnscreen()
# Load sounds
roll_over_sound = load_sound('menu_rollover.wav')
click_sound = load_sound('menu_click.wav')
#load/start music
pygame.mixer.music.load(os.path.join('snd', 'Mechanolith.mp3'))
pygame.mixer.music.play(-1)
all = pygame.sprite.RenderUpdates()
MenuOutline.containers = all
while running:
time_passed = clock.tick(60)
in_box1 = (pygame.mouse.get_pos()[0] <= x_right and
pygame.mouse.get_pos()[0] >= x_left and
pygame.mouse.get_pos()[1] <= 351 and
pygame.mouse.get_pos()[1] >= 311)
in_box2 = (pygame.mouse.get_pos()[0] <= x_right and
pygame.mouse.get_pos()[0] >= x_left and
pygame.mouse.get_pos()[1] <= 402 and
pygame.mouse.get_pos()[1] >= 363)
in_box3 = (pygame.mouse.get_pos()[0] <= x_right and
pygame.mouse.get_pos()[0] >= x_left and
pygame.mouse.get_pos()[1] <= 452 and
pygame.mouse.get_pos()[1] >= 413)
in_box4 = (pygame.mouse.get_pos()[0] <= x_right and
pygame.mouse.get_pos()[0] >= x_left and
pygame.mouse.get_pos()[1] <= 505 and
pygame.mouse.get_pos()[1] >= 465)
# Sound
if (in_box1 or in_box2 or in_box3 or in_box4) and playsound:
roll_over_sound.play()
playsound = False
if not (in_box1 or in_box2 or in_box3 or in_box4):
playsound = True
# User Input
for event in pygame.event.get():
if in_box1:
MenuOutline(top, outline, x_right, x_left, 351, 311)
selection = 'start game'
elif in_box2:
MenuOutline(second, outline, x_right, x_left, 402, 363)
selection = 'instructions'
elif in_box3:
MenuOutline(third, outline, x_right, x_left, 452, 413)
selection = 'highscores'
elif in_box4:
MenuOutline(bottom, outline, x_right, x_left, 505, 465)
selection = 'quit'
else:
selection = ''
if event.type == MOUSEBUTTONDOWN:
if selection == 'start game':
click_sound.play()
game = color_choice.color_choice()
returnscreen()
elif selection == 'instructions':
click_sound.play()
instructions = Instructions.instructions()
returnscreen()
elif selection == 'highscores':
click_sound.play()
highscores = Highscores.highscores(None, 0)
returnscreen()
elif selection == 'quit':
click_sound.play()
pygame.time.delay(300)
running = False
if event.type == KEYDOWN:
if event.key == K_m:
if mus_pause:
mus_pause = False
pygame.mixer.music.unpause()
else:
mus_pause = True
pygame.mixer.music.pause()
all.clear(screen, background)
all.update()
dirty = all.draw(screen)
pygame.display.update(dirty)
sys.exit(0)
def showInstructions(self):
Instructions(self)
eventRecorder = Data_Handler(savePath)
eventRecorder.Competitive = expInfo['Competitive']
games = Game(window, savePath, eventRecorder)
if expInfo['Restart?'] != 'No':
restart = True
else: # dont want to restart (broke during tutorial)
if expInfo['skipIntro'] == 'No': # do want to skip intro
if 'Temp' in os.listdir(os.path.expanduser('~') + '/Desktop'):
shutil.rmtree(savePath)
print 'here'
os.mkdir(savePath) # if subject did not restart, make a new temporary savepath dir.
restart = False
Instructions.Run_AllIntro(window, savePath,expInfo['skipIntro'],expInfo['Competitive'])
games.window.flip()
# Wait for main experiment to begin and tell server ready to play.
visual.TextStim(win = window, text = 'Please wait while all participants ' +
'complete the instructions.\n\nThe game will begin shortly.').draw()
games.window.flip()
gamesock.sendto(expInfo['ContactID']+'-'+expInfo['Computer'],Mother)
gamesock.setblocking(1)
# When task begins server sends the subject their ID.
SubjID = gamesock.recvfrom(100)[0]
eventRecorder.clock.reset()
#___________________________________ LET THE GAMES BEGIN ___________________________________
while 1:
# Ask for new game
if restart:
BetweenText = []
txt = 'This is the end of the first round of tasks. There will be two more rounds similar to this one. \n\n'
#txt += 'In the "DOES IT HAVE MEANING?" task, please respond as quickly as possible. '
#txt += '\n\nThe Q key will always correspond to "' + responses[0]
#txt += '" and the P key to "' + responses[1] + '". Make sure your index fingers rest on these keys.\n\n'
txt += 'Take a short break if you want to. Press any key to continue to the next block of the experiment.'
BetweenText.append(txt)
txt = 'This is the end of the second round of tasks. There will be one more round similar to this one. \n\n'
#txt += 'In the "DOES IT HAVE MEANING?" task, please respond as quickly as possible. '
#txt += '\n\nThe Q key will always correspond to "' + responses[0]
#txt += '" and the P key to "' + responses[1] + '". Make sure your index fingers rest on these keys.\n\n'
txt += 'Take a short break if you want to. Press any key to continue to the next block of the experiment.'
BetweenText.append(txt)
instr = Instructions.Instructions(myWin,responses)
instr.Run()
for tsk in range(3):
if tsk == 1:
# priming
instructions.setText(ImageReelText)
instructions.draw()
myWin.flip()
event.waitKeys()
myWin.flip()
#core.wait(interTaskTime-.5)
#myWin.flip()
core.wait(0.5)
task = ImageReelTask.Task(myWin,"Files/images/" + imageFolders[taskOrder[tsk]-1])
else:
