def draw(canvas): global interactions, addedInteractions, numberOfPlatforms, madeGoat, framecount lv1background.update(canvas) platforms.draw(canvas) if not addedInteractions: for i in range(len(platforms.getCoords())): interaction = Interaction(player1, platforms.coords[i]) interactions.append(interaction) addedInteractions = True for i in range(len(platforms.getCoords())): platforms.coords[i].p1 = Vector( platforms.coords[i].getp1().getP()[0], platforms.coords[i].getp1().getP()[1] + 1) platforms.coords[i].p2 = Vector( platforms.coords[i].getp2().getP()[0], platforms.coords[i].getp2().getP()[1] + 1) tempPlatform = Platform2(0) if platforms.coords[i].p1.y > 700: platforms.coords.pop(i) if i > 1: while not (abs(tempPlatform.getx1() -platforms.coords[i-1].getx1()) > platforms.DISTANCE*platforms.difficulty or \ abs(tempPlatform.getx2() - platforms.coords[i - 1].getx2()) > platforms.DISTANCE * platforms.difficulty): tempPlatform = Platform2(0) platforms.coords.insert(i, tempPlatform) tempInteraction = Interaction(player1, tempPlatform) else: tempInteraction = Interaction(player1, platforms.coords[i]) interactions.pop(i) interactions.insert(i, tempInteraction) numberOfPlatforms += 1 if numberOfPlatforms % 5 == 0 and not madeGoat: #numberOfPlatforms % 5 == 0 and not madeGoat makeGoat(platforms.coords[len(platforms.coords) - 1]) madeGoat = True for j in range(len(monsters)): if platforms.coords[i] == monsters[j].platform: monsters[j].pos = Vector( monsters[j].pos.x, platforms.coords[i].p1.y - platforms.coords[i].thickness - monsters[j].frameHeight / 2) monsters[j].update(canvas) if monsters[j].pos.y > 630: monsters.pop(j) madeGoat = False framecount += 1 for i in range(len(interactions)): if platforms.coords[i].covers(player1.pos): interactions[i].update() platforms.draw(canvas) player1.update(canvas)
def draw(canvas): global interactions , addedInteractions, numberOfPlatforms , framecount,numberOfGoats,goats lv1background.update(canvas) platforms.draw(canvas) if not addedInteractions: for i in range(len(platforms.getCoords()) ): interaction = Interaction(player1, platforms.coords[i]) interactions.append(interaction) addedInteractions = True for i in range(len(platforms.getCoords())): platforms.coords[i].p1 = Vector(platforms.coords[i].getp1().getP()[0],platforms.coords[i].getp1().getP()[1] + 1) platforms.coords[i].p2 = Vector(platforms.coords[i].getp2().getP()[0],platforms.coords[i].getp2().getP()[1] + 1) tempPlatform = Platform2(0) if platforms.coords[i].p1.y > 700: platforms.coords.pop(i) if i > 1: while not (abs(tempPlatform.getx1() -platforms.coords[i-1].getx1()) > platforms.DISTANCE*platforms.difficulty or \ abs(tempPlatform.getx2() - platforms.coords[i - 1].getx2()) > platforms.DISTANCE * platforms.difficulty): tempPlatform = Platform2(0) platforms.coords.insert(i,tempPlatform) tempInteraction = Interaction(player1, tempPlatform) else: tempInteraction = Interaction(player1, platforms.coords[i]) interactions.pop(i) interactions.insert(i,tempInteraction) if random.randint(0,1) > 0.5 and numberOfGoats<3 and platforms.coords[i].p1.y < player1.pos.y: #numberOfPlatforms % 5 == 0 and not madeGoat makeGoat(platforms.coords[i]) numberOfGoats+=1 madeGoat = True #print("len monsters:",len(monsters)) monstersToPop = [] for j in range(len(goats)): print("len monsters:",len(goats)) if platforms.coords[i] ==goats[j].platform: goats[j].pos = Vector(goats[j].pos.x,platforms.coords[i].p1.y-platforms.coords[i].thickness-goats[j].frameHeight/2) goats[j].update(canvas) #print("pos y:",monsters[j].pos.y) if goats[j].pos.y > 630: monstersToPop.append(goats[j]) numberOfGoats-=1 print("monsters to pop:",monstersToPop) for j in range(len(monstersToPop)): goats.remove(monstersToPop[j]) framecount += 1 for i in range(len(interactions)): if platforms.coords[i].covers(player1.pos): interactions[i].update() platforms.draw(canvas) player1.update(canvas)
def draw(canvas): global interactions, addedInteractions platforms.draw(canvas) if not addedInteractions: for i in range(len(platforms.getCoords())): interaction = Interaction(player1, platforms.coords[i]) interactions.append(interaction) addedInteractions = True #platform2.draw(canvas) for i in range(len(platforms.getCoords())): platforms.coords[i].p1 = Vector( platforms.coords[i].getp1().getP()[0], platforms.coords[i].getp1().getP()[1] + 1) platforms.coords[i].p2 = Vector( platforms.coords[i].getp2().getP()[0], platforms.coords[i].getp2().getP()[1] + 1) #print("platform: ",platforms.coords[i]) tempPlatform = Platform2(0) if platforms.coords[i].p1.getP()[1] > 700: platforms.coords.pop(i) if i > 1: while not (abs(tempPlatform.getx1() -platforms.coords[i-1].getx1()) > platforms.DISTANCE*platforms.difficulty or \ abs(tempPlatform.getx2() - platforms.coords[i - 1].getx2()) > platforms.DISTANCE * platforms.difficulty): tempPlatform = Platform2(0) platforms.coords.insert(i, tempPlatform) tempInteraction = Interaction(player1, tempPlatform) else: tempInteraction = Interaction(player1, platforms.coords[i]) interactions.pop(i) interactions.insert(i, tempInteraction) #print("inserted new interaction:",platforms.coords[i]) for i in range(len(interactions)): # print(len(interactions)) # print("coords: ",len(platforms.coords)) #print(platforms.coords[i].covers(player1.pos)) #print(player1.pos.getP()[1]-player1.frameHeight/2<platforms.coords[i].p1.getP()[1]) and pos.getP()[1]<self.yCoord //and player1.pos.getP()[1]-player1.frameHeight<platforms.coords[i].p1.getP()[1] #distPlayerPlat = platforms.coords[i].p1.getP()[1] - player1.pos.getP()[1]-player1.frameHeight if platforms.coords[i].covers( player1.pos ): #and player1.pos.getP()[1]-player1.frameHeight<platforms.coords[i].p1.getP()[1]: interactions[i].update() #print("i: ",i) #canvas.draw_line(player1.getCoordinates().getP(),platform2.p1.getP(),3,"blue") #canvas.draw_line(player1.getCoordinates().getP(),platform2.p2.getP(),3,"blue") platforms.draw(canvas) #canvas.draw_line((player1.getCoordinates() + Vector(0,player1.frameHeight/2)).getP(),(abs(platform2.p2.x - platform2.p1.x),platform2.p1.y),3,"yellow") #platform1.draw(canvas) #player2.update(canvas) player1.update(canvas)
def draw(canvas): global interactions, addedInteractions lv1.update(canvas) platforms.draw(canvas) if not addedInteractions: for i in range(len(platforms.getCoords())): interaction = Interaction(player1, platforms.coords[i]) interactions.append(interaction) addedInteractions = True for i in range(len(platforms.getCoords())): platforms.coords[i].p1 = Vector( platforms.coords[i].getp1().getP()[0], platforms.coords[i].getp1().getP()[1] + 0.5) platforms.coords[i].p2 = Vector( platforms.coords[i].getp2().getP()[0], platforms.coords[i].getp2().getP()[1] + 0.5) tempPlatform = Platform2(0) if platforms.coords[i].p1.getP()[1] > 700: platforms.coords.pop(i) if i > 1: while not (abs(tempPlatform.getx1() - platforms.coords[ i - 1].getx1()) > platforms.DISTANCE * platforms.difficulty or \ abs(tempPlatform.getx2() - platforms.coords[ i - 1].getx2()) > platforms.DISTANCE * platforms.difficulty): tempPlatform = Platform2(0) platforms.coords.insert(i, tempPlatform) tempInteraction = Interaction(player1, tempPlatform) else: tempInteraction = Interaction(player1, platforms.coords[i]) interactions.pop(i) interactions.insert(i, tempInteraction) for i in range(len(interactions)): if platforms.coords[i].covers(player1.pos): interactions[i].update() # print("i: ",i) platforms.draw(canvas) player1.update(canvas)
def makeChild(self,parentconf,frame=1,usetype='all',makeCellList = True, redobox=False): self.debug = parentconf.debug self.param = parentconf.param # Single frame for the child self.multiopt = "single" # And we have already narrowed down to the types we are looking for self.usetype = "all" self.sigma = parentconf.sigma self.monodisperse = parentconf.monodisperse if parentconf.multiopt=="single": useparts = parentconf.getUseparts(usetype) self.N = len(useparts) self.rval = parentconf.rval[useparts,:] self.vval = parentconf.vval[useparts,:] self.nval = parentconf.nval[useparts,:] self.radius = parentconf.radius[useparts] self.ptype = parentconf.ptype[useparts] self.flag = parentconf.flag[useparts] else: useparts = parentconf.getUseparts(usetype,frame) self.N = len(useparts) self.rval = parentconf.rval[frame,useparts,:] self.vval = parentconf.vval[frame,useparts,:] self.nval = parentconf.nval[frame,useparts,:] self.radius = parentconf.radius[frame,useparts] self.ptype = parentconf.ptype[frame,useparts] self.flag = parentconf.flag[frame,useparts] # For defect tracking vnorm = np.sqrt(self.vval[:,0]**2 + self.vval[:,1]**2+self.vval[:,2]**2) self.vhat = self.vval / np.outer(vnorm,np.ones((3,))) # Generating new interaction assuming that it's not monodisperse and contains a single k #def __init__(self,param,sigma,ignore=False,debug=False): self.inter=Interaction(self.param,self.sigma,False,True) #self.geom=geometries[param.constraint](param) #self.inter = parentconf.inter self.geom = parentconf.geom if makeCellList: if redobox: rmin = np.zeros((3,)) rmax = np.zeros((3,)) rmin[0] = np.amin(self.rval[:,0])-self.sigma rmin[1] = np.amin(self.rval[:,1])-self.sigma rmin[2] = np.amin(self.rval[:,2])-self.sigma rmax[0] = np.amax(self.rval[:,0])+self.sigma rmax[1] = np.amax(self.rval[:,1])+self.sigma rmax[2] = np.amax(self.rval[:,2])+self.sigma self.makeCellList(1,rmin,rmax) # def makeCellList(self,frame=1,rmin='default',rmax='default'): else: self.makeCellList(1)
def test_wealth_growth_nd(self): pl1, pl2 = get_two_players({ 'red': 0, 'blue': 0 }, { 'red': 1, 'blue': 1 }) interact = Interaction.Interaction(self.table) interact.interact(pl1, pl2) new_wealth_pl1 = pl1.wealth new_wealth_pl2 = pl2.wealth self.assertEqual(new_wealth_pl1, self.table[0, 1]) self.assertEqual(new_wealth_pl2, self.table[1, 0])
def fromPython(self,param,rval,vval,nval,radius,ptype,flag,makeCellList=True,redobox=False): self.debug = False self.param = param self.multiopt = "single" self.usetype = "all" self.rval = rval self.vval = vval self.nval = nval self.radius = radius self.ptype = ptype self.flag = flag # For defect tracking vnorm = np.sqrt(self.vval[:,0]**2 + self.vval[:,1]**2+self.vval[:,2]**2) self.vhat = self.vval / np.outer(vnorm,np.ones((3,))) self.N = len(radius) self.sigma = np.mean(radius) print("New sigma is " + str(self.sigma)) self.monodisperse = False # Generating new interaction assuming that it's not monodisperse and contains a single k #def __init__(self,param,sigma,ignore=False,debug=False): self.inter=Interaction(self.param,self.sigma,True,False) print (param.box) self.geom=geometries[param.constraint](param) if makeCellList: # Cut off the boxes. Curently only on minimal z, for cornea. Others is less of a problem #if self.geom.manifold == 'sphere': # zmin = np.amin(self.rval[:,2])-self.sigma #else: # zmin = 'all' if redobox: rmin = np.zeros((3,)) rmax = np.zeros((3,)) rmin[0] = np.amin(self.rval[:,0])-self.sigma rmin[1] = np.amin(self.rval[:,1])-self.sigma rmin[2] = np.amin(self.rval[:,2])-self.sigma rmax[0] = np.amax(self.rval[:,0])+self.sigma rmax[1] = np.amax(self.rval[:,1])+self.sigma rmax[2] = np.amax(self.rval[:,2])+self.sigma # def makeCellList(self,frame=1,rmin='default',rmax='default'): self.makeCellList(1,rmin,rmax) else: self.makeCellList(1)
def test_manager(self): pl1, pl2 = get_two_players({ 'red': 0, 'blue': 1 }, { 'red': 1, 'blue': 1 }) interact = Interaction.Interaction(self.table) interact.interact(pl1, pl2) players = [pl1, pl2] Uni = Interaction.Universe(players, interact) manag = manager.Manager(Uni) manag.plot_and_update()
def __init__(self, fn='Text/nhk_easy.txt'): self.articles = SimpleUI.read_articles(fn) self.all_wordlist = [] self.all_uniq_wordlist = [] for a in self.articles.values(): self.all_wordlist += a.wordlist self.all_wordlist = sorted(self.all_wordlist) self.all_uniq_wordlist = list(set(self.all_wordlist)) self.word_index = {self.all_uniq_wordlist[i]:i for i in xrange(len(self.all_uniq_wordlist))} #zipf = {w:self.all_wordlist.count(w) for w in self.all_uniq_wordlist} #print sorted(zipf.values()) #print sum([len(a.wordlist) for a in self.articles]), len(self.all_wordlist) self.recommender = MasteryRecommender() self.hci = Interaction(self) print 'Edge Density:', self.hci.knowledge.EdgeDensity() self.display_article = 0
def run(self, population, p=Parameters): #initial evaluation for i in range(0, p.popNum): population[i].fitness = self.makespam(population[i].genotype, p) if p.SIGA_flag == "Yes": gEngine = Interaction.Interaction(self.param) #for k in range(len(population)): #print(k,":", "Fit:", population[k].fitness, "Social:", population[k].socialFitness, "Total:", population[k].totalFitness) #main loop for i in range(0, int(p.generations)): if p.SIGA_flag == "Yes": gEngine.socialInteraction( self.findBest(population, p).fitness, self.population) for k in range(len(population)): population[k].totalFitness = self.calculateTotalFitness( population[k], p) #selection + crossover offspring = self.crossover(population, p) population = sorted(population, key=attrgetter('fitness')) #mutation #get index of individuals for mutation muta_index = random.sample(range(int(p.popNum * 0.1), p.popNum), int(p.mutation_rate * p.popNum)) for k in muta_index: population[k].genotype = self.mutation(population[k].genotype, p) population[k].fitness = self.makespam(population[k].genotype, p) population = self.update(population, offspring, p) #print(g[len(g)-1].fitness, g[len(g)-1].genotype[0], g[len(g)-1].genotype[1]) self.bests.append(copy.copy(self.findBest(population, p))) #storing information of the behavior of every individual if p.SIGA_flag == "Yes": tmp_list = [0, 0, 0, 0] for ik in range(0, self.param.popNum): if population[ik].strat_name == 'ALLC': tmp_list[0] += 1 elif population[ik].strat_name == 'ALLD': tmp_list[1] += 1 elif population[ik].strat_name == 'TFT': tmp_list[2] += 1 else: tmp_list[3] += 1 self.behavior_ind.append(tmp_list) #write result File self.writeResult("Out/C|" + str(self.param.machines) + "|" + str(self.param.jobs) + "x" + str(self.param.popNum) + "/" + self.outname) if p.SIGA_flag == "Yes": self.writeBehavior("Out/C|" + str(self.param.machines) + "|" + str(self.param.jobs) + "x" + str(self.param.popNum) + "/Behavior" + self.outname) b = min(self.bests, key=attrgetter('fitness')) #return best return b.fitness
def __init__(self, param, filename_cells, filename_faces, ignore=False, debug=False): self.param = param # Read the local data geometries = { 'sphere': GeometrySphere, 'plane': GeometryPlane, 'plane_periodic': GeometryPeriodicPlane, 'none': Geometry, 'tube': GeometryTube, 'peanut': GeometryPeanut, 'hourglass': GeometryHourglass } print "Processing file : ", filename_cells data = ReadData(filename_cells) if data.keys.has_key('x'): x, y, z = np.array(data.data[data.keys['x']]), np.array( data.data[data.keys['y']]), np.array(data.data[data.keys['z']]) else: print "Error: did not find positions in data file!" return 1 self.N = len(x) if data.keys.has_key('vx'): vx, vy, vz = np.array(data.data[data.keys['vx']]), np.array( data.data[data.keys['vy']]), np.array( data.data[data.keys['vz']]) else: vx, vy, vz = np.zeros(np.shape(x)), np.zeros( np.shape(y)), np.zeros(np.shape(z)) try: nx, ny, nz = np.array(data.data[data.keys['nx']]), np.array( data.data[data.keys['ny']]), np.array( data.data[data.keys['nz']]) except KeyError: nx, ny, nz = np.zeros(np.shape(x)), np.zeros( np.shape(y)), np.zeros(np.shape(z)) if data.keys.has_key('fx'): fx, fy, fz = np.array(data.data[data.keys['fx']]), np.array( data.data[data.keys['fy']]), np.array( data.data[data.keys['fz']]) # Now some cell-specific things: # area cell_area cell_perim cont_num boundary if data.keys.has_key('area'): self.area_native = np.array(data.data[data.keys['area']]) else: # Assume the default of pi self.area_native = 3.141592 * np.ones(np.shape(x)) if data.keys.has_key('cell_area'): self.area = np.array(data.data[data.keys['cell_area']]) if data.keys.has_key('cell_perim'): self.perim = np.array(data.data[data.keys['cell_perim']]) if data.keys.has_key('cont_num'): self.ncon = np.array(data.data[data.keys['cont_num']]) if data.keys.has_key('boundary'): self.boundary = np.array(data.data[data.keys['boundary']]) if data.keys.has_key('type'): self.ptype = data.data[data.keys['type']] else: self.ptype = np.ones((self.N, )) if data.keys.has_key('flag'): self.flag = data.data[data.keys['flag']] self.rval = np.column_stack((x, y, z)) self.vval = np.column_stack((vx, vy, vz)) self.nval = np.column_stack((nx, ny, nz)) self.fval = np.column_stack((fx, fy, fz)) # Create the right geometry environment (TBC): self.geom = geometries[param.constraint](param) print self.geom # Create the Interaction class # Not yet created for the active vertex model #self.inter=Interaction(self.param,self.radius,ignore) # Again, not implemented yet. Keep it however, since this should eventually happen if self.geom.periodic: # Apply periodic geomtry conditions just in case (there seem to be some rounding errors floating around) self.rval = self.geom.ApplyPeriodic2d(self.rval) self.rval = self.geom.ApplyPeriodic12(np.array([0.0, 0.0, 0.0]), self.rval) # unit normal to the surface (only sphere so far) vel = np.sqrt(self.vval[:, 0]**2 + self.vval[:, 1]**2 + self.vval[:, 2]**2) self.vhat = ((self.vval).transpose() / (vel).transpose()).transpose() # Now get the connectivity here from the faces files #print "Processing file : ", filename_faces data_faces = ReadFaces(filename_faces) self.Faces = data_faces.Faces self.NFaces = data_faces.Nfaces # Create the Interaction class # This is essentially dummy for now self.radius = 1 self.inter = Interaction(self.param, self.radius, True) # Create the cell list # This is provisional, again. Here a lot more info from the nlist / triangulation should come in cellsize = param.nlist_rcut if cellsize > 5 * self.inter.sigma: cellsize = 5 * self.inter.sigma print "Warning! Reduced the cell size to manageable proportions (5 times mean radius). Re-check if simulating very long objects!" self.clist = CellList(self.geom, cellsize) # Populate it with all the particles: for k in range(self.N): self.clist.add_particle(self.rval[k, :], k) #self.clist.printMe() if debug: fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(self.rval[:, 0], self.rval[:, 1], self.rval[:, 2], zdir='z', c='b')
def readDataSingle(self,filename,dialect,internal=False,readtypes='all'): print("Processing file : " + filename) rd = ReadData(filename,dialect) # Using a pandas dataframe now x0 = rd.data["x"] x = rd.data["x"].to_numpy() y = rd.data["y"].to_numpy() # CCPy and others don't have z coordinate if "z" in rd.data.columns: z = rd.data["z"].to_numpy() else: z = np.zeros((len(x),)) vx = rd.data["vx"].to_numpy() vy = rd.data["vy"].to_numpy() # CCPy and others don't have z coordinate if "vz" in rd.data.columns: vz = rd.data["vz"].to_numpy() else: vz = np.zeros((len(x),)) nx = rd.data["nx"].to_numpy() ny = rd.data["ny"].to_numpy() # CCPy and others don't have z coordinate if "nz" in rd.data.columns: nz = rd.data["nz"].to_numpy() else: nz = np.zeros((len(x),)) if "type" in rd.data.columns: ptype0 = rd.data["type"].to_numpy() if readtypes == 'all': N = len(x) ptype = ptype0 useparts = range(N) else: useparts=[] for v in range(len(ptype0)): if ptype0[v] in readtypes: useparts.append(v) if len(useparts)==0: print('Error: No particles of the correct types in simulation, looking for ' + str(readtypes)) sys.exit() else: N=len(useparts) hmm = np.array(ptype0) ptype = hmm[useparts] else: if readtypes == 'all': N = len(x) ptype = np.ones((N,)) useparts = range(N) else: print("Error: looking for data with types " + str(readtypes) + " but data has no type information.") sys.exit() rval = np.column_stack((x[useparts],y[useparts],z[useparts])) vval = np.column_stack((vx[useparts],vy[useparts],vz[useparts])) nval = np.column_stack((nx[useparts],ny[useparts],nz[useparts])) if not "radius" in rd.data.columns: radius = np.ones(N) monodisperse=True sigma = 1.0 else: radius0 = rd.data["radius"].to_numpy() radius = radius0[useparts] sigma = np.mean(radius) monodisperse=False if "flag" in rd.data.columns: flag0 = rd.data["flag"].to_numpy() flag = flag0[useparts] else: flag = range(N) # Do the rest of the configuration only if this is not part of a series of reading in data if internal: return N,rval,vval,nval,radius,ptype,flag,sigma,monodisperse else: self.N = N self.rval = rval self.vval = vval self.nval = nval self.radius = radius self.sigma = sigma self.monodisperse = monodisperse self.ptype = ptype self.flag = flag # Create the Interaction class self.inter=Interaction(self.param,monodisperse,self.radius,self.ignore) # Apply periodic geomtry conditions just in case (there seem to be some rounding errors floating around) if self.geom.periodic: self.rval=self.geom.ApplyPeriodic2d(self.rval) if self.debug: fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(self.rval[:,0], self.rval[:,1], self.rval[:,2], zdir='z', c='b')
from Interaction import * hci = Interaction("Genki12") while True: response = hci.request() if response.end_of_assessment: print 'end' break else: print hci.num_assessment_answered + 1, '.', response.mastery_iter.sentence, response.message ans = input() if ans == 1: hci.response(StudentResponse.UNDERSTOOD) elif ans == 0: hci.response(StudentResponse.NOT_UNDERSTOOD)
# -*- coding: utf-8 -*- """ Created on Fri Jul 22 10:41:10 2016 @author: Lina492375qW1188 """ import Create, Deform, Interaction, Construct #----------------- Number of atom ------------------# xmax = 150 # num of atoms in x-dir = (2*xmax+1, 2*xmax) ymax = 50 # num of atoms in y-dir = ymax*4 #----------------- Initialization ------------------# create = Create.Create(xmax,ymax) deform = Deform.Deform() interaction = Interaction.Interaction(create.ymax) infile='data.unknown' construct = Construct.Construct(infile) #---------- Rolling, Set bond and angle ------------# # action choices: (a)create plane (b)create paper roll. action = '(b)' if action == '(a)': coord1 = create.trigonal() elif action == '(b)': coord1 = deform.rolling(create.trigonal()) bond1 = interaction.bond(coord1) angle1 = interaction.angle(coord1)
def Game(x, y): os.system("cls") varRand = randint(1, 4) print(' ') print(x, y) Description(x, y, descriptionMap) print(' ') print("1 = Intéragir") print("2 = Se déplacer") print("3 = Ouvrir son inventaire") print("4 = Ouvrir la MAP") print("5 = Voir la quête en cours") print("6 = Vos stats") print("7 = Sauvegarder") joueur = int(input()) if joueur == 1: if str(x) + "," + str(y) in interaction: if interaction[str(x) + "," + str(y)][4] == "oui": Interaction(x, y, backpack) Game(x, y) else: print("Il n'y a pas d'interaction possible ici") Game(x, y) else: print("Il n'y a pas d'interaction possible ici") Game(x, y) elif joueur == 2: print("Vous vous déplacez.") m = Mouvement(x, y) if varRand == 3: c = Combat(OrdreDePassage(PickAMonster())) if c == "perdu": quit() AjouterInventaire(backpack, "300", "argent") Game(m[0], m[1]) elif joueur == 3: test = False while test == False: print( "Vous êtes dans votre sac magique, veuillez choisir l'une des sacoches :" ) print("1 = La sacoche à potions") print("2 = La sacoche à équipements") print("3 = La sacoche d'objets de quête") print("4 = Votre bourse d'argent") print("5 = Retour") b = int(input()) test = ParcourirInventaire(backpack, b) Game(x, y) elif joueur == 4: fenetre = tk.Tk() photo = tk.PhotoImage(file='MapPrologue.png') label = tk.Label(fenetre, image=photo) label.pack() print("FERMER LA MAP AVANT TOUTE AUTRE ACTION OU LE JEU CRASHERA") Game(x, y) fenetre.mainloop() elif joueur == 5: print(dicoQueteActive["g"]) Game(x, y) elif joueur == 6: VoirStat() attendre = input() Game(x, y) elif joueur == 7: Save(x, y, backpack) Game(x, y) else: print("Vous avez mal tapé ! Veuillez recommencer.") Game( x, y, )
def readDataMany(self,dialect,skip=0,step=1,howmany='all',Nvariable=False,readtypes = 'all'): self.Nvariable=Nvariable try: filepattern = self.param.dumpname except: filepattern = 'frame' files0 = sorted(glob.glob(self.datapath + filepattern + '*.dat')) if len(files0) == 0: files0 = sorted(glob.glob(self.datapath + filepattern + '*.dat.gz')) if len(files0) == 0: files0 = sorted(glob.glob(self.datapath + filepattern + '*.csv')) if len(files0) == 0: print("Error: could not identify data file name pattern, does not end in .dat or .dat.gz, or is not part of parameters, and is not 'frame'. Stopping.") sys.exit() if howmany == 'all': files = files0 else: nfin = skip + step*howmany if nfin>len(files0): nfin = len(files0) print("Warning: not enough files in simulation, reading only " + str((nfin-skip)/step) + " files.") files = files0[skip:nfin:step] self.Nsnap=len(files) # If we know that the number of particles is variable # We need to actually go read the number of particles in each file first if self.Nvariable: self.Nval=np.zeros((self.Nsnap,),dtype='int') u=0 for f in files: #print "Pre - Processing file : ", f rd = ReadData(f,dialect) x = rd.data["x"].to_numpy() if readtypes == 'all': self.Nval[u]=len(x) else: if "type" in rd.data.columns: ptype = rd.data["type"].to_numpy() useparts = [] for v in range(len(ptype)): if ptype[v] in readtypes: useparts.append(v) if len(useparts)==0: print('Error: No particles of the correct types in simulation, looking for ' + str(readtypes)) sys.exit() else: self.Nval[u]=len(useparts) else: print("Error: looking for data with types " + str(readtypes) + " but data has no type information.") sys.exit() u+=1 self.N=int(np.amax(self.Nval)) else: self.N,rval,vval,nval,radius,ptype,flag,self.sigma,monodisperse = self.readDataSingle(files[0],dialect,True,readtypes) self.Nval=[self.N for i in range(self.Nsnap)] print("Handling a total of maximum " + str(self.N) + " particles!") self.rval=np.zeros((self.Nsnap,self.N,3)) self.vval=np.zeros((self.Nsnap,self.N,3)) self.nval=np.zeros((self.Nsnap,self.N,3)) self.flag=np.zeros((self.Nsnap,self.N)) self.radius=np.zeros((self.Nsnap,self.N)) self.ptype=np.zeros((self.Nsnap,self.N)) u=0 self.sigma = 0.0 for f in files: # first read the data, for all types #return N,rval,vval,nval,radius,ptype,flag,sigma,monodisperse N,rval,vval,nval,radius,ptype,flag,sigma,monodisperse = self.readDataSingle(f,dialect,True,readtypes) # Running tab on maximum particle size for CellList if sigma>self.sigma: self.sigma = sigma # Then arrange in a sensible shape self.rval[u,:self.Nval[u],:]=rval self.vval[u,:self.Nval[u],:]=vval self.nval[u,:self.Nval[u],:]=nval self.flag[u,:self.Nval[u]]=flag self.radius[u,:self.Nval[u]]=radius self.ptype[u,:self.Nval[u]]=ptype u+=1 self.monodisperse=monodisperse # Create the Interaction class #__init__(self,param,sigma,ignore=False,debug=False): self.inter=Interaction(self.param,self.sigma,self.ignore) # Apply periodic geomtry conditions just in case if self.geom.periodic: self.rval=self.geom.ApplyPeriodic3d(self.rval)
def draw(canvas): global interactions, addedInteractions, numberOfPlatforms, framecount, timer,numberOfGoats,goats time = Timer() lv1background.update(canvas) platforms.draw(canvas) time.draw(canvas) scoreCount.update(canvas) lifeBar.update(canvas) flood.draw(canvas) if not addedInteractions: for i in range(len(platforms.getCoords())): interaction = Interaction(player1, platforms.coords[i]) interactions.append(interaction) addedInteractions = True for i in range(len(platforms.getCoords())): platforms.coords[i].p1 = Vector(platforms.coords[i].getp1().getP()[0], platforms.coords[i].getp1().getP()[1] + 1) platforms.coords[i].p2 = Vector(platforms.coords[i].getp2().getP()[0], platforms.coords[i].getp2().getP()[1] + 1) tempPlatform = Platform2(0) if platforms.coords[i].p1.y > 700: platforms.coords.pop(i) if i > 1: while not (abs(tempPlatform.getx1() - platforms.coords[ i - 1].getx1()) > platforms.DISTANCE * platforms.difficulty or \ abs(tempPlatform.getx2() - platforms.coords[ i - 1].getx2()) > platforms.DISTANCE * platforms.difficulty): tempPlatform = Platform2(0) platforms.coords.insert(i, tempPlatform) tempInteraction = Interaction(player1, tempPlatform) else: tempInteraction = Interaction(player1, platforms.coords[i]) interactions.pop(i) interactions.insert(i, tempInteraction) if random.randint(0,1) > 0.5 and framecount % 360 == 0 and numberOfGoats <3 and platforms.coords[i].p1.y < player1.pos.y : # numberOfPlatforms % 5 == 0 and not madeGoat makeGoat(platforms.coords[i]) numberOfGoats+=1 goatsToPop = [] for j in range(len(goats)): if platforms.coords[i] == goats[j].platform: goats[j].pos = Vector(goats[j].pos.x,platforms.coords[i].p1.y-platforms.coords[i].thickness-goats[j].frameHeight/2) goats[j].update(canvas) if goats[j].isColliding(player1): if goats[j].harmsPlayer(player1): player1.lifePoints -=1 print("rekt") goatsToPop.append(goats[j]) numberOfGoats -= 1 if goats[j].pos.y > 630: goatsToPop.append(goats[j]) numberOfGoats-=1 for j in range(len(goatsToPop)): goats.remove(goatsToPop[j]) framecount += 1 for i in range(len(interactions)): if platforms.coords[i].covers(player1.pos): interactions[i].update() platforms.draw(canvas) player1.update(canvas)
def __init__(self, param, filename, ignore=False, debug=False): self.param = param # Outdated list of geometries #geometries={'sphere':GeometrySphere,'plane':GeometryPeriodicPlane,'none':Geometry,'tube':GeometryTube,'peanut':GeometryPeanut,'hourglass':GeometryHourglass} geometries = { 'sphere': GeometrySphere, 'plane': GeometryPlane, 'plane_periodic': GeometryPeriodicPlane, 'none': Geometry, 'tube': GeometryTube, 'peanut': GeometryPeanut, 'hourglass': GeometryHourglass } print "Processing file : ", filename data = ReadData(filename) x, y, z = np.array(data.data[data.keys['x']]), np.array( data.data[data.keys['y']]), np.array(data.data[data.keys['z']]) vx, vy, vz = np.array(data.data[data.keys['vx']]), np.array( data.data[data.keys['vy']]), np.array(data.data[data.keys['vz']]) try: nx, ny, nz = np.array(data.data[data.keys['nx']]), np.array( data.data[data.keys['ny']]), np.array( data.data[data.keys['nz']]) except KeyError: nx, ny, nz = np.zeros(np.shape(x)), np.zeros( np.shape(y)), np.zeros(np.shape(z)) self.monodisperse = False self.N = len(x) if not data.keys.has_key('radius'): # MISSING: read them in from the initial configuration self.radius = np.array([1.0 for i in range(self.N)]) self.monodisperse = True #self.sigma=1.0 else: self.radius = np.array(data.data[data.keys['radius']]) #self.sigma = np.mean(self.radius) if data.keys.has_key('type'): self.ptype = data.data[data.keys['type']] else: self.ptype = np.ones((self.N, )) if data.keys.has_key('flag'): self.flag = data.data[data.keys['flag']] self.rval = np.column_stack((x, y, z)) self.vval = np.column_stack((vx, vy, vz)) self.nval = np.column_stack((nx, ny, nz)) # Create the right geometry environment (TBC): self.geom = geometries[param.constraint](param) print self.geom # Create the Interaction class self.inter = Interaction(self.param, self.radius, ignore) if self.geom.periodic: # Apply periodic geomtry conditions just in case (there seem to be some rounding errors floating around) self.rval = self.geom.ApplyPeriodic2d(self.rval) self.rval = self.geom.ApplyPeriodic12(np.array([0.0, 0.0, 0.0]), self.rval) # unit normal to the surface (only sphere so far) vel = np.sqrt(self.vval[:, 0]**2 + self.vval[:, 1]**2 + self.vval[:, 2]**2) self.vhat = ((self.vval).transpose() / (vel).transpose()).transpose() # Create the cell list cellsize = param.nlist_rcut if cellsize > 5 * self.inter.sigma: cellsize = 5 * self.inter.sigma print "Warning! Reduced the cell size to manageable proportions (5 times mean radius). Re-check if simulating very long objects!" self.clist = CellList(self.geom, cellsize) # Populate it with all the particles: for k in range(self.N): self.clist.add_particle(self.rval[k, :], k) #self.clist.printMe() if debug: fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.scatter(self.rval[:, 0], self.rval[:, 1], self.rval[:, 2], zdir='z', c='b')
#!/usr/bin/env python import roslib roslib.load_manifest('pr2_pbd_interaction'); import sys import signal import rospy from Interaction import * def signal_handler(signal, frame): # The following makes sure the state of a user study is saved, so that it can be recovered global interaction interaction.saveExperimentState() print 'Program Terminated!!' sys.exit(0) signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGQUIT, signal_handler) if __name__ == "__main__": global interaction rospy.init_node('pr2_pbd_interaction', anonymous=True) interaction = Interaction() #rospy.spin() while(not rospy.is_shutdown()): interaction.update()