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()
