def __init__(self,
master=None,
toplevel=None,
document=None,
show_visible=0,
show_printable=1,
resolution=None,
**kw):
apply(PyWidget.__init__, (self, master), kw)
Viewport.__init__(self, resolution)
QueueingPublisher.__init__(self)
self.toplevel = toplevel
self.move_window_count = 0
self.show_page_outline = 1
self.show_visible = show_visible
self.show_printable = show_printable
self.gcs_initialized = 0
self.gc = GraphicsDevice()
self.init_transactions()
if document is not None:
self.SetDocument(document)
else:
self.SetDocument(Document(create_layer=1))
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 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'
class CountiesApp(App):
def build(self):
self.root = Viewport(size=(1920,2160))
self.bottom_display = BottomDisplay()
self.top_display = TopDisplay()
self.root.add_widget(self.bottom_display)
self.root.add_widget(self.top_display)
return self.root
def set_origin(self, xorg, yorg, move_contents=1):
self.begin_transaction()
try:
Viewport.set_origin(self, xorg, yorg, move_contents=move_contents)
self.set_gc_transforms()
self.issue_view()
finally:
self.end_transaction()
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 _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 set_origin(self, xorg, yorg, move_contents = 1): self.begin_transaction() try: Viewport.set_origin(self, xorg, yorg, move_contents = move_contents) self.set_gc_transforms() self.issue_view() finally: self.end_transaction()
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"]
class Scene(object):
def __init__(self, filename, windows_width, window_height, sprites ):
self.tmx_data = helpers.TmxDataProvider(filename)
self.tile_size = self.tmx_data.get_tile_size()
self.size = self.tmx_data.get_map_size()
self.cam = Camera(Position(0,0))
self.renderer = renderer.sfml_renderer(sprites)
windows_size = Size(windows_width, window_height)
viewport_limit = Limits(Position(0,0), self.size, windows_size, self.tile_size)
self.viewport = Viewport(Position(0,0), viewport_limit)
self.visible_layers = []
def set_visible_layers(self, layers):
self.visible_layers = layers
def render(self , context):
for layer in self.visible_layers:
self._render_from_layer(context, layer)
def set_camera(self, camera):
self.camera = camera
def set_images_path(self, path):
self.renderer.set_images_path(path)
def _render_from_layer(self, context, layer):
tmx_layer = self.tmx_data.get_layer(layer['name'])
tmx_layer.set_distance(layer['distance'])
self._render_layer(tmx_layer, context)
def _render_layer(self, layer, context):
layer_position = self._get_position_from_layer(layer)
self.viewport.set_layer_position(layer_position, self.tile_size)
for position in self.viewport.get_visibles_tiles():
tile = self.tmx_data.get_tile(layer, position)
self.renderer.render_tile(tile, layer_position , context)
def _get_position_from_layer(self, layer):
camera_position = self.cam.get_position()
distance_factor = layer.get_distance_factor()
return Position(camera_position.x * distance_factor , camera_position.y * distance_factor)
def update(self, dt):
self.cam.update(dt)
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 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 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 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 _viewport_component_changed(self):
if self.viewport_component is None:
self.viewport_component = Viewport()
self.viewport_component.component = self.component
self.viewport_component.view_position = [0, 0]
self.viewport_component.view_bounds = self.bounds
self.add(self.viewport_component)
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 SetScale(self, scale, do_center=1):
# Set current scale
self.begin_transaction()
try:
Viewport.SetScale(self, scale, do_center=do_center)
self.set_gc_transforms()
finally:
self.end_transaction()
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 ResizedMethod(self, width, height): Viewport.ResizedMethod(self, width, height) self.gc.WindowResized(width, height) if self.widget_size: center = self.WinToDoc(width / 2, height / 2,) dx = ((width - self.widget_size[0]) / 2) / self.scale dy = ((height - self.widget_size[1]) / 2) / self.scale self.SetCenter((center[0] - dx, center[1] + dy)) self.RedrawMethod() self.widget_size = (width, height)
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 __init__(self, master=None, toplevel = None, document = None, show_visible = 0, show_printable = 1, resolution = None, **kw): apply(PyWidget.__init__, (self, master), kw) Viewport.__init__(self, resolution) QueueingPublisher.__init__(self) self.toplevel = toplevel self.move_window_count = 0 self.show_page_outline = 1 self.show_visible = show_visible self.show_printable = show_printable self.gcs_initialized = 0 self.gc = GraphicsDevice() self.init_transactions() if document is not None: self.SetDocument(document) else: self.SetDocument(Document(create_layer = 1))
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 __init__(self, options):
self.options = options
if options['record']:
replay.start(options['record'], options['level'])
elif options['replay']:
options['level'], rand_state = replay.open(options['replay'])
utils.RANDOM.setstate(rand_state)
self.output_file = options['output']
self.viewport = Viewport()
self.world = World(options['red'], options['blue'], options['level'])
self.viewport.set_world(self.world)
self.running = True
self.world_lock = threading.Lock()
def __init__(self, filename, windows_width, window_height, sprites ):
self.tmx_data = helpers.TmxDataProvider(filename)
self.tile_size = self.tmx_data.get_tile_size()
self.size = self.tmx_data.get_map_size()
self.cam = Camera(Position(0,0))
self.renderer = renderer.sfml_renderer(sprites)
windows_size = Size(windows_width, window_height)
viewport_limit = Limits(Position(0,0), self.size, windows_size, self.tile_size)
self.viewport = Viewport(Position(0,0), viewport_limit)
self.visible_layers = []
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 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 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"))
class Gameview(object): def __init__(self, world, player, images, debug=None): self.world = world self.player = player self.screenSize = (1024, 600) self.surface = pygame.display.set_mode(self.screenSize) self.images = images self.debug = debug self.renderTime = 0 self.boxes = [] self.viewportPos = (28, 28) viewportLength = Viewport.size * Cell.size self.viewportRect = pygame.Rect(self.viewportPos, (viewportLength, viewportLength)) self.boxes.append(self.viewportRect) self.viewport = Viewport(self.surface.subsurface(self.viewportRect), self.viewportPos, world, player, images) self.displayPos = (viewportLength + 56, 28) self.displayRect = pygame.Rect(self.displayPos, (Cell.size * 12, viewportLength)) self.display = DisplayPanel(self.surface.subsurface(self.displayRect), self.displayPos, self.player, images) player.screenshot = self.printscreen def draw(self): self.surface.fill(THECOLORS["royalblue4"]) self.viewport.draw() self.display.draw() if self.debug is not None and self.player.debug: self.viewport.display(self.debug()) pygame.display.flip() def notify(self, pos, event): if self.viewportRect.collidepoint(pos): self.viewport.notify(pos, event) if self.displayRect.collidepoint(pos): self.display.notify(pos, event) def printscreen(self): date = time.gmtime() fileName = "screenshot_" + \ str(date[0]) + '-' + \ str(date[1]) + '-' + \ str(date[2]) + '-' + \ str(date[3]-8) + '-' + \ str(date[4]) + '-' + \ str(date[5]) + \ '.jpg' pygame.image.save(self.surface, fileName)
def __init__(self, world, player, images, debug=None): self.world = world self.player = player self.screenSize = (1024, 600) self.surface = pygame.display.set_mode(self.screenSize) self.images = images self.debug = debug self.renderTime = 0 self.boxes = [] self.viewportPos = (28, 28) viewportLength = Viewport.size * Cell.size self.viewportRect = pygame.Rect(self.viewportPos, (viewportLength, viewportLength)) self.boxes.append(self.viewportRect) self.viewport = Viewport(self.surface.subsurface(self.viewportRect), self.viewportPos, world, player, images) self.displayPos = (viewportLength + 56, 28) self.displayRect = pygame.Rect(self.displayPos, (Cell.size * 12, viewportLength)) self.display = DisplayPanel(self.surface.subsurface(self.displayRect), self.displayPos, self.player, images) player.screenshot = self.printscreen
class DisplayView():
__instance = None
@staticmethod
def getInstance():
""" Static access method. """
if DisplayView.__instance is None:
DisplayView()
return DisplayView.__instance
def __init__(self):
""" Virtually private constructor. """
self.__viewport = None
if DisplayView.__instance is not None:
raise Exception("This class is a singleton!")
else:
DisplayView.__instance = self
def get_display(self):
return self.__viewport
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_welcome_text(self):
self.__welcome_msg = Texto(globales.TEXTO[0], globales.FONT,
(120, 3, 12), customEnums.TipoTexto.TITULO)
posX = self.__viewport.horizontal_center(
self.__welcome_msg.getSurface())
posY = self.__viewport.vertical_center(self.__welcome_msg.getSurface())
self.__welcome_msg.setPosicion(posX, posY)
def main_menu_draw(self):
self.__viewport.draw(self.__welcome_msg.getSurface(),
self.__welcome_msg.getPosicion())
def __init__(self, config, level_name):
self.config = config
self.physics_manager = PhysicsManager()
self.material_manager = MaterialManager(config["material_file"])
self.transmutation_manager = TransmutationManager(self.material_manager)
self.transmutation_manager.blow_key = "stone"
self.level = Level("{0}/{1}.lvl".format(config["levels_dir"], level_name), self.physics_manager, self.material_manager)
self.main_char = Player.genMainCharacter()
self.main_char.physical.position = [25, 10]
self.level.actors.append(self.main_char)
self.viewport = Viewport(config["width"], config["height"], self.main_char, self.level, 100)
self.picking_handler = PickingHandler(self.viewport, self.transmutation_manager, self.physics_manager)
self.ui_overlay = UIOverlay(config["font_file"])
self.ui_overlay.text_elements["score"] = TextElement((20, 20), 20, (0, 0, 0), "0 pts")
self.physics_manager.add_actor(self.main_char)
self._highlight_actors = False
self.sound_manager = SoundManager()
self.sound_manager.actors.append(self.main_char)
class App:
def __init__(self, master):
self.objeto = object
#init Frames
self.framePontoVista = Frame(master, relief=FLAT, borderwidth=2)
self.framePlanoProjecao = Frame(master, relief=FLAT, borderwidth=2)
self.frameObjeto = Frame(master, relief=FLAT, borderwidth=2)
self.frameSaidaGrafica = Frame(master, relief=SUNKEN, borderwidth=2, bg="black")
#Griding Frames
self.framePontoVista.grid(row=0, column=0)
self.framePlanoProjecao.grid(row=1, column=0)
self.frameObjeto.grid(row=2, column=0)
self.frameSaidaGrafica.grid(row=0, column=1, rowspan=4)
#Labels
Label(self.framePontoVista, text="Ponto de Vista").grid(row=0, column=0, columnspan=2)
Label(self.framePontoVista, text="A:").grid(row=1, column=0, sticky=E)
Label(self.framePontoVista, text="B:").grid(row=2, column=0, sticky=E)
Label(self.framePontoVista, text="C:").grid(row=3, column=0, sticky=E)
Label(self.framePlanoProjecao, text="Plano de Projecao").grid(row=0, column=0, columnspan=4)
Label(self.framePlanoProjecao, text="P1:").grid(row=1, column=0, sticky=E)
Label(self.framePlanoProjecao, text="P2:").grid(row=2, column=0, sticky=E)
Label(self.framePlanoProjecao, text="P3:").grid(row=3, column=0, sticky=E)
Label(self.frameObjeto, text="Objeto").grid(row=0, column=0, columnspan=2)
#Entradas
self.entradaA = Entry(self.framePontoVista, width=3)
self.entradaA.insert(0, "3")
self.entradaB = Entry(self.framePontoVista, width=3)
self.entradaB.insert(0, "3")
self.entradaC = Entry(self.framePontoVista, width=3)
self.entradaC.insert(0, "3")
self.entradaP1X = Entry(self.framePlanoProjecao, width=3)
self.entradaP1Y = Entry(self.framePlanoProjecao, width=3)
self.entradaP1Z = Entry(self.framePlanoProjecao, width=3)
self.entradaP2X = Entry(self.framePlanoProjecao, width=3)
self.entradaP2Y = Entry(self.framePlanoProjecao, width=3)
self.entradaP2Z = Entry(self.framePlanoProjecao, width=3)
self.entradaP3X = Entry(self.framePlanoProjecao, width=3)
self.entradaP3Y = Entry(self.framePlanoProjecao, width=3)
self.entradaP3Z = Entry(self.framePlanoProjecao, width=3)
self.entradaArq = Entry(self.frameObjeto, state="readonly")
#Griding Entradas
self.entradaA.grid(row=1, column=1)
self.entradaB.grid(row=2, column=1)
self.entradaC.grid(row=3, column=1)
self.entradaP1X.grid(row=1, column=1)
self.entradaP1Y.grid(row=1, column=2)
self.entradaP1Z.grid(row=1, column=3)
self.entradaP2X.grid(row=2, column=1)
self.entradaP2Y.grid(row=2, column=2)
self.entradaP2Z.grid(row=2, column=3)
self.entradaP3X.grid(row=3, column=1)
self.entradaP3Y.grid(row=3, column=2)
self.entradaP3Z.grid(row=3, column=3)
self.entradaArq.grid(row=2, column=0, columnspan=2)
#Canvas
self.saidaGrafica = Canvas(self.frameSaidaGrafica, width=640, height=480, bg="white")
self.saidaGrafica.pack()
#self.saidaGrafica.create_rectangle(100, 100, 300, 200, activefill="red", width=1)
#Button
self.botaoObjeto = Button(self.frameObjeto, text="Escolher Objeto", command=self.arquivoObjeto).grid(row=3, column=0, columnspan=2)
self.botaoProjetar = Button(self.frameObjeto, text="Projetar", command=self.projetar).grid(row=4, column=0, columnspan=2)
def cartesiano(self, matriz):
nMatriz = [[0 for x in range(len(self.objeto.matrizPontos[0]))] for x in range(3)]
for j in range(len(matriz[0])):
nMatriz[0][j] = matriz[0][j] / matriz[3][j]
nMatriz[1][j] = matriz[1][j] / matriz[3][j]
nMatriz[2][j] = 1
return nMatriz
def reflexao(self, matriz):
nMatriz = matriz
for j in range(len(matriz[0])):
nMatriz[1][j] = -matriz[1][j]
return nMatriz
def desenhar(self, matriz):
self.saidaGrafica.delete(ALL)
for sup in self.objeto.superficies:
for i in range(len(sup)):
if (i == len(sup)-1):
ponto1 = int(sup[i])
ponto2 = int(sup[0])
else:
ponto1 = int(sup[i])
ponto2 = int(sup[i+1])
self.saidaGrafica.create_line(round(matriz[0][ponto1]), round(matriz[1][ponto1]), round(matriz[0][ponto2]), round(matriz[1][ponto2]), width=2, smooth=1)
def arquivoObjeto(self):
self.filename = askopenfilename()
if self.objeto:
del self.objeto
self.objeto = Objeto(self.filename)
self.entradaArq.configure(state="normal")
self.entradaArq.delete(0, END)
self.entradaArq.insert(0, self.filename)
self.entradaArq.configure(state="readonly")
self.entradaArq.update()
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)
class Domination:
""" Initializes the game. Keeps track of events. """
def __init__(self, options):
self.options = options
if options['record']:
replay.start(options['record'], options['level'])
elif options['replay']:
options['level'], rand_state = replay.open(options['replay'])
utils.RANDOM.setstate(rand_state)
self.output_file = options['output']
self.viewport = Viewport()
self.world = World(options['red'], options['blue'], options['level'])
self.viewport.set_world(self.world)
self.running = True
self.world_lock = threading.Lock()
def game_loop(self):
step = 0
while(self.running):
#if the world lock is set, only update the GUI, don't move agents.
if self.world_lock.acquire(False):
self.on_simulation_step()
if step % SIMULATION_RESOLUTION == 0:
threading.Thread(target=self.on_action).start()
#on_action will release the lock after all agents have
#declared their action or the time ran out.
else:
self.world_lock.release()
step += 1
replay.step()
for event in pygame.event.get():
self.on_event(event)
self.on_render()
if step > MAX_TIMESTEPS:
self.running = False
self.on_cleanup()
def on_event(self, event):
if event.type == KEYS_EVENT:
self.on_keys()
if event.type == VIDEORESIZE:
self.viewport.resize(event.size)
if event.type == QUIT:
self.running = False
def on_action(self):
self.world.action_step()
self.world_lock.release()
def on_keys(self):
move_speed = 10
keys = pygame.key.get_pressed()
if keys[K_UP]:
self.viewport.move_offset((0,-move_speed))
if keys[K_RIGHT]:
self.viewport.move_offset((move_speed,0))
if keys[K_DOWN]:
self.viewport.move_offset((0,move_speed))
if keys[K_LEFT]:
self.viewport.move_offset((-move_speed,0))
if ((keys[K_RALT] or keys[K_LALT]) and keys[K_F4]) or keys[K_ESCAPE]:
self.running = False
def on_simulation_step(self):
self.world.simulation_step()
def on_render(self):
if not self.options['invisible']:
self.world.render(self.viewport)
pygame.display.update()
def on_cleanup(self):
replay.end()
self.world.cleanup()
with open(self.output_file, "w") as f:
for team in self.world.teams:
f.write(str(team) + "\n")
pygame.quit()
def zoom_fit_rect(self, rect, save_viewport = 0): if save_viewport: self.save_viewport() Viewport.zoom_fit_rect(self, rect)
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
class Level(Completable, Inputable):
def __init__(self, surface, level, **kwargs):
super().__init__(**kwargs)
self._surface = surface
self.map = Map(level[0], level[1])
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 addEntity(self, register=False, entity=None):
if not entity:
raise Exception("Entity must not be None.")
tid = entity.getId()
self._entities[tid] = entity
if register:
self._registered[tid] = entity
self._entity_map[tid] = set()
return tid
def removeEntity(self, entity):
del self._entities[entity.id]
def get(self, entityId):
return self._entities.get(entityId)
def process(self):
for entity in self._entities.values():
result = entity.tick()
if not entity.isAlive():
self._entities.pop(entity.getId())
# This should generally only apply to playable characters.
if entity in self._registered.values():
if Tiles.End in result.keys():
self.setFinished()
if not entity.isAlive():
self.setLost()
for s in self._enemySpawns.values():
s.tick()
self._camera.tick()
self._countdown.tick()
if self._countdown.isFinished():
self.setLost()
if self.editor.enabled():
self.editor.tick(self._camera)
if self.isComplete():
pass
# self._sound.fadeout(3000)
def render(self):
self._surface.fill((0, 0, 0))
self._background.draw(self._total_surface, self._camera)
for s in self._enemySpawns.values():
s.draw(self._total_surface)
for entity in self._entities.values():
entity.draw(self._total_surface)
self.map.draw(self._total_surface)
if self.editor.enabled():
self.editor.draw(self._total_surface)
self._camera.draw(self._surface, self._total_surface)
self._healthBar.draw(self._surface)
self._countdown.draw(self._surface)
if self.editor.enabled():
self.editor.menu.draw()
def tick(self):
self._input()
self.process()
self.render()
class GameInstance(object):
def __init__(self, config, level_name):
self.config = config
self.physics_manager = PhysicsManager()
self.material_manager = MaterialManager(config["material_file"])
self.transmutation_manager = TransmutationManager(self.material_manager)
self.transmutation_manager.blow_key = "stone"
self.level = Level("{0}/{1}.lvl".format(config["levels_dir"], level_name), self.physics_manager, self.material_manager)
self.main_char = Player.genMainCharacter()
self.main_char.physical.position = [25, 10]
self.level.actors.append(self.main_char)
self.viewport = Viewport(config["width"], config["height"], self.main_char, self.level, 100)
self.picking_handler = PickingHandler(self.viewport, self.transmutation_manager, self.physics_manager)
self.ui_overlay = UIOverlay(config["font_file"])
self.ui_overlay.text_elements["score"] = TextElement((20, 20), 20, (0, 0, 0), "0 pts")
self.physics_manager.add_actor(self.main_char)
self._highlight_actors = False
self.sound_manager = SoundManager()
self.sound_manager.actors.append(self.main_char)
"""
Internally sets and returns the tilesize required to display on the given screen
"""
def _recalc_tilesize(self, screen):
self.tile_size = screen.get_width() / self.config["width_tiles"]
return self.tile_size
"""
Clears the event queue and performs associated actions for the existing events
"""
def _handle_events(self, events):
for event in events:
event_name = event if isinstance(event, int) else event[0]
if event_name == Actions.START_USER_LEFT:
self.main_char.physical.velocity[0] -= self.config["user_motion_speed"]
elif event_name == Actions.START_USER_RIGHT:
self.main_char.physical.velocity[0] += self.config["user_motion_speed"]
elif event_name == Actions.START_USER_UP:
if self.main_char.physical.velocity[1] == 0:
self.main_char.physical.velocity[1] -= self.config["user_jump_speed"]
elif event_name == Actions.STOP_USER_LEFT:
self.main_char.physical.velocity[0] += self.config["user_motion_speed"]
elif event_name == Actions.STOP_USER_RIGHT:
self.main_char.physical.velocity[0] -= self.config["user_motion_speed"]
elif event_name == Actions.USER_SUCK:
[self.transmutation_manager.suck(actor) for actor in self.level.actors if self.picking_handler.is_picked(actor, event[1])]
elif event_name == Actions.USER_BLOW:
(new_actor, tile_pos, weight) = self.transmutation_manager.blow(event[1], self.tile_size)
new_actor.physical.position = tile_pos
self.level.actors.append(new_actor)
self.physics_manager.add_actor(new_actor)
elif event_name == Actions.START_BLOW_SELECTION:
self.picking_handler.start_user_selection(event[1], self.tile_size)
elif event_name == Actions.STOP_BLOW_SELECTION:
self.picking_handler.stop_user_selection()
elif event_name == Actions.START_DISSOLVE_SELECTION:
self._highlight_actors = True
elif event_name == Actions.STOP_DISSOLVE_SELECTION:
self._highlight_actors = False
elif event_name == Actions.CHOOSE_MATERIAL:
self.transmutation_manager.blow_key = event[1]
elif event_name == Actions.MUTE:
self.sound_manager.mute()
elif event_name == Actions.UNMUTE:
self.sound_manager.unmute()
"""
Updates all game objects and manager systems based on the frame time delta
"""
def _handle_updates(self, delta):
self.sound_manager.update(delta)
self.physics_manager.update(delta, self.tile_size)
self.picking_handler.update(delta, self.tile_size)
self.transmutation_manager.update(delta)
self.ui_overlay.text_elements["score"].value = "{0} pts".format(self.transmutation_manager.current_points)
self.ui_overlay.update(delta)
self.level.update(delta, self.tile_size)
self.viewport.update(delta)
"""
Renders all game objects to the screen
"""
def _render(self, screen):
additional_drawables = []
mouse_position = pygame.mouse.get_pos()
for actor in self.level.actors:
if self._highlight_actors and self.picking_handler.is_picked(actor, mouse_position) and actor.dissolvable:
picker = (pygame.Surface(actor.surface.get_size()), actor.position, True)
picker[0].set_colorkey((0,0,0))
pygame.draw.rect(picker[0], tuple(self.config["picking_color"]), picker[0].get_rect(), 2)
additional_drawables.append(picker)
additional_drawables.append((self.picking_handler.surface, self.picking_handler.position, True))
additional_drawables += self.ui_overlay.get_drawables()
screen.blit(self.viewport.render(additional_drawables), (0,0))
"""
Handle events, update game state, and render to the given screen
"""
def doFrame(self, screen, delta, events):
self._recalc_tilesize(screen)
self._handle_events(events)
self._handle_updates(delta)
if self.level.is_player_at_goal(self.main_char):
pygame.event.post(pygame.event.Event(CustomEvents.USERWINS))
self._render(screen)
class Level(Completable, Inputable):
def __init__(self, surface, level, **kwargs):
super().__init__(**kwargs)
self._surface = surface
self.map = Map(level[0], level[1])
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 addEntity(self, register=False, entity=None):
if not entity:
raise Exception("Entity must not be None.")
tid = entity.getId()
self._entities[tid] = entity
if register:
self._registered[tid] = entity
self._entity_map[tid] = set()
return tid
def removeEntity(self, entity):
del self._entities[entity.id]
def get(self, entityId):
return self._entities.get(entityId)
def process(self):
for entity in self._entities.values():
result = entity.tick()
if not entity.isAlive():
self._entities.pop(entity.getId())
# This should generally only apply to playable characters.
if entity in self._registered.values():
if Tiles.End in result.keys():
self.setFinished()
if not entity.isAlive():
self.setLost()
for s in self._enemySpawns.values():
s.tick()
self._camera.tick()
self._countdown.tick()
if self._countdown.isFinished():
self.setLost()
if self.editor.enabled():
self.editor.tick(self._camera)
if self.isComplete():
pass
# self._sound.fadeout(3000)
def render(self):
self._surface.fill((0, 0, 0))
self._background.draw(self._total_surface, self._camera)
for s in self._enemySpawns.values():
s.draw(self._total_surface)
for entity in self._entities.values():
entity.draw(self._total_surface)
self.map.draw(self._total_surface)
if self.editor.enabled():
self.editor.draw(self._total_surface)
self._camera.draw(self._surface, self._total_surface)
self._healthBar.draw(self._surface)
self._countdown.draw(self._surface)
if self.editor.enabled():
self.editor.menu.draw()
def tick(self):
self._input()
self.process()
self.render()
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()
class Scrolled(Container):
"""
A Scrolled acts like a viewport with scrollbars for positioning the view
position. Rather than subclassing from viewport, it delegates to one.
"""
# The component that we are viewing
component = Instance(Component)
# The viewport onto our component
viewport_component = Instance(Viewport)
# Inside padding is a background drawn area between the edges or scrollbars
# and the scrolled area/left component.
inside_padding_width = Int(5)
# The inside border is a border drawn on the inner edge of the inside
# padding area to highlight the viewport.
inside_border_color = ColorTrait("black")
inside_border_width = Int(0)
# The background color to use for filling in the padding area.
bgcolor = ColorTrait("white")
# Should the horizontal scrollbar be shown?
horiz_scrollbar = Bool(True)
# Should the vertical scrollbar be shown?
vert_scrollbar = Bool(True)
# Should the scrollbars always be shown?
always_show_sb = Bool(False)
# Should the mouse wheel scroll the viewport?
mousewheel_scroll = Bool(True)
# Should the viewport update continuously as the scrollbar is dragged,
# or only when drag terminates (i.e. the user releases the mouse button)
continuous_drag_update = Bool(True)
# Override the default value of this inherited trait
auto_size = False
# ---------------------------------------------------------------------------
# Traits for support of geophysics plotting
# ---------------------------------------------------------------------------
# An alternate vertical scroll bar to control this Scrolled, instead of the
# default one that lives outside the scrolled region.
alternate_vsb = Instance(Component)
# The size of the left border space
leftborder = Float(0)
# A component to lay out to the left of the viewport area (e.g. a depth
# scale track)
leftcomponent = Any
# ---------------------------------------------------------------------------
# Private traits
# ---------------------------------------------------------------------------
_vsb = Instance(NativeScrollBar)
_hsb = Instance(NativeScrollBar)
# Stores the last horizontal and vertical scroll positions to avoid
# multiple updates in update_from_viewport()
_last_hsb_pos = Float(0.0)
_last_vsb_pos = Float(0.0)
# Whether or not the viewport region is "locked" from updating via
# freeze_scroll_bounds()
_sb_bounds_frozen = Bool(False)
# Records if the horizontal scroll position has been updated while the
# Scrolled has been frozen
_hscroll_position_updated = Bool(False)
# Records if the vertical scroll position has been updated while the
# Scrolled has been frozen
_vscroll_position_updated = Bool(False)
# Whether or not to the scroll bars should cause an event
# update to fire on the viewport's view_position. This is used to
# prevent redundant events when update_from_viewport() updates the
# scrollbar position.
_hsb_generates_events = Bool(True)
_vsb_generates_events = Bool(True)
# ---------------------------------------------------------------------------
# Scrolled interface
# ---------------------------------------------------------------------------
def __init__(self, component, **traits):
self.component = component
Container.__init__(self, **traits)
self._viewport_component_changed()
return
def update_bounds(self):
self._layout_needed = True
if self._hsb is not None:
self._hsb._widget_moved = True
if self._vsb is not None:
self._vsb._widget_moved = True
return
def sb_height(self):
""" Returns the standard scroll bar height
"""
# Perhaps a placeholder -- not sure if there's a way to get the standard
# width or height of a wx scrollbar -- you can set them to whatever you want.
return 15
def sb_width(self):
""" Returns the standard scroll bar width
"""
return 15
def freeze_scroll_bounds(self):
""" Prevents the scroll bounds on the scrollbar from updating until
unfreeze_scroll_bounds() is called. This is useful on components with
view-dependent bounds; when the user is interacting with the scrollbar
or the viewport, this prevents the scrollbar from resizing underneath
them.
"""
if not self.continuous_drag_update:
self._sb_bounds_frozen = True
def unfreeze_scroll_bounds(self):
""" Allows the scroll bounds to be updated by various trait changes.
See freeze_scroll_bounds().
"""
self._sb_bounds_frozen = False
if self._hscroll_position_updated:
self._handle_horizontal_scroll(self._hsb.scroll_position)
self._hscroll_position_updated = False
if self._vscroll_position_updated:
self._handle_vertical_scroll(self._vsb.scroll_position)
self._vscroll_position_updated = False
self.update_from_viewport()
self.request_redraw()
# ---------------------------------------------------------------------------
# Trait event handlers
# ---------------------------------------------------------------------------
def _compute_ranges(self):
""" Returns the range_x and range_y tuples based on our component
and our viewport_component's bounds.
"""
comp = self.component
viewport = self.viewport_component
offset = getattr(comp, "bounds_offset", (0, 0))
ranges = []
for ndx in (0, 1):
scrollrange = float(comp.bounds[ndx] - viewport.view_bounds[ndx])
if round(scrollrange / 20.0) > 0.0:
ticksize = scrollrange / round(scrollrange / 20.0)
else:
ticksize = 1
ranges.append((offset[ndx], offset[ndx] + comp.bounds[ndx], viewport.view_bounds[ndx], ticksize))
return ranges
def update_from_viewport(self):
""" Repositions the scrollbars based on the current position/bounds of
viewport_component.
"""
if self._sb_bounds_frozen:
return
x, y = self.viewport_component.view_position
range_x, range_y = self._compute_ranges()
modify_hsb = self._hsb and x != self._last_hsb_pos
modify_vsb = self._vsb and y != self._last_vsb_pos
if modify_hsb and modify_vsb:
self._hsb_generates_events = False
else:
self._hsb_generates_events = True
if modify_hsb:
self._hsb.range = range_x
self._hsb.scroll_position = x
self._last_hsb_pos = x
if modify_vsb:
self._vsb.range = range_y
self._vsb.scroll_position = y
self._last_vsb_pos = y
if not self._hsb_generates_events:
self._hsb_generates_events = True
return
def _layout_and_draw(self):
self._layout_needed = True
self.request_redraw()
def _component_position_changed(self, component):
self._layout_needed = True
return
def _bounds_changed_for_component(self):
self._layout_needed = True
self.update_from_viewport()
self.request_redraw()
return
def _bounds_items_changed_for_component(self):
self.update_from_viewport()
return
def _position_changed_for_component(self):
self.update_from_viewport()
return
def _position_items_changed_for_component(self):
self.update_from_viewport()
return
def _view_bounds_changed_for_viewport_component(self):
self.update_from_viewport()
return
def _view_bounds_items_changed_for_viewport_component(self):
self.update_from_viewport()
return
def _view_position_changed_for_viewport_component(self):
self.update_from_viewport()
return
def _view_position_items_changed_for_viewport_component(self):
self.update_from_viewport()
return
def _component_bounds_items_handler(self, object, new):
if new.added != new.removed:
self.update_bounds()
def _component_bounds_handler(self, object, name, old, new):
if old == None or new == None or old[0] != new[0] or old[1] != new[1]:
self.update_bounds()
return
def _component_changed(self, old, new):
if old is not None:
old.on_trait_change(self._component_bounds_handler, "bounds", remove=True)
old.on_trait_change(self._component_bounds_items_handler, "bounds_items", remove=True)
if new is None:
self.component = Container()
else:
if self.viewport_component:
self.viewport_component.component = new
new.container = self
new.on_trait_change(self._component_bounds_handler, "bounds")
new.on_trait_change(self._component_bounds_items_handler, "bounds_items")
self._layout_needed = True
return
def _bgcolor_changed(self):
self._layout_and_draw()
def _inside_border_color_changed(self):
self._layout_and_draw()
def _inside_border_width_changed(self):
self._layout_and_draw()
def _inside_padding_width_changed(self):
self._layout_needed = True
self.request_redraw()
def _viewport_component_changed(self):
if self.viewport_component is None:
self.viewport_component = Viewport()
self.viewport_component.component = self.component
self.viewport_component.view_position = [0, 0]
self.viewport_component.view_bounds = self.bounds
self.add(self.viewport_component)
def _alternate_vsb_changed(self, old, new):
self._component_update(old, new)
return
def _leftcomponent_changed(self, old, new):
self._component_update(old, new)
return
def _component_update(self, old, new):
""" Generic function to manage adding and removing components """
if old is not None:
self.remove(old)
if new is not None:
self.add(new)
return
def _bounds_changed(self, old, new):
Component._bounds_changed(self, old, new)
self.update_bounds()
return
def _bounds_items_changed(self, event):
Component._bounds_items_changed(self, event)
self.update_bounds()
return
# ---------------------------------------------------------------------------
# Protected methods
# ---------------------------------------------------------------------------
def _do_layout(self):
""" This is explicitly called by _draw().
"""
self.viewport_component.do_layout()
# Window is composed of border + scrollbar + canvas in each direction.
# To compute the overall geometry, first calculate whether component.x
# + the border fits in the x size of the window.
# If not, add sb, and decrease the y size of the window by the height of
# the scrollbar.
# Now, check whether component.y + the border is greater than the remaining
# y size of the window. If it is not, add a scrollbar and decrease the x size
# of the window by the scrollbar width, and perform the first check again.
if not self._layout_needed:
return
padding = self.inside_padding_width
scrl_x_size, scrl_y_size = self.bounds
cont_x_size, cont_y_size = self.component.bounds
# available_x and available_y are the currently available size for the
# viewport
available_x = scrl_x_size - 2 * padding - self.leftborder
available_y = scrl_y_size - 2 * padding
# Figure out which scrollbars we will need
need_x_scrollbar = self.horiz_scrollbar and ((available_x < cont_x_size) or self.always_show_sb)
need_y_scrollbar = (
self.vert_scrollbar and ((available_y < cont_y_size) or self.always_show_sb)
) or self.alternate_vsb
if need_x_scrollbar:
available_y -= self.sb_height()
if need_y_scrollbar:
available_x -= self.sb_width()
if (available_x < cont_x_size) and (not need_x_scrollbar) and self.horiz_scrollbar:
available_y -= self.sb_height()
need_x_scrollbar = True
# Put the viewport in the right position
self.viewport_component.outer_bounds = [available_x, available_y]
container_y_pos = padding
if need_x_scrollbar:
container_y_pos += self.sb_height()
self.viewport_component.outer_position = [padding + self.leftborder, container_y_pos]
range_x, range_y = self._compute_ranges()
# Create, destroy, or set the attributes of the horizontal scrollbar
if need_x_scrollbar:
bounds = [available_x, self.sb_height()]
hsb_position = [padding + self.leftborder, 0]
if not self._hsb:
self._hsb = NativeScrollBar(
orientation="horizontal", bounds=bounds, position=hsb_position, range=range_x, enabled=False
)
self._hsb.on_trait_change(self._handle_horizontal_scroll, "scroll_position")
self._hsb.on_trait_change(self._mouse_thumb_changed, "mouse_thumb")
self.add(self._hsb)
else:
self._hsb.range = range_x
self._hsb.bounds = bounds
self._hsb.position = hsb_position
elif self._hsb is not None:
self._hsb = self._release_sb(self._hsb)
if not hasattr(self.component, "bounds_offset"):
self.viewport_component.view_position[0] = 0
else:
# We don't need to render the horizontal scrollbar, and we don't
# have one to update, either.
pass
# Create, destroy, or set the attributes of the vertical scrollbar
if self.alternate_vsb:
self.alternate_vsb.bounds = [self.sb_width(), available_y]
self.alternate_vsb.position = [2 * padding + available_x + self.leftborder, container_y_pos]
if need_y_scrollbar and (not self.alternate_vsb):
bounds = [self.sb_width(), available_y]
vsb_position = [2 * padding + available_x + self.leftborder, container_y_pos]
if not self._vsb:
self._vsb = NativeScrollBar(orientation="vertical", bounds=bounds, position=vsb_position, range=range_y)
self._vsb.on_trait_change(self._handle_vertical_scroll, "scroll_position")
self._vsb.on_trait_change(self._mouse_thumb_changed, "mouse_thumb")
self.add(self._vsb)
else:
self._vsb.bounds = bounds
self._vsb.position = vsb_position
self._vsb.range = range_y
elif self._vsb:
self._vsb = self._release_sb(self._vsb)
if not hasattr(self.component, "bounds_offset"):
self.viewport_component.view_position[1] = 0
else:
# We don't need to render the vertical scrollbar, and we don't
# have one to update, either.
pass
self._layout_needed = False
return
def _release_sb(self, sb):
if sb is not None:
if sb == self._vsb:
sb.on_trait_change(self._handle_vertical_scroll, "scroll_position", remove=True)
if sb == self._hsb:
sb.on_trait_change(self._handle_horizontal_scroll, "scroll_position", remove=True)
self.remove(sb)
# We shouldn't have to do this, but I'm not sure why the object
# isn't getting garbage collected.
# It must be held by another object, but which one?
sb.destroy()
return None
def _handle_horizontal_scroll(self, position):
if self._sb_bounds_frozen:
self._hscroll_position_updated = True
return
c = self.component
viewport = self.viewport_component
offsetx = getattr(c, "bounds_offset", [0, 0])[0]
if position + viewport.view_bounds[0] <= c.bounds[0] + offsetx:
if self._hsb_generates_events:
viewport.view_position[0] = position
else:
viewport.set(view_position=[position, viewport.view_position[1]], trait_change_notify=False)
return
def _handle_vertical_scroll(self, position):
if self._sb_bounds_frozen:
self._vscroll_position_updated = True
return
c = self.component
viewport = self.viewport_component
offsety = getattr(c, "bounds_offset", [0, 0])[1]
if position + viewport.view_bounds[1] <= c.bounds[1] + offsety:
if self._vsb_generates_events:
viewport.view_position[1] = position
else:
viewport.set(view_position=[viewport.view_position[0], position], trait_change_notify=False)
return
def _mouse_thumb_changed(self, object, attrname, event):
if event == "down" and not self.continuous_drag_update:
self.freeze_scroll_bounds()
else:
self.unfreeze_scroll_bounds()
def _draw(self, gc, view_bounds=None, mode="default"):
if self.layout_needed:
self._do_layout()
with gc:
self._draw_container(gc, mode)
self._draw_inside_border(gc, view_bounds, mode)
dx, dy = self.bounds
x, y = self.position
if view_bounds:
tmp = intersect_bounds((x, y, dx, dy), view_bounds)
if tmp is empty_rectangle:
new_bounds = tmp
else:
new_bounds = (tmp[0] - x, tmp[1] - y, tmp[2], tmp[3])
else:
new_bounds = view_bounds
if new_bounds is not empty_rectangle:
for component in self.components:
if component is not None:
with gc:
gc.translate_ctm(*self.position)
component.draw(gc, new_bounds, mode)
def _draw_inside_border(self, gc, view_bounds=None, mode="default"):
width_adjustment = self.inside_border_width / 2
left_edge = self.x + 1 + self.inside_padding_width - width_adjustment
right_edge = self.x + self.viewport_component.x2 + 2 + width_adjustment
bottom_edge = self.viewport_component.y + 1 - width_adjustment
top_edge = self.viewport_component.y2 + width_adjustment
with gc:
gc.set_stroke_color(self.inside_border_color_)
gc.set_line_width(self.inside_border_width)
gc.rect(left_edge, bottom_edge, right_edge - left_edge, top_edge - bottom_edge)
gc.stroke_path()
# ---------------------------------------------------------------------------
# Mouse event handlers
# ---------------------------------------------------------------------------
def _container_handle_mouse_event(self, event, suffix):
"""
Implement a container-level dispatch hook that intercepts mousewheel
events. (Without this, our components would automatically get handed
the event.)
"""
if self.mousewheel_scroll and suffix == "mouse_wheel":
if self.alternate_vsb:
self.alternate_vsb._mouse_wheel_changed(event)
elif self._vsb:
self._vsb._mouse_wheel_changed(event)
event.handled = True
return
# ---------------------------------------------------------------------------
# Persistence
# ---------------------------------------------------------------------------
def __getstate__(self):
state = super(Scrolled, self).__getstate__()
for key in ["alternate_vsb", "_vsb", "_hsb"]:
if state.has_key(key):
del state[key]
return state
def loadLevel(self, filename=None):
self.activeLevel = Level(filename)
Viewport().levelHeight = self.activeLevel.physicalSize.y
self.activeLevel.setup()
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 __setPixelPosition(self,value):
self.rect.move_ip(*value)
self.__physicalPosition = Viewport().convertPixelsToPhysicalCoords(self.rect.center)
def build(self):
vp = Viewport(size=(par_width, par_height))
mw = MainWidget()
vp.add_widget(mw)
mw.initial_load()
return vp
def build(self):
self.root = Viewport(size=Window.size)
self.root.add_widget(Menu())
return self.root
