def render(self, visibility, topMost):
if self.gameStarted:
return
if self.items == []:
return
Scene.render(self, visibility, topMost)
self.engine.view.setOrthogonalProjection(normalize = True)
self.engine.view.setViewport(1,0)
w, h = self.engine.view.geometry[2:4]
if self.img_background:
self.engine.drawImage(self.img_background, scale = (1.0, -1.0), coord = (w/2,h/2), stretched = 3)
try:
if self.mode == 0:
self.renderSetlist(visibility, topMost)
if self.moreInfoTime > 0:
self.engine.theme.setlist.renderMoreInfo(self)
if self.miniLobbyTime > 0:
self.engine.theme.setlist.renderMiniLobby(self)
# I am unsure how I want to handle this for now. Perhaps as dialogs, perhaps in SCS.
elif self.mode == 1:
self.renderSpeedSelect(visibility, topMost)
elif self.mode == 2:
self.renderTimeSelect(visibility, topMost)
finally:
self.engine.view.resetProjection()
class Application:
def __init__(self, title, _width, _height):
pygame.init()
self.surface = pygame.display.set_mode((_width, _height))
pygame.display.set_caption(title)
self.clock = pygame.time.Clock()
self.fps = 60
self.running = True
self.resolution = 2
self.Scenes = Scene(self.surface, _width, _height)
def Run(self):
while self.running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
keys = pygame.key.get_pressed()
if len(keys):
self.Scenes.key_pressed(keys)
self.surface.fill((10, 10, 10))
self.Scenes.draw()
#print("tick {0} | fps {1}".format(self.clock.tick(self.fps), self.clock.get_fps()))
pygame.display.update()
pygame.quit()
def test_Scene_set_init_velo_1():
x = randrange(-10e6, 10e6)
y = randrange(-10e6, 10e6)
s = randrange(1, 10e6)
m = randrange(1, 10e6)
v_x = randrange(-10e6, 10e6)
v_y = randrange(-10e6, 10e6)
def F_x(t):
return randrange(-50, 50) * t + randrange(-50, 50)
def F_y(t):
return randrange(-50, 50) * t + randrange(-50, 50)
t = TriangleT(x, y, s, m)
scene = Scene(t, F_x, F_y, v_x, v_y)
new_v_x = randrange(-10e6, 10e6)
new_v_y = randrange(-10e6, 10e6)
scene.set_init_velo(new_v_x, new_v_y)
assert scene.get_init_velo() == (new_v_x, new_v_y)
def processEvent(self, event):
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
m = MessageScene(self.director, self)
self.director.setScene(m)
self.player.controller.processEvent(event)
Scene.processEvent(self, event)
def test_Scene_set_shape_1():
x = randrange(-10e6, 10e6)
y = randrange(-10e6, 10e6)
s = randrange(1, 10e6)
m = randrange(1, 10e6)
v_x = randrange(-10e6, 10e6)
v_y = randrange(-10e6, 10e6)
length = randrange(10e4)
x_s = [randrange(-10e6, 10e6) for _ in range(length)]
y_s = [randrange(-10e6, 10e6) for _ in range(length)]
m_s = [randrange(1, 10e6) for _ in range(length)]
def F_x(t):
return randrange(-50, 50) * t + randrange(-50, 50)
def F_y(t):
return randrange(-50, 50) * t + randrange(-50, 50)
t = TriangleT(x, y, s, m)
b = BodyT(x_s, y_s, m_s)
scene = Scene(t, F_x, F_y, v_x, v_y)
scene.set_shape(b)
assert scene.get_shape() == b
def __init__(self, map, image, soundtrack, pj):
Scene.__init__(self, map, image, soundtrack, pj)
self.npcs = [
Npc("imagenes/personajes/paperi_sheet.png", False, [
"hola", "soy paperi", "buenos dias", "ven a nuestra tienda",
"vendemos pan"
], 600, 100, 68, 189),
Npc("imagenes/personajes/Peto_sheet.png", False, [
"paperi siempre esta igual",
"deberiamos llamarnos peto y paperi"
], 500, 600, 114, 145),
Npc("imagenes/personajes/Tapa_sheet.png", False,
["me llamo Tapa :D", "vente luego a jugar", "miau"], 1200, 600,
68, 77),
Npc("imagenes/personajes/Kea_sheet.png", False,
["me preocupan peto y paperi", "no paran de pelear", "jopé"],
1200, 200, 84, 131)
]
self.objetos = [self.pj.objects[0]]
self.obs = [
Obstaculo(780, 520, 155, 100),
Obstaculo(1080, 520, 155, 100),
Obstaculo(0, 400, 50, 130, True),
Obstaculo(680, self.mapa[1] - 50, 125, 50, True),
Obstaculo(600, 0, 125, 50, True),
Obstaculo(300, 50, 200, 400, False, "imagenes/objetos/casa.png"),
Obstaculo(700, 350, 50, 50, False, "imagenes/objetos/stone.png",
True)
]
class DanceCV():
def __init__(self, song, speed):
self.input = Input()
self.resource = Resource()
self.audio = Audio()
self.audio.pre_open()
pygame.init()
self.audio.open()
if song != None:
self.song = loadSong(self.resource, song)
else:
self.song = loadSong(self.resource, "gangnam")
self.clock = pygame.time.Clock()
pygame.display.set_mode(
(Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT))
pygame.display.set_caption("DanceCV")
screen = pygame.display.get_surface()
if speed != None:
self.scene = Scene(self.resource, self.song, screen, self.input,
speed)
else:
self.scene = Scene(self.resource, self.song, screen, self.input, 2)
def run(self):
while True:
for events in pygame.event.get():
if events.type == QUIT:
sys.exit(0)
self.input.run()
self.scene.run()
pygame.display.update()
self.clock.tick(30)
def test_Scene_set_unbal_forces_2():
x = randrange(-10e6, 10e6)
y = randrange(-10e6, 10e6)
s = randrange(1, 10e6)
m = randrange(1, 10e6)
v_x = randrange(-10e6, 10e6)
v_y = randrange(-10e6, 10e6)
def F_x(t):
return randrange(-50, 50) * t + randrange(-50, 50)
def F_y(t):
return randrange(-50, 50) * t + randrange(-50, 50)
def new_F_x(t):
return 0
def new_F_y(t):
return 0
t = TriangleT(x, y, s, m)
scene = Scene(t, F_x, F_y, v_x, v_y)
scene.set_unbal_forces(new_F_x, new_F_y)
assert scene.get_unbal_forces() == (new_F_x, new_F_y)
def __init__(self):
Scene.__init__(self)
self.callback = self._default_cb
self.wait_img = Screen.get_instance().create_image(self.get_name() +
"_wait")
if not self.wait_img.is_cached():
img = Screen.create_button(ResourceManager.get("empty.png"),
Strings.get("Please wait..."),
Config.get("text_color"),
ResourceManager.get(Config.get("font")),
100)
self.wait_img.load_surface(img)
self.wait_img.save()
self.nb_imgs = len(Config.get("photomaton")["placeholders"])
self.one_more_imgs = []
for i in xrange(self.nb_imgs):
self.one_more_imgs.append(
Screen.get_instance().create_image(self.get_name() +
"_one_more%d" % i))
if not self.one_more_imgs[i].is_cached():
img = Screen.create_button(
ResourceManager.get("empty.png"),
Strings.get(
"Encore une... (%d / %d)" % (i + 1, self.nb_imgs)),
Config.get("text_color"),
ResourceManager.get(Config.get("font")), 100)
self.one_more_imgs[i].load_surface(img)
self.one_more_imgs[i].save()
def __init__(self,
director,
pausedScene,
title='Warning!',
message='Message',
tooltip='Press here to continue'):
Scene.__init__(self, director)
self.bluredBackground = None
self.b = 1
self.pausedScene = pausedScene
layer = Layer(director)
backgroundImage = Resources.load_image("message_box.png")
buttonImage = Resources.load_image("message_box_button.png")
buttonWidth = 372
style = MessageBox.createMessageBoxStyle(backgroundImage, buttonImage,
buttonWidth)
self.messageBox = MessageBox.MessageBox(
self.director, (SCREEN_W / 2 - style['bg'].get_width() / 2,
SCREEN_H / 2 - style['bg'].get_height() / 2),
style, True)
self.messageBox.button.onMouseDown = lambda: self.popScene()
self.messageBox.title = title
self.messageBox.message = message
self.messageBox.tooltip = tooltip
layer.append(self.messageBox)
self.layers.append(layer)
def render_task(cfgpath, pid, taskqueue, resultqueue):
#print('pid:%d'%(pid))
# print("SceneInit:X:%d,Y:%d,W:%d,H:%d"%(beginx,beginy,width,height))
# scene = Scene()
# if scene.init_scene(cfgpath) == False:
# print("Scene Init Faild")
# return
# print("Scene Render Begin")
# scene.render_range(beginx, beginy, width, height, pixelqueue)
# print("Range Finish")
#colors = []
#colordict[pid] = []
#if colordict.has_key(pid) == False:
#print("Key:%d"%(pid))
#colordict[7] = 5
scene = Scene()
if scene.init_scene(cfgpath) == False:
print("Scene Init Faild")
return None
# print("Scene Render Begin:PID:,X:%d,Y:%d,W:%d,H:%d"%(data[0],data[1],data[2],data[3]))
# scene.render_range(data[0],data[1],data[2],data[3],data[4],data[5], colors)
# print("Range Finish")
# return colors
while taskqueue.empty() == False:
dt = taskqueue.get(True)
print("Scene Render Begin:PID:%d,X:%d,Y:%d,W:%d,H:%d"%(pid,dt[0],dt[1],dt[2],dt[3]))
scene.render_range(dt[0],dt[1],dt[2],dt[3],dt[4],dt[5], resultqueue)
print("Range Finish")
def quit(self, Player, Controller, Scene):
Scene.clear_screen()
Scene.screen.addstr(
Scene.line, 1,
"-----------------------------------------------------------------------------------------------------------------------"
)
Scene.line += 1
Scene.screen.addstr(
Scene.line, 1,
" Quit Game",
Scene.cyan)
Scene.line += 1
Scene.screen.addstr(
Scene.line, 1,
"-----------------------------------------------------------------------------------------------------------------------"
)
Scene.line += 1
loop = True
while loop == True:
Scene.line = 3
#Are you Sure you want to quit?
Scene.screen.addstr(Scene.line, 1, Scene.make_line(87, "Menu", {}))
Scene.line += 1
response = Controller.get_response(Player, False, Scene)
if Controller.bools["Yes"] == True:
loop = False
if self.menu == False:
self.return_to_menu(Controller, Scene, Player)
elif Controller.bools["No"] == True:
loop = False
if self.menu == True:
self.initialize()
def GetScene(self):
scene = Scene()
self.dataSource.LoadPage()
upComingDateString = self.dataSource.GetUpcomingGameDate()
if self.shouldDisplayUpComingGame(upComingDateString):
scene.Home_Team_Logo_Image = self.dataSource.GetUpcomingGameHomeTeamLogo(
)
scene.Away_Team_Logo_Image = self.dataSource.GetUpcomingGameAwayTeamLogo(
)
split = upComingDateString.split(" ")
firstline = ""
secondline = ""
for line in split[:3]:
firstline += line + " "
for line in split[3:]:
secondline += line + " "
scene.AdditionalText.append(firstline)
scene.AdditionalText.append(secondline)
else:
scene.Home_Team_Logo_Image = self.dataSource.GetHomeTeamLogo()
scene.Away_Team_Logo_Image = self.dataSource.GetAwayTeamLogo()
scene.Home_Team_Score = self.dataSource.GetHomeTeamScore()
scene.Away_Team_Score = self.dataSource.GetAwayTeamScore()
scene.MainText = self.dataSource.GetInning()
scene.AdditionalText = self.dataSource.GetAdditionalText()
return scene
def options(self, Player, Controller, Scene, File):
self.Options = True
Scene.clear_screen()
Scene.screen.addstr(
Scene.line, 1,
"-----------------------------------------------------------------------------------------------------------------------"
)
Scene.line += 1
Scene.screen.addstr(
Scene.line, 1,
" Options",
Scene.cyan)
Scene.line += 1
Scene.screen.addstr(
Scene.line, 1,
"-----------------------------------------------------------------------------------------------------------------------"
)
Scene.line += 1
#Type back to Exit
Scene.screen.addstr(Scene.line, 1, Scene.make_line(65, "Menu", {}))
Scene.line += 1
#Type Your Selection
Scene.screen.addstr(
Scene.line, 1, Scene.print_header(Scene.make_line(92, "Menu", {})))
Scene.line += 3
selections = ["Change Names", "Delete Save Data"]
for x in range(len(selections)):
Scene.screen.addstr(Scene.line, 1, "* ", Scene.yellow)
Scene.screen.addstr(selections[x])
Scene.line += 1
self.loop = True
while self.loop == True:
Controller.line = Scene.line
Controller.get_command(Player, File, self, Scene)
def __init__(self, frame_skip = 2):
height = 400
width = 600
goal_length = 300
self.scene = Scene(width, height)
self.frame_skip = frame_skip
self.ball_idle = 0
self.ball_idle_limit = 3
self.action_space = ActionSpace([Action.up, Action.down, Action.nomoveshoot])
self.box = Box(0, width, 0, height, 0)
self.goal1 = Goal(leftright_margin, height / 2, Way.left, goal_length)
self.player1 = Player(80, height / 2, player_radius, player_mass, \
player_restitution, player_damping, player_kick_damping, player_kick_power, Side.red)
self.ball = Ball(width - 100, height / 2, ball_radius, ball_mass, ball_restitution, ball_damping)
self.penalty_spot = Disc(self.ball.center.x, self.ball.center.y, 4, 0, 0, 0, Color.green).make_ghost().make_hollow()
# self.player_border_left = VerticalBorder(50, height / 2, height, 0, visible=True)
# self.player_border_right = VerticalBorder(100, height / 2, height, 0, visible=True)
self.scene.add_object(self.goal1)
self.scene.add_object(self.player1)
self.scene.add_object(self.ball)
self.scene.add_object(self.penalty_spot)
self.scene.add_object(self.box)
self.reset()
class DanceCV():
def __init__(self, song, speed):
self.input = Input()
self.resource = Resource()
self.audio = Audio()
self.audio.pre_open()
pygame.init()
self.audio.open()
if song != None:
self.song = loadSong(self.resource, song)
else:
self.song = loadSong(self.resource, "gangnam")
self.clock = pygame.time.Clock()
pygame.display.set_mode((Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT))
pygame.display.set_caption("DanceCV")
screen = pygame.display.get_surface()
if speed != None:
self.scene = Scene(self.resource, self.song, screen, self.input, speed)
else:
self.scene = Scene(self.resource, self.song, screen, self.input, 2)
def run(self):
while True:
for events in pygame.event.get():
if events.type == QUIT:
sys.exit(0)
self.input.run()
self.scene.run()
pygame.display.update()
self.clock.tick(30)
def processEvent(self, event):
if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
m = MessageScene(self.director, self)
self.director.setScene(m)
self.player.controller.processEvent(event)
Scene.processEvent(self, event)
def show(self, callback=None):
Scene.show(self, self.wait_img)
self.current_step = 0
if callback:
self.callback = callback
else:
self.callback = self._default_cb
Screen.get_instance().start_preview()
def show(self, callback=None):
Scene.show(self)
if callback:
self.callback = callback
self.img = PIL.Image.open(
ResourceManager.get(Config.get("photomaton")["template"]))
self.img_counter = 0
SceneManager.get_instance().show_scene("snap", self._process_img)
def Story_UI(self, Player, Scene, Command):
Scene.player_HUD(Player, self)
Scene.inventory_list(Player, self)
if self.spellbook == True:
Scene.spellbook_display(Player, self)
if self.in_tower == True:
Scene.tower_map(self)
Scene.command_line()
def draw(self, screen):
s = pygame.Surface((SCREEN_W, SCREEN_H))
self.pausedScene.draw(s)
self.bluredBackground = self.blur(s, self.b)
if self.b < 10:
self.b = self.b + 0.1
screen.blit(self.bluredBackground, (0, 0))
Scene.draw(self, screen)
def __init__(self):
self.input = Input()
pygame.init()
pygame.display.set_mode(
(Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT))
pygame.display.set_caption("Twister!")
screen = pygame.display.get_surface()
self.scene = Scene(screen, self.input)
def draw(self, screen):
s = pygame.Surface((SCREEN_W, SCREEN_H))
self.pausedScene.draw(s)
self.bluredBackground = self.blur(s, self.b)
if self.b < 10:
self.b = self.b + 0.1
screen.blit(self.bluredBackground, (0, 0))
Scene.draw(self, screen)
def __init__(self, map, image, soundtrack, pj):
Scene.__init__(self, map, image, soundtrack, pj)
self.npcs = []
self.objetos = []
self.obs = [
Obstaculo(780, 520, 155, 100),
Obstaculo(self.mapa[0] - 150, self.mapa[1] - 50, 125, 50, True)
]
def __init__(self, flower, sheep, grass, sign):
Scene.__init__(self, flower, sheep, grass, sign)
self.animations = [
FireFlowerAnimation(flower),
FireSheepAnimation(sheep),
FireGrassAnimation(grass),
FireSignAnimation(sign)
]
def __init__(self, objectManager, inputManager, space, width, height):
Scene.__init__(self)
self.objectManager = objectManager
self.inputManager = inputManager
self.visibilityManager = VisibilityManager()
self.space = space
self.spriteBatch = pyglet.graphics.Batch()
self.width = width
self.height = height
def __init__(self, filename):
print('Parsing ' + filename)
self.Materials = dict() # used for storing ref to materials
self.Nodes = dict() # used for storing ref to nodes
self.NodeStack = []
self.scene = Scene()
xml = minidom.parse(filename)
self.parse(xml)
print('parsing done.')
def __init__(self, sim_dir, simulation_helper):
self.__sim_dir = sim_dir
self.__sim_helper = simulation_helper
self.__scene = Scene()
# calculated members
self.__input_conf_path = os.path.join(sim_dir, "Parameters", "input.conf")
f = open(self.__input_conf_path)
self.__input_conf = json.load(f)
f.close()
def on_update(self, time, keys, director):
Scene.on_update(self, time, keys, director)
if self.pj.rect_col.colliderect(
self.obs[2].rect
) or self.pj.rect_col.colliderect(
self.obs[3].rect
) or self.pj.rect_spr.colliderect(
self.obs[4].rect
): #cambiamos de zona al chocar con los cuadrados de transporte
self.changeScene(1, director, (map2[0] - 150, map2[1] - 100))
def __init__(self, arduino, camera):
Scene.__init__(self)
self.arduino = arduino
self.camera = camera
self.timer = None
self.current_step = 0
self.callback = self._default_cb
self.cheese_img = Screen.get_instance().create_image(self.get_name() +
"_cheese")
if not self.cheese_img.is_cached():
base_img = Screen.get_instance().create_empty_image(True)
self.cheese_img.load_surface(base_img.img)
surf_text = Screen.create_text(
Strings.get("Cheese"), ResourceManager.get(Config.get("font")),
100, Config.get("text_color"))
tw, th = surf_text.get_size()
bw, bh = self.cheese_img.img.get_size()
self.cheese_img.img.blit(surf_text, ((bw - tw) / 2, (bh - th) / 2))
self.cheese_img.save()
self.wait_img = Screen.get_instance().create_image(self.get_name() +
"_wait")
if not self.wait_img.is_cached():
img = Screen.create_button(ResourceManager.get("empty.png"),
Strings.get("Please wait..."),
Config.get("text_color"),
ResourceManager.get(Config.get("font")),
100)
self.wait_img.load_surface(img)
self.wait_img.save()
self.imgs = []
wait_before = Config.get("wait_before_snap")
for i in xrange(wait_before, 0, -1):
cache_img = Screen.get_instance().create_image(
"%s_%d" % (self.get_name(), i), True)
if not cache_img.is_cached():
base_img = Screen.get_instance().create_empty_image(True)
cache_img.load_surface(base_img.img)
img = Screen.create_text(str(i), None, 200, (255, 0, 0))
iw, ih = img.get_size()
w, h = base_img.size
cache_img.img.blit(img, (10, 10))
cache_img.img.blit(img, (w - iw - 10, 10))
cache_img.img.blit(img, (10, h - ih - 10))
cache_img.img.blit(img, (w - iw - 10, h - ih - 10))
cache_img.save()
self.imgs.append(cache_img)
Screen.get_instance().register_callback("on_preview_starts",
self._on_preview_starts)
def credits(self, Player, Controller, Scene):
Scene.clear_screen()
Scene.screen.addstr(
Scene.line, 1,
"-----------------------------------------------------------------------------------------------------------------------"
)
Scene.line += 1
Scene.screen.addstr(
Scene.line, 1,
" Credits",
Scene.cyan)
Scene.line += 1
Scene.screen.addstr(
Scene.line, 1,
"-----------------------------------------------------------------------------------------------------------------------"
)
Scene.line += 1
Scene.screen.addstr(Scene.line, 53, "Story By")
Scene.line += 1
Scene.screen.addstr(Scene.line, 50, "Daniel Navarro", Scene.cyan)
Scene.line += 2
Scene.screen.addstr(Scene.line, 51, "Programming")
Scene.line += 1
Scene.screen.addstr(Scene.line, 50, "Daniel Navarro", Scene.cyan)
Scene.line += 2
Scene.screen.addstr(Scene.line, 44, "Assistant to the Programmer")
Scene.line += 1
Scene.screen.addstr(Scene.line, 51, "Iroh the Cat", Scene.cyan)
Scene.line += 2
Scene.screen.addstr(Scene.line, 52, "QA Testers")
Scene.line += 1
Scene.screen.addstr(Scene.line, 50, "Daniel Navarro", Scene.cyan)
Scene.line += 1
Scene.screen.addstr(Scene.line, 50, "Madhu Kottalam", Scene.cyan)
Scene.line += 2
Scene.screen.addstr(Scene.line, 50, "Special Thanks")
Scene.line += 1
Scene.screen.addstr(Scene.line, 51, "Jey Kottalam", Scene.cyan)
Scene.line += 1
Scene.screen.addstr(Scene.line, 50, "Madhu Kottalam", Scene.cyan)
Scene.line += 1
Scene.screen.addstr(Scene.line, 50, "Estella Garcia", Scene.cyan)
Scene.line += 1
Scene.screen.addstr(Scene.line, 51, "Iroh the Cat", Scene.cyan)
Scene.line += 2
#Type back to Exit
Scene.screen.addstr(Scene.line, 1, Scene.make_line(65, "Menu", {}))
Scene.line += 1
loop = True
while loop == True:
response = Controller.get_response(Player, False, Scene)
if Controller.bools["Exit"] == True:
loop = False
self.main_menu(Player, Controller, Scene)
def __init__(self, title, _width, _height):
pygame.init()
self.surface = pygame.display.set_mode((_width, _height))
pygame.display.set_caption(title)
self.clock = pygame.time.Clock()
self.fps = 60
self.running = True
self.resolution = 2
self.Scenes = Scene(self.surface, _width, _height)
def __init__(self, debug_mode=True):
pyxel.init(200, 200, caption="ADV")
pyxel.mouse(visible=True)
pyxel.load("../asset.pyxres")
self.debug_mode = debug_mode
messages = self.get_messages()
self.scene = Scene(messages, debug_mode=self.debug_mode)
pyxel.run(self.update, self.draw)
class PoseTracking():
def __init__(self, mode):
if mode == 'local' or mode == 'Local' or mode =='LOCAL':
print("Running in a local video...")
self.input = Input()
self.mode = 1
elif mode == 'reatime' or mode == 'RealTime' or mode =='realTime' or mode =='Realtime' or mode =='REALTIME':
self.input = Input()
pygame.init()
pygame.display.set_mode((Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT))
pygame.display.set_caption("PoseTracking!")
screen = pygame.display.get_surface()
self.scene = Scene(screen, self.input)
self.mode = 0
def run(self):
while True:
# To run the algorithm
self.input.run()
# Showing the scene
self.scene.run()
def run_local(self, data_input, data_output, speed = 30):
# Opens the Video file
cap = cv2.VideoCapture(data_input)
# Abrindo o video e passando cada frame como parametro
frames_array = []
get_par = 0
while(cap.isOpened()):
ret, frame = cap.read()
if ret == False:
break
# Getting video parameters
if get_par == 0:
height, width, layers = frame.shape
size = (width,height)
get_par = 1
self.input.run_local(ret, frame, frames_array)
if ret == False:
break
# Saving all frames as a video
out = cv2.VideoWriter(data_output,cv2.VideoWriter_fourcc(*'DIVX'), speed, size)
for i in range(len(frames_array)):
out.write(frames_array[i])
out.release()
def parseScenes(self, storyPath):
dom = xml.dom.minidom.parse(storyPath)
scenes = dom.getElementsByTagName("scene")
for x in scenes:
idscene = x.getAttribute("id")
fondo = x.getElementsByTagName("background")[0]
background = fondo.getAttribute("value")
if len(x.getElementsByTagName("escena_opcion1")) != 0:
escena_opcion1 = x.getElementsByTagName("escena_opcion1")[0].getAttribute("value")
if len(x.getElementsByTagName("escena_opcion2")) != 0:
escena_opcion2 = x.getElementsByTagName("escena_opcion2")[0].getAttribute("value")
if len(x.getElementsByTagName("escena_opcion3")) != 0:
escena_opcion3 = x.getElementsByTagName("escena_opcion3")[0].getAttribute("value")
audio = x.getElementsByTagName("audio")[0].getAttribute("value")
relato = x.getElementsByTagName("relato")[0].getAttribute("value")
opciones = x.getElementsByTagName("option")
parsedOptions = []
for opcion in opciones:
print "parsing option"
optionId = opcion.getAttribute("id")
optionImage = opcion.getElementsByTagName("image")[0].getAttribute("value")
optionPosX = opcion.getElementsByTagName("position")[0].getAttribute("x")
optionPosY = opcion.getElementsByTagName("position")[0].getAttribute("y")
action_verb = opcion.getElementsByTagName("action")[0].getAttribute("verb")
action_resource = opcion.getElementsByTagName("action")[0].getAttribute("resource")
action_x = opcion.getElementsByTagName("action")[0].getAttribute("x")
action_y = opcion.getElementsByTagName("action")[0].getAttribute("y")
action_speed = opcion.getElementsByTagName("action")[0].getAttribute("x")
personajeId = opcion.getElementsByTagName("character")[0].getAttribute("charid")
act = Action(action_verb,action_resource,action_x,action_y,action_speed)
newOpt = Option(optionId,optionImage,optionPosX, optionPosY,act,personajeId)
parsedOptions.append(newOpt)
scene = Scene(self._surf_display, background, escena_opcion1 , escena_opcion2, escena_opcion3, audio, relato, parsedOptions)
characters_xml = x.getElementsByTagName("scene_character")
print "personajes " + str(len(characters_xml))
for charxml in characters_xml:
charid = charxml.getAttribute("id")
print "IdEscena= " + idscene + ". Personaje " + charid
charx = charxml.getElementsByTagName("position")[0].getAttribute("x")
chary = charxml.getElementsByTagName("position")[0].getAttribute("y")
if charid != "guzman":
toAdd = Character(charid, self.character_sprites[charid], charx, chary)
scene.addCharacter(toAdd)
print "[Main] se agrego un personaje a la escena. Personaje " + charid
print "se creo escena con" + str(len(parsedOptions)) + " opciones"
self.scenes[idscene] = scene
self.scenes[self.current_scene].setearDatos(self._surf_display, self.current_scene)
self.imprimir.setearDatos(self._surf_display)
def draw(self, screen):
screen.fill(0x000000)
if self.bg:
screen.blit(self.bg, self.camera.state)
if Constants.DEBUG:
self.drawRaytracing(screen)
self.player.draw(screen, self.camera)
for group in self.groups:
group.draw(screen, self.camera)
self.drawDanger(screen);
# TODO: move maps and characters to its own layer
Scene.draw(self, screen) # draws rest of layers
def setUp(self):
'''
Create a scene with a camera placed at [0, 0, 4] and looking at the
world origin.
'''
scene = Scene()
self.scene = scene
#Camera
camera = Camera({'from':np.array([1.,4.,-2.]),
'to':np.array([1.,-2.,4]),
'up':GT.normalize(np.array([-1.,1.,0.])),
'fov':45,
'width':10001, 'height':10001}) # choose very high dimension to avoid rounding error
render = Render({'camera':camera})
scene.render = render
def __init__(self, filename):
print('Parsing ' + filename)
self.Materials = dict() # used for storing ref to materials
self.Nodes = dict() # used for storing ref to nodes
self.NodeStack = []
self.scene = Scene()
xml = minidom.parse(filename)
self.parse(xml)
print('parsing done.')
def run(self, ticks):
if self.cmdPlay:
self.startGame()
return
if len(self.engine.world.songQueue) > 0 and self.queued:
self.startGame(fromQueue=True)
return
if self.gameStarted or self.items == []:
return
Scene.run(self, ticks)
if self.queued:
self.queued = False
if self.scrolling:
self.scrollTime -= ticks
if self.scrollTime < 0:
self.scrollTime = self.scrollRate
self.scroller[self.scrolling]()
if self.mode == 0:
if self.previewDelay > 0 and self.autoPreview:
self.previewDelay -= ticks
if self.previewDelay < 0:
self.previewDelay = 0
if not self.previewLoaded and self.previewDelay == 0:
self.previewSong()
d = self.cameraOffset - self.selectedOffset
self.cameraOffset -= d * ticks / 192.0
for i in range(len(self.itemRenderAngles)):
if i == self.selectedIndex:
self.itemRenderAngles[i] = min(90, self.itemRenderAngles[i] + ticks / 2.0)
else:
self.itemRenderAngles[i] = max(0, self.itemRenderAngles[i] - ticks / 2.0)
if self.moreInfo:
self.moreInfoTime += ticks
elif self.moreInfoTime > 0:
self.moreInfoTime -= ticks
if self.moreInfoTime < 0:
self.moreInfoTime = 0
self.engine.theme.setlist.run(ticks)
def __init__(self, director, pausedScene, title='Warning!', message='Message', tooltip='Press here to continue'):
Scene.__init__(self, director)
self.bluredBackground = None
self.b = 1
self.pausedScene = pausedScene
layer = Layer(director)
backgroundImage = Resources.load_image("message_box.png")
buttonImage = Resources.load_image("message_box_button.png")
buttonWidth = 372
style = MessageBox.createMessageBoxStyle(
backgroundImage, buttonImage, buttonWidth)
self.messageBox = MessageBox.MessageBox(
self.director, (SCREEN_W / 2 - style['bg'].get_width() / 2, SCREEN_H / 2 - style['bg'].get_height() / 2), style, True)
self.messageBox.button.onMouseDown = lambda: self.popScene()
self.messageBox.title = title
self.messageBox.message = message
self.messageBox.tooltip = tooltip
layer.append(self.messageBox)
self.layers.append(layer)
def initialize(self):
speller = GazeSpeller()
tracker = self._ckeckAvailableTracker()
canvas = self._initializeCanvas()
if isinstance(tracker,MouseTracker):
canvas.bind('<Motion>',tracker.onMotion) # use this to let the tracker get updates from the mouse event without actual get knowledge of the GUIs
# it's named "inversion of control"
self.scene = Scene(canvas, tracker, speller)
self.scene.initialize(1)
def __init__(self, song, speed):
self.input = Input()
self.resource = Resource()
self.audio = Audio()
self.audio.pre_open()
pygame.init()
self.audio.open()
if song != None:
self.song = loadSong(self.resource, song)
else:
self.song = loadSong(self.resource, "gangnam")
self.clock = pygame.time.Clock()
pygame.display.set_mode((Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT))
pygame.display.set_caption("DanceCV")
screen = pygame.display.get_surface()
if speed != None:
self.scene = Scene(self.resource, self.song, screen, self.input, speed)
else:
self.scene = Scene(self.resource, self.song, screen, self.input, 2)
def __init__(self, width, height):
# create pyglet window
self.window = pyglet.window.Window(resizable=True)
self.window.on_draw = self.on_draw
self.window.on_key_press = self.on_key_press
self.window.on_key_release = self.on_key_release
self.window.on_mouse_press = self.on_mouse_press
self.window.on_mouse_release = self.on_mouse_release
self.window.on_mouse_drag = self.on_mouse_drag
self.window.width = width
self.window.height = height
self.menu_window = False
self.gen_entity = 'SQUARE'
self.gen_size = 50
self.gen_mass = 500
self.key_pressed = []
self.clicked_object = None
self.clicked_dx = 0
self.clicked_dy = 0
# create fps display
self.fps_display = pyglet.clock.ClockDisplay()
self.clock = 0
# sync clock
pyglet.clock.schedule_interval(self.tick, 1.0/60.0)
pyglet.clock.set_fps_limit(60)
# create world
world_width = 3000
world_height = 3000
self.world = World(world_width, world_height)
# create scene- match dimensions of the app window
self.scene = Scene(width=width, height=height, background_width=world_width, background_height=world_height)
#self.demo_1(world_width, world_height)
#self.demo_2(world_width, world_height)
#self.demo_3(world_width, world_height)
# initialize background music
self.music = Music()
self.music.play_bg()
# Making the player here (testing)
mag = 40000
offset = 400
player_type = Triangle(size=20, position=Vector2(x=offset, y=offset))
self.scene.entities.append(player_type)
self.player = Player(entity=player_type, mass=100)
self.world.add_body(self.player)
def __init__(self, director, player):
Scene.__init__(self, director)
self.player = player
self.enemyGroup = EntityGroup([])
self.bulletGroup = EntityGroup([])
self.groups = []
self.groups.append(self.enemyGroup)
self.groups.append(self.bulletGroup)
self.bg = None
self.collisionBg = None
self.camera = Camera()
self.HUD = HUD(self.director, (0, 467), True, player)
hudLayer = Layer(self.director)
hudLayer.append(self.HUD)
self.layers.append(hudLayer)
self.mouseHoveringHUD = False
self.danger = False
self.dangerLevel = 0
self.gameOver = False
def update(self, time):
if self.gameOver:
mainMenu = MainMenu.MainMenu(self.director)
self.director.setScene(mainMenu)
return
if self.danger:
self.dangerLevel = 210
self.danger = False
if self.collisionBg != None:
self.player.update(time, self)
for group in self.groups:
group.update(time, self)
self.camera.update(self.player)
Scene.update(self, time)
if self.gameOver:
game_over_scene = MessageScene(self.director, self)
game_over_scene.set_message("Has Muerto.")
self.director.setScene(game_over_scene)
class App(object):
def __init__(self):
self.render_asap = False;
self.app_should_exit = False
self.root = Tk()
self.scene = None
self.lastUpdateMoment = 0
self.renderingTechniq = RENDER_ON_MAINLOOP
def setAppExit(self):
self.app_should_exit = TRUE
def initialize(self):
speller = GazeSpeller()
tracker = self._ckeckAvailableTracker()
canvas = self._initializeCanvas()
if isinstance(tracker,MouseTracker):
canvas.bind('<Motion>',tracker.onMotion) # use this to let the tracker get updates from the mouse event without actual get knowledge of the GUIs
# it's named "inversion of control"
self.scene = Scene(canvas, tracker, speller)
self.scene.initialize(1)
def startRendering(self):
if self.renderingTechniq == RENDER_ON_MAINLOOP:
self.runOnTkInterMainLoop()
if self.renderingTechniq == RENDER_ON_TIMER_TICK:
self.runOnExpectedFixedFramerate()
sys.exit(0)
def _ckeckAvailableTracker(self):
#TODO check if tracker available if not use mouse
return MouseTracker(self.root)
def _initializeCanvas(self):
self.root.attributes("-fullscreen", True)
self.root.protocol("WM_DELETE_WINDOW", self.setAppExit)
canvas = Canvas(self.root)
canvas.pack(fill=BOTH, expand=YES)
return canvas
def _processRenderLoop(self, deltaTime, CallTkUpdates = False):
self.scene.update(deltaTime)
self.scene.render()
if CallTkUpdates:
self.root.update_idletasks() # render / drawing
self.root.update() # perform processing of key events etc
def _estimateFrameTime(self):
currentMoment = time()
deltaTime = currentMoment - self.lastUpdateMoment
self.lastUpdateMoment = currentMoment
return deltaTime
# example rendering A
def runOnExpectedFixedFramerate(self):
self.lastUpdateMoment = time()
while not self.app_should_exit:
deltaTime = self._estimateFrameTime()
self._processRenderLoop(deltaTime, CallTkUpdates = True)
if not self.render_asap:
sleep(self.scene.getExpectedUpdateTime())
#example rendering B
def runOnTkInterMainLoop(self):
self._callUpdatingOnAfterCall();
self.root.mainloop()
def _callUpdatingOnAfterCall(self):
deltaTime = self._estimateFrameTime()
self._processRenderLoop(deltaTime)
# uses a scheduler from tkinter GUI Mainloop - test
# self.scene.getExpectedUpdateTime()
self.root.after(1, self._callUpdatingOnAfterCall)
def __init__(self):
Scene.__init__(self)
self.sprite = Sprite("test1.png")
self.sprite.position = 100, 100
def draw(self):
Scene.draw(self)
self.sprite.draw()
def update(self):
Scene.update(self)
from pygame.locals import *
from Scene import Scene
from Circle import Circle
pygame.init()
DISPLAYSURF = pygame.display.set_mode((400, 300))
pygame.display.set_caption('Hello World!')
"""Aller, on crée une scène et on y met un objet"""
myScene = Scene(123)
myObject = Circle(50)
myScene.addEntity(myObject)
print(myScene.getEntities())
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
pygame.display.update()
#!/usr/bin/python3
import sys, logging, time
from Scene import Scene
logging.basicConfig(level=logging.DEBUG)
s = Scene()
s.fromFile(sys.argv[1])
running = []
times = sorted(s.commands.keys())
t = 0
while t <= s.getDuration():
## Check if we reached a new command ##
if (len(times) > 0) and (t >= times[0]):
for c in s.commands[times[0]]:
print("%10dms: BEG: %s" % (t, c))
running.append((t, c))
times.pop(0)
## Maintain running commands ##
stillRunning = []
for c in running:
res = c[1].maintain(t-c[0])
if res == 0:
stillRunning.append(c)
elif res == 1:
print("%10dms: END: %s" % (t, c[1]))
elif res == 2:
stillRunning.append(c)
print("%10dms: RST: %s" % (t, c[1]))
t -= 1
else:
raise ValueError()
def __init__(self, id = None, manager = None): Scene.__init__(self, id, manager)
[pygame.image.load("%sa2/4%s"%("IndividualFrames/bmp16/",".bmp"))],
[pygame.image.load("%sa2/5%s"%("IndividualFrames/bmp16/",".bmp"))],
[pygame.image.load("%sa2/6%s"%("IndividualFrames/bmp16/",".bmp"))],
[pygame.image.load("%sa2/7%s"%("IndividualFrames/bmp16/",".bmp"))],
[pygame.image.load("%sa2/8%s"%("IndividualFrames/bmp16/",".bmp"))],
[pygame.image.load("%sa2/9%s"%("IndividualFrames/bmp16/",".bmp"))]
]
dynamicObj = DynamicDrawableObject(switch1,'',1,39,3, 2, 2)
secondDynamicObj = DynamicDrawableObject(switch1,'',1,39,100, 3, 3)
staticObj = DynamicDrawableObject(switch2,'',1,40,43, 4, 4)
initialList = [dynamicObj, secondDynamicObj]
secondaryList = [staticObj]
myScene = Scene(initialList)
myScene.addObjects(secondaryList)
myScene.nextFrame()
blitAndFlip()
time.sleep(2)
myScene.getObject(1).scale(100, 100)
myScene.getObject(1).nextFrame()
myScene.getObject(0).nextFrame()
myScene.getObject(2).nextFrame()
blitAndFlip()
time.sleep(2)
myScene.getObject(1).rotate(45)
myScene.getObject(1).nextFrame()
myScene.getObject(0).nextFrame()
myScene.getObject(2).nextFrame()
def __init__(self, engine, libraryName=None, songName=None):
Scene.__init__(self, engine)
if self.engine.world.sceneName == "SongChoosingScene": # MFH - dual / triple loading cycle fix
Log.warn("Extra SongChoosingScene was instantiated, but detected and shut down. Cause unknown.")
raise SuppressScene # stump
else:
self.engine.world.sceneName = "SongChoosingScene"
if self.engine.config.get("debug", "use_new_song_database"):
Song.updateSongDatabase(self.engine)
self.wizardStarted = False
self.libraryName = libraryName
self.songName = songName
if not self.libraryName:
self.libraryName = self.engine.config.get("setlist", "selected_library")
if not self.libraryName:
self.libraryName = Song.DEFAULT_LIBRARY
if not self.songName:
self.songName = self.engine.config.get("setlist", "selected_song")
self.gameMode = self.engine.world.gameMode
self.careerMode = self.gameMode == CAREER
self.practiceMode = self.gameMode == PRACTICE
self.gameMode2p = self.engine.world.multiMode
self.autoPreview = not self.engine.config.get("audio", "disable_preview")
self.sortOrder = self.engine.config.get("game", "sort_order")
self.tut = self.engine.world.tutorial
self.playerList = self.players
self.gameStarted = False
self.gamePlayers = len(self.playerList)
self.parts = [None for i in self.playerList]
self.diffs = [None for i in self.playerList]
self.time = 0
self.lastTime = 0
self.mode = 0
self.moreInfo = False
self.moreInfoTime = 0
self.miniLobbyTime = 0
self.selected = 0
self.camera = Camera()
self.cameraOffset = 0.0
self.song = None
self.songLoader = None
self.loaded = False
text = _("Initializing Setlist...")
if self.engine.cmdPlay == 2:
text = _("Checking Command-Line Settings...")
elif len(self.engine.world.songQueue) > 0:
text = _("Checking Setlist Settings...")
elif len(self.engine.world.songQueue) == 0:
self.engine.world.playingQueue = False
self.splash = Dialogs.showLoadingSplashScreen(self.engine, text)
self.items = []
self.cmdPlay = False
self.queued = True
self.loadStartTime = time.time()
if self.tut == True:
self.library = self.engine.tutorialFolder
else:
self.library = os.path.join(self.engine.config.get("setlist", "base_library"), self.libraryName)
if not os.path.isdir(self.engine.resource.fileName(self.library)):
self.library = self.engine.resource.fileName(
os.path.join(self.engine.config.get("setlist", "base_library"), Song.DEFAULT_LIBRARY)
)
self.searchText = ""
# user configurables and input management
self.listingMode = 0 # with libraries or List All
self.preloadSongLabels = False
self.showCareerTiers = 1 + (self.careerMode and 1 or 0) # 0-Never; 1-Career Only; 2-Always
self.scrolling = 0
self.scrollDelay = self.engine.config.get("game", "scroll_delay")
self.scrollRate = self.engine.config.get("game", "scroll_rate")
self.scrollTime = 0
self.scroller = [lambda: None, self.scrollUp, self.scrollDown]
self.scoreDifficulty = Song.difficulties[self.engine.config.get("game", "songlist_difficulty")]
self.scorePart = Song.parts[self.engine.config.get("game", "songlist_instrument")]
self.sortOrder = self.engine.config.get("game", "sort_order")
self.queueFormat = self.engine.config.get("game", "queue_format")
self.queueOrder = self.engine.config.get("game", "queue_order")
self.queueParts = self.engine.config.get("game", "queue_parts")
self.queueDiffs = self.engine.config.get("game", "queue_diff")
self.nilShowNextScore = self.engine.config.get("songlist", "nil_show_next_score")
# theme information
self.themename = self.engine.data.themeLabel
self.theme = self.engine.data.theme
# theme configurables
self.setlistStyle = self.engine.theme.setlist.setlistStyle # 0 = Normal; 1 = List; 2 = Circular
self.headerSkip = self.engine.theme.setlist.headerSkip # items taken up by header (non-static only)
self.footerSkip = self.engine.theme.setlist.footerSkip # items taken up by footer (non-static only)
self.itemSize = self.engine.theme.setlist.itemSize # delta (X, Y) (0..1) for each item (non-static only)
self.labelType = self.engine.theme.setlist.labelType # Album covers (0) or CD labels (1)
self.labelDistance = self.engine.theme.setlist.labelDistance # number of labels away to preload
self.showMoreLabels = (
self.engine.theme.setlist.showMoreLabels
) # whether or not additional unselected labels are rendered on-screen
self.texturedLabels = self.engine.theme.setlist.texturedLabels # render the art as a texture?
self.itemsPerPage = self.engine.theme.setlist.itemsPerPage # number of items to show on screen
self.followItemPos = (self.itemsPerPage + 1) / 2
self.showLockedSongs = self.engine.theme.setlist.showLockedSongs # whether or not to even show locked songs
self.showSortTiers = (
self.engine.theme.setlist.showSortTiers
) # whether or not to show sorting tiers - career tiers take precedence.
self.selectTiers = (
self.engine.theme.setlist.selectTiers
) # whether or not tiers should be selectable as a quick setlist.
if self.engine.cmdPlay == 2:
self.songName = Config.get("setlist", "selected_song")
self.libraryName = Config.get("setlist", "selected_library")
self.cmdPlay = self.checkCmdPlay()
if self.cmdPlay:
Dialogs.hideLoadingSplashScreen(self.engine, self.splash)
return
elif len(self.engine.world.songQueue) > 0:
Dialogs.hideLoadingSplashScreen(self.engine, self.splash)
return
# variables for setlist management (Not that this is necessary here - just to see what exists.)
self.songLoader = None # preview handling
self.tiersPresent = False
self.startingSelected = self.songName
self.selectedIndex = 0
self.selectedItem = None
self.selectedOffset = 0.0
self.previewDelay = 1000
self.previewLoaded = False
self.itemRenderAngles = [0.0]
self.itemLabels = [None]
self.xPos = 0
self.yPos = 0
self.pos = 0
self.infoPage = 0
self.menu_force_reload = False
self.menu_text_color = (1, 1, 1)
self.menu_selected_color = (0.66, 0.66, 0)
self.menu_text_pos = (0.2, 0.31)
self.menu = Menu(
self.engine,
[
ConfigChoice(self.engine, self.engine.config, "game", "queue_format", autoApply=True),
ConfigChoice(self.engine, self.engine.config, "game", "queue_order", autoApply=True),
ConfigChoice(self.engine, self.engine.config, "game", "queue_parts", autoApply=True),
ConfigChoice(self.engine, self.engine.config, "game", "queue_diff", autoApply=True),
ActiveConfigChoice(self.engine, self.engine.config, "game", "sort_order", onChange=self.forceReload),
ActiveConfigChoice(
self.engine, self.engine.config, "game", "sort_direction", onChange=self.forceReload
),
ActiveConfigChoice(
self.engine, self.engine.config, "game", "songlist_instrument", onChange=self.forceReload
),
ActiveConfigChoice(
self.engine, self.engine.config, "game", "songlist_difficulty", onChange=self.forceReload
),
],
name="setlist",
fadeScreen=False,
onClose=self.resetQueueVars,
font=self.engine.data.pauseFont,
pos=self.menu_text_pos,
textColor=self.menu_text_color,
selectedColor=self.menu_selected_color,
)
# now, load the first library
self.loadLibrary()
# load the images
self.loadImages()
class Simulation(object):
def __init__(self, width, height):
# create pyglet window
self.window = pyglet.window.Window(resizable=True)
self.window.on_draw = self.on_draw
self.window.on_key_press = self.on_key_press
self.window.on_key_release = self.on_key_release
self.window.on_mouse_press = self.on_mouse_press
self.window.on_mouse_release = self.on_mouse_release
self.window.on_mouse_drag = self.on_mouse_drag
self.window.width = width
self.window.height = height
self.menu_window = False
self.gen_entity = 'SQUARE'
self.gen_size = 50
self.gen_mass = 500
self.key_pressed = []
self.clicked_object = None
self.clicked_dx = 0
self.clicked_dy = 0
# create fps display
self.fps_display = pyglet.clock.ClockDisplay()
self.clock = 0
# sync clock
pyglet.clock.schedule_interval(self.tick, 1.0/60.0)
pyglet.clock.set_fps_limit(60)
# create world
world_width = 3000
world_height = 3000
self.world = World(world_width, world_height)
# create scene- match dimensions of the app window
self.scene = Scene(width=width, height=height, background_width=world_width, background_height=world_height)
#self.demo_1(world_width, world_height)
#self.demo_2(world_width, world_height)
#self.demo_3(world_width, world_height)
# initialize background music
self.music = Music()
self.music.play_bg()
# Making the player here (testing)
mag = 40000
offset = 400
player_type = Triangle(size=20, position=Vector2(x=offset, y=offset))
self.scene.entities.append(player_type)
self.player = Player(entity=player_type, mass=100)
self.world.add_body(self.player)
def tick(self, dt):
# update physics
self.world.update(dt)
self.player.translate(dt, self.key_pressed)
# move scene
if key.LEFT in self.key_pressed:
self.scene.translate_x(-10)
if key.RIGHT in self.key_pressed:
self.scene.translate_x(10)
if key.UP in self.key_pressed:
self.scene.translate_y(-10)
if key.DOWN in self.key_pressed:
self.scene.translate_y(10)
if key.M in self.key_pressed:
self.music.pause_bg()
self.key_pressed.remove(key.M)
self.clock += 1
def on_draw(self):
# clear window
self.window.clear()
# redraw scene
self.scene.render()
# draw fps clock
self.fps_display.draw()
self.player.draw(self.scene)
# draw foreground/ui ? in here or scene
def on_key_press(self, symbol, modifiers):
if symbol == key.ESCAPE:
if not self.menu_window:
# self.tick, self.tick_stub = self.tick_stub, self.tick
pyglet.clock.unschedule(self.tick)
self.menu_window = True
self.menu_window = Menu(self, width=500, height=500)
return pyglet.event.EVENT_HANDLED
else:
self.key_pressed.append(symbol)
def on_key_release(self, symbol, modifiers):
if symbol in self.key_pressed:
self.key_pressed.remove(symbol)
def demo_1(self, world_width, world_height):
mag = 100000
offset = 100
sq1 = Square(size=50, position=Vector2(x=offset, y=offset))
self.scene.entities.append(sq1)
body1 = RigidBody(entity=sq1, mass=100)
body1.add_impulse(Force(vector=Vector2(x=mag, y=mag)))
self.world.add_body(body1)
sq2 = Circle(size=50, position=Vector2(x=world_width-offset, y=offset))
self.scene.entities.append(sq2)
body2 = RigidBody(entity=sq2, mass=100)
body2.add_impulse(Force(vector=Vector2(x=-mag, y=mag)))
self.world.add_body(body2)
sq3 = Square(size=50, position=Vector2(x=offset, y=world_height/2-offset))
self.scene.entities.append(sq3)
body3 = RigidBody(entity=sq3, mass=100)
body3.add_impulse(Force(vector=Vector2(x=mag, y=-0)))
self.world.add_body(body3)
sq4 = Circle(size=50, position=Vector2(x=world_width - offset, y=world_height/2-offset))
self.scene.entities.append(sq4)
body4 = RigidBody(entity=sq4, mass=100)
body4.add_impulse(Force(vector=Vector2(x=-mag, y=0)))
self.world.add_body(body4)
def demo_2(self, world_width, world_height):
for i in xrange(0, 5):
size = 50
pos = Vector2(x=(i * size * 1) + world_width/2 - (size * 3), y=world_height/2)
ent = Square(size=size, position=pos, num_vertices=10)
bdy = RigidBody(entity=ent, mass=100)
v = Vector2(x=random() * 100, y=random() * 100)
o = Vector2(x=random() * size, y=random() * size)
bdy.add_impulse(Force(vector=v, offset=o))
self.scene.entities.append(ent)
self.world.add_body(bdy)
for i in xrange(0, 5):
size = 50
pos = Vector2(x=(i * size * 1) + world_width/2 - (size * 3), y=world_height/2 + size)
ent = Square(size=size, position=pos, num_vertices=10)
bdy = RigidBody(entity=ent, mass=100)
self.scene.entities.append(ent)
self.world.add_body(bdy)
for i in xrange(0, 5):
size = 50
pos = Vector2(x=(i * size * 1) + world_width/2 - (size * 3), y=world_height/2 + 2 * size)
ent = Square(size=size, position=pos, num_vertices=10)
bdy = RigidBody(entity=ent, mass=100)
self.scene.entities.append(ent)
self.world.add_body(bdy)
sq4 = Circle(radius=25, position=Vector2(x=world_width/2 + 10, y=100))
self.scene.entities.append(sq4)
body4 = RigidBody(entity=sq4, mass=10)
body4.add_impulse(Force(vector=Vector2(x=0, y=100000)))
self.world.add_body(body4)
def demo_3(self, world_width, world_height):
for _ in xrange(0, 10):
pos = Vector2(x=random() * world_width, y=random() * world_height)
size = random() * 50 + 25
ent = Circle(radius=size, position=pos, num_vertices=10)
bdy = RigidBody(entity=ent, mass=100)
v = Vector2(x=random() * 100, y=random() * 100)
o = Vector2(x=random() * size, y=random() * size)
bdy.add_impulse(Force(vector=v, offset=o))
self.scene.entities.append(ent)
self.world.add_body(bdy)
def on_mouse_press(self, x, y, button, modifiers):
#Clear the stored dx and dy
self.clicked_dx = 0
self.clicked_dy = 0
#If there is an item under the pointer, remove it from bodies,
#keep track of it by itself, and zero out all forces
for body in self.world.bodies:
if is_in_polygon(body.entity.get_screen_relative_vertices_vectors(
self.scene.top_left['x'], self.scene.top_left['y'],
self.scene.height), Vector2(x=x, y=y)):
self.world.remove_body(body)
self.clicked_object = body
self.clicked_object.zero_forces()
return
#If there was no object under the pointer, create a new object but
#keep it free from physics for now
if self.gen_entity == 'CIRCLE':
entity = Circle(radius=self.gen_size / 2, position=Vector2(
x=x + self.scene.top_left['x'],
y=self.scene.height - y + self.scene.top_left['y']))
elif self.gen_entity == 'SQUARE':
entity = Square(size=self.gen_size, position=Vector2(
x=x + self.scene.top_left['x'],
y=self.scene.height - y + self.scene.top_left['y']))
self.scene.entities.append(entity)
self.clicked_object = RigidBody(entity=entity, mass=self.gen_mass)
def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers):
#Store the dx and dy since mouse release does not track movements
self.clicked_dx = dx
self.clicked_dy = dy
#If there is an item being clicked on, move it.
if self.clicked_object is not None:
self.clicked_object.entity.translate_vector(Vector2(x=dx, y=-dy))
def on_mouse_release(self, x, y, button, modifiers):
#If there is an object being clicked on, release it with the velocity
#determined from self.dx and self.dy
if self.clicked_object is not None:
self.world.add_body(self.clicked_object)
self.clicked_object.add_impulse(Force(
vector=Vector2(x=self.clicked_dx*100000, y=-self.clicked_dy*100000)))
#Clear the stored dx, dy, as well as the object being clicked on
self.clicked_dx = 0
self.clicked_dy = 0
self.clicked_object = None
self.clicked_offset = None
import sys, time
from Scene import Scene
if __name__ == '__main__':
start_time = time.time()
if len(sys.argv) < 3:
width = 740
height = 740
samples = 1
else:
width = int(sys.argv[1])
height = int(sys.argv[2])
samples = int(sys.argv[3])
s = Scene()
s.build(width, height, samples)
s.camera.render(s)
end_time = time.time()
print "\r" + "Render Time: " + str(int(end_time - start_time)) + " seconds."
class SceneParser:
'''
Parses an XML file and create a Scene class. The default value of a
particular variable will go into the class that uses that variable.
This class is implemented so that it doesn't have to know a lot about
the individual nodes in the scene. For instance light may have some special
variables that only the Light class knows how to process. In that case
it makes more sense to just pass all the parameters to Light class for it to
do the processing. Therefore, this class basically builds all the attributes
of a node into a parameter dictionary and passes it to the appropriate class.
This class does however need to know the variable names and datatype and
the nodes that can be in the scene description file. __var_datatypes store
the mapping between variable name and their type. New variables and their
type can simply be added to this dictionary. This information can also be
stored as an external file and loaded here. Node types can also be generalized
by modifying the xml file schema but that is not done for consistency with
the existing xml format (this would require a major rewrite of the xml files.)
When the parser doesn't recognize a node it simply ignores it.
'''
__var_datatypes = {'ambient': np.ndarray, 'color': np.ndarray,
'name': str, 'from' : np.ndarray, 'to': np.ndarray,
'up': np.ndarray,
'radius' : float, 'center' : np.ndarray,
'power': float, 'type': str,
'diffuse': np.ndarray, 'specular': np.ndarray,
'hardness': float,
'rotation': np.ndarray, 'translation': np.ndarray,
'scale' : np.ndarray,
'bgcolor' : np.ndarray,
'min': np.ndarray, 'max' : np.ndarray,
'normal': np.ndarray, 'coeffs': np.ndarray,
}
def __init__(self, filename):
print('Parsing ' + filename)
self.Materials = dict() # used for storing ref to materials
self.Nodes = dict() # used for storing ref to nodes
self.NodeStack = []
self.scene = Scene()
xml = minidom.parse(filename)
self.parse(xml)
print('parsing done.')
def method_dispatcher(self, method_name, arg):
if(hasattr(self, method_name)):
handler = getattr(self, method_name)
return handler(arg)
else:
print('WARNING: %s METHOD NOT FOUND' % method_name)
def parse(self, node):
method_name = 'parse_' + node.__class__.__name__
return self.method_dispatcher(method_name, node)
def parse_Document(self, node):
self.parse(node.documentElement)
def parse_Element(self, node):
return self.method_dispatcher('process_' + node.tagName, node)
def parse_Text(self, node):
pass # ignore Text node
def parse_Comment(self, node):
pass # ignore Comment node
def convert_attribute_value(self, value, var_type):
if var_type is float:
return float(value)
elif var_type is int:
return int(value)
elif var_type is np.ndarray:
return np.array(map(float, str(value).split()))
else: # return as string
return value
def create_params(self, attribs):
params = dict()
for key in attribs.keys():
var_type = self.__var_datatypes.get(key, str)
params[key] = self.convert_attribute_value(attribs[key].value, var_type)
return params
def create_params_from_child(self, node, params):
for e in node.childNodes:
val = self.parse(e)
if val is not None:
key = str(val.__class__.__name__).lower()
if params.has_key(key):
print('key ' + key + ' already exists')
if type(params[key]) is list:
print('appending')
params[key].append(val)
else: #if the key already exists but is not a list
print('creating list and appending')
cval = params[key]
params[key] = [cval, val]
else:
params[key] = val
return params
def process_scene(self, node):
params = self.create_params(node.attributes)
self.scene.set_params(params)
#self.NodeStack.append(SceneNode()) # root scene node
for e in node.childNodes:
self.parse(e)
#self.scene.surfaces.append(self.NodeStack.pop())
def process_light(self, node):
''' <light name="myLight" color="1 1 1" from="0 0 0 " power="1.0" type="point" /> '''
self.scene.lights.append(Light(self.create_params(node.attributes)))
def process_material(self, node):
'''<material name="blue" diffuse="0 0 1" specular="0 0 0" hardness="0" />'''
params = self.create_params(node.attributes)
if params.has_key('ref'):
if not self.Materials.has_key(params['ref']):
print('Warning: Material ' + params['ref'] + ' not found')
return self.Materials.get(params['ref'])
else:
print('adding Material ' + params['name'])
material = Material(params)
self.Materials[params.get('name')] = material
return material
def process_material2(self, node):
return self.process_material(node)
def process_node(self, node):
'''Nodes can refer to other nodes '''
print('start process_node')
#self.scene.start_node()
params = self.create_params(node.attributes)
#TODO: remove this comment block (currently kept for reference)
# print(params)
# rot_angles = np.array(params.get('rotation', [0., 0., 0.]))
# translate_amount = np.array(params.get('translation', [0., 0., 0.]))
# scale_amount = np.array(params.get('scale', [1., 1., 1.]))
#
# '''The raytracer SceneNode takes care of the hierarchical transformation'''
# M = GT.translate(translate_amount) * GT.rotateX(rot_angles[0]) * \
# GT.rotateY(rot_angles[1]) * GT.rotateZ(rot_angles[2]) * \
# GT.scale(scale_amount)
# print M.getA()
''' push the current node before further processing '''
self.NodeStack.append(SceneNode(params = params))
if params.has_key('ref'):
if not self.Nodes.has_key(params['ref']):
print('WARNING: Ref ' + params['ref'] + ' not found.')
else:
'''handle ref to other nodes. What happens to the root
transformation of the ref node? The orig transformation gets
overridden'''
print('Found ref node : ' + params['ref'])
self.NodeStack[-1].children = copy.deepcopy(self.Nodes[params['ref']].children)
for e in node.childNodes: # what sort of things can be in the childnode of ref nodes?
val = self.parse(e)
if val is not None: #Handle plane i.e. material2
if e.tagName == 'material':
self.NodeStack[-1].children[-1].material = val
elif e.tagName == 'material2':
self.NodeStack[-1].children[-1].material2 = val
else: # for non ref nodes do the usual processing
for e in node.childNodes:
self.parse(e)
topNode = self.NodeStack.pop()
if len(self.NodeStack) == 0:
print('adding node to scene')
self.scene.surfaces.append(topNode)
else:
# add to the current node
self.NodeStack[-1].children.append(topNode)
# add to node table for future reference
nodeName = params.get('name')
if nodeName is not None:
self.Nodes[nodeName] = topNode
print('end process_node')
def process_render(self, node):
params = self.create_params(node.attributes)
params = self.create_params_from_child(node, params)
self.scene.render = Render(params)
def process_camera(self, node):
camera = Camera(self.create_params(node.attributes))
return camera
def create_geom_object(self, node, ObjClass):
params = self.create_params(node.attributes)
params = self.create_params_from_child(node, params)
geom_obj = ObjClass(params)
print('create_geom_object: ' + str(geom_obj))
# decide if the object is going to be in the SceneNode or appended to the
# scene directly
if len(self.NodeStack) == 0:
self.scene.surfaces.append(geom_obj)
else:
self.NodeStack[-1].children.append(geom_obj)
return geom_obj
def process_sphere(self, node):
return self.create_geom_object(node, Sphere)
def process_box(self, node):
return self.create_geom_object(node, Box)
def process_plane(self, node):
return self.create_geom_object(node, Plane)
class GameEngine(object):
"""
The Fortune Engine GameEngine is a main loop wrapper around pygame.
It manages the event and drawing loops allowing the user to just
register for user events and drawing time in the draw loop.
"""
instance = None
def __init__(self, width=1200, height=900, always_draw=False,
fps_cap=15, version=False, title="FortuneEngine"):
"""
Constructor for the game engine.
@param width: Window width
@param height: Window height
@param always_draw: Boolean to set the animation mode to always
draw vs draw when set_dirty is called
@param fps_cap: Sets the framerate cap. Set to 0 to disable
the cap. Warning: setting the cap to 0 when
always draw = False will cause cpu 100% when
not driving.
@param version: If true, use new rendering system, false uses
only the draw system
@param title: Window Title
"""
GameEngine.instance = self
pygame.init()
pygame.mouse.set_visible(False)
self.__version = version #true is new, false is old
# Window Settings
self.width = width
self.height = height
size = width, height
self.screen = pygame.display.set_mode(size)
pygame.display.set_caption(title)
self.__fps = DrawableFontObject("", pygame.font.Font(None, 17))
self.__fps.setPosition(0, 0)
self.__scene = Scene(self.__fps)
# Engine Internal Variables
self.__fps_cap = fps_cap
self.__showfps = False
self.__dirty = True
self.__always_draw = always_draw
self.__font = pygame.font.Font(None, 17)
self.__run_event = False
# Variables to hold game engine elements and callbacks
self.__event_cb = []
self.__draw_lst = []
self.__object_hold = {}
# Game Timers
self.__active_event_timers = []
self.__active_event_timers_tick = []
# Game Clock
self.clock = pygame.time.Clock()
self.__tick_time = 0
# Inspector
self._inspector = GameInspect(self.__object_hold)
# Time Profiler Timers
self.__draw_time = {}
self.__draw_calls = {}
self.__event_time = {}
self.__event_calls = {}
self.__timer_time = {}
self.__timer_calls = {}
# Initialize Py Console
self.console = GameEngineConsole(self, (0, 0, width, height / 2))
# Disable Mouse Usage
# TODO Allow mouse motion on request
pygame.event.set_blocked(pygame.MOUSEMOTION)
def set_dirty(self):
"""
Sets the dirty flag to force the engine to draw the next time
it enters the draw flag.
"""
self.__dirty = True
def get_scene(self):
"""
Returns the scene object
@return: Returns the scene object held by the game engine
"""
return self.__scene
def start_event_timer(self, function_cb, time):
"""
Starts a timer that fires a user event into the queue every "time"
milliseconds
@param function_cb: The function to call when timer fires
@param time: Milliseconds between fires
"""
avail_timer = len(self.__active_event_timers)
if avail_timer + pygame.USEREVENT < pygame.NUMEVENTS:
if function_cb not in self.__active_event_timers:
self.__timer_time[str(function_cb)] = 0
self.__timer_calls[str(function_cb)] = 0
self.__active_event_timers.append(function_cb)
self.__active_event_timers_tick.append(time)
pygame.time.set_timer(pygame.USEREVENT + avail_timer, time)
else:
print "ERROR TIMER IN LIST"
else:
print "Ran out of timers :("
self.stop_event_loop()
def stop_event_timer(self, function_cb):
"""
Stops the timer that has id from firing
@param function_cb: The function registered with the timer that
should be canceled
"""
try:
timer_id = self.__active_event_timers.index(function_cb)
except ValueError:
return
pygame.time.set_timer(pygame.USEREVENT + timer_id, 0)
del self.__active_event_timers[timer_id]
del self.__active_event_timers_tick[timer_id]
# Timers have been removed, now need to clear any events
# already fired and in the queue
pygame.event.clear(pygame.USEREVENT + timer_id)
def list_event_timers(self):
"""
returns a list of configured timers, if the timers has a time of 0 the
timer is disabled
"""
timer_list = "Event Timers:\n"
i = 0
for timer_item in self.__active_event_timers:
timer_list += "\t%d: %d\n" % (timer_item,
self.__active_event_timers_tick[i])
i = i + 1
return timer_list
def list_timer_time(self):
"""
Returns a string representation of the time the game spends
in each timer callback.
"""
mystr = "Timer Times:\n\tName\tCalls\tTotal Time\tAvg"
for key in self.__timer_time:
timer_times = self.__timer_time[key]
timer_calls = self.__timer_calls[key]
if timer_calls == 0:
avg = 0
else:
avg = timer_times / timer_calls
mystr = "%s\n\t%s\n\t\t%d\t%f\t%f" % \
(mystr, key, timer_calls, timer_times, avg)
return mystr
def start_main_loop(self):
"""
Starts the game loop.
This function does not return until after the game loop exits
"""
self.__run_event = True
self._event_loop()
def _draw(self, tick_time):
"""
Draws all elements in draw callback to the screen
@param tick_time: The amount of time passed since last
draw cycle. (should be produced by
pygamme.clock.tick method)
"""
screen = self.screen
# If console is active, we want to draw console, pausing
# game drawing (events are still being fired, just no
# draw updates.
if self.__version:
if self.console.active:
self.console.draw()
pygame.display.flip()
else:
for fnc in self.__draw_lst:
start = time()
fnc()
self.__draw_time[str(fnc)] += time() - start
self.__draw_calls[str(fnc)] += 1
# Print Frame Rate
if self.__showfps:
self.__fps.changeText('FPS: %d' % self.clock.get_fps(),
(255, 255, 255))
else:
self.__fps.changeText('')
self.__scene.update(tick_time)
pygame.display.update(self.__scene.draw(screen))
else:
if self.console.active:
self.console.draw()
pygame.display.flip()
else:
for fnc in self.__draw_lst:
start = time()
fnc(screen, tick_time)
self.__draw_time[str(fnc)] += time() - start
self.__draw_calls[str(fnc)] += 1
# Print Frame Rate
if self.__showfps:
text = self.__font.render('FPS: %d' % \
self.clock.get_fps(), False, (255, 255, 255),
(159, 182, 205))
screen.blit(text, (0, 0))
pygame.display.flip()
def _event_loop(self):
"""
The main event loop.
"""
while self.__run_event:
event = pygame.event.poll()
# Handle Game Quit Message
if event.type == pygame.QUIT:
self.__run_event = False
# No-Op sent, draw if set to always draw
elif event.type == pygame.NOEVENT:
# Tick even if not drawing
# We want to pause the cpu from getting into a
# 100% usage looping on the poll until something
# becomes dirty
self.__tick_time += self.clock.tick(self.__fps_cap)
if self.__always_draw or self.__dirty:
self.__dirty = False
self._draw(self.__tick_time)
self.__tick_time = 0
# Handle User event Timers
elif event.type >= pygame.USEREVENT and \
event.type < pygame.NUMEVENTS:
timer_id = event.type - pygame.USEREVENT
# Call timer
str_rep = str(self.__active_event_timers[timer_id])
start = time()
self.__active_event_timers[timer_id]()
self.__timer_time[str_rep] += time() - start
self.__timer_calls[str_rep] += 1
# Check if we should activate the console
elif event.type == pygame.KEYDOWN and event.key == pygame.K_w \
and pygame.key.get_mods() & pygame.KMOD_CTRL:
self.console.set_active()
self.set_dirty()
# Pass event to console
elif self.console.process_input(event):
self.set_dirty()
# Pass events to all others
else:
# Make a copy first so that adding events don't get fired
# right away
list_cp = self.__event_cb[:]
# Reverse list so that newest stuff is on top
# TODO: cache this list
list_cp.reverse()
for cb in list_cp:
# Fire the event for all in cb and stop
# if the callback returns True
start = time()
retur_val = cb(event)
self.__event_time[str(cb)] += time() - start
self.__event_calls[str(cb)] += 1
if retur_val:
break
def stop_event_loop(self):
"""
Sends a pygame.QUIT event into the event queue which
exits the event loop
"""
pygame.event.post(pygame.event.Event(pygame.QUIT))
def add_event_callback(self, cb):
"""
Adds event callback to the event callback stack
@param cb: Callback to be added to the stack when events are fired.
"""
self.__event_time[str(cb)] = 0
self.__event_calls[str(cb)] = 0
self.__event_cb.append(cb)
def remove_event_callback(self, cb):
"""
Removes an event from the event callback stack
@param cb: The callback to remove from the event callback stack
@return: Returns true if successful in removing callback
"""
try:
self.__event_cb.remove(cb)
return True
except:
return False
def list_event_callbacks(self):
"""
Returns a string representation of all events registered with the game
engine
"""
event_callbacks = "Event Listeners:\n"
for eventlst in self.__event_cb:
event_callbacks = "%s\t%s\n" % (event_callbacks, str(eventlst))
return event_callbacks
def list_event_time(self):
"""
Returns a string representation of the time the game spends
in each event callback.
"""
mystr = "Event Times:\n\tName\tCalls\tTotal Time\tAvg"
for key in self.__event_time:
event_times = self.__event_time[key]
event_calls = self.__event_calls[key]
if event_calls == 0:
avg = 0
else:
avg = event_times / event_calls
mystr = "%s\n\t%s\n\t\t%d\t%f\t%f" % \
(mystr, key, event_calls, event_times, avg)
return mystr
def add_draw_callback(self, fnc):
"""
Adds a callback to the draw list. Function will be passed the
game screen it should draw too.
@param fnc: The function to call when system is drawing
"""
self.__draw_time[str(fnc)] = 0
self.__draw_calls[str(fnc)] = 0
self.__draw_lst.append(fnc)
def pop_draw_callback(self):
"""
Removes top of draw stack and returns it
@return: Returns the top callback function that was removed
"""
return self.__draw_lst.pop()
def clear_draw_callback(self):
"""
Empties draw callback stack
"""
self.__draw_lst = []
def remove_draw_callback(self, fnc):
"""
Removes a draw callback from the game engine draw function
@param fnc: The callback function to remove
@return: Returns true if successful removal of the function
"""
try:
self.__draw_lst.remove(fnc)
return True
except:
return False
def list_draw_callbacks(self):
"""
Lists all the draw callbacks currently registered with the game engine
"""
callbacks = "Draw Callbacks:\n"
for eventlst in self.__draw_lst:
callbacks += "\t%s\n" % str(eventlst)
return callbacks
def list_draw_time(self):
"""
Returns a string representation of the time the game spends
in each drawing callback.
"""
mystr = "Drawing Times:\n\tName\tCalls\tTotal Time\tAvg"
for key in self.__draw_time:
draw_times = self.__draw_time[key]
draw_calls = self.__draw_calls[key]
if draw_calls == 0:
avg = 0
else:
avg = draw_times / draw_calls
mystr = "%s\n\t%s\n\t\t%d\t%f\t%f" % \
(mystr, key, draw_calls, draw_times, avg)
return mystr
def has_object(self, name):
"""
Returns true if object is stored in game engine
@param name: Name of the object to check if exists
@return: Returns true if object found
"""
return name in self.__object_hold
def add_object(self, name, obj):
"""
Adds an object to the game engine datastore
@param name: The name used to store the object
@param obj: The object to store
"""
self.__object_hold[name] = obj
def get_object(self, name):
"""
Returns an object from the game engine datastore
@param name: The name of object to return
@return: Returns the object
"""
return self.__object_hold[name]
def remove_object(self, name):
"""
Removes an object from the game engine datastore
@param name: The name of the object to remove
"""
del self.__object_hold[name]
def list_objects(self):
"""
Returns a sting of registered objects
"""
objlist = "Objects Registered:\n"
for eventlst in self.__object_hold:
objlist += "\t%s\n" % str(eventlst)
return objlist
def toggle_fps(self):
"""
Toggles fps display
"""
self.__showfps = not self.__showfps
def art_scale(self, original, expected, width=True):
if width:
return int(self.width / float(expected) * float(original))
else:
return int(self.height / float(expected) * float(original))
def main():
# 初始化
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("T-Rex Rush-公众号: Charles的皮卡丘")
clock = pygame.time.Clock()
# 得分
score = 0
# 加载一些素材
jump_sound = pygame.mixer.Sound("./music/jump.wav")
jump_sound.set_volume(6)
die_sound = pygame.mixer.Sound("./music/die.wav")
die_sound.set_volume(6)
pygame.mixer.init()
pygame.mixer.music.load("./music/bg_music.mp3")
pygame.mixer.music.set_volume(0.6)
pygame.mixer.music.play(-1)
font = pygame.font.Font('./font/simkai.ttf', 20)
# 实例化
dinosaur = Dinosaur(WIDTH, HEIGHT)
scene = Scene(WIDTH, HEIGHT)
plants = pygame.sprite.Group()
pteras = pygame.sprite.Group()
# 产生障碍物事件
GenPlantEvent = pygame.constants.USEREVENT + 0
pygame.time.set_timer(GenPlantEvent, 1500)
GenPteraEvent = pygame.constants.USEREVENT + 1
pygame.time.set_timer(GenPteraEvent, 5000)
# 游戏是否结束了
running = True
# 是否可以产生障碍物flag
flag_plant = False
flag_ptera = False
t0 = time.time()
# 主循环
while running:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
pygame.quit()
if event.type == GenPlantEvent:
flag_plant = True
if event.type == GenPteraEvent:
if score > 50:
flag_ptera = True
key_pressed = pygame.key.get_pressed()
if key_pressed[pygame.K_SPACE]:
dinosaur.is_jumping = True
jump_sound.play()
screen.fill(BACKGROUND)
time_passed = time.time() - t0
t0 = time.time()
# 场景
scene.move()
scene.draw(screen)
# 小恐龙
dinosaur.is_running = True
if dinosaur.is_jumping:
dinosaur.be_afraid()
dinosaur.jump(time_passed)
dinosaur.draw(screen)
# 障碍物-植物
if random.random() < sigmoid(score) and flag_plant:
plant = Plant(WIDTH, HEIGHT)
plants.add(plant)
flag_plant = False
for plant in plants:
plant.move()
if dinosaur.rect.left > plant.rect.right and not plant.added_score:
score += 1
plant.added_score = True
if plant.rect.right < 0:
plants.remove(plant)
continue
plant.draw(screen)
# 障碍物-飞龙
if random.random() < sigmoid(score) and flag_ptera:
if len(pteras) > 1:
continue
ptera = Ptera(WIDTH, HEIGHT)
pteras.add(ptera)
flag_ptera = False
for ptera in pteras:
ptera.move()
if dinosaur.rect.left > ptera.rect.right and not ptera.added_score:
score += 5
ptera.added_score = True
if ptera.rect.right < 0:
pteras.remove(ptera)
continue
ptera.draw(screen)
# 碰撞检测
if pygame.sprite.spritecollide(dinosaur, plants, False) or pygame.sprite.spritecollide(dinosaur, pteras, False):
die_sound.play()
running = False
# 显示得分
score_text = font.render("Score: "+str(score), 1, (0, 0, 0))
screen.blit(score_text, [10, 10])
pygame.display.flip()
clock.tick(60)
res = show_gameover(screen)
return res
def __init__(self, width=1200, height=900, always_draw=False,
fps_cap=15, version=False, title="FortuneEngine"):
"""
Constructor for the game engine.
@param width: Window width
@param height: Window height
@param always_draw: Boolean to set the animation mode to always
draw vs draw when set_dirty is called
@param fps_cap: Sets the framerate cap. Set to 0 to disable
the cap. Warning: setting the cap to 0 when
always draw = False will cause cpu 100% when
not driving.
@param version: If true, use new rendering system, false uses
only the draw system
@param title: Window Title
"""
GameEngine.instance = self
pygame.init()
pygame.mouse.set_visible(False)
self.__version = version #true is new, false is old
# Window Settings
self.width = width
self.height = height
size = width, height
self.screen = pygame.display.set_mode(size)
pygame.display.set_caption(title)
self.__fps = DrawableFontObject("", pygame.font.Font(None, 17))
self.__fps.setPosition(0, 0)
self.__scene = Scene(self.__fps)
# Engine Internal Variables
self.__fps_cap = fps_cap
self.__showfps = False
self.__dirty = True
self.__always_draw = always_draw
self.__font = pygame.font.Font(None, 17)
self.__run_event = False
# Variables to hold game engine elements and callbacks
self.__event_cb = []
self.__draw_lst = []
self.__object_hold = {}
# Game Timers
self.__active_event_timers = []
self.__active_event_timers_tick = []
# Game Clock
self.clock = pygame.time.Clock()
self.__tick_time = 0
# Inspector
self._inspector = GameInspect(self.__object_hold)
# Time Profiler Timers
self.__draw_time = {}
self.__draw_calls = {}
self.__event_time = {}
self.__event_calls = {}
self.__timer_time = {}
self.__timer_calls = {}
# Initialize Py Console
self.console = GameEngineConsole(self, (0, 0, width, height / 2))
# Disable Mouse Usage
# TODO Allow mouse motion on request
pygame.event.set_blocked(pygame.MOUSEMOTION)
