コード例 #1
0
def blockCreate(LoC, color):
	#initialize fill
	fill = Image.open("img" + os.sep + "block_%s.png" % color)
	fillX, fillY = fill.size
	fillL = fill.load()
	#initialize LoC
	L = len(LoC)
	minX, minY = maxX, maxY = LoC[0]
	for (x, y) in LoC:
		minX = min(minX, x)
		maxX = max(maxX, x)
		minY = min(minY, y)
		maxY = max(maxY, y)
	#initialize block
	img = Image.new("RGBA", (maxX - minX, maxY - minY), (255, 255, 255, 255))
	imgL = img.load()
	for i in xrange(maxX - minX):
		for j in xrange(maxY - minY):
			r, g, b, alpha = fillL[(i + minX) % fillX, (j + minY) % fillY]
			for k in xrange(L):
				if p.det(LoC[k], LoC[(k + 1) % L], p.vadd((i, j), (minX, minY))) > 0:
					alpha = 0
					break
			imgL[i, j] = (r, g, b, alpha)
	return img
コード例 #2
0
	def exitMe(self, wp, i):
		epsilon = 2
		P = self.LoC[i]
		Q = self.LoC[(i + 1) % len(self.LoC)]
		R = (wp.x, wp.y)
		nextR = p.vadd(R, wp.v)
		det = p.det(P, Q, R)
		d = p.dist(P, Q)
		# check edge collision
		checkDist = (d * (wp.r - wp.maxSpeed - epsilon) <= det <= d * (wp.r + epsilon))
コード例 #3
0
	def update(self):
		#if not in universe
		if not (0 < self.x < self.width and 0 < self.y < self.height):
			self.health = 0
		#check health
		if self.health == 0:
			#play death sound
			subprocess.Popen(["python", self.path + os.sep + "aud" + os.sep + "death.py"])
		self.health = self.health / self.mhu * self.mhu
		if self.isParticle:
			#no wave positions
			self.posList = None
			#velocity affected by gravity
			self.v = p.vadd(self.v, self.g)
			if p.dist(self.v) >= self.maxSpeed:
				#then transform to wave
				self.isParticle = False
				self.r = 12
				self.g = (0, 0)
				self.v = p.fixNorm(self.v, self.maxSpeed)
			if not self.collision:
				#gravity has effect
				self.g = self.gravity
			#select image to draw
		#select particle image
		if self.v[0] < 0:
			self.img = self.imgL
		elif self.v[0] > 0:
			self.img = self.imgR
		#change position
		(self.x, self.y) = p.vadd((self.x, self.y), self.v)
		if not self.isParticle:
			#then draw ray
			if self.posList == None:
				self.posList = [(self.x, self.y)]
			else:
				self.posList.append(p.vadd(p.sprod(self.posList[-1], 2/3.0), p.sprod((self.x, self.y), 1/3.0)))
				self.posList.append(p.sprod(p.vadd(self.posList[-1], (self.x, self.y)), 0.5))
				self.posList.append((self.x, self.y))
				while len(self.posList) > self.mrl:
					del self.posList[0: 3]
コード例 #4
0
	def move_up(self):
		if not self.collision:
			#cannot jump in the air
			return False
		subprocess.Popen(["python", self.path + os.sep + "aud" + os.sep + "jump.py"])
		(P, Q) = self.collision
		(x, y) = p.vsub(Q, P)
		if self.collision and x <= 0 and abs(x) >= abs(y):
			#surface angle leq 45, can jump
			impDir = p.orthogonal((x, y))
			self.v = p.vadd(self.v, p.fixNorm(impDir, self.maxJump))
			self.collision = False
		return True
コード例 #5
0
	def update(self):
		if not self.isActive:
			return None
		if p.dist(self.P, self.pathList[self.index]) < 2:
			#then near this position, guard moves towards next target
			self.index = (self.index + 1) % self.L
			self.target = self.pathList[self.index]
		dist = p.dist(self.P, self.target)
		direction = p.vsub(self.target, self.P)
		if direction[0] < 0:
			self.imgDir = 0
		elif direction[0] > 0:
			self.imgDir = 1
		move = p.fixNorm(direction, min(self.stride, dist))
		self.P = p.vadd(self.P, move)
