def update(self, msSinceLast):
'''
Overrides Sprite update
'''
if Viewport().hasMoved:
self.rect.center = Viewport().convertPhysicalToPixelCoords(self.__physicalPosition)
self.dirty = 1
if self.hasPhysics:
newPhysicalPosition = Vect(self.body.position.x,self.body.position.y)
if newPhysicalPosition != self.physicalPosition:
self.physicalPosition = newPhysicalPosition
getVel = self.body.GetLinearVelocity()
self.curVel = (getVel.x, getVel.y)
if self.curVel[0] >= -2.0 and self.curVel[0] < 0.0:
self.tryStop()
self.animstate = Spaceman.STANDING_LEFT
elif self.curVel[0] <= 2.0 and self.curVel[0] > 0.0:
self.tryStop()
self.animstate = Spaceman.STANDING_RIGHT
elif self.curVel[0] > 2.0:
if self.isOnGround():
self.animstate = Spaceman.WALKING_RIGHT
elif self.tryingToJump:
self.animstate = Spaceman.JUMPING_RIGHT
else:
self.animstate = Spaceman.STANDING_RIGHT
elif self.curVel[0] < -2.0:
if self.isOnGround():
self.animstate = Spaceman.WALKING_LEFT
elif self.tryingToJump:
self.animstate = Spaceman.JUMPING_LEFT
else:
self.animstate = Spaceman.STANDING_LEFT
self.spriteIndex += (msSinceLast/33.0)
if self.animstate == Spaceman.WALKING_RIGHT:
self.image = self.spritesRight[int(self.spriteIndex%len(self.spritesRight))]
elif self.animstate == Spaceman.WALKING_LEFT:
self.image = self.spritesLeft[int(self.spriteIndex%len(self.spritesLeft))]
elif self.animstate == Spaceman.JUMPING_RIGHT:
index = int(self.spriteIndex%len(self.sprJumpingRight))
if self.spriteIndex>len(self.sprJumpingRight)/2:
index = len(self.sprJumpingRight)/2
self.image = self.sprJumpingRight[index]
elif self.animstate == Spaceman.JUMPING_LEFT:
index = int(self.spriteIndex%len(self.sprJumpingLeft))
if self.spriteIndex>len(self.sprJumpingLeft)/2:
index = len(self.sprJumpingLeft)/2
self.image = self.sprJumpingLeft[index]
elif self.animstate == Spaceman.STANDING_RIGHT:
self.image = ImageHandler()["standingRight"]
elif self.animstate == Spaceman.STANDING_LEFT:
self.image = ImageHandler()["standingLeft"]
def update(self, msSinceLast):
'''
Overrides Sprite update
'''
if Viewport().hasMoved:
self.rect.center = Viewport().convertPhysicalToPixelCoords(self.__physicalPosition)
self.dirty = 1
if self.hasPhysics:
newPhysicalPosition = Vect(self.body.position.x,self.body.position.y)
if newPhysicalPosition != self.physicalPosition:
self.physicalPosition = newPhysicalPosition
def projetar(self):
self.pontoVista = PontoVista(int(self.entradaA.get()),
int(self.entradaB.get()),
int(self.entradaC.get()))
ponto1 = [
int(self.entradaP1X.get()),
int(self.entradaP1Y.get()),
int(self.entradaP1Z.get())
]
ponto2 = [
int(self.entradaP2X.get()),
int(self.entradaP2Y.get()),
int(self.entradaP2Z.get())
]
ponto3 = [
int(self.entradaP3X.get()),
int(self.entradaP3Y.get()),
int(self.entradaP3Z.get())
]
self.planoProjecao = PlanoProjecao(ponto1, ponto2, ponto3)
self.projPerspectiva = ProjPerspectiva(self.pontoVista,
self.planoProjecao, self.objeto)
matriz = self.projPerspectiva.projetarObjeto()
cMatriz = self.cartesiano(matriz)
rMatriz = self.reflexao(cMatriz)
self.janelaMundo = Janela(min(rMatriz[0]), min(rMatriz[1]),
max(rMatriz[0]), max(rMatriz[1]))
self.janelaViewport = Janela(20, 20, 620, 460)
self.viewport = Viewport(self.janelaMundo, self.janelaViewport,
rMatriz)
matrizFinal = self.viewport.transfViewport()
self.desenhar(matrizFinal)
def __init__(self, da):
self.display_file = DisplayFile()
self.draw_counter = 0
self.da = da
da_width = da.get_allocation().width
da_height = da.get_allocation().height
# Window and viewport start with the same size as the drawing area,
# but compensating for the clipping border size (otherwise you
# wouldn't see by default a point drawn at 0,0).
self.window = Window(-cbz, -cbz, da_width - cbz, da_height - cbz)
self.viewport = Viewport(-cbz, -cbz, da_width - cbz, da_height - cbz)
self.transform = Transform()
# Pass reference to window for Transform and Viewport
self.transform.setWindow(self.window)
self.viewport.setWindow(self.window)
# To verify that both normalize() and denormalize() work
# print(self.transform.normalize(0,0))
# print(self.transform.normalize(self.window.getWidth(),self.window.getHeight()))
# print(self.transform.denormalize(-1,-1))
# print(self.transform.denormalize(1,1))
self.projection = 'parallel'
def resetGame():
global screen, viewport, score, mosquito, bat, mute
score = Score(screen)
bgImage = pygame.image.load("resources/gfx/tlo_ost_calosc.png").convert()
bgSize = bgImage.get_size()
boundariesX = (0, bgSize[0])
boundariesY = (0, bgSize[1])
mosquito = Mosquito()
mosquito.x = 100
mosquito.y = 100
mosquito.score = score
mosquito.set_boundaries(boundariesX, boundariesY)
mosquito.image = pygame.image.load(
"resources/gfx/mosquito.png").convert_alpha()
mosquito.empty_animation = pyxel.AnimatedPyxel(
pyxel.Pyxel('resources/gfx/Latanie.pyxel', 'tmp'))
mosquito.mid_animation = pyxel.AnimatedPyxel(
pyxel.Pyxel('resources/gfx/Latanie_napełniony1.pyxel', 'tmp'))
mosquito.full_animation = pyxel.AnimatedPyxel(
pyxel.Pyxel('resources/gfx/Latanie_napełniony2.pyxel', 'tmp'))
mosquito.suck_target = None
bat = Bat()
bat.x = -500
bat.y = -300
bat.animation = pyxel.AnimatedPyxel(
pyxel.Pyxel('resources/gfx/Topesz_Latajuncy.pyxel', 'tmp'))
mute = 0
viewport = Viewport(bgImage, screen, mosquito, [bat])
def run(self):
rekt2 = Triangles((-0.5, -0.5, 0), (0.5, -0.5, 0), (0.5, 0.5, 0),
colors=[(1, 0, 0), (0, 1, 0), (0, 0, 1)])
delta_time = 0
v_port2 = Viewport(400,
300,
400,
300,
50,
0.001,
clear_before_draw=True)
v_port1 = self.window.viewports[0]
self.window.viewports = (self.window.viewports[0], v_port2)
v_port1.camera.look_at_pos = (0.3, 0, 0)
rotate = True
tme = 0
colors = rekt2.colors
while True:
tme = fmod(tme + (delta_time * 2 * pi * rotate), 2 * pi)
curr_time = time.time()
self.draw_all()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
break
if event.type == pygame.KEYUP:
if event.key == pygame.K_SPACE:
rotate = not rotate
print(colors)
print(rekt2.colors)
rekt2.colors = tuple([
tuple(map(mul, color, ((sin(tme) + 1) / 2, ) * len(color)))
for color in colors
])
delta_time = time.time() - curr_time
def __init__(self):
self.entities = {'all': pygame.sprite.Group()}
mapRender = MapRender(World.LEVEL_ONE_FILENAME)
self.map_surface = mapRender.get_surface()
self.add_entity(
mapRender.get_object_entities('blocker', Entity, passable=False),
('blockers', ))
self.add_entity(
mapRender.get_object_entities('door', Door, passable=False),
('doors', ))
self.add_entity(
mapRender.get_object_entities('trigger', Entity, passable=True),
('triggers', ))
key_image = pygame.image.load('images/card.png')
self.add_entity(
mapRender.get_object_entities('key',
Entity,
passable=True,
image=key_image), ('keys', ))
# parallax this
basement = mapRender.map_data.get_layer_by_name('basement')
self.basement = {
'image': pygame.image.load(basement.source.replace('../', '')),
'x': 800,
'y': 650,
}
self.viewport = Viewport()
self.level_surface = pygame.Surface(mapRender.get_size())
def main(self):
self.running = True
self.state = "INTRO"
msSinceLast = 0
intro = self.image = ImageHandler()["start"]
self.surface.blit(intro, (0, 0))
pygame.display.flip()
while self.running and self.state == "INTRO":
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
elif event.type == pygame.KEYDOWN:
self.state = "PLAYING"
pygame.mixer.music.stop()
pygame.mixer.music.load("alone2.mp3")
pygame.mixer.music.play(-1)
while self.running and self.state == "PLAYING":
self.processEventLoop()
self.activeLevel.update(msSinceLast)
msSinceLast = self.clock.tick(FRAMERATE)
self.activeLevel.render(self.surface)
pygame.display.flip()
Viewport().hasMoved = False
def _launch_game_round(dt=None):
width = BLOCK_SIZE[0] * GAME_AREA_SIZE[0]
height = BLOCK_SIZE[1] * GAME_AREA_SIZE[1]
game_scene = Viewport(width=width, height=height)
game = MoonRabbitGame()
game_scene.add_widget(game)
self.context.scene = game_scene
Clock.schedule_once(game_scene.fit_to_window, -1)
def update(self, msSinceLast):
'''
Overrides Sprite update
'''
if Viewport().hasMoved:
self.rect.center = Viewport().convertPhysicalToPixelCoords(self.__physicalPosition)
self.dirty = 1
if self.hasPhysics:
newPhysicalPosition = Vect(self.body.position.x,self.body.position.y)
if newPhysicalPosition != self.physicalPosition:
self.physicalPosition = newPhysicalPosition
newRotation = self.body.angle
if abs(newRotation - self.rotation) > 0.001:
self.rotation = newRotation
self.dirty = 1
self.image = pygame.transform.rotate(self._image, self.rotation*(180.0/3.14159))
def playerWin(player, viewport, SCREEN_HEIGHT, SCREEN_WIDTH, level):
viewport.render_victory_message()
pygame.display.update()
time.sleep(5)
#RELOAD LEVEL
# Load in block sprites
renders = file_rendering.render(level) # load level from Excel file
block_list = renders['ground']
power_list = renders['power']
pipe_list = renders['pipe']
brick_list = renders['breakable']
coin_list = renders['coin']
hidden_list = renders['hidden']
single_coin_group = renders['singleCoin']
star_group = renders['star']
oneUp_group = renders['oneUp']
multi_group = renders['multiCoin']
enemy_list = renders['enemies']
powerup_list = pygame.sprite.Group()
if (power_list != None):
block_list.add(power_list)
block_list.add(brick_list)
block_list.add(pipe_list)
if (single_coin_group != None):
block_list.add(single_coin_group)
if (star_group != None):
block_list.add(star_group)
if (oneUp_group != None):
block_list.add(oneUp_group)
if (multi_group != None):
block_list.add(multi_group)
if (coin_list != None):
block_list.add(coin_list)
if (hidden_list != None):
block_list.add(hidden_list)
flag_list = renders['flag']
pipe_list = renders['pipe']
flagLoc = []
# Load in image sprite
player = Character(140, 20)
player.powerUp(2)
viewport = Viewport(SCREEN_WIDTH, SCREEN_HEIGHT)
return player, viewport, renders, block_list, enemy_list
def render(self,surface):
'''
Renders a game step after the logic is complete
'''
self.allObjects.draw(surface,self.background)
if self.drawDebug:
upperLeftCorner = Viewport().convertPhysicalToPixelCoords((0,self.physicalSize.y))
size = self.physicalSize * PIXELS_PER_METER
debugRect = pygame.Rect(upperLeftCorner,size)
pygame.draw.rect(surface,(255,0,0),debugRect,1)
def _load_parcellation_check(self):
pcw = self.parcellation_chooser_window
if not pcw.finished: return
if pcw.ctl.new_dataset:
if pcw.ctl.new_dataset_name == '':
self.error_dialog('Must specify a dataset name!')
return
elif pcw.ctl.new_dataset_name in self.controller.ds_instances:
self.error_dialog('Dataset name is not unique')
return
else:
ds_name = pcw.ctl.new_dataset_name
import preprocessing
parc_struct = preprocessing.process_parc(pcw.ctl, self)
if parc_struct is None: return #preprocessing errored out
lab_pos, labnam, srf, labv, subject_name, parc_name = parc_struct
display_metadata = DisplayMetadata(subject_name=subject_name,
parc_name=parc_name,
adj_filename='')
ds = Dataset(ds_name, lab_pos, labnam, srf, labv, gui=self)
self.controller.add_dataset(ds, display_metadata)
else:
import preprocessing
parc_struct = preprocessing.process_parc(pcw.ctl, self)
if parc_struct is None: return
lab_pos, labnam, srf, labv, subject_name, parc_name = parc_struct
pcw.ctl.ds_ref._load_parc(lab_pos, labnam, srf, labv)
self.controller.update_display_metadata(pcw.ctl.ds_ref.name,
subject_name=subject_name,
parc_name=parc_name)
#find the viewports that were previously holding this scene
#find_dataset_views returns a DatasetViewportInterface object
#with references to the viewports (source in viewport.py)
ds_interface = self.controller.find_dataset_views(pcw.ctl.ds_ref)
ds_interface.mayavi_port = Viewport(pcw.ctl.ds_ref)
ds_interface.matrix_port = Viewport(pcw.ctl.ds_ref)
ds_interface.circle_port = Viewport(pcw.ctl.ds_ref)
def __init__(self,
*size,
viewports=[
Viewport(0, 0, 800, 600, 50, 0.001),
],
mode='pygame',
**kwargs):
self.x = size[0]
self.y = size[1]
self.viewports = viewports
self.mode = mode
self.additional_options = kwargs
self.all_windows.add(self)
def run(self):
rekt1 = Polygon((-0.25, -0.25, 0), (0.25, -0.25, 0), (0.25, 0.25, 0),
(-0.25, 0.25, 0),
colors=[(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 1)])
rekt2 = Polygon((-0.25, -0.25, 0), (0.25, -0.25, 0), (0.25, 0.25, 0),
(-0.25, 0.25, 0),
colors=[(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 1)])
rekt3 = Polygon((-0.25, -0.25, 0), (0.25, -0.25, 0), (0.25, 0.25, 0),
(-0.25, 0.25, 0),
colors=[(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 1)])
rekt4 = Polygon((-0.25, -0.25, 0), (0.25, -0.25, 0), (0.25, 0.25, 0),
(-0.25, 0.25, 0),
colors=[(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 1)])
rekt1.transform = (-0.5, 0.5, 0)
rekt2.transform = (0.5, 0.5, 0)
rekt3.transform = (0.5, -0.5, 0)
rekt4.transform = (-0.5, -0.5, 0)
delta_time = 0
v_port2 = Viewport(400,
300,
400,
300,
50,
0.001,
clear_before_draw=False)
v_port1 = self.window.viewports[0]
self.window.viewports = (self.window.viewports[0], v_port2)
v_port1.camera.pos = (0, 0, 2)
v_port1.camera.look_at_pos = (0.3, 0, 0)
rotate = True
while True:
curr_time = time.time()
print('time', delta_time)
self.draw_all()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
break
if event.type == pygame.KEYUP:
if event.key == pygame.K_SPACE:
rotate = not rotate
rekt1.rotation = tuple(
map(add, rekt1.rotation, (0, 0, 90 * delta_time * rotate)))
rekt2.rotation = tuple(
map(add, rekt2.rotation, (0, 0, 180 * delta_time * rotate)))
rekt3.rotation = tuple(
map(add, rekt3.rotation, (0, 0, 50 * delta_time * rotate)))
rekt4.rotation = tuple(
map(add, rekt4.rotation, (0, 0, 360 * delta_time * rotate)))
delta_time = time.time() - curr_time
def run(self):
tpot = TeaPot(color=(0, 0, 1), solid=False)
tpots_around = [TeaPot(color=(0, 1, 0), solid=False) for _ in range(7)]
for tpt in tpots_around:
tpt.scale = (0.5, 0.5, 0.5)
for index, tpt in enumerate(tpots_around):
tpt.transform = (3 * cos(index * (2 * pi / len(tpots_around))), 0,
3 * sin(index * (2 * pi / len(tpots_around))))
rotation_times = tuple(
[random.uniform(-360, 360) for _ in range(len(tpots_around))])
composite_obj = Composite(*tpots_around)
composite_rot = random.uniform(-360, 360)
self.window.viewports[0].camera.pos = (0, 1.5, 5)
self.window.viewports.append(
Viewport(400,
300,
400,
300,
50,
0.001,
clear_before_draw=False,
projection='persp'))
self.window.viewports[1].camera.pos = (5, 5, 0)
def display_func():
current_time = time.time()
tpot.rotation = (0, (tpot.rotation[1] + (self.delta_time * 360)) %
360, 0)
# tpots_around[0].rotation = (0,(tpot.rotation[1] + (self.delta_time * 180)) % 360,0)
for tpt, rotation_time in zip(tpots_around, rotation_times):
tpt.rotation = (0, (tpt.rotation[1] +
(self.delta_time * rotation_time)) % 360,
0)
composite_obj.rotation = (0, composite_obj.rotation[1] +
(self.delta_time * composite_rot) % 360,
0)
self.draw_all()
self.delta_time = time.time() - current_time
def keyboard_func(*args):
print(args)
glutKeyboardFunc(keyboard_func)
glutDisplayFunc(display_func)
glutMainLoop()
def handleKeyDown(self, event):
vp = Viewport()
if event.key == pygame.K_ESCAPE:
self.running = False
elif event.key == pygame.K_UP:
self.activeLevel.characterJump()
#vp.move((0,50))
elif event.key == pygame.K_w:
self.activeLevel.moveShip(0, 5)
elif event.key == pygame.K_s:
self.activeLevel.moveShip(0, -5)
elif event.key == pygame.K_d:
self.activeLevel.moveShip(5, 0)
elif event.key == pygame.K_a:
self.activeLevel.moveShip(-5, 0)
def start(self):
self.map.load()
self._entity_map = {}
self._position_map = {}
self._entities = {}
self._registered = {}
self._enemySpawns = {}
for x, y in self.map.getMap().keys():
self._position_map[(x, y)] = []
self._total_surface = Surface((self.map.w, self.map.h))
tid = self.addEntity(register=True,
entity=MChar(self,
self.map.getType(Tiles.Start)[0],
inputStream=self.getInputStream()))
self._camera = Viewport(
tuple([s * const.res for s in const.screenSize]),
lambda: self.map.getAttr("scale"), self.get(tid),
(150, 200, 150, 200), self.map)
self._background = Parallax(const.backgrounds)
self.editor = Editor(self.map,
self._surface,
enabled=False,
inputStream=self.getInputStream())
self._input = Input(inputStream=self.getInputStream())
self._input.set(KEYDOWN, self.editor.toggleEnabled, K_e)
self._input.set(KEYDOWN, self.start, K_r)
# self._sound = Sound("assets\\music.ogg")
# self._sound.play(-1)
try:
self._healthBar = HealthBar(10, 10, self.get(tid))
except AssertionError:
pass
for (x, y), val in self.map.enemies.items():
block = self.map.get(x, y)
self._enemySpawns[block] = EnemySpawn(level=self,
anchor=Object(pos=(block.x,
block.y)),
maxEmitted=val,
timeBetween=2)
self._countdown = CountdownTimer(const.screenSize[0] * const.res - 50,
10, self.map.getAttr("timeLim"))
def main():
# First check if there is a command-line argument.
# If not, use 'usa.txt'
if len(sys.argv) == 2:
img_name = sys.argv[1]
else:
img_name = 'usa.txt'
(img_width, img_height, img) = read_img(img_name)
# Initialize the viewport
port = Viewport(60,20)
port.set_img(img_width, img_height)
while True:
# This is the prompt-move loop
# Show the viewport's portion of the image
port.display(img)
print (port)
reply = input('Right, Left, Up, Down, Quit? ')
# Do some input validation
input_OK = True
if len(reply) > 0:
code = reply.lower()[0]
if code not in 'udlrq':
input_OK = False
else:
input_OK = False
if not input_OK:
print ('u d r l q only, please!')
continue
if code == 'q':
break
elif code == 'r':
port.move_right()
elif code == 'l':
port.move_left()
elif code == 'u':
port.move_up()
elif code == 'd':
port.move_down()
def __setPhysicalPosition(self,value):
self.__physicalPosition = value
self.rect.center = Viewport().convertPhysicalToPixelCoords(value)
self.dirty = 1
from PIL import Image
from PIL import ImageEnhance
from mandelbrot_03 import MandelbrotSet
from viewport import Viewport
if __name__ == "__main__":
print("This might take a while...")
mandelbrot_set = MandelbrotSet(max_iterations=256, escape_radius=1000)
image = Image.new(mode="L", size=(512, 512))
for pixel in Viewport(image, center=-0.7435 + 0.1314j, width=0.002):
c = complex(pixel)
instability = 1 - mandelbrot_set.stability(c, smooth=True)
pixel.color = int(instability * 255)
enhancer = ImageEnhance.Brightness(image)
enhancer.enhance(1.25).show()
#default movement indicators
moving_right = False
moving_left = False
jumping = False
# Load in enemy list
enemy_list = pygame.sprite.Group()
e0 = Enemy0(400, 20, -1)
e1 = Enemy1(100, 20, 2)
e3 = Enemy3(200, 20, 1)
for e in [e0, e1, e3]:
enemy_list.add(e)
# Initialize viewport
viewport = Viewport(SCREEN_WIDTH, SCREEN_HEIGHT)
#A list of all rects in the level
allRects = file_rendering.render(level)
#initial momentum value
player_x_momentum = 0
player_y_momentum = 0
while True:
#Fills the background with the sky color constant
viewport.reset(SKY_COLOR)
#if character falls below floor, resets to floor. Will fix once collisions are implemented
if player_location[1] > 208:
player_location[1] = 208
def __init__(self):
super(GeoLogic, self).__init__()
self.imported_tools = load_tools("macros.gl")
self.env = GraphicalEnv(self.imported_tools)
self.vis = self.env.vis
self.general_tools = GToolDict(self.imported_tools.tool_dict)
self.keyboard_capture = None
menu_items = (
("Undo", self.undo, "<Control>z"),
("Redo", self.redo, "<Control><Shift>z"),
("Reset", self.restart, "<Control>n"),
("Open...", self.load, "<Control>o"),
("Save", self.save, "<Control>s"),
("Save as...", self.save_as, "<Control><Shift>s"),
("Export SVG...", self.export_svg, "<Control><Shift>e"),
("Quit", self.on_exit, "<Control>q"),
)
gtools = (
ComboPoint(),
ComboLine(),
ComboPerpLine(),
ComboCircle(),
ComboCircumCircle(),
GToolMove(),
GToolHide(),
GToolLabel(),
GToolReason(),
)
self.key_to_gtool = dict(
(gtool.get_key_shortcut(), gtool) for gtool in gtools)
vbox = Gtk.VBox()
self.add(vbox)
self.toolbar = ToolBar(menu_items, gtools, self.general_tools)
vbox.pack_start(self.toolbar, False, False, 0)
hpaned = Gtk.HPaned()
vbox.add(hpaned)
self.step_list = StepList(self.env)
hpaned.pack1(self.step_list, False, True)
self.viewport = Viewport(self.env, self)
self.viewport.set_tool(ComboPoint())
hpaned.pack2(self.viewport.darea, True, False)
hpaned.set_position(250)
self.viewport.click_hook = self.toolbar.entry.unselect
self.toolbar.set_entry_unselect(self.viewport.darea.grab_focus)
self.toolbar.change_tool_hook = self.viewport.set_tool
self.add_accel_group(self.toolbar.accelerators)
def update_progress_bar(done, size):
if size == 0: self.progress_bar.set_fraction(0)
else: self.progress_bar.set_fraction(done / size)
return False
def update_progress_bar_idle(done, size):
GLib.idle_add(update_progress_bar, done, size)
proof_checker.paralelize(progress_hook=update_progress_bar_idle)
self.progress_bar = Gtk.ProgressBar(show_text=False)
vbox.pack_end(self.progress_bar, False, False, 0)
self.connect("key-press-event", self.on_key_press)
self.connect("key-release-event", self.on_key_release)
self.connect("delete-event", self.on_exit)
self.resize(1000, 600)
self.set_position(Gtk.WindowPosition.CENTER)
self.set_events(Gdk.EventMask.KEY_PRESS_MASK
| Gdk.EventMask.KEY_RELEASE_MASK)
self.show_all()
self.update_title(None)
def init_welcome_screen(self):
self.__viewport = Viewport(*globales.DIMENSION)
self.__viewport.init_viewport(globales.LOGO, globales.CAPTION)
self.__viewport.bkg_color(globales.COLOR_FONDO)
self.init_welcome_text()
def __init__(self, content=None, parent=None):
Group.__init__(self, content, parent)
self._viewport = Viewport(content)
camera.append(
WebcamVideoStream(
0,
width=width,
height=height,
portrait_alignment=False,
Viewport=Viewport,
Framebuffer=data.Framebuffer,
flip_h=False,
flip_v=False,
gamma=0.5,
floor=5000,
threshold_filter=8))
Webcam = Cameras(source=camera, current_camera=0)
_Deepdreamer = dreamer.Artist('test', Framebuffer=data.Framebuffer)
Model = neuralnet.Model(program_duration=-1, current_program=0, Renderer=_Deepdreamer)
Viewport = Viewport(window_name='deepdreamvisionquest', monitor=data.MONITOR_MAIN, fullscreen=True, listener=listener)
Composer = Composer()
# new idea, so objects have common pointers
data.vis = np.zeros((data.viewsize[1], data.viewsize[0], 3), np.uint8)
data.Model=Model
data.Webcam=Webcam
data.Viewport=Viewport
data.Renderer=_Deepdreamer
data.Composer = Composer
main()
def __init__(self, *args, **kwargs):
wx.Frame.__init__(self, *args, **kwargs)
self.app = wx.GetApp()
self.preMaxPos = None
self.preMaxSize = None
self.actns = {
ID_EDIT_UNDO: self.app.Undo,
ID_EDIT_REDO: self.app.Redo,
ID_EDIT_GROUP: self.app.Group,
ID_EDIT_UNGROUP: self.app.Ungroup,
ID_EDIT_PARENT: self.app.Parent,
ID_EDIT_UNPARENT: self.app.Unparent
}
# Bind frame events
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.Bind(wx.EVT_KEY_UP, p3d.wx.OnKeyUp)
self.Bind(wx.EVT_KEY_DOWN, p3d.wx.OnKeyDown)
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_MOVE, self.OnMove)
# Bind publisher events
pub.subscribe(self.OnUpdate, 'Update')
# Build application preferences
self.cfg = wx.Config('pandaEditor')
# Build toolbars
self.BuildFileActions()
self.BuildEditActions()
self.BuildModifyActions()
self.BuildXformActions()
self.BuildLayoutActions()
# Build viewport. Don't initialise just yet as ShowBase has not yet
# been created.
self.pnlViewport = Viewport(self)
# Build editor panels
self.pnlSceneGraph = SceneGraphPanel(self, style=wx.SUNKEN_BORDER)
self.pnlLightLinker = LightLinkerPanel(self, style=wx.SUNKEN_BORDER)
self.pnlProps = PropertiesPanel(self, style=wx.SUNKEN_BORDER)
self.pnlRsrcs = ResourcesPanel(self, style=wx.SUNKEN_BORDER)
self.pnlLog = LogPanel(self, style=wx.SUNKEN_BORDER)
# Build aui manager to hold all the widgets
self.BuildAuiManager()
# Build menus and menu bar
self.mb = wx.MenuBar()
self.BuildViewMenu()
self.BuildCreateMenu()
self.BuildWindowMenu()
self.BuildMenuBar()
# Populate the panels menu bar with items representing each floating
# panel.
self.RebuildPanelMenu()
# Update the view menu based on the perspective saved in preferences
self.OnUpdateWindowMenu(None)
def playerDeath(player, viewport, SCREEN_HEIGHT, SCREEN_WIDTH, level, level_info):
# If lose_life() returns true, we end the game
end_game = level_info.lose_life()
viewport.render_death_message(level_info.lives)
pygame.display.update()
time.sleep(3)
if end_game:
pygame.display.quit()
pygame.quit() # Stop pygame
sys.exit() # Stop script
#RELOAD LEVEL
# Load in block sprites
# Load in block sprites
renders = file_rendering.render(level) # load level from Excel file
block_list = renders['ground']
power_list = renders['power']
pipe_list = renders['pipe']
brick_list = renders['breakable']
coin_list = renders['coin']
hidden_list = renders['hidden']
single_coin_group = renders['singleCoin']
star_group = renders['star']
oneUp_group = renders['oneUp']
multi_group = renders['multiCoin']
enemy_list = renders['enemies']
powerup_list = pygame.sprite.Group()
if(power_list != None):
block_list.add(power_list)
block_list.add(brick_list)
block_list.add(pipe_list)
if(single_coin_group != None):
block_list.add(single_coin_group)
if(star_group != None):
block_list.add(star_group)
if(oneUp_group != None):
block_list.add(oneUp_group)
if(multi_group != None):
block_list.add(multi_group)
if(coin_list != None):
block_list.add(coin_list)
if(hidden_list != None):
block_list.add(hidden_list)
flag_list = renders['flag']
flagLoc = []
# Load in image sprite
player = Character(140, 20)
#END RELOAD
player = Character(140, 20)
player.powerUp(1)
viewport = Viewport(SCREEN_WIDTH, SCREEN_HEIGHT)
return player, viewport, renders, block_list, enemy_list
def loadLevel(self, filename=None):
self.activeLevel = Level(filename)
Viewport().levelHeight = self.activeLevel.physicalSize.y
self.activeLevel.setup()
def __setPixelPosition(self,value):
self.rect.move_ip(*value)
self.__physicalPosition = Viewport().convertPixelsToPhysicalCoords(self.rect.center)
