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)
