async def run_spaceship(canvas, spaceship_frame, coroutines, obstacles, obstacles_collisions, years, timeout, row, column): assert all(i >= 0 for i in (row, column, timeout)), AssertionError( "row, column and timeout have to be non-negative") assert bool(years), AssertionError( "Years has to be initiated with int value.") height, width = canvas.getmaxyx() row_speed = 0 column_speed = 0 # "spinlock" waiting for updating spaceship_frame while not spaceship_frame: await asyncio.sleep(0) frame, rocket_height, rocket_width = spaceship_frame draw_frame(canvas, row, column, frame) while True: collisions = set( filter(lambda o: o.has_collision(row, column), obstacles)) if collisions: obstacles_collisions.update(collisions) draw_frame(canvas, row, column, frame, negative=True) await explode(canvas, row, column) coroutines.append(get_game_over(canvas)) spaceship_frame[0] = None return # handle a user control row_shift, col_shift, space = read_controls(canvas) draw_frame(canvas, row, column, frame, negative=True) row_speed, column_speed = update_speed(row_speed, column_speed, row_shift, col_shift) # keep rocket in borders row = calc_location(row + row_speed, height - rocket_height - 1) column = calc_location(column + column_speed, width - rocket_width - 1) # shoot if space and years[0] >= 2020: coroutines.append( fire(canvas, obstacles, obstacles_collisions, row - 1, column + 2, -2)) frame, rocket_height, rocket_width = spaceship_frame draw_frame(canvas, row, column, frame) await asyncio.sleep(0)
def generatefire(self): if self.__level==1: level = level01() layout = level.getLayout() img_list = level.getSprites() elif self.__level ==2 : level = level02() layout = level.getLayout() img_list = level.getSprites() centerPoint = [108,180] self.fire = fire(centerPoint,img_list[level.FIRE]) self.firelist.append(pygame.sprite.RenderPlain(self.fire))
def loadsprite(self): x_offset = (BRICKSIZE/2) y_offset = (BRICKSIZE/2) if self.__level == 1 : level = level01() layout = level.getLayout() img_list = level.getSprites() elif self.__level ==2 : level = level02() layout = level.getLayout() img_list = level.getSprites() self.brick_sprites = pygame.sprite.Group() self.coin_sprites = pygame.sprite.Group() self.ladder_sprites = pygame.sprite.Group() self.brokenladder_sprites = pygame.sprite.Group() for y in xrange(len(layout)): for x in xrange(len(layout[y])): centerPoint = [(x*BRICKSIZE)+x_offset,(y*BRICKSIZE+y_offset)]#calculated centerpoint becoz we have to place the center exactly on the position of matrix if layout[y][x]==level.BRICK: brick = Sprite(centerPoint, img_list[level.BRICK]) self.brick_sprites.add(brick) elif layout[y][x]==level.PLAYER: self.player = player(centerPoint,img_list[level.PLAYER]) elif layout[y][x]==level.COIN: coin = Sprite(centerPoint, img_list[level.COIN]) self.coin_sprites.add(coin) elif layout[y][x]==level.LEFT_LADDER : ladder = Sprite(centerPoint , img_list[level.LEFT_LADDER]) self.ladder_sprites.add(ladder) elif layout[y][x]==level.RIGHT_LADDER : ladder = Sprite(centerPoint , img_list[level.RIGHT_LADDER]) self.ladder_sprites.add(ladder) elif layout[y][x] == level.TANK: self.tank = Sprite(centerPoint,img_list[level.TANK]) elif layout[y][x] == level.MONSTER : self.monster = monster(centerPoint,img_list[level.MONSTER]) elif layout[y][x] == level.FIRE : self.fire = fire(centerPoint,img_list[level.FIRE]) elif layout[y][x] == level.QUEEN : self.queen = Sprite(centerPoint , img_list[level.QUEEN]) elif layout[y][x] == level.BROKENLADDERLEFT : self.broke = Sprite(centerPoint , img_list[level.BROKENLADDERLEFT]) self.brokenladder_sprites.add(self.broke) elif layout[y][x] == level.BROKENLADDERRIGHT : self.broke = Sprite(centerPoint , img_list[level.BROKENLADDERRIGHT]) self.brokenladder_sprites.add(self.broke) self.player_sprites = pygame.sprite.RenderPlain(self.player) self.monster_sprites = pygame.sprite.RenderPlain(self.monster) self.firelist.append(pygame.sprite.RenderPlain(self.fire)) self.tank_sprites = pygame.sprite.RenderPlain(self.tank) self.queen_sprites = pygame.sprite.RenderPlain(self.queen)
def create_pokemon(self): health = random.randint(70, 100) speed = random.randint(1, 10) element = self.pokemon_elements[random.randint( 0, len(self.pokemon_elements) - 1)] name = self.pokemon_names[random.randint(0, len(self.pokemon_names) - 1)] if element == "FIRE": pokemon = fire(name, element, health, speed) elif element == "WATER": pokemon = water(name, element, health, speed) else: pokemon = grass(name, element, health, speed)
async def animate_spaceship(canvas, row, column, frames): shots = [] height, width = curses_tools.get_frame_size(frames[0]) for frame in itertools.cycle(frames): row, column, space_pressed = get_ship_coordinates( canvas, row, column, frame) curses_tools.draw_frame(canvas, row, column, frame) if space_pressed and state.shotgun_enabled: shots.append(fire(canvas, row, column + 2, rows_speed=-0.5)) shots = animate_fire(canvas, shots) await asyncio.sleep(0) curses_tools.draw_frame(canvas, row, column, frame, negative=True) for obstacle in state.obstacles: if obstacle.has_collision(row, column, obj_size_rows=height, obj_size_columns=width): state.obstacles_in_last_collisions.append(obstacle) raise GameOverException()
def display_room(beginning): room = beginning if room == "start": clear() room = start() display_room(room) elif room == "initial_room": clear() room = initial_room() display_room(room) elif room == "cabin": clear() room = cabin() display_room(room) elif room == "outside": clear() room = outside() display_room(room) elif room == "garden": clear() room = garden() display_room(room) elif room == "woods": clear() room = woods() display_room(room) elif room == "fire": clear() room = fire() display_room(room) elif room == "upstairs": clear() room = upstairs() display_room(room) elif room == "sleep": clear() room = sleep() display_room(room) elif room == "end": clear() print("Ok, goodbye!")
def draw(canvas, stars_count): max_y, max_x = canvas.getmaxyx() canvas.nodelay(True) rocket_frames = get_frames_from_files(('frame_1.txt', 'frame_2.txt')) coroutine_fire = fire(canvas, max_y / 2, max_x / 2, columns_speed=0) coroutine_ship = animate_spaceship(canvas, 20, 20, rocket_frames) coroutines = [ blink(canvas, randint(1, max_y - 1), randint(1, max_x - 1), choice('+*.:'), randint(1, 5)) for _ in range(stars_count) ] coroutines.append(coroutine_fire) coroutines.append(coroutine_ship) canvas.border() curses.curs_set(False) while coroutines: for coroutine in coroutines: try: coroutine.send(None) canvas.refresh() except StopIteration: coroutines.remove(coroutine) time.sleep(TIC_TIMEOUT)
def play_the_game(canvas, tic): assert tic > 0, AssertionError("Tic interval has to be more that 0") border = ord('|') height, width = canvas.getmaxyx() # number of starts covers 4% of canvas square num_stars = round(height * width * 0.04) # stars coroutines = list(get_stars(canvas, num_stars)) # explosion coroutines.append(fire(canvas, height // 2, width // 2)) # rocket coroutines.append(get_rocket(canvas, 1)) # canvas stuff canvas.border(border, border) curses.curs_set(False) canvas.nodelay(True) # loop while coroutines: for i, coroutine in enumerate(coroutines): try: if coroutine is None: continue coroutine.send(None) except StopIteration: coroutines[i] = None canvas.refresh() time.sleep(tic)
X_array = X.toarray() genes = np.arange(1, X_array.shape[1] + 1) datasave = "output_68k" dao.create_folder(datasave) preprocessedData, selGenes = pp.ranger_preprocess(X_array, genes, optionToSave=False, dataSave=datasave) pickle.dump(preprocessedData, open("./output_68k/preprocessedData.p", "wb")) pickle.dump(selGenes, open("./output_68k/selGenes.p", "wb")) import fire predictions, scores, duration = fire.fire(preprocessedData) pickle.dump(predictions, open("./output_68k/predictions_{}.p".format(method), "wb")) pickle.dump(scores, open("./output_68k/scores_{}.p".format(method), "wb")) from MulticoreTSNE import MulticoreTSNE as TSNE t0 = time.time() tsne = TSNE(n_jobs=16, random_state=1) X_embedded = tsne.fit_transform(preprocessedData) t1 = time.time() durationTsne = round(t1 - t0, ndigits=4) print("Total running tsne time is :" + str(durationTsne) + " s") pickle.dump(X_embedded, open("./output_68k/X_embedded.p", "wb"))
def run(second): print(second) second = int(second) return fire(second)
def main_probe_loc_feat(): fire.fire(download_probe_localization_features)
def make_fire(size=100, dob0=10, steps=100, max_size=300): """ 1. setup 1. Make initial grid... """ DOBS = np.zeros(max_size+100) xs = np.zeros(max_size+100) ys =np.zeros(max_size+100) tree, burning, space = 1,2,0 neighbourhood = np.array(((-1,-1), (-1,0), (-1,1), (0,-1), (0, 1), (1,-1), (1,0), (1,1))) neighbourhood = np.array(( (-1,0), (0,-1), (0, 1), (1,0), )) # do setup stuff #grid = np.zeros((xSize, ySize,)).astype(np.int) l0 = np.random.randint(0,2,size=(size,size)).astype(np.int) # do some smoothing on it to make it more realistic... #import pdb; pdb.set_trace() l0 = scipy.ndimage.filters.median_filter(l0, 5).astype(np.int) l0 = scipy.ndimage.filters.median_filter(l0, 5).astype(np.int) #init = l0.copy() #import pdb; pdb.set_trace() #l0 = np.ones((size, size,)).astype(np.int) """ 2. Seed fire in a vegetation location """ idx = np.where(l0==1)[0] idy = np.where(l0==1)[1] #import pdb; pdb.set_trace() if idx.shape[0] == 0: # no trees for some reason return 'what' x0 = idx[np.random.randint(1,idx.shape[0])] y0 = idy[np.random.randint(1,idy.shape[0])] l0[x0,y0] = 2 """ Some constants to add randomness """ f = 0.97 sto = [] """ 3. Run simulation for timesteps """ fails = 0 burnt_count = 0 doy = dob0 # start at 10 lt = l0.copy() test = np.empty(4, dtype=np.bool_) for t in xrange(35): if burnt_count <= max_size: for x in range(1, size-1): for y in range(1, size-1): # check if cell is burning if l0[x,y] == burning: lt[x,y] = space elif l0[x,y] == space: lt[x,y] = space # keep as space... elif l0[x,y] == tree: # check if a neighbour is burning #import pdb; pdb.set_trace() for i in xrange(4): # check neighbours #import pdb; pdb.set_trace() dx = neighbourhood[i][0] dy = neighbourhood[i][1] test[i] = l0[(x+dx,y+dy)] == burning if np.any(test): # a neighbour is burning.. if np.random.random() < f: lt[x,y] = burning # store out to arrays... # vary up and down day a bit... DOBS[burnt_count] = doy + np.random.randint(-1,2) xs[burnt_count] =x ys[burnt_count] =y burnt_count += 1 #print burnt_count else: # what about burning after a day? #delayed_burn.append((x,y)) lt[x,y] = space # sort out cells that are meant to have been # burnt in the last time step... # idea set to burning again? #if len(delayed_burn) > 0: #xx,yy = delayed_burn.pop() #lt[(xx,yy)] = burning # after each iteration re-assign grid... #print t doy +=1 #import pdb; pdb.set_trace() l0 = lt.copy() #sto.append(lt) # check seeding worked properly # burned area should increase each time right... #if abs(l0.sum() - lt.sum()) == 0: # fails += 1 #if fails > 20: # # return what you'ev got # #print 'here' # #raise FireIssue("algorithm failed") # #raise SeedError("Seeding has failed...") return fire(DOBS, xs, ys)
player.nextPlayer() if event.key == pygame.K_d: if player.movesLeft>0 and active["x"]>init.gameSize["x"]: player.movesLeft-=1 active["x"]+=10 active["y"]=tanks.findHeight(active["x"]) if event.key == pygame.K_a: if player.movesLeft>0 and active["x"]<init.gameSize["width"]: player.movesLeft-=1 active["x"]-=10 active["y"]=tanks.findHeight(active["x"]) if event.key ==pygame.K_SPACE: fire.fire(active['x']+100,active['y'],interface.attack,player.angle,player.power) player.nextPlayer() if tanks.checkEnd: endgame.endGame() init.surface.fill(colors.BLACK) mapDraw.gameFrame() mapDraw.drawMap() for team in tanks.tanks: for tank in team: if tank==active: tanks.drawTank(tank,player.angle) else: tanks.drawTank(tank)
import pygame, sys, time, random from pygame.locals import * from ship import ship from fire import fire from fireball import fireball from enemy import enemy from ball import ball ufo = ship() fye = fire() bal = fireball() kill = enemy() fie = ball() FPS = 100 WHITE = (250, 250, 250) fpsClock = pygame.time.Clock() def update_ship(): DISPLAYSURF.blit(ufo.image, ufo.rect) def update_fire(): DISPLAYSURF.blit(fye.imgae, ufo.rect) def update_fireball(): DISPLAYSURF.blit(bal.imgae, bal.rect) def update_enemy():
# !/usr/bin/env python3 import os from glob import glob import fire def generate_seg_script(filepattern, model, out_seg_dir, out_script_file): # spm_encode --model =./ xxx.model - -output_format = piece <./ file_0_0.txt >./ file_0_0_seg.txt script_file = out_script_file outdir = out_seg_dir os.makedirs(outdir, exist_ok=True) infiles = glob(filepattern) cmd_list = [] for infile in infiles: outfile = os.path.join(outdir, os.path.basename(infile)) cmd = 'spm_encode --model={} --output_format=piece <{} >{}'.format( model, infile, outfile) cmd_list.append(cmd) with open(script_file, 'w') as f: f.write('\n'.join(cmd_list)) if __name__ == '__main__': fire.fire()
def play_the_game(canvas_init, tic, print_obstacles=False): assert tic > 0, AssertionError("Tic interval has to be more that 0") border = ord('|') # set main canvas height_init, width_init = canvas_init.getmaxyx() canvas = canvas_init.derwin(height_init - 2, width_init, 0, 0) height, width = canvas.getmaxyx() # set years canvas canvas_year = canvas_init.derwin(height_init - 1, 0) # number of starts covers 4% of canvas square num_stars = round(height * width * 0.04) coroutines = [] # obstacles obstacles = set() obstacles_collisions = set() years = [1957] # fill coroutines # years coroutines.append(years_increment(years)) coroutines.append(show_years(canvas_year, years)) # stars coroutines.extend(list(get_stars(canvas, num_stars))) # rocket coroutines.extend( get_rocket_handlers(canvas, coroutines, obstacles, obstacles_collisions, years, 1)) # garbage handler coroutines.append( fill_orbit_with_garbage(canvas, coroutines, obstacles, obstacles_collisions, years)) # print garbage borders if print_obstacles: coroutines.append(show_obstacles(canvas, obstacles)) # explosion coroutines.append( fire(canvas, obstacles, obstacles_collisions, height // 2, width // 2)) # canvas stuff canvas.keypad(True) canvas.border(border, border) curses.curs_set(False) canvas.nodelay(True) # loop while coroutines: for i, coroutine in enumerate(coroutines): try: coroutine.send(None) except StopIteration: coroutines.pop(i) canvas.refresh() canvas_year.refresh() time.sleep(tic)
#!/usr/bin/env python3 from fire import Fire as fire from easyAccess import webApp def main(host='0.0.0.0', port=2580, debug=True): webApp.run(host=host, port=port, debug=debug) if __name__ == '__main__': fire(main)
from human import human from scissors import scissors from fire import fire state = True while state: player_element = input() player_element.lower() pc_element = random.randint(1, 9) if player_element == "камень" or player_element == "stone": stone(pc_element) if player_element == "пистолет" or player_element == "gun": gun(pc_element) if player_element == "вода" or player_element == "water": water(pc_element) if player_element == "воздух" or player_element == "air": air(pc_element) if player_element == "бумага" or player_element == "paper": paper(pc_element) if player_element == "губка" or player_element == "sponge": sponge(pc_element) if player_element == "человек" or player_element == "human": human(pc_element) if player_element == "ножницы" or player_element == "scissors": scissors(pc_element) if player_element == "огонь" or player_element == "fire": fire(pc_element) if player_element == "выход" or player_element == "exit": break
import sys #import time #import numpy as np # from header import header from montecarlo import montecarlo from fire import fire from control import control effect = "" try: effect = sys.argv[1] except IndexError: print("") # Initialize Pixels num_pixels, pixels = header(300) if (effect == "montecarlo"): montecarlo(num_pixels, pixels) elif (effect == "fire"): fire(num_pixels, pixels) elif (effect == "control"): control(num_pixels, pixels)