def __init__(self, screen):
print("Initializing Lumidify Isometric Engine (LIE) Version 1.0 ...")
self.screen = screen
self.screen.blit(FONT.render("Loading...", True, (255, 255, 255)),
(0, 0))
self.screen.blit(
FONT.render("Remember - patience is a virtue.", True,
(255, 255, 255)), (0, 40))
pygame.display.update()
self.tiles, self.obstacles, self.characters, self.items, self.bullets = load_tiles(
)
self.floor = Floor(self.screen, self.tiles)
self.obstacles = Obstacles(self.screen, self.obstacles,
self.characters, self.items, self.bullets,
self)
temp = self.obstacles.characters["GUB"].copy()
temp["weapon"] = None
self.player = Montag(self.screen,
x=0,
y=0,
obstaclemap=self.obstacles,
**temp)
self.obstacles.player = self.player
self.game_variables = {}
self.active_layer = 0
self.screen_offset = [0, 0]
self.loaded_maps = {}
self.saved_maps = []
self.current_map = ""
self.wongame = False
self.lostgame = False
self.show_fps = True
def runSim():
nodesExplored = {}
q = []
success, solution = generatePath(q, startEndCoor, nodesExplored, 0)
solution.reverse()
Q = Quadrotor(ax,
x=s1,
y=s2,
z=s3,
roll=roll,
pitch=pitch,
yaw=yaw,
size=1,
show_animation=show_animation)
O = {}
region = [[0, 5, 0, 5], [6, 10, 0, 5], [0, 5, 6, 10], [6, 10, 6, 10]]
for i in range(4):
O[i] = Obstacles(ax,
x=region[i][0],
y=region[i][3],
z=2.5,
roll=roll,
pitch=pitch,
yaw=yaw,
size=1,
show_animation=show_animation,
region=region[i])
plotExploredNodes(nodesExplored, ax2)
plotPath(solution, ax2)
followPath(Q, solution, O, q, nodesExplored, 0)
def run_agent(pos, player, queue, sema=None, train=True):
global WIDTH, HEIGHT
if not train:
pygame.init()
surface = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("FlappyBirdAI")
clock = pygame.time.Clock()
score = 0
bird = Bird.Bird(WIDTH, HEIGHT, 8)
obs = Obstacles.Obstacles(WIDTH, HEIGHT, 30, 50, 125, 200, 2)
end = False
while not end:
if not train:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
end = True
if event.type == pygame.MOUSEBUTTONDOWN:
end = True
obsx, obsy = obs.getClosestObsticle(bird.x, bird.size)
data = [
bird.x / WIDTH, bird.y / HEIGHT, obsx / WIDTH, obsy / HEIGHT,
bird.velocity / 100
]
jump = player.forward(data, 's')
if jump == 1:
bird.jump()
out = bird.move()
obs.moveObstacles()
hit, rev = obs.detectCollision(bird.x, bird.y, bird.size)
if hit or out or (score > 200000 and train):
end = True
if train:
print(pos, score)
if not queue is None:
queue.put((pos, score))
else:
score += 1 + rev
if not train:
if hit or out:
col = (255, 0, 0)
else:
col = (0, 255, 0)
surface.fill((0, 0, 0))
bird.draw(surface, col)
obs.draw(surface)
pygame.display.flip()
clock.tick(60)
if not sema is None:
sema.release()
def read_obstacles(file_name):
obstacles = []
with open(file_name, 'r') as file:
reader = csv.reader(file, delimiter=',')
for row in reader:
if (row[0][0].isnumeric()):
obstacle = Obstacles(float(row[0]), float(row[1]),
float(row[2]) / 2)
obstacles.append(obstacle)
return obstacles
def is_collision(A, B, obstacles):
'''checks if any obstacle is in collision with line segment'''
'''between nodes A and B'''
eps = 0.001
d_AB = dist(A, B)
for C in obstacles:
# D is a point on AB such that CD is normal to AB
dot = ((C.x - A.x) * (B.x - A.x) + (C.y - A.y) *
(B.y - A.y)) / (d_AB * d_AB + eps)
d_AD = abs(dot * d_AB)
x = A.x + (B.x - A.x) * dot
y = A.y + (B.y - A.y) * dot
D = Obstacles(x, y)
d_BD = dist(B, D)
d_DC = dist(D, C)
if d_DC > C.r:
continue
if (abs(d_AD + d_BD - d_AB) < eps):
return True
if (d_AD <= C.r or d_BD <= C.r):
return True
return False
def runGame(self, simulateState):
# list of boids
boidSystems = []
# generate and create boids
for i in range(2):
num1 = random.randint(20, 40)
scale1 = 30 / num1
newBoidSystem = Boids(num1, scale1, self.screen_width,
self.screen_height)
newBoidSystem.makeBoid()
boidSystems.append(newBoidSystem)
obstacles = Obstacles()
self.simulateState = simulateState
count = 0
self.frame_surface.fill((0, 0, 0))
self.frame_marker.fill((0, 0, 0))
#game loop
while not self.done:
# handle user input
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.done = True
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 3:
# create an array of boids
num2 = random.randint(20, 40)
scale2 = 30 / num1
controller = copy.deepcopy(boidSystems[0].controller)
newBoidSystem = Boids(num2, scale2, self.screen_width,
self.screen_height, controller)
newBoidSystem.makeBoid()
boidSystems.append(newBoidSystem)
if len(boidSystems) > 5:
boidSystems.pop(0)
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
# create single boid
mousePos = pygame.mouse.get_pos()
mouseVec1 = pygame.math.Vector2((mousePos))
for i in range(len(boidSystems)):
boidSystems[i].addBoid(mouseVec1)
elif event.type == pygame.KEYDOWN:
if event.unicode == "A" or event.unicode == "a":
for i in range(len(boidSystems)):
# Alignment state
if boidSystems[i].controller[0] == True:
boidSystems[i].controller[0] = False
boidSystems[i].stateChange()
else:
boidSystems[i].controller[0] = True
boidSystems[i].stateChange()
elif event.unicode == "C" or event.unicode == "c":
for i in range(len(boidSystems)):
# Cohesion state
if boidSystems[i].controller[1] == True:
boidSystems[i].controller[1] = False
boidSystems[i].stateChange()
else:
boidSystems[i].controller[1] = True
boidSystems[i].stateChange()
elif event.unicode == "S" or event.unicode == "s":
for i in range(len(boidSystems)):
# Seperation state
if boidSystems[i].controller[2] == True:
boidSystems[i].controller[2] = False
boidSystems[i].stateChange()
else:
boidSystems[i].controller[2] = True
boidSystems[i].stateChange()
elif event.unicode == "N" or event.unicode == "n":
for i in range(len(boidSystems)):
# Noise State
if boidSystems[i].controller[3] == True:
boidSystems[i].controller[3] = False
boidSystems[i].stateChange()
else:
boidSystems[i].controller[3] = True
boidSystems[i].stateChange()
elif event.unicode == "B" or event.unicode == "b":
for i in range(len(boidSystems)):
# Debug State
if boidSystems[i].controller[5] == True:
boidSystems[i].controller[5] = False
boidSystems[i].stateChange()
else:
boidSystems[i].controller[5] = True
boidSystems[i].stateChange()
elif event.unicode == "F" or event.unicode == "f":
# Change to fullscreen
if self.screen.get_flags() & pygame.FULLSCREEN:
pygame.display.set_mode(
(self.screen_width * self.scale,
self.screen_height * self.scale),
pygame.HWSURFACE | pygame.DOUBLEBUF, 32)
else:
pygame.display.set_mode(
(self.screen_width * self.scale,
self.screen_height * self.scale),
pygame.HWSURFACE | pygame.DOUBLEBUF
| pygame.FULLSCREEN, 32)
elif event.unicode == "R" or event.unicode == "r":
# Random State
if self.randomState == True:
self.randomState = False
else:
self.randomState = True
elif event.unicode == "D" or event.unicode == "d":
# Draw State
if self.simulateState == True:
self.simulateState = False
else:
self.simulateState = True
elif event.unicode == "W" or event.unicode == "w":
# Make wall
mousePos = pygame.mouse.get_pos()
mouseVec2 = pygame.math.Vector2((mousePos))
obstaclesRadius = random.randint(10, 20)
obstacles.makeObstacles(mouseVec2, obstaclesRadius)
# Drawing Styles
elif event.unicode == "1":
for i in range(len(boidSystems)):
# Triangle State
boidSystems[i].controller[4] = 1
elif event.unicode == "2":
for i in range(len(boidSystems)):
# Arrow Trails State
boidSystems[i].controller[4] = 2
elif event.unicode == "3":
for i in range(len(boidSystems)):
# Circle State
boidSystems[i].controller[4] = 3
elif event.unicode == "4":
for i in range(len(boidSystems)):
# Trails State
boidSystems[i].controller[4] = 4
elif event.unicode == "5":
for i in range(len(boidSystems)):
# Diamond State
boidSystems[i].controller[4] = 5
elif event.unicode == "6":
for i in range(len(boidSystems)):
# Diamond Trail State
boidSystems[i].controller[4] = 6
elif event.unicode == "7":
for i in range(len(boidSystems)):
# Paper Trail State
boidSystems[i].controller[4] = 7
kinectTracker = trackKinect(self.kinect)
if kinectTracker != None:
self.cur_left, self.cur_right, self.left_State, self.right_State = kinectTracker
else:
mousePos = pygame.mouse.get_pos()
Rx, Ry = mousePos[0], mousePos[1]
self.cur_right = Rx, Ry
self.right_State = 3
self.cur_left = Rx, Ry
self.left_State = 3
self.stateChange(boidSystems)
if self.randomState == False:
#mousePos = pygame.mouse.get_pos()
#Rx, Ry = mousePos[0], mousePos[1]
Rx = (self.cur_right[0])
Ry = (self.cur_right[1])
Lx = (self.cur_left[0])
Ly = (self.cur_left[1])
target1 = pygame.math.Vector2((Rx, Ry))
target2 = pygame.math.Vector2((Lx, Ly))
else:
if count % 30 == 0:
target1 = pygame.math.Vector2(
(random.random() * self.screen_width,
random.random() * self.screen_height))
target2 = pygame.math.Vector2(
(random.random() * self.screen_width,
random.random() * self.screen_height))
count += 1
if self.randomColor == True:
for i in range(len(boidSystems)):
boidSystems[i].randomColor()
self.randomColor = False
# else:
# self.colorCount += 1
# if self.colorCount == 1:
# for i in range(len(boidSystems)):
# tempNum = boidSystems[i].num
# tempScale = boidSystems[i].scale
# controller = copy.deepcopy(boidSystems[0].controller)
# newBoidSystem = Boids(
# tempNum, tempScale, self.screen_width, self.screen_height, controller)
# newBoidSystem.makeBoid()
# boidSystems.append(newBoidSystem)
# boidSystems.pop(0)
for i in range(len(boidSystems)):
if i % 2 == 0:
boidSystems[i].update(target1, target2,
obstacles.obstaclesList)
else:
boidSystems[i].update(target2, target1,
obstacles.obstaclesList)
# reset and draw things to screen
if self.simulateState:
# drawing mode off (keep filling the background)
self.frame_surface.fill((0, 0, 0))
self.frame_marker.fill((0, 0, 0))
for i in range(len(boidSystems)):
boidSystems[i].draw(self.frame_surface, self.frame_marker,
False, (self.cur_left, self.cur_right),
(self.left_State, self.right_State),
self.countLeft, self.countRight)
self.textDraw(self.frame_surface, self.frame_marker)
obstacles.drawObstacles(self.frame_surface)
# Kinect hand tracking circles
drawKinect(self.frame_marker, self.cur_left, self.cur_right)
# resize the drawing to fit the screen.
h_to_w = float(self.frame_surface.get_height()
) / self.frame_surface.get_width()
target_height = int(h_to_w * self.screen.get_width())
boidSurface = pygame.transform.scale(
self.frame_surface, (self.screen.get_width(), target_height))
kinectSurface = pygame.transform.scale(
self.frame_marker, (self.screen.get_width(), target_height))
# Draw boid layer
self.screen.blit(boidSurface, (0, 0))
# Draw kinect layer
self.screen.blit(kinectSurface, (0, 0))
pygame.display.update()
# print(self.clock.get_fps())
self.clock.tick(120)
self.kinect.close()
pygame.quit()
import numpy
from multiprocessing import Process
import Player
import Obstacle
import Obstacles
from ObstacleRectangle import *
import Map
import GameScreen
from Funcs import *
if __name__ == '__main__':
running = True
# СОЗДАНИЕ ОБЪЕКТОВ
pygame.mouse.set_visible(False)
player = Player.Player([300, 300])
obstacles = Obstacles.Obstacles()
obstacles.add_obstacle(
ObstacleRectangle([screenWidth / 2, screenHeight / 2], screenWidth,
screenHeight, BLACK, WHITE))
obstacles.add_obstacle(ObstacleRectangle([400, 425], 100, 100))
obstacles.add_obstacle(ObstacleRectangle([400, 225], 100, 100))
mapp = Map.Map(player, obstacles, 0.25)
gameScreen = GameScreen.GameScreen(mapp)
# ОКОНЧАНИЕ ГСОЗДАНИЕ ОБЪЕКТОВ
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
pygame.event.pump()
pygame.time.delay(16)
