def __init__(self, parent):
Location.__init__(self, parent, menu_background)
pygame.mixer.music.load(music)
pygame.mixer.music.play(-1)
pygame.mouse.set_visible(1)
pygame.key.set_repeat(0)
self.start_button = PlayButton(240, 300)
self.surfaces = []
self.controls = pygame.sprite.Group()
self.controls.add(self.start_button)
self.platform1 = Platform(120, 600)
self.platform2 = Platform(240, 490)
self.platform3 = Platform(360, 550)
self.doodle = Doodle()
self.animation = pygame.sprite.Group()
self.animation.add(self.platform1)
self.animation.add(self.platform2)
self.animation.add(self.platform3)
self.animation.add(self.doodle)
self.window.blit(self.background, (0, 0))
def load_map(self, folder, name):
#This should be read from layout.txt
self.spawn_x = 50
self.spawn_y = 50
#opens an .oel file and create map from it
tree = ET.parse(os.path.join('data', 'maps', folder, name))
root = tree.getroot()
self.camera.map_w = int(root.attrib['width'])
self.camera.map_h = int(root.attrib['height'])
for r in root:
for o in r:
if o.tag == 'tile':
size = 25
target = Platform(
int(o.attrib['x']) * size,
int(o.attrib['y']) * size, int(o.attrib['tx']),
int(o.attrib['ty']), size)
self.platforms.append(target)
else:
target = Object(int(o.attrib['x']),
int(o.attrib['y']),
o.tag + '.png',
colorkey=None,
folder='maps')
target.set_message('This is a ' + o.tag)
self.objects.append(target)
self.entity.append(target)
return self
def create_platforms(self):
platform_x = random.randint(SC.platform_range[0], SC.platform_range[1])
platform_position1 = (platform_x, SC.platform_start_y)
platform_position2 = (platform_x + SC.platform_width +
SC.platform_gap_size, SC.platform_start_y)
hammer_x = random.randint(SC.platform_range[0], SC.platform_range[1])
hammer_position1 = (platform_x + .9 * SC.platform_width -
Hammer.default_width,
SC.platform_start_y + SC.platform_height)
hammer_position2 = (platform_x + SC.platform_width +
SC.platform_gap_size + .1 * SC.platform_width,
SC.platform_start_y + SC.platform_height)
first_platform = Platform(platform_position1, SC.platform_velocity)
self.platforms.append(first_platform)
second_platform = Platform(platform_position2, SC.platform_velocity)
self.platforms.append(second_platform)
first_hammer = Hammer(hammer_position1, SC.platform_velocity)
self.hammers.append(first_hammer)
second_hammer = Hammer(hammer_position2, SC.platform_velocity)
self.hammers.append(second_hammer)
def run_game():
#Инициализация игры и создание объекта на экране
#timer = pygame.time.Clock()
pygame.init()
ai_setting = Settings()
screen = pygame.display.set_mode(
(ai_setting.screen_width, ai_setting.screen_height))
pygame.display.set_caption("Arcanoid")
platform = Platform(ai_setting, screen)
bricks = Group()
ball = Ball(ai_setting, screen, platform, bricks)
#блок музыки - начало игры
music_file = "mus/title.mp3"
pygame.mixer.music.load(music_file)
pygame.mixer.music.play() #Проигрываем5
#
# Create the wall of bricks.
gameF.create_wall(ai_setting, screen, platform, bricks)
#Запуск основного цикла в игре
while True:
# timer.tick(240)
if (ai_setting.life == 0):
break
gameF.checkEvents(platform) #Функция реагирования на события
platform.update() #Обновление платформы
ball.update() #Обновление мяча
gameF.updateScreen(ai_setting, screen, platform, ball,
bricks) #Функция перерисовки экрана
def __init__(self, player):
teleporter = Teleporter()
# Call the parent constructor
Level.__init__(self, player)
self.level_limit = 1500
# Array with type of platform, and x, y location of the platform.
level = [
[210, 70, 450, 770],
[210, 70, 850, 520],
[210, 70, 1000, 420],
[210, 70, 1120, 580],
]
# Go through the array above and add platforms
for platform in level:
block = Platform(platform[0], platform[1])
block.rect.x = platform[2]
block.rect.y = platform[3]
block.player = self.player
self.platform_list.add(block)
teleporter.rect.x = self.level_limit
teleporter.rect.y = 50
self.teleporter_list.add(teleporter)
def platsassemble(levelnow,levelindex):
for p in range(len(levelnow)):
platform = Platform(levelnow[p])
platform.harvesthour(mapsizes[levelindex][0],mapsizes[levelindex][1])
wall_list.add(platform)
sprite_list.add(platform)
print(str(levelnow[p]))
def load_map(self,folder,name):
#This should be read from layout.txt
self.spawn_x = 50
self.spawn_y = 50
#opens an .oel file and create map from it
tree = ET.parse(os.path.join('data','maps',folder,name))
root = tree.getroot()
self.camera.map_w = int(root.attrib['width'])
self.camera.map_h = int(root.attrib['height'])
for r in root:
for o in r:
if o.tag == 'tile':
size = 25
target = Platform(int(o.attrib['x'])*size,int(o.attrib['y'])*size,int(o.attrib['tx']),int(o.attrib['ty']),size)
self.platforms.append(target)
else:
target = Object(int(o.attrib['x']),int(o.attrib['y']),o.tag+'.png',colorkey=None,folder='maps')
target.set_message('This is a ' + o.tag)
self.objects.append(target)
self.entity.append(target)
return self
def __init__(self, player):
teleporter = Teleporter()
# Call the parent constructor
Level.__init__(self, player)
self.level_limit = 2000
# Array with width, height, x, and y of platform
level = [[210, 40, 500, 650], [210, 40, 900, 600],
[210, 40, 1200, 550], [210, 40, 1400, 450],
[1000, 40, 2010, 795], [1000, 40, 2010, 795]]
# Go through the array above and add platforms
for platform in level:
block = Platform(platform[0], platform[1])
block.rect.x = platform[2]
block.rect.y = platform[3]
block.player = self.player
self.platform_list.add(block)
teleporter.rect.x = 1000
teleporter.rect.y = 620
self.teleporter_list.add(teleporter)
# X and Y coordinates for generating enemies
enemy_list = []
enemy_level = [[230, 420], [500, 420], [800, 300]]
for n in enemy_level:
enemy = Enemy()
enemy.rect.x = n[0]
enemy.rect.y = n[1]
self.enemy_list.add(enemy)
#X and Y for the score chests
chest_list = []
chest_level = [[300, 100], [550, 300]]
for n in chest_level:
chest = Chest()
chest.rect.x = n[0]
chest.rect.y = n[1]
self.chest_list.add(chest)
def platsassemble(levelnow, levelindex):
for p in range(len(levelnow)):
platform = Platform(levelnow[p])
platform.harvesthour(mapsizes[levelindex][0], mapsizes[levelindex][1])
wall_list.add(platform)
sprite_list.add(platform)
print(str(levelnow[p]))
def start_game(self):
try:
if self.reRun:
if self.death_text != None:
self.Scen.removeItem(self.death_text)
self.death_text = None
if self.win_text != None:
self.Scen.removeItem(self.win_text)
self.win_text = None
self.test_player.setY(-60)
self.test_player = Player(self.player_specs)
self.backGround = Background(-1, -1, self.window_width + 1,
self.window_height + 1)
self.skyObject = self.backGround.skyObj
self.bottom_lava = Lava(-1, self.window_height - 50,
self.window_width + 1, 51)
self.test_platform = Platform(0, 300,
self.window_width - 100, 40)
self.test_platform_2 = Platform(self.window_width - 50,
320, 100, 35)
self.init_game_screen()
self.completion = 0
self.goal_added = False
self.view.setScene(self.scene)
self.game_timer.start(10)
except Exception as r:
print('JJJJJJJJ')
def __init__(self, player):
'''call parent constructor'''
Level.__init__(self, player)
self.level_limit = -10000
'''array with with width, height, x, and y of platform'''
level = [
[210, 70, 500, 500],
[210, 70, 800, 400],
[210, 70, 1120, 280],
[210, 70, 2000, 300],
[210, 70, 1800, 500],
[210, 70, 2900, 400],
]
walls = [[70, 600, 0, 0], [70, 600, 3200, 0]]
'''go through the array and add platforms'''
for platform in level:
block = Platform(platform[0], platform[1])
block.rect.x = platform[2]
block.rect.y = platform[3]
block.player = self.player
self.platform_list.add(block)
'''do the same for level walls'''
for wall in walls:
block = Wall(wall[0], wall[1])
block.rect.x = wall[2]
block.rect.y = wall[3]
block.player = self.player
self.walls_list.add(block)
'''add enemies to level'''
self.enemy_list.add(Enemy())
self.enemy_list.add(Enemy())
def load_platforms(self):
platforms = set()
if self.stageName == 'first':
left = Platform(470, 490, 246, 10, platforms, 0) #530
right = Platform(1196, 490, 246, 10, platforms, 0)
top = Platform(833, 330, 246, 10, platforms, 0) # 408
floor = Platform(290, 710, 1360, 18, platforms, 1)
return platforms
def __init__(self):
self.win = Window((Game.win_width, Game.win_height))
self.sky = Sky(Game.win_width, Game.win_height)
self.platform = Platform(Game.win_width, 96, Game.win_height - 96 - 30)
self.dino = None
self.enemy_velocity = 250
self.score = 0
self.create_handlers()
self.enemies = []
def createExit(self, j, i):
self.stageScale = 50
x = self.stageScale * (j)
y = self.stageScale * (i)
sprite = Platform()
sprite.rect = pygame.Rect((x, y), (self.stageScale, self.stageScale))
sprite.image = self.imageDictionary["goldBrick"]
sprite.image = pygame.transform.scale(sprite.image, (self.stageScale, self.stageScale))
self.exitGroup.add(sprite);
def __init__(self):
setWindowPositionCentered(self.width, self.height)
self.window = pygame.display.set_mode((self.width, self.height))
pygame.display.set_caption("Ping Pong!")
pygame.font.init()
# Instantiates components
self.ball = Ball(self.window)
platformsX = (350 - 60) // 2
self.topPlatform = Platform(self.window, platformsX, 0)
self.bottomPlatform = Platform(self.window, platformsX, 480)
self.score = Score(self.window)
def __init__(self,
numchannels,
accumulation_length,
bandwidth,
input_bitwidth,
fft_out_bitwidth,
antennas=1):
self.maxdesigns = 1
self.blocks = {}
self.totalblocks = 0
#add the platform array
self.platforms = {}
# add platforms: cost, inputbw, outputbw, resources
self.platforms['ROACH'] = Platform.createRoach('dollars')
self.platforms['GTX580'] = Platform.createGTX580Server('dollars')
#self.platforms['IBOB'] = Platform('IBOB',2000,10,1,['resources'])
# add the ADC
adc_bw = bandwidth * input_bitwidth
self.blocks['ADC'] = CBlock(
'ADC', CBlock.getADCModel(self.platforms, bandwidth,
input_bitwidth), -1, 0, 0, 'PFB', 0,
adc_bw, antennas)
self.totalblocks += antennas
# add the PFB
pfb_bw = bandwidth * 32
self.blocks['PFB'] = CBlock(
'PFB',
CBlock.getPFBModel(self.platforms, bandwidth, input_bitwidth,
numchannels), 'ADC', 0, pfb_bw, 'FFT', 0,
adc_bw, antennas)
self.totalblocks += antennas
# add the FFT
fft_out_bandwidth = bandwidth * fft_out_bitwidth
self.blocks['FFT'] = CBlock(
'FFT', CBlock.getFFTModel(self.platforms, bandwidth, numchannels),
'PFB', 0, pfb_bw, 'VAcc', 0, fft_out_bandwidth, antennas)
self.totalblocks += antennas
#add the Vacc
self.blocks['VAcc'] = CBlock(
'VAcc',
CBlock.getVAccModel(self.platforms, bandwidth, fft_out_bitwidth,
accumulation_length), 'FFT', 0,
fft_out_bandwidth, -1, 0, 0, antennas)
self.totalblocks += antennas
def frametest():
p = Platform()
a = testScreen(p, p.frontdisplay)
# a = VUScreen(p, p.frontdisplay, 0.5)
l = p.chLogic()
print( "testScreen initialised: ", a, p )
print"logic ", l
for k in l:
p.activeSource= l[k]
p.frontdisplay.draw(a.draw)
time.sleep(3)
print( "testScreen draw executed")
def main():
pygame.init()
width, height = 1600, 900
screen = pygame.display.set_mode((width, height),pygame.FULLSCREEN)
player = Player()
plat0 = Platform()
player.setX(800)
player.setY(387)
while 1:
screen.fill(0)
player.update()
screen.blit(player.getImage(), (player.getX(),player.getY()))
screen.blit(plat0.getImage(),(20,450))
pygame.display.flip()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit(0)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_a:
player.setXSpeed(-1)
if event.key == pygame.K_d:
player.setXSpeed(1)
if event.key == pygame.K_k:
player.setJumping(True)
player.wdown = True
if event.type == pygame.KEYUP:
if event.key == pygame.K_a and player.getXSpeed() < 0:
player.setXSpeed(0)
player.facingLeft = True
if event.key == pygame.K_d and player.getXSpeed() > 0:
player.setXSpeed(0)
player.facingLeft == False
if event.key == pygame.K_k:
player.wdown = False
def get_sprites(self):
platforms_group = pygame.sprite.Group()
for x in range(len(self.level_array)):
for y in range(len(self.level_array[0])):
if self.level_array[x, y] == 1:
platforms_group.add(Platform(y * 20, x * 20, 20, 20, self))
return platforms_group
def generating_platforms(group, going):
"""Генерация платформ"""
y = 5
while y < HEIGHT:
generate_platform(group, y)
y += going
Platform(group, 200, 600)
def gen_platform(self, plat): # Left side of platform plat_l = Platform(plat[0], plat[1]) plat_l.rect.x = 0 plat_l.rect.y = plat[2] plat_l.player = self.player # Right side of platform plat_r = Platform(SCREEN_WIDTH - plat[0] - GAP_LEN, plat[1]) plat_r.rect.x = plat[0] + GAP_LEN plat_r.rect.y = plat[2] plat_r.player = self.player # Add both platforms to platform_list self.platform_list.add(plat_l) self.platform_list.add(plat_r)
def setPlatform(x,y,size, image):
for i in range(size):
platforms.append( Platform())
platforms[len(platforms)-1].set_dimensions(50, 50)
platforms[len(platforms)-1].x_pos = x+i*50
platforms[len(platforms)-1].y_pos = y
platformImages.append(image)
def new(self):
self.all_sprites = pg.sprite.Group()
self.platforms = pg.sprite.Group()
self.saws = pg.sprite.Group()
plts_conf, plr_conf, saw_conf, fl_saw_conf, prtl_conf = self.create_level(
levels.level1)
self.player = Player(*plr_conf, self)
self.all_sprites.add(self.player)
for plt in plts_conf:
p = Platform(*plt)
self.all_sprites.add(p)
self.platforms.add(p)
for saw in saw_conf:
s = Saw(*saw)
self.all_sprites.add(s)
self.saws.add(s)
for fl_saw in fl_saw_conf:
s = FlyingSaw(*fl_saw, self.platforms)
self.all_sprites.add(s)
self.saws.add(s)
self.portal = Portal(*prtl_conf)
self.all_sprites.add(self.portal)
self.run()
def create_object(ch, x, y):
if ch in ['1', '2', '3', '4', '5']:
obj = Jelly(ord(ch) - ord('1'), x, y)
gfw.world.add(gfw.layer.item, obj)
#print('creating Jelly', x, y)
elif ch in ['O', 'P']:
dy = 1 if ch == 'Q' else 3
y -= dy * BLOCK_SIZE // 2
x -= BLOCK_SIZE // 2
obj = Platform(ord(ch) - ord('O'), x, y)
gfw.world.add(gfw.layer.platform, obj)
#print('creating Platform', x, y)
elif ch in ['B']:
pass
else:
ao = factory.create(ch, x, y)
if ao is None:
global ignore_char_map
if ch not in ignore_char_map:
print("Error? I don't know about: '%s'" % ch)
ignore_char_map |= {ch}
return
l, b, r, t = ao.get_bb()
ao.pass_wh(r - l, t - b)
gfw.world.add(gfw.layer.enemy, ao)
def randomPlatform(self, top=True):
x = random.randint(0, screen_width - platform_width)
bad_y = []
for spr in self.allsprites:
bad_y.append((spr.y - platform_y_padding, spr.y + platform_y_padding + spr.rect.height))
good = 0
while not good:
if top:
y = random.randint(-100, 100)
else:
y = random.randint(0, screen_height)
good = 1
for bad_y_item in bad_y:
if bad_y_item[0] <= y <= bad_y_item[1]:
good = 0
break
dig = random.randint(0, 100)
if dig < 35:
return MovingPlatform(x, y)
elif 35 <= dig < 50:
return CrashingPlatform(x, y)
else:
return Platform(x, y)
def __init__(self, world):
self.__world = world
self.__platforms = pg.sprite.Group()
self.__items = pg.sprite.Group()
self.__exit = pg.sprite.Group()
self.__bg = (BLUE)
row_count = 0
for row in self.__world:
col_count = 0
for tile in row:
if tile == 1:
wall = Platform(col_count * TILE_SIZE_W,
row_count * TILE_SIZE_H, TILE_SIZE_W,
TILE_SIZE_H, BLUE)
self.__platforms.add(wall)
#tile = (wall.image, wall.rect)
elif tile == 2:
grogu = Key(col_count * TILE_SIZE_W,
row_count * TILE_SIZE_H, 20, 20, GREEN)
self.__items.add(grogu)
elif tile == 3:
ship = Extraction_point(col_count * TILE_SIZE_W,
row_count * TILE_SIZE_H,
TILE_SIZE_W, TILE_SIZE_H, PURPLE)
self.__exit.add(ship)
col_count += 1
row_count += 1
self.__spawn_point = ((WIDTH, HEIGHT))
def load_map_level(map_name, x_player, y_player):
global sprites, platforms, level, hero, camera
sprites = pygame.sprite.Group()
platforms = list()
level = load_level(map_name)
hero = Player(x_player, y_player)
sprites.add(hero)
x = 0
y = 0
for row in level:
for col in row:
if col == "#":
pf = Platform(x, y)
sprites.add(pf)
platforms.append(pf)
elif col == '@':
fin = Final(x, y)
sprites.add(fin)
platforms.append(fin)
x += PLATFORM_WIDTH
y += PLATFORM_HEIGHT
x = 0
total_level_width = len(level[0]) * PLATFORM_WIDTH
total_level_height = len(level) * PLATFORM_HEIGHT
camera = Camera(camera_configure, total_level_width, total_level_height)
def __init__(self, conf):
Platform.__init__(self, "cluster", conf)
if "files_url" not in self._conf:
raise MissingConfigParamError("files_url")
url = urlparse(self._conf["files_url"])
self._files_scheme = url.scheme
self._files_host = url.netloc
if self._files_scheme not in ["ssh", "file", "rsync"]:
raise Exception("Unsupported scheme: {}".format(self._files_scheme))
self._remote_path = self._conf.get("remote_path", self._work_path)
self._projects_path = self._conf.get("projects_path", os.path.join(self._work_path, "projects"))
self._rsync_path = self._conf.get("rsync_path", "rsync")
def __init__(self):
pygame.init()
self.screen = Screen()
self.clock = pygame.time.Clock()
self.doodler = Doodler(Screen.WIDTH / 2, Screen.HEIGHT / 2)
self.p1 = Platform(Screen.WIDTH / 2, Screen.HEIGHT / 2 + 130)
def __init__(self, conf):
Platform.__init__(self, "cluster", conf)
if "files_url" not in self._conf:
raise MissingConfigParamError("files_url")
url = urlparse(self._conf["files_url"])
self._files_scheme = url.scheme
self._files_host = url.netloc
if self._files_scheme not in ["ssh", "file", "rsync"]:
raise Exception("Unsupported scheme: {}".format(
self._files_scheme))
self._remote_path = self._conf.get("remote_path", self._work_path)
self._projects_path = self._conf.get(
"projects_path", os.path.join(self._work_path, "projects"))
self._rsync_path = self._conf.get("rsync_path", "rsync")
def init(p1_actions):
platforms.empty()
global player
for i in range(height // 100):
for j in range(width // 420):
platform = Platform((random.randint(5, (width - 50) // 10) * 10,
120 * j + random.randint(0, 4) * 100), 'images/platform.png', 70, 40)
platforms.add(platform)
player = Player((platforms.sprites()[-1].rect.centerx, platforms.sprites()[-1].rect.centery - 300), p1_actions)
sprites.add(player)
def __init__(self):
# initialize pygame and create window
pygame.init()
self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("My Game")
self.clock = pygame.time.Clock()
self.running = True
self.spritesheet = Spritesheet(
os.path.join(img_folder, "p1_spritesheet.png"))
self.ground = Platform(0, HEIGHT - 40, WIDTH, 40, self)
def frametest(display):
# frames = (VolumeAmountFrame, TextFrame, MenuFrame, SourceIconFrame, VUFrame, SpectrumFrame) # create a list of all screens to test one by one
scaled_frames = (RecordingScreen)
# frames = (VU2chFrame, VUV2chFrame, Spectrum2chFrame)
limits = ((0.3,"white"), (0.6,"grey"), (0.8,"red"))
events = Events(( 'Platform', 'CtrlTurn', 'CtrlPress', 'VolKnob', 'Audio', 'RemotePress'))
p = Platform(events)
if display=='int':
d = p.internaldisplay
else:
d = p.frontdisplay
geo = Geometry(d.boundary)
geo.scale( (1.0, 1.0) ) # make the Screen scale width
# for f in scaled_frames:
# f = VUV2chFrame
# # a = f(geo.coords, p, d, 'left', limits )
# a = f(geo.coords, p, d, 0.3 )
# f = SpectrumFrame
# a = f(geo.coords, p, d, 'left', 0.4 )
# print( "%s initialised: %s" % (type(f).__name__, a) )
# f = Spectrum2chFrame
# a = f(geo.coords, p, d, 1.0 )
# print( "%s initialised: %s" % (type(f).__name__, a) )
# f = VUMeterAFrame
# a = f(geo.coords, p, d, 'left', 0.5 )
# a = testScreen1(p, d)
# print( "%s initialised: %s" % (type(f).__name__, a) )
# import math
# a = MetersAScreen(p, d)
# d.draw(a)
# for _ in range(0, 10):
# for x in range(0,360,10):
#
# p.vu['left'] = math.pow(math.sin(x),2)
# p.vu['right'] = math.pow(math.cos(x),2)
# print("x =",x, p.vu)
# d.draw(a)
# time.sleep(0.1)
#
# print( "Drawn: %s" % ( a) )
# time.sleep(5)
#
#
a = RecordingScreen(p, d)
print( "RecordingScreen initialised: ", a, p )
d.draw(a)
time.sleep(5)
def crete_platforms(self):
ws_platform_static = [[80, 35, 0, 175], [40, 30, 80, 200],
[40, 30, 120, 220], [220, 15, 120, 220],
[275, 75, 370, 175], [115, 250, 640, 0],
[50, 40, 0, 500], [380, 40, 50, 540],
[350, 50, 430, 500], [180, 100, 750, 395],
[150, 50, 930, 430], [50, 50, 1080, 395]]
for ws in ws_platform_static:
platform_object = Platform(*ws)
self.set_of_platforms.add(platform_object)
def __init__(self):
pygame.init()
self.game_settings = Settings()
self.screen = pygame.display.set_mode([
self.game_settings.screen_width, self.game_settings.screen_height
])
self.title = pygame.display.set_caption(self.game_settings.title)
self.running = True
############
#OBJ IN GAME
############
#SINGLE OBJ
self.game_bird = Bird(self)
self.game_platform = Platform(self)
#GROUP OBJ
self.game_pipes = pygame.sprite.Group()
self.create_pipes()
class Command(object):
def __init__(self, *args, **kwargs):
self.storage = DataStore()
self.platform = Platform()
def _app_string(self):
return colored.cyan('Bam!')
def all(self):
lists = self.storage.get_all_lists()
for list_name, values in lists.iteritems():
with indent(INDENT):
puts(list_name)
for k, v in values.iteritems():
with indent(INDENT):
puts('{}:\t\t{}'.format(k, v))
def overview(self):
lists = self.storage.get_all_lists()
if lists:
for list_name, values in lists.iteritems():
with indent(INDENT):
puts("{} ({})".format(list_name, len(values)))
else:
self.help()
def create_list(self, list_name, item_name=None, item_value=None):
self.storage.create_list(list_name)
print '{} Created a new list called {}.'.format(
self._app_string(),
colored.yellow(list_name)
)
if item_name and item_value:
self.add_item(list_name, item_name, item_value)
def detail_list(self, list_name):
if self.storage.list_exists(list_name):
for k, v in self.storage.get_list(list_name).iteritems():
with indent(INDENT_LARGE):
puts('{}:\t\t{}'.format(k, v))
else:
print 'Cannot find list "{}".'.format(list_name)
def delete_list(self, list_name):
answer = raw_input(
"You sure you want to delete everything in {}? (y/n): ".format(
colored.yellow(list_name))
)
if answer.strip().lower() == 'y':
self.storage.delete_list(list_name)
print "{} Deleted all your {}.".format(
self._app_string(),
colored.yellow(list_name)
)
else:
print "Just kidding then."
def add_item(self, list_name, name, value):
self.storage.add_item(list_name, name, value)
print '{} {} in {} is {}. Got it.'.format(
self._app_string(),
colored.yellow(name),
colored.yellow(list_name),
colored.yellow(value)
)
def search_list_for_item(self, list_name, name):
value = self.storage.get_item(name, list_name=list_name)
print "{} We just copied {} to your clipboard.".format(
self._app_string(),
colored.yellow(self.platform.copy(value))
)
def search_items(self, name):
value = self.storage.get_item(name)
print "We just copied {} to your clipboard.".format(
colored.yellow(self.platform.copy(value))
)
def delete_item(self, list_name, name):
if self.storage.list_exists(list_name):
try:
self.storage.delete_item(list_name, name)
print "{} {} is gone forever.".format(
self._app_string(),
colored.yellow(name)
)
except KeyError:
print "{} {} {}.".format(
colored.yellow(name),
colored.red("not found in"),
colored.yellow(list_name)
)
else:
print "We cound't find that list."
def echo(self, major, minor=None):
list_name = list_name = None
if minor:
list_name, item_name = major, minor
else:
item_name = major
output = self.storage.get_item(item_name, list_name=list_name)
if not output:
if list_name and item_name:
output = "{} {} {}".format(
colored.yellow(item_name),
colored.red("not found in"),
colored.yellow(list_name)
)
else:
output = "{} {}".format(
colored.yellow(item_name),
colored.red("not found")
)
print output
def edit(self):
print "{} {}".format(
self._app_string(),
self.platform.edit(self.storage.data_path)
)
def open(self, major, minor):
noun = None
if self.storage.list_exists(major):
the_list = self.storage.get_list(major)
if minor:
value = self.storage.get_item(minor, list_name=major)
if value:
self.platform.open(value)
output = "{} We just opened {} for you."
noun = value
else:
for value in the_list.values():
self.platform.open(value)
output = "{} We just opened all of {} for you."
noun = major
else:
value = self.storage.get_item(major)
if value:
self.platform.open(value)
output = "{} We just opened {} for you."
noun = value
print output.format(
self._app_string(),
colored.yellow(noun)
)
def random(self, major):
if major and self.storage.list_exists(major):
values = self.storage.get_list(major).values()
else:
values = self.storage.get_values()
print "{} We just opened {} for you.".format(
self._app_string(),
colored.yellow(self.platform.open(choice(values)))
)
def execute(self):
args = clint.Args()
command = args.get(0)
major = args.get(1)
minor = args.get(2)
if not command:
return self.overview()
self.delegate(command, major, minor)
def delegate(self, command, major, minor):
if command == 'all':
return self.all()
elif command == 'help' or command[0] == '-':
return self.help()
elif command in ['echo', 'e']:
return self.echo(major, minor)
elif command == 'edit':
return self.edit()
elif command in ['open', 'o']:
return self.open(major, minor)
elif command in ['random', 'rand', 'r']:
return self.random(major)
if self.storage.list_exists(command):
if major == DELETE_OPTION:
return self.delete_list(command)
if not major:
return self.detail_list(command)
if minor != DELETE_OPTION:
if minor:
return self.add_item(command, major, minor)
return self.search_list_for_item(command, major)
if minor == DELETE_OPTION and self.storage.item_exists(major):
return self.delete_item(command, major)
if self.storage.item_exists(command) and not major:
return self.search_items(command)
return self.create_list(command, item_name=major, item_value=minor)
def empty(self):
text = """
You don't have anything yet! To start out, create a new list:
$ bam <list-name>
And then add something to your list!
$ bam <list-name> <item-name> <item-value>
You can then grab your new item:
$ bam <item-name>"""[1:]
print textwrap.dedent(text)
def help(self):
text = """
- bam: help ---------------------------------------------------
bam display high-level overview
bam all show all items in all lists
bam edit edit the bam JSON file in $EDITOR
bam help this help text
bam <list> create a new list
bam <list> show items for a list
bam <list> --delete deletes a list
bam <list> <name> <value> create a new list item
bam <name> copy item's value to clipboard
bam <list> <name> copy item's value to clipboard
bam open <name> open item's url in browser
bam open <list> <name> open all item's url in browser for a list
bam random open a random item's url in browser
bam random <list> open a random item's url for a list in browser
bam echo <name> echo the item's value without copying
bam echo <list> <name> echo the item's value without copying
bam <list> <name> --delete deletes an item
"""
with indent(INDENT):
puts(textwrap.dedent(text))
def __init__(self,player):
Level.__init__(self, player)
self.obstacles = [
[800,20,20,SCREEN_HEIGHT-120],
[200,20,860,SCREEN_HEIGHT-120],
[SCREEN_WIDTH-380,20,400,SCREEN_HEIGHT-220],
[150,20,210,SCREEN_HEIGHT-220],
[700,20,20,SCREEN_HEIGHT-320],
[300,20,760,SCREEN_HEIGHT-320],
[SCREEN_WIDTH-380,20,400,SCREEN_HEIGHT-420],
[200,20,160,SCREEN_HEIGHT-420],
[500,20,20,SCREEN_HEIGHT-520],
[400,20,560,SCREEN_HEIGHT-520],
[SCREEN_WIDTH-330,20,350,SCREEN_HEIGHT-620],
[100,20,210,SCREEN_HEIGHT-620],
[750,20,20,SCREEN_HEIGHT-720],
[200,20,810,SCREEN_HEIGHT-720],
[SCREEN_WIDTH-380,20,400,SCREEN_HEIGHT-820],
[150,20,210,SCREEN_HEIGHT-820],
[100,20,600,SCREEN_HEIGHT-920],
[200,20,740,SCREEN_HEIGHT-920],
]
self.ladders = [
[820,SCREEN_HEIGHT-120,55,100],
[350,SCREEN_HEIGHT-220,55,100],
[710,SCREEN_HEIGHT-320,55,100],
[350,SCREEN_HEIGHT-420,55,100],
[515,SCREEN_HEIGHT-520,55,100],
[305,SCREEN_HEIGHT-620,55,100],
[755,SCREEN_HEIGHT-720,55,100],
[355,SCREEN_HEIGHT-820,55,100],
[695,SCREEN_HEIGHT-920,55,100],
[800,SCREEN_HEIGHT-220,55,30],
[800,SCREEN_HEIGHT-160,55,20],
[800,SCREEN_HEIGHT-620,55,30],
[800,SCREEN_HEIGHT-560,55,20]
]
L = [self.level[0],self.level[2]]
for platform in L:
k = platform[3]
for i in range(platform[1]/16):
block = Platform()
block.rect.x = platform[2]
block.rect.y = k
self.platform_list.add(block)
k+=16
__level = [self.level[1],self.level[3]]
for i in self.obstacles:
__level.append(i)
for platform in __level:
__k = platform[2]
for i in range(platform[0]/16):
block = Platform()
block.rect.x = __k
block.rect.y = platform[3]
block.player = self.player
self.platform_list.add(block)
__k+=16
for ladder in self.ladders:
block = Ladders(ladder[2],ladder[3])
block.rect.x = ladder[0]
block.rect.y = ladder[1]
self.ladder_list.add(block)
def __init__(self, conf): Platform.__init__(self, "local", conf)
def createSprite(self,lines, j, i, character):
self.stageScale = 50
# Para que player aparezca en esquina superior izquierda
x = self.stageScale * (j)
y = self.stageScale * (i)
sprite = Platform()
sprite.i = i
sprite.j = j
if character == "a":
sprite.image = self.imageDictionary["topCement"]
sprite.imagen2 = self.imageDictionary["topCement"]
elif character == "t":
sprite.image = self.imageDictionary["lowEarth"]
sprite.imagen2 = self.imageDictionary["lowEarth"]
elif character == "b":
sprite.image = self.imageDictionary["water"]
sprite.imagen2 = self.imageDictionary["watert"]
sprite.color = "Blue"
elif character == "l":
sprite.image = self.imageDictionary["lavat"]
sprite.imagen2 = self.imageDictionary["lavat"]
elif character == "s":
sprite.image = self.imageDictionary["sand"]
sprite.imagen2 = self.imageDictionary["sand"]
elif character == "w":
sprite.image = self.imageDictionary["watert"]
sprite.imagen2 = self.imageDictionary["watert"]
elif character == 'r':
sprite.image = self.imageDictionary["lava"]
sprite.imagen2 = self.imageDictionary["lava"]
#sprite.color = "Green"
elif character == "O":
sprite.image = self.imageDictionary["water"]
sprite.imagen2 = self.imageDictionary["watert"]
sprite.color = "Blue"
elif character == "P":
sprite.image = self.imageDictionary["lava"]
sprite.imagen2 = self.imageDictionary["lavat"]
sprite.color = "Green"
elif character == "Q":
sprite.image = self.imageDictionary["water"]
sprite.imagen2 = self.imageDictionary["watert"]
sprite.color = "Blue"
elif character == "F":
sprite.image = self.imageDictionary["lava"]
sprite.imagen2 = self.imageDictionary["lavat"]
sprite.color = "Green"
else:
sprite.image = self.imageDictionary["lava"]
sprite.imagen2 = self.imageDictionary["lavat"]
sprite.color = "Green"
if character == "P" or character == "O":
colorlargo = self.createPlatform(lines,j,i,"H")
color = colorlargo[0]
scale_x = colorlargo[1]
scale_y = colorlargo[2]
sprite.color = color
#scale = 2
x = self.stageScale * (j)
y = self.stageScale * (i)
sprite.scale_x = scale_x
sprite.scale_y = scale_y
sprite.x_scale = self.stageScale *scale_x
sprite.y_scale = self.stageScale*scale_y
sprite.image = pygame.transform.scale(sprite.image, (int(scale_x*self.stageScale), int(scale_y*self.stageScale)))
sprite.imagen2 = pygame.transform.scale(sprite.imagen2, (int(scale_x*self.stageScale), int(scale_y*self.stageScale)))
sprite.rect = pygame.Rect((x, y), (scale_x*self.stageScale, scale_y*self.stageScale))
sprite.imagenoriginal = sprite.image
elif character == "F" or character == "Q":
sprite.x_scale = self.stageScale
sprite.y_scale = self.stageScale
sprite.image = pygame.transform.scale(sprite.image, (int(0.5*self.stageScale), 5*self.stageScale))
sprite.imagen2 = pygame.transform.scale(sprite.imagen2, (int(0.5*self.stageScale), 5*self.stageScale))
sprite.rect = pygame.Rect((x, y), (int(0.5*self.stageScale), 5*self.stageScale))
sprite.imagenoriginal = sprite.image
if character == "F":
sprite.color = "Green"
elif character == "Q":
sprite.color = "Blue"
else:
sprite.x_scale = self.stageScale
sprite.y_scale = self.stageScale
sprite.image = pygame.transform.scale(sprite.image, (self.stageScale, self.stageScale))
sprite.imagen2 = pygame.transform.scale(sprite.imagen2, (self.stageScale, self.stageScale))
sprite.rect = pygame.Rect((x, y), (self.stageScale, self.stageScale))
sprite.imagenoriginal = sprite.image
# Define rectangulos que serviran para delimitar etapa y limitar movimiento de la camara
if i == 0 and j == 0:
self.firstRect = pygame.Rect((x, y), (self.stageScale, self.stageScale))
elif i == (self.height - 1) and j == (self.width - 1):
self.lastRect = pygame.Rect((x, y), (self.stageScale, self.stageScale))
sprite.colororiginal = sprite.color
self.group.add(sprite);
def __init__(self, numchannels, numantpol, accumulation_length, skybandwidth, input_bitwidth, fft_out_bitwidth):
self.blocks = {}
self.totalblocks = 0
self.maxdesigns = 1
self.singleimplementation = 1
self.windowsize = 1024
cost = 'dollars'
#cost = 'power'
#add the platforms
self.platforms = {}
#self.platforms['GTX580'] = Platform.createGTX580Server(cost)
#self.platforms['ROACH'] = Platform.createRoach(cost)
self.platforms['DualGTX690'] = Platform.createDualGTX690Server(cost)
self.platforms['ROACH2'] = Platform.createRoach2(cost)
# add the ADC
adc_bw = skybandwidth*2*input_bitwidth
#self.blocks['ADC'] = CBlock('ADC',CBlock.getADCModel(self.platforms, skybandwidth, input_bitwidth),-1,0,0,'FIR',0,4*adc_bw,numantpol/4)
# we are using a 16 input adc board
# multiplier needs to be a multiple of 4 because the benchmarks do 4 parallel firs and ffts
adcmultiplier = 4 # process 4 streams at a time
self.blocks['ADC'] = CBlock('ADC',CBlock.getADCModel(self.platforms, skybandwidth, input_bitwidth), -1,0,0,'PFB',0,adcmultiplier*adc_bw,numantpol/adcmultiplier, CBlock.getADCMaximums(self.platforms, adcmultiplier))
self.totalblocks += numantpol/adcmultiplier
#use pfb to process 4 channels at a time
fft_out_bandwidth = skybandwidth * 2 * fft_out_bitwidth
pfb_model = CBlock.getPFBModel(self.platforms, skybandwidth, input_bitwidth, numchannels)
fft_model = CBlock.getFFTRealModel(self.platforms, skybandwidth, numchannels)
firfftmodel = CBlock.combineModels(pfb_model, fft_model)
#print firfftmodel
#firfft2xmodel = CBlock.combineModels(firfftmodel, firfftmodel)
#print firfft2xmodel
self.blocks['PFB'] = CBlock('PFB',firfftmodel,'ADC',0,adcmultiplier*adc_bw,'Transpose',0,adcmultiplier*fft_out_bandwidth,numantpol/adcmultiplier)
self.totalblocks += numantpol/adcmultiplier
transposemodel = CBlock.getTransposeModel(self.platforms, skybandwidth, numchannels, self.windowsize)
self.blocks['Transpose'] = CBlock('Transpose',transposemodel,'PFB',0,adcmultiplier*fft_out_bandwidth,'XEng',0,adcmultiplier*fft_out_bandwidth,numantpol/adcmultiplier)
self.totalblocks += numantpol/adcmultiplier
# add the PFBTranspose
#fft_out_bandwidth = skybandwidth * 2 * fft_out_bitwidth
#firmodel = CBlock.getPFBModel(self.platforms, skybandwidth, input_bitwidth, numchannels)
#fftmodel = CBlock.getFFTRealModel(self.platforms, skybandwidth, numchannels)
#transposemodel = CBlock.getTransposeModel(self.platforms, skybandwidth, numchannels, self.windowsize)
#combinedmodel = CBlock.combineModels(firmodel, CBlock.combineModels(fftmodel, transposemodel))
#we need 4 of these for our 16 input adc
#self.blocks['PFBTranspose'] = CBlock('PFBTranspose',combinedmodel,'ADC',0,adcmultiplier*adc_bw,'XEng',1,adcmultiplier * fft_out_bandwidth,numantpol/adcmultiplier)
#self.totalblocks += numantpol/adcmultiplier
# add the XEngines
gtx580_max_bw = {32:0.06914, 64:0.03095, 96:0.01748, 128:0.01069, 192:0.00536, 256:0.00318, 512:0.00087, 1024:0.00023}
# the minimum number of xengines we need
# if we use any fewer, they will not fit on the gpu
mingpuxengines = int(numpy.power(2,numpy.ceil(numpy.log2(skybandwidth/gtx580_max_bw[numantpol]))))
# assume xengine is running at 200MHz, takes nantpol clock cycles to get the data out for a single frequency channel
# maximum bandwidth it can process is 200MHz/nantpol
maxfpgaxengbw = .2/numantpol
#the maximum amount of bandwidth we can process in an xengine and still support our platforms
maxxenginebw = min(maxfpgaxengbw,gtx580_max_bw[numantpol])
# we need to create this many xengines to meet the spec
minxengines = int(skybandwidth/maxxenginebw)
#note: this needs to be a power of 2
numxengines = 8*minxengines
#numxengines = 4*mingpuxengines
#print 'Num xengines is: ' + `numxengines`
#numxengines = mingpuxengines*4
xengine_sky_bandwidth = skybandwidth/numxengines
#print 'Sky bw is: ' + `xengine_sky_bandwidth`
#print xengine_sky_bandwidth
xengine_in_bandwidth = numantpol*fft_out_bandwidth/numxengines
#print CBlock.getXEngModel(self.platforms, xengine_sky_bandwidth, numantpol)
self.blocks['XEng'] = CBlock('XEng',CBlock.getXEngModel(self.platforms, xengine_sky_bandwidth, numantpol) ,'Transpose', 1,xengine_in_bandwidth,-1,0,0,numxengines)
self.totalblocks += numxengines
def __init__(self, *args, **kwargs):
self.storage = DataStore()
self.platform = Platform()
def main():
screen = display.set_mode(WIN_SIZE)
display.set_caption('ARCANOID')
bg = Surface(WIN_SIZE)
bg.fill((100,100,200))
win = image.load('Spr/win.png')
boll = Boll(500, 300)
pl = Platform(500, 500)
bricks = [
[0, 1, 2, 3, 0, 1, 2, 3, 0, 1],
[1, 2, 3, 0, 1, 2, 3, 0, 1, 2],
[2, 3, 0, 1, 2, 3, 0, 1, 2, 3],
[3, 0, 1, 2, 3, 0, 1, 2, 3, 0],
[0, 1, 2, 3, 0, 1, 2, 3, 0, 1],
[1, 2, 3, 0, 1, 2, 3, 0, 1, 2],
[2, 3, 0, 1, 2, 3, 0, 1, 2, 3],
[3, 0, 1, 2, 3, 0, 1, 2, 3, 0],
[0, 1, 2, 3, 0, 1, 2, 3, 0, 1],
[1, 2, 3, 0, 1, 2, 3, 0, 1, 2],
]
left = right = reboot =False
timer = pygame.time.Clock()
count = True
while count:
timer.tick(60)
for e in event.get():
if e.type == QUIT:
count = False
if e.type == KEYDOWN and e.key == K_LEFT:
left = True
if e.type == KEYDOWN and e.key == K_RIGHT:
right = True
if e.type == KEYUP and e.key == K_LEFT:
left = False
if e.type == KEYUP and e.key == K_RIGHT:
right = False
if e.type == KEYDOWN and e.key == K_r:
reboot = True
bricks = [
[0, 1, 2, 3, 0, 1, 2, 3, 0, 1],
[1, 2, 3, 0, 1, 2, 3, 0, 1, 2],
[2, 3, 0, 1, 2, 3, 0, 1, 2, 3],
[3, 0, 1, 2, 3, 0, 1, 2, 3, 0],
[0, 1, 2, 3, 0, 1, 2, 3, 0, 1],
[1, 2, 3, 0, 1, 2, 3, 0, 1, 2],
[2, 3, 0, 1, 2, 3, 0, 1, 2, 3],
[3, 0, 1, 2, 3, 0, 1, 2, 3, 0],
[0, 1, 2, 3, 0, 1, 2, 3, 0, 1],
[1, 2, 3, 0, 1, 2, 3, 0, 1, 2],
]
if e.type == KEYUP and e.key == K_r:
reboot = False
screen.blit(bg, (0, 0))
win_count = 0
x = y = 0
for row in bricks:
for col in row:
if col != 4:
br = Brick(x+BOLL_D, y+BOLL_D, col)
br.draw(screen)
win_count = 1
x += BRICK_WIDTH
y += BRICK_HEIGHT
x = 0
boll.update(bricks, pl, reboot)
if not win_count:
boll.dx = 0
boll.dy = 0
boll.draw(screen)
if not win_count:
screen.blit(win, (0, 0))
pl.update(left, right, reboot)
pl.draw(screen)
display.update()
def CheckCollision(self, player, group, x1, y1):
newPos = pygame.Rect(x1, y1, player.sprite.rect.width, player.sprite.rect.height)
playerMoved = pygame.sprite.Sprite()
playerMoved.rect = newPos
spriteListaux = pygame.sprite.spritecollide(playerMoved, group, False)
self.spriteList = spriteListaux
if len(spriteListaux) >= 1:
for sprite in spriteListaux:
if sprite.color == player.color or sprite.color == "Todos" or sprite.activada :
rect = sprite.rect
self.topY = rect.top
self.bottomY = rect.top + rect.height
self.rightX = rect.left + rect.width
self.leftX = rect.left
if sprite.color == player.color:
sprite.activada = True
player.colisionada = sprite
return True
elif sprite.activada == False and sprite.tipo =="Color":
companeroPos = pygame.Rect(player.companero.X, player.companero.Y+1, player.companero.sprite.rect.width, player.companero.sprite.rect.height)
companeroMoved = Platform()
companeroMoved.color = player.companero.color
companeroMoved.rect = companeroPos
if companeroMoved.color == sprite.color and pygame.sprite.collide_rect(sprite,companeroMoved):
rect = sprite.rect
self.topY = rect.top
self.bottomY = rect.top + rect.height
self.rightX = rect.left + rect.width
self.leftX = rect.left
sprite.activada = True
player.colisionada = sprite
return True
else:
sprite.activada = False
companeroPos = pygame.Rect(player.companero.X+1, player.companero.Y, player.companero.sprite.rect.width, player.companero.sprite.rect.height)
companeroMoved = Platform()
companeroMoved.color = player.companero.color
companeroMoved.rect = companeroPos
if companeroMoved.color == sprite.color and pygame.sprite.collide_rect(sprite,companeroMoved):
rect = sprite.rect
self.topY = rect.top
self.bottomY = rect.top + rect.height
self.rightX = rect.left + rect.width
self.leftX = rect.left
sprite.activada = True
player.colisionada = sprite
return True
else:
sprite.activada = False
companeroPos = pygame.Rect(player.companero.X-1, player.companero.Y+1, player.companero.sprite.rect.width, player.companero.sprite.rect.height)
companeroMoved = Platform()
companeroMoved.color = player.companero.color
companeroMoved.rect = companeroPos
if companeroMoved.color == sprite.color and pygame.sprite.collide_rect(sprite,companeroMoved):
rect = sprite.rect
self.topY = rect.top
self.bottomY = rect.top + rect.height
self.rightX = rect.left + rect.width
self.leftX = rect.left
sprite.activada = True
player.colisionada = sprite
return True
else:
sprite.activada = False
sprite.activada = False
return False
else:
return False
