def onMouseDown(self, event):
if event.button is 1:
Camera.current_camera.get_component('CameraTrackingBehavior').target = Game.camera_to_world(event.pos)
c = Crosshair(ResourceLoader.load('data//crosshair.png'))
c.position = Game.camera_to_world(event.pos)
self.add(c)
def __init__(self):
super(NewScene, self).__init__()
EventManager.subscribe(self, "onMouseDown")
self.pool = GameObjectPool(Sprite, (ResourceLoader.load("data/crosshair.png"),))
self.add(self.pool)
def load_level(self, oel_file):
"""Loads an Ogmo level file and returns a Scene built from the
definitions.
:param oel_file: The Ogmo level to load.
:type oel_file: A filepath.
"""
rel_path = '/'.join(oel_file.split('/')[:len(oel_file.split('/')) - 1])
level_data = dict_from_xml(oel_file)
level = Scene()
for key in level_data.level:
if key in self.layer_definitions:
xsi_type = self.layer_definitions[key]['xsi:type']
if xsi_type == 'TileLayerDefinition':
tile_layer = level_data.level[key]
export_mode = tile_layer.exportMode
data = []
if export_mode == 'CSV':
rows = str(tile_layer).split('\n')
for row in rows:
data.append(map(int, row.split(',')))
dimension = self.layer_definitions[key]['Grid']
path = self.tilesets[tile_layer.tileset]['FilePath']
surf = ResourceLoader.load(rel_path + '/' + path)
sheet = ImageSheet(surf, dimension)
tilemap = TileMap(sheet, data)
level.add(tilemap)
elif xsi_type == 'EntityLayerDefinition':
level.add(GameObject())
elif key == 'camera':
camera = Camera(self.camera_size)
camera.top_left = int(level_data.level.camera.x), int(level_data.level.camera.y)
level.add(camera)
elif key == 'width':
level.width = int(level_data.level[key])
elif key == 'height':
level.width = int(level_data.level[key])
else:
setattr(level, key, level_data.level[key])
return level
def __init__(self):
super(NewScene, self).__init__()
Camera.current_camera.clear_color = 20, 12, 28
Camera.current_camera.viewport = 640, 480
dimension = 32, 32
data = ResourceLoader.load('data//planets.png')
sheet = ImageSheet(data, dimension)
# Create a sun in the center of the scene
sun = Sprite(sheet[0], (144, 104))
self.add(sun)
mercury = Sprite(sheet[3])
mercury.add(OrbitBehavior(28.0, 3.25))
mercury.add(Emitter(Particle, (1250, (133, 149, 161)), 160, Particle.on_create))
sun.add(mercury)
planet = Sprite(sheet[1])
planet.add(OrbitBehavior(64.0, 0.75))
planet.add(Emitter(Particle, (5000, (89, 125, 206)), 400, Particle.on_create))
sun.add(planet)
moon = Sprite(sheet[3])
moon.add(OrbitBehavior(24.0, 1.875))
moon.add(Emitter(Particle, (2500, (133, 149, 161)), 200, Particle.on_create))
planet.add(moon)
planet = Sprite(sheet[2])
planet.add(OrbitBehavior(132.0, 0.25))
planet.add(Emitter(Particle, (12000, (109, 170, 44)), 800, Particle.on_create))
sun.add(planet)
moon = Sprite(sheet[3])
moon.add(OrbitBehavior(20.0, 4.25))
moon.add(Emitter(Particle, (1250, (133, 149, 161)), 100, Particle.on_create))
planet.add(moon)
moon = Sprite(sheet[3])
moon.add(OrbitBehavior(42.0, 1.75))
moon.add(Emitter(Particle, (2500, (133, 149, 161)), 200, Particle.on_create))
planet.add(moon)
planet = Sprite(sheet[4])
planet.add(OrbitBehavior(232.0, 0.125))
planet.add(Emitter(Particle, (18000, (208, 70, 72)), 1000, Particle.on_create))
sun.add(planet)
moon = Sprite(sheet[3])
moon.add(OrbitBehavior(48.0, 0.75))
moon.add(Emitter(Particle, (2500, (133, 149, 161)), 200, Particle.on_create))
planet.add(moon)
def __init__(self, image, lifetime):
super(Particle, self).__init__(image)
self.__velocity = Vector2D.from_angle(random.randrange(80, 100)) * -1.35
sheet = ImageSheet(ResourceLoader.load('data//puffs.png'), (32, 32))
puff = [(sheet[3], int(lifetime * 0.2)),
(sheet[2], int(lifetime * 0.1)),
(sheet[1], int(lifetime * 0.3)),
(sheet[0], int(lifetime * 2.0))]
self.animation = Animation('puff', puff)
self.add(self.animation)
self.add(DestroyAfter(lifetime))
def __init__(self):
super(EmitterPerformanceTest, self).__init__()
bg = Gradient.createVerticalGradient((20, 15), (255,255,255), (228, 139, 165), (111,86,117))
bg = pygame.transform.scale(bg, (320, 240))
self.add(Sprite(bg, (160, 120)))
num_emitters = 8
for i in range(num_emitters):
e = Emitter(Particle, (ImageSheet(ResourceLoader.load('data//puffs.png'), (32, 32))[0], 1000), 40, self.onCreate)
e.position = 40 + (i * (256 / (num_emitters - 1))), 216
self.add(e)
self.add(EndGameAfter(1000 * 30))
def __init__(self):
super(NewScene, self).__init__()
# Read the alphabet string from a file.
alphaArray = open('Data\\anomaly.dat','r').readline()
# Define the font dimensions
fontDimension = (32,32)
# Create bitmap font object
font = BitmapFont(ResourceLoader.load('Data\\anomaly.png'), fontDimension, alphaArray)
# Create the text object
text = Text(font,'Basic Text')
# Set the text object's position
text.position = (0, 88)
self.add(text)
def __init__(self):
super(NewScene, self).__init__()
EventManager.subscribe(self, 'onKeyDown')
# Read the alphabet string from a file.
alphaArray = open('Data\\anomaly.dat','r').readline()
# Define the font dimensions
fontDimension = (32,32)
# Create bitmap font object
self.font = BitmapFont(ResourceLoader.load('Data\\anomaly.png'), fontDimension, alphaArray)
# Create the text object
self.text = Text(self.font,'Wavy Text')
# Wrap the text object with an effect
self.effect = wavy_text.WavyText(self.text)
# Set the text object's position
self.effect.position = (16, 88)
self.add(self.text)
def __init__(self):
super(NewScene, self).__init__()
dimension = (32, 37)
data = ResourceLoader.load('data//player_run.png')
sheet = ImageSheet(data, dimension)
interval = 80
run = [(sheet[i], interval) for i in range(8)]
for i in range(8):
animation = Animation('run_cycle', run)
animation.play('run_cycle', i)
staticSprite = Sprite(sheet[i])
staticSprite.position = (i + 1) * 32 + 16, 84
self.add(staticSprite)
animatedSprite = Sprite(animation)
animatedSprite.position = (i + 1) * 32 + 16, 148
self.add(animatedSprite)
def __init__(self, lifetime):
super(PuffEmitter, self).__init__(Particle, (ImageSheet(ResourceLoader.load('data//puffs.png'), (32, 32))[3], 300), 20, self.onCreate)
self.__counter = 0
self.lifetime = lifetime
self.position = Vector2D(0, 0)
self.velocity = Vector2D(0, 0)
# Define the origin
ORIGIN = (0,0)
# Set the screen size
SCREEN_SIZE = (256, 256)
# Setup pygame display
pygame.display.set_mode(SCREEN_SIZE)
# Get a surface the size of the window
screen = pygame.display.get_surface()
# Create a buffer to render to
buffer = pygame.Surface((43, 43))
# Define the sub-image dimension.
dimension = (40,43)
data = ResourceLoader.load('Data/run.png')
# Create the image sheet object.
sheet = ImageSheet(data, dimension)
target = sheet[0]
interval = 80
run = [(sheet[0], interval),
(sheet[1], interval),
(sheet[2], interval),
(sheet[3], interval),
(sheet[4], interval),
(sheet[5], interval),
