def fill(self, cam):
env = Environment.Environment
dis = random.randint(150, 200)
self.lat = random.uniform(-1, 1)
self.lon = (cam.rot[1] + math.pi) + random.uniform(-1, 1)
lonS = math.sin(self.lon)
lonC = math.cos(self.lon)
self.pos = Vex(lonS * dis, lonC * dis, random.randint(
-10, 10)) + cam.pos.copy().setZ(0)
ast = Asteroid.Asteroid(random.Random(), self, 0,
self.pos.copy().setZ(0))
#ast.speed = 0
Asteroid.Asteroid.add_temp_asteroid(ast)
self.lat = random.uniform(-Stars.pi, Stars.pi)
self.lon = random.uniform(-Stars.pi, Stars.pi)
v = (self.pos - cam.pos).rotate2dXY(cam.rot[1])
v.setY(v.Y() + cam.mov[2])
v.setZ(v.Z() + -cam.pos.Z())
v = v.rotate2dYZ(0, cam.rot[0])
f = env.fov / (v.z() + .00000001)
if (f < env.lim):
f = 1000
v = v * f
v = v + env.center
self.lp = v.p2D()
def clf_make(test):
print(test)
x = []
y = []
for grade in range(1, 4):
for num in range(1, 127):
if num % 10 == test:
continue
try:
a = []
f = open('paragraph/%d/%d.t' % (grade, num), 'r')
except:
continue
text = f.read()
text = text.replace('\n', ' ')
a.extend(Word.Count([text]))
a.extend(Vex.Count([text], fqc=True))
sents = nltk.sent_tokenize(text)
k = Len.tkn(sents)
a.extend(k)
a.extend(Len.Test(sents, range(2, 4)))
f1 = open('paragraph/%d/%d.list' % (grade, num), 'w')
json.dump(a, f1)
x.append(a)
y.append(grade - 1)
clf_p = svm.SVC()
clf_p.fit(x, y)
f = open('clf_p_v.p', 'wb')
pickle.dump(clf_p, f)
f.close()
def pDistance(self, pv):
x, y = self.seg[0].p2D()
x1, y1 = self.seg[1].p2D()
x2, y2 = pv.p2D()
A = x - x1
B = y - y1
C = x2 - x1
D = y2 - y1
dot = A * C + B * D
len_sq = C * C + D * D
param = -1
if (len_sq != 0): #//in case of 0 length line
param = dot #/ len_sq;
xx, yy = 0, 0
if (param < 0):
xx = x
yy = y
elif (param > 1):
xx = x1
yy = y1
else:
xx = x + param * C
yy = y + param * D
dx = x - xx
dy = y - yy
return (math.sqrt(dx * dx + dy * dy), Vex.Vex(xx, yy))
def fillDef(self, cam):
env = Environment.Environment
dis = random.randint(0, 200)
self.lat = random.uniform(-1, 1)
self.lon = random.uniform(-math.pi, math.pi)
lonS = math.sin(self.lon)
lonC = math.cos(self.lon)
self.pos = Vex(lonS * dis, lonC * dis, random.randint(
-10, 10)) + cam.pos.copy().setZ(0)
self.lat = random.uniform(-Stars.pi, Stars.pi)
self.lon = random.uniform(-Stars.pi, Stars.pi)
v = (self.pos - cam.pos).rotate2dXY(cam.rotSC[0])
v.setY(v.y() + cam.mov[2])
v.setZ(v.z() - cam.pos.z())
v = v.rotate2dYZ(0, cam.rotSC[1])
f = env.fov / (v.z() + .00000001)
if (f < 1):
f = 1000
v = v * f
v = v + env.center
self.lp = v.p2D()
def judge(text, grade=0, num=0):
dl = [0, 0, 0]
sl = []
a = []
text = text.replace('\n', ' ')
a.extend(Word.Count([text]))
a.extend(Vex.Count([text], fqc=True))
sents = nltk.sent_tokenize(text)
k = Len.tkn(sents)
a.extend(k)
a.extend(Len.Test(sents, range(2, 4)))
clf_p = pickle.load(open('clf_p_v.p', 'rb'))
pr = clf_p.predict([a])
return pr[0]
def __init__(self, cam):
pi = 3.141
maxDist = 100
minDist = maxDist - 50
self.ang = random.uniform(-pi*2,pi )
dis = random.randint(minDist, maxDist)
self.pos = cam.pos.add( Vex(math.sin(self.ang)*dis, math.cos(self.ang)*dis, 0))
self.pos.setZ(0)
self.speed = -.1
self.ship = Ship.Ship(self)
self.inship = False
self.inatmosphere = False
self.state = 0
self.mindDur = 0
self.mindCho = 0
self.mindTim = 0
self.shotspd = 2
self.shotms = 0
self.statement = ""
self.creature = Creature.Creature(self)
self.target = []
self.enterShip(self.ship)
Mind.Minds.extend([self])
def find_intersection(self, ln):
p0 = self.seg[0].pos
p1 = self.seg[1].pos
p2 = ln.seg[0].pos
p3 = ln.seg[1].pos
s10_x = p1[0] - p0[0]
s10_y = p1[1] - p0[1]
s32_x = p3[0] - p2[0]
s32_y = p3[1] - p2[1]
denom = s10_x * s32_y - s32_x * s10_y
if denom == 0: return None # collinear
denom_is_positive = denom > 0
s02_x = p0[0] - p2[0]
s02_y = p0[1] - p2[1]
s_numer = s10_x * s02_y - s10_y * s02_x
if (s_numer < 0) == denom_is_positive: return None # no collision
t_numer = s32_x * s02_y - s32_y * s02_x
if (t_numer < 0) == denom_is_positive: return None # no collision
if (s_numer > denom) == denom_is_positive or (
t_numer > denom) == denom_is_positive:
return None # no collision
# collision detected
t = t_numer / denom
intersection_point = Vex.Vex(p0[0] + (t * s10_x), p0[1] + (t * s10_y))
return intersection_point
def testShotHit(shot):
x,y,z = shot.pos.Pos()
#def testShotHit(x, y, z, dmg, ant):
out = False
for self in reversed(Mind.Minds):
v = Vex(x, y, z)
if v.dist2D(self.pos)<=2:
tdmg = 0
if not self.inship:
tdmg = int(shot.damage - self.creature.stats.getDEX()*(self.creature.stats.doLUK()*10))
else:
tdmg = int(shot.damage - self.ship.stats.getDEX()*(self.ship.stats.doLUK()*10))
out = True
if tdmg>0:
DrawINFO.DrawINFO(x, y, z, tdmg, Color.RED)
ParticleEngine.Emitter(Vex(x, y, z), shot.angle_rad, 0)
self.ship.stats.hpDMG(tdmg)
if shot.source.isAlive():
if shot.source not in self.target:
self.target.extend([shot.source])
else:
DrawINFO.DrawINFO(x, y, z, "MISS", Color.ORANGE)
if self.inship:
if self.ship.stats.isDead():
if shot.source.ship.stats.updateXP(random.randint(self.ship.stats.getLVL(),2*self.ship.stats.getLVL() )):
DrawINFO.DrawINFO(x, y, z, "LEVEL UP", Color.RED)
ParticleEngine.Emitter(Vex(x, y, z), shot.angle_rad, 1)
Mind.Minds.remove(self)
else:
if self.creature.stats.isDead():
if shot.source.stats.updateXP(random.randint(1*self.creature.stats.getLVL(),10*self.creature.stats.getLVL() )):
DrawINFO.DrawINFO(x, y, z, "LEVEL UP", Color.RED)
ParticleEngine.Emitter(Vex(x, y, z), shot.angle_rad, 1)
Mind.Minds.remove(self)
return out
def update(cam):
env = Environment.Environment
r1 = cam.rotSC[0]
r2 = cam.rotSC[1]
max = 250
for s in Stars.__shooting:
if s.pos.dist2D(cam.pos) > max:
s.fill(cam)
else:
lonS = math.sin(s.lon)
lonC = math.cos(s.lon)
sp = .5
s.pos += (Vex(sp * lonC, sp * lonS, 0))
v = (s.pos - cam.pos).rotate2dXY(r1) # roll
v.setY(v.Y() + cam.mov[2])
v.setZ(v.Z() + -cam.pos.Z())
v = v.rotate2dYZ(0, r2)
f = env.fov / (v.z() + .00000001)
if (f < env.lim):
f = 1000
v = v * f
v = v + env.center
p = v.p2D()
if env.inScreen(p) and env.inScreen(s.lp):
brt = 255 #random.randint(20, 155)
pygame.draw.line(env.getScreen(), (brt, brt, brt), p, s.lp,
1)
s.lp = p
for s in Stars.__debre:
if s.pos.dist2D(cam.pos) > max:
s.fill(cam)
else:
v = (s.pos - cam.pos).rotate2dXY(r1)
v.setY(v.Y() + cam.mov[2])
v.setZ(v.Z() + -cam.pos.Z())
v = v.rotate2dYZ(0, r2)
f = env.fov / (v.z() + .00000001)
if (f < env.lim):
f = 1000
v = v * f
v = v + env.center
p = v.p2D()
if env.inScreen(p) and env.inScreen(s.lp):
brt = random.randint(20, 155)
pygame.draw.line(env.getScreen(), (brt, brt, brt), p, s.lp,
1)
s.lp = p
for s in Stars.__stars:
v = (s.pos).rotate2dXY(r1)
v = v.rotate2dYZ(0, r2)
f = env.fov / (v.z() + .00000001)
if (f < env.lim):
f = 1000
v = v * f
v = v + env.center
p = v.p2D()
if env.inScreen(p) and env.inScreen(s.lp):
brt = random.randint(20, 155)
pygame.draw.line(env.getScreen(), (brt, brt, brt), p, s.lp, 1)
s.lp = p
class Stars:
__stars = []
__debre = []
__shooting = []
pi = 3.14159265359 * 2
def __init__(self, cam):
self.lat = 0.0
self.lon = 0.0
self.pos = None
self.fillDef(cam)
self.lp = [0.0, 0.0]
def fillDef(self, cam):
env = Environment.Environment
dis = random.randint(0, 200)
self.lat = random.uniform(-1, 1)
self.lon = random.uniform(-math.pi, math.pi)
lonS = math.sin(self.lon)
lonC = math.cos(self.lon)
self.pos = Vex(lonS * dis, lonC * dis, random.randint(
-10, 10)) + cam.pos.copy().setZ(0)
self.lat = random.uniform(-Stars.pi, Stars.pi)
self.lon = random.uniform(-Stars.pi, Stars.pi)
v = (self.pos - cam.pos).rotate2dXY(cam.rotSC[0])
v.setY(v.y() + cam.mov[2])
v.setZ(v.z() - cam.pos.z())
v = v.rotate2dYZ(0, cam.rotSC[1])
f = env.fov / (v.z() + .00000001)
if (f < 1):
f = 1000
v = v * f
v = v + env.center
self.lp = v.p2D()
def fill(self, cam):
env = Environment.Environment
dis = random.randint(150, 200)
self.lat = random.uniform(-1, 1)
self.lon = (cam.rot[1] + math.pi) + random.uniform(-1, 1)
lonS = math.sin(self.lon)
lonC = math.cos(self.lon)
self.pos = Vex(lonS * dis, lonC * dis, random.randint(
-10, 10)) + cam.pos.copy().setZ(0)
ast = Asteroid.Asteroid(random.Random(), self, 0,
self.pos.copy().setZ(0))
#ast.speed = 0
Asteroid.Asteroid.add_temp_asteroid(ast)
self.lat = random.uniform(-Stars.pi, Stars.pi)
self.lon = random.uniform(-Stars.pi, Stars.pi)
v = (self.pos - cam.pos).rotate2dXY(cam.rot[1])
v.setY(v.Y() + cam.mov[2])
v.setZ(v.Z() + -cam.pos.Z())
v = v.rotate2dYZ(0, cam.rot[0])
f = env.fov / (v.z() + .00000001)
if (f < env.lim):
f = 1000
v = v * f
v = v + env.center
self.lp = v.p2D()
@staticmethod
def init(cam, max=100):
for i in range(max):
s = Stars(cam)
Stars.__stars.extend([s])
for i in range(max):
s = Stars(cam)
Stars.__debre.extend([s])
for i in range(5):
s = Stars(cam)
Stars.__shooting.extend([s])
@staticmethod
def update(cam):
env = Environment.Environment
r1 = cam.rotSC[0]
r2 = cam.rotSC[1]
max = 250
for s in Stars.__shooting:
if s.pos.dist2D(cam.pos) > max:
s.fill(cam)
else:
lonS = math.sin(s.lon)
lonC = math.cos(s.lon)
sp = .5
s.pos += (Vex(sp * lonC, sp * lonS, 0))
v = (s.pos - cam.pos).rotate2dXY(r1) # roll
v.setY(v.Y() + cam.mov[2])
v.setZ(v.Z() + -cam.pos.Z())
v = v.rotate2dYZ(0, r2)
f = env.fov / (v.z() + .00000001)
if (f < env.lim):
f = 1000
v = v * f
v = v + env.center
p = v.p2D()
if env.inScreen(p) and env.inScreen(s.lp):
brt = 255 #random.randint(20, 155)
pygame.draw.line(env.getScreen(), (brt, brt, brt), p, s.lp,
1)
s.lp = p
for s in Stars.__debre:
if s.pos.dist2D(cam.pos) > max:
s.fill(cam)
else:
v = (s.pos - cam.pos).rotate2dXY(r1)
v.setY(v.Y() + cam.mov[2])
v.setZ(v.Z() + -cam.pos.Z())
v = v.rotate2dYZ(0, r2)
f = env.fov / (v.z() + .00000001)
if (f < env.lim):
f = 1000
v = v * f
v = v + env.center
p = v.p2D()
if env.inScreen(p) and env.inScreen(s.lp):
brt = random.randint(20, 155)
pygame.draw.line(env.getScreen(), (brt, brt, brt), p, s.lp,
1)
s.lp = p
for s in Stars.__stars:
v = (s.pos).rotate2dXY(r1)
v = v.rotate2dYZ(0, r2)
f = env.fov / (v.z() + .00000001)
if (f < env.lim):
f = 1000
v = v * f
v = v + env.center
p = v.p2D()
if env.inScreen(p) and env.inScreen(s.lp):
brt = random.randint(20, 155)
pygame.draw.line(env.getScreen(), (brt, brt, brt), p, s.lp, 1)
s.lp = p
def __init__(self, pa, pb):
if isinstance(pa, Vex.Vex) and isinstance(pb, Vex.Vex):
self.seg = [pa, pb]
else:
self.seg = [Vex.Vex(pa[0], pa[1]), Vex.Vex(pb[0], pb[1])]
def LineA(pa, pb):
v1 = Vex.Vex(pa[0], pa[1])
v2 = Vex.Vex(pb[0], pb[1])
return Line(v1, v2)
def updateAI(self, player):
# distance variable
dis = 0
# angle variable
ang = 0
# does the mind have a target and is it not the player
if self.target and self.target[0] != player:
self.state = Mind.ATTACK
# if there are any dead targets, loop
while self.target and not self.target[0].isAlive():
self.target.remove(self.target[0])
#sort to attack closest enemy
self.target.sort(key = lambda m: self.pos.dist2D(m.pos), reverse = True)
print (str(self.target))
# if the list still isn't empty
if self.target:
# get the distance and angle to target
dis = self.pos.dist2D(self.target[0].pos)
ang = math.degrees(self.target[0].pos.ang2D(self.pos))+90.0
elif self.target and self.target[0] == player:
self.state = Mind.ATTACK
dis = self.pos.dist2D(player.cam.pos)
ang = math.degrees(player.cam.pos.ang2D(self.pos))+90.0
self.statment="I'm going to get you!"
else:
self.state = Mind.ROAM
self.statment = ""
#if dis < 100:
#self.state = Mind.FLEE
# if self.stats.getHP() > 20:
# this signifies the attack state
# self.state = Mind.ATTACK
# pass
if ang < self.ang-180:ang = 360.0+ang
if ang > self.ang+180:ang = ang - 360.0
# testedA = Asteroid.testRadiusCollision(self, self.pos, self.getRadius())
# if testedA:
# self.pos.assign(testedA.setZ(self.pos.z()))
#
# action
diffA = ang - self.ang
if self.state == Mind.ATTACK:
if diffA > 1:
self.ang += 2.0 + random.uniform(0,.1)
elif diffA < -1 :
self.ang -= 2.0 - random.uniform(0, .1)
if dis > 10 :
# get the x, y movement
rads = math.radians(-self.ang)
x = math.sin(rads)*self.speed
y = math.cos(rads)*self.speed
tv = Vex(x, y)
# testedA = Asteroid.testRadiusCollision(self, self.pos+tv, self.getRadius())
# if testedA:
# self.pos.assign(testedA.setZ(self.pos.z()))
#
tested = Planets.testRadiusCollision(self, self.pos+tv, self.getRadius())
if not tested:
self.pos.selfAdd2D(x, y)
else:
self.pos.assign(tested.setZ(self.pos.z()))
elif dis < 9 :
# get the x, y movement
rads = math.radians(self.ang)
x = math.sin(rads)*self.speed
y = math.cos(rads)*self.speed
tv = Vex(x, y)
# testedA = Asteroid.testRadiusCollision(self, self.pos+tv, self.getRadius())
# if testedA:
# self.pos.assign(testedA.setZ(self.pos.z()))
#
tested = Planets.testRadiusCollision(self, self.pos+tv, self.getRadius())
if not tested:
self.pos.selfAdd2D(x, y)
else:
self.pos.assign(tested.setZ(self.pos.z()))
if self.ang < ang+3 and self.ang > ang - 3:
self.state = Mind.FIRE
if self.state == Mind.FLEE:
self.statement = "Run away!"
if diffA > 1:
self.ang += 2.0 + random.uniform(0,.1)
elif diffA < -1 :
self.ang -= 2.0 - random.uniform(0, .1)
# get the x, y movement
rads = math.radians(self.ang)
x = math.sin(rads)*self.speed
y = math.cos(rads)*self.speed
tv = Vex(x, y)
# testedA = Asteroid.testRadiusCollision(self, self.pos+tv, self.getRadius())
# if testedA:
# self.pos.assign(testedA.setZ(self.pos.z()))
tested = Planets.testRadiusCollision(self, self.pos+tv, self.getRadius())
if not tested:
self.pos.selfAdd2D(x, y)
else:
self.pos.assign(tested.setZ(self.pos.z()))
if self.state == Mind.FIRE:
self.statement = "Pew pew pew!"
self.shoot()
if self.state == Mind.ROAM:
self.statement = ""
if self.mindCho == 0:
self.mindTim = pygame.time.get_ticks()
self.mindDur = random.randint(500,1500)
self.mindCho = random.randint(0,2)
elif self.mindCho == 1:
self.ang += 1
elif self.mindCho == 2:
self.ang -= 1
if pygame.time.get_ticks()-self.mindTim > self.mindDur:
self.mindCho = 0
# get the x, y movement
rads = math.radians(-self.ang)
x = math.sin(rads)*self.speed
y = math.cos(rads)*self.speed
tv = Vex(x, y)
# testedA = Asteroid.testRadiusCollision(self, self.pos+tv, self.getRadius())
# if testedA:
# self.pos.assign(testedA.setZ(self.pos.z()))
#
tested = Planets.testRadiusCollision(self, self.pos+tv, self.getRadius())
if not tested:
self.pos.selfAdd2D(x, y)
else:
self.pos.assign(tested.setZ(self.pos.z()))