コード例 #6
0
	def checkVertexCollision(self, wp, i):
		epsilon = 2
		P = self.LoC[i]
		R = (wp.x, wp.y)
		# check vertex collision with P
		checkDist = p.dist(P, R) <= wp.r + epsilon
		if checkDist:
			#move particle back to proper location
			self.calibrateParticleVertex(wp, P, R)
			L = len(self.LoC)
			Q = self.LoC[(i + 1) % L]
			S = self.LoC[(i - 1) % L]
			u = p.fixNorm(p.vsub(Q, P))
			v = p.fixNorm(p.vsub(P, S))
			w = p.vadd(u, v)
			if wp.isParticle:
				self.particleVertexCollision(wp, P)
			else:
				self.waveVertexCollision(wp, w)
			wp.collision = ((0, 0), w)
コード例 #7
0
	def collision(self, wp):
		#check if in bounding box
		if not (self.minX - wp.r <= wp.x <= self.maxX + wp.r and self.minY - wp.r <= wp.y <= self.maxY + wp.r):
			return False
		epsilon = 2
		L = len(self.LoC)
		if self.inMe:
			inside = True	#still inside
			for i in xrange(L):
				P = self.LoC[i]
				Q = self.LoC[(i + 1) % L]
				R = (wp.x, wp.y)
				nextR = p.vadd((wp.x, wp.y), wp.v)
				det = p.det(P, Q, nextR)
				#if moving away from wall, continue
				if p.det(P, Q, R) >= det: continue
				inside &= (det <= p.dist(P, Q) * (epsilon - wp.r))
				if not inside: break #to retain values of P, Q
			if inside:
				return True #because collision
			#otherwise  check for internal reflection
			base = p.vsub(Q, P)
			if not p.refract(wp.v, base, self.rIndex, 1):
				wp.v = p.reflect(wp.v, base)
				return True
			#otherwise if not complete exit, return collision true
			if det < p.dist(P, Q) * wp.r:
				return True
			#otherwise complete exit, change angle
			self.inMe = False
			wp.v = p.fixNorm(p.refract(wp.v, p.vsub((0, 0), base), self.rIndex, 1), wp.maxSpeed)
			return False
		else:
			#check each individual side
			for i in xrange(L):
				if self.checkEdgeCollision(wp, i):
					return True
			for i in xrange(L):
				if self.checkVertexCollision(wp, i):
					return True
			return False
コード例 #8
0
	def checkEdgeCollision(self, wp, i):
		epsilon = 2
		P = self.LoC[i]
		Q = self.LoC[(i + 1) % len(self.LoC)]
		R = (wp.x, wp.y)
		nextR = p.vadd(R, wp.v)
		det = p.det(P, Q, R)
		d = p.dist(P, Q)
		# check edge collision
		checkDist = (d * (wp.r - wp.maxSpeed - epsilon) <= det <= d * (wp.r + epsilon))
		checkAngle1 = (p.distSq(P, Q) + p.distSq(Q, R) - p.distSq(P, R)) / p.dist(P, Q) / p.dist(Q, R) > 0
		checkAngle2 = (p.distSq(P, Q) + p.distSq(P, R) - p.distSq(Q, R)) / p.dist(P, Q) / p.dist(P, R) > 0
		checkDir = p.det(P, Q, R) + epsilon >= p.det(P, Q, nextR)
		if checkDist and checkAngle1 and checkAngle2 and checkDir:
			#move particle back to proper location
			self.calibrateParticleEdge(wp, P, Q, R)
			#calculate new velocity/gravity
			if wp.isParticle:
				self.particleEdgeCollision(wp, P, Q)
			else:
				self.waveEdgeCollision(wp, P, Q)
			wp.collision = (P, Q)
			return True
コード例 #9
0
	def calibrateParticleEdge(self, wp, P, Q, R):
		if wp.isParticle:
			base = p.vsub(Q, P)
			perPt = p.perPt(P, Q, R)
			#ensure particle not in wall
			(wp.x, wp.y) = p.vadd(perPt, p.fixNorm(p.orthogonal(base), wp.r))
コード例 #10
0
	def calibrateParticleVertex(self, wp, P, R):
		(wp.x, wp.y) = p.vadd(P, p.fixNorm(p.vsub(R, P), wp.r))