def __init__(self, screen, game):
self.textBox1 = pygame.Surface((100, 250))
self.textBox1.fill( yellow )
self.textBox2 = pygame.Surface((300, 100))
self.textBox2.fill( yellow )
self.playerkeys = 0
#for displaying messages or menus
self.screen = screen
self.invItems = []
self.frameBox1, r = load_image("hudBox1.bmp",-1)
self.frameBox2, r = load_image("hudBox2.bmp",-1)
self.weaponImg = range(4)
self.weaponImg[0], r = load_image("sword.bmp",-1)
self.armorImg = range(3)
self.armorImg[0], r = load_image("bplate.bmp",None)
self.armorImg[2], r = load_image("shield.bmp",None)
self.scrollText = ['']*3
self.game = game
self.gameBoard = game.gameBoard
self.On = True
def train(**kwargs):
cfg = Config()
for k, v in kwargs.items():
setattr(cfg, k, v)
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
content = load_image(cfg.content, transform, max_size=cfg.max_size)
style = load_image(cfg.style,
transform,
shape=[content.size(3),
content.size(2)])
target = Variable(content.clone(), requires_grad=True)
optimizer = torch.optim.Adam([target], lr=cfg.lr, betas=[0.5, 0.999])
vgg = VGGNet()
if cfg.use_gpu:
vgg.cuda()
for step in range(cfg.total_step):
target_features = vgg(target)
content_features = vgg(Variable(content))
style_features = vgg(Variable(style))
style_loss = 0
content_loss = 0
for f1, f2, f3 in zip(target_features, content_features,
style_features):
# Compute content loss
content_loss += torch.mean((f1 - f2)**2)
_, c, h, w = f1.size()
f1 = f1.view(c, h * w)
f3 = f3.view(c, h * w)
# Compute gram matrix
f1 = torch.mm(f1, f1.t())
f3 = torch.mm(f3, f3.t())
style_loss += torch.mean((f1 - f3)**2) / (c * h * w)
loss = content_loss + cfg.style_weight * style_loss
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (step + 1) % cfg.log_step == 0:
print('Step [%d/%d], Content Loss: %.4f, Style Loss: %.4f' %
(step + 1, cfg.total_step, content_loss.data[0],
style_loss.data[0]))
if (step + 1) % cfg.sample_step == 0:
denorm = transforms.Normalize((-2.12, -2.04, -1.80),
(4.37, 4.46, 4.44))
img = target.clone().cpu().squeeze()
img = denorm(img.data).clamp_(0, 1)
torchvision.utils.save_image(img, 'output-%d.png' % (step + 1))
def __init__(self):
self.myHero = hero.hero()
self.myMenu = menu.menu()
self.myMap = None
self.levelDepth = 2
# a dungeon is just an array of maps
self.myDungeon = []
for mapFileName in mapList:
self.myDungeon += [map.map(mapFileName)]
self.myMap = self.myDungeon[self.levelDepth]
self.allsprites = pygame.sprite.RenderPlain((self.myHero))
#this is true while player is in a particular game
self.gameOn = True
#this is true while player is in a particular level
self.levelOn = True
self.gameBoard = pygame.Surface( [450,450] )
self.gameFrame, self.gameFrameRect = load_image('gamescreen600.bmp', -1)
self.DIM = DIM
# 0 : camera
# 1 : sword
# 2 : miss
self.sounds = range(3)
self.sounds[0] = pygame.mixer.Sound(os.path.join('SND', 'camera.wav' ))
self.sounds[1] = pygame.mixer.Sound(os.path.join('SND', 'sword1.wav' ))
self.sounds[2] = pygame.mixer.Sound(os.path.join('SND', 'miss.wav' ))
self.myHud = hud.hud(screen, self)
self.myBattle = battle.battle(screen,self.myHud)
def train_epoch(model, sess, train_list, merged):
loss = 0.0
st, ed, times = 0, FLAGS.batch_size, 0
#print(len(train_list))
while st < len(train_list) and ed <= len(train_list):
start_time = time.time()
train_batch = train_list[st:ed]
rg_list = []
black_list = []
encode_list = []
for image_dir in train_batch:
img, img_black = load_image(image_dir, FLAGS.picture_size)
img_encode = naive_encode(img[:, :, 1:], FLAGS.picture_size)
rg_list.append(img[:, :, 1:])
black_list.append(img_black)
encode_list.append(img_encode)
feed = {
model.x_: black_list,
model.y_: rg_list,
model.keep_prob: FLAGS.keep_prob,
model.encode: encode_list,
model.train: True
}
load_time = time.time()
logging.debug("load:" + str(load_time - start_time))
summary, loss_, _ = sess.run([merged, model.loss, model.train_op],
feed)
logging.debug("run:" + str(time.time() - load_time))
loss += loss_
st, ed = ed, ed + FLAGS.batch_size
times += 1
loss /= times
return loss, summary
def __init__(self, left, top, way):
Task.__init__(self)
self.image = load_image("./img/gorem_tama.png", -1)
self.rect.left = left
self.rect.top = top
self.rect.width = self.image.get_rect().width
self.rect.height = self.image.get_rect().height
self.way = way
def __init__(self, filename):
self.image = load_image(filename)
self.rect = self.image.get_rect()
self.images = []
for i in range(self.rect.w / 16):
surface = pygame.Surface((16, 16))
surface.blit(self.image, (0, 0), (16 * i, 0, 16, 16))
surface = surface.convert()
self.images.append(surface)
def __init__(self, filename):
self.image = load_image(filename, -1)
self.rect = self.image.get_rect()
self.images = []
for i in range(self.rect.w / 16):
surface = pygame.Surface((16, 16))
surface.blit(self.image, (0, 0), (16 * i, 0, 16, 16))
if i == 0:
surface.set_colorkey(surface.get_at((0, 0)), RLEACCEL)
surface = surface.convert()
self.images.append(surface)
def __init__(self, screen, hud):
self.battleField = pygame.Surface( (300,300) )
self.battleField.fill( black )
self.images = range(3)
self.screen = screen
self.myMenu = menu.menu()
self.images[0], r = load_image('cursor.bmp')
self.myHud = hud
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(SCR)
pygame.display.set_caption(CAP)
self.clock = pygame.time.Clock()
self.quit = False
self.pause_flag = False
self.pause_image = load_image("./img/pause.png", -1)
x = Tracker.instance().stage.data["x"]
y = Tracker.instance().stage.data["y"]
player_task = Player("./img/robot.png", "./img/robojump.png", x, y)
Tracker.instance().add_task(player_task)
Tracker.instance().player_task = player_task
Tracker.instance().add_task(Boss0Task(180, 160))
ground_task = GroundTask()
Tracker.instance().add_task(ground_task)
Tracker.instance().ground_task = ground_task
Tracker.instance().add_task(CountTask())
self.is_pressed_pause_key = False
self.temp_surface = pygame.Surface((320, 240)).convert()
base_image = load_image("./img/counter.png", -1)
self.base_images = []
for i in range(base_image.get_rect().w / 16):
surface = pygame.Surface((16, 16))
surface.blit(base_image, (0, 0), (16 * i, 0, 16, 16))
surface = surface.convert()
surface.set_colorkey(surface.get_at((0, 0)), RLEACCEL)
self.base_images.append(surface)
import os
for line in open(os.path.join(os.path.dirname(__file__), '../data/highscore.dat'),'r'):
temp = line[:-1].split(':')
self.highscore = temp[0]
self.highstage = temp[1]
self.rect = pygame.Rect(16, 16, 16 * 4, 16)
self.image = pygame.Surface((16 * 4, 16)).convert()
self.image.set_colorkey(self.image.get_at((0, 0)), RLEACCEL)
def titleLoop(self):
titlecount = 0
start_draw_flag = True
titleimage = load_image('./img/title.png', -1)
startimage = load_image('./img/pushstart.png',-1)
subtitleimage = load_image('./img/subtitle.png',-1)
typed_start = False
while not typed_start:
titlecount += 1
if titlecount > 16:
if start_draw_flag:
start_draw_flag = False
else:
start_draw_flag = True
titlecount = 0
game.screen.fill(color_blue)
game.screen.blit(titleimage, (60, 50))
game.screen.blit(subtitleimage, (70, 110))
if start_draw_flag:
game.screen.blit(startimage, (20,200))
tmpSurface = pygame.Surface((320, 240))
tmpSurface.blit(game.screen, (0, 0))
game.screen.blit(pygame.transform.scale(tmpSurface, (640, 480)), (0, 0))
pygame.display.flip()
for event in pygame.event.get():
if (event.type == KEYDOWN and event.key == K_SPACE):
typed_start = True
if event.type == QUIT:
self.quit = True
if (event.type == KEYDOWN and event.key == K_ESCAPE):
self.quit = True
self.clock.tick(60)
return
def __init__(self, player_task):
Task.__init__(self)
self.player_task = player_task
self.image = pygame.Surface((16, 16)).convert()
self.balloon = load_image("./img/balloon.png").convert()
self.image.blit(self.balloon, (0, 0))
self.image.set_colorkey(self.image.get_at((0, 0)), RLEACCEL)
self.rect.left = player_task.rect.left
self.rect.top = player_task.rect.top - self.image.get_rect().height
self.rect.width = self.image.get_rect().width
self.rect.height = self.image.get_rect().height
def __init__(self):
Task.__init__(self)
base_image = load_image("./img/counter.png", -1)
self.base_images = []
for i in range(base_image.get_rect().w / 16):
surface = pygame.Surface((16, 16))
surface.blit(base_image, (0, 0), (16 * i, 0, 16, 16))
surface = surface.convert()
surface.set_colorkey(surface.get_at((0, 0)), RLEACCEL)
self.base_images.append(surface)
self.rect = pygame.Rect(120, 150, 16 * 4, 16)
self.image = pygame.Surface((16 * 4, 16)).convert()
self.image.set_colorkey(self.image.get_at((0, 0)), RLEACCEL)
self.attacked_time = Tracker.instance().attacked_time
def __init__(self, left, top):
Task.__init__(self)
surface = load_image("./img/umb_bullet.png", -1)
self.images = []
for i in range(2):
self.images.append(pygame.Surface((16, 16)))
self.images[i].blit(surface, (0, 0), (i * 16, 0, 16, 16))
self.images[i].set_colorkey(self.images[i].get_at((0, 0)), RLEACCEL)
self.images[i] = self.images[i].convert()
self.image = self.images[0]
self.base_top = top
self.rect.left = left
self.rect.top = top
self.rect.width = self.image.get_rect().width
self.rect.height = self.image.get_rect().height
self.counter = 0
def __init__(self, left, top):
Task.__init__(self)
self.image = load_image("./img/mons_last.png", -1)
self.images = []
self.images.append(pygame.Surface((39, 33)))
self.images[0].blit(self.image, (0, 0), (0, 0, 39, 33))
self.images[0].set_colorkey(self.images[0].get_at((0, 0)), RLEACCEL)
self.images[0] = self.images[0].convert()
self.image = self.images[0]
self.counter = 135
self.is_right = True
self.base_left = left
self.base_top = top
self.rect.left = left
self.rect.top = top
self.rect.width = self.image.get_rect().width
self.rect.height = self.image.get_rect().height
def gameOver(self):
gameoverimage = load_image('./img/gameover.png', -1)
while True:
game.screen.fill(color_blue)
game.screen.blit(gameoverimage, (10, 50))
tmpSurface = pygame.Surface((320, 240))
tmpSurface.blit(game.screen, (0, 0))
game.screen.blit(pygame.transform.scale(tmpSurface, (640, 480)), (0, 0))
pygame.display.flip()
self.clock.tick(60)
for event in pygame.event.get():
if (event.type == KEYDOWN and event.key == K_SPACE):
return
if event.type == QUIT:
self.quit = True
return
if (event.type == KEYDOWN and event.key == K_ESCAPE):
self.quit = True
return
def __init__(self, left, top):
Task.__init__(self)
self.image = load_image("./img/mons_slim.png", -1)
self.images = []
for i in range(2):
self.images.append(pygame.Surface((48, 64)))
self.images[i].blit(self.image, (0, 0), (i * 48, 0, 48, 64))
self.images[i].set_colorkey(self.images[i].get_at((0, 0)), RLEACCEL)
self.images[i] = self.images[i].convert()
self.image = self.images[0]
self.rect.left = left
self.rect.top = top
self.rect.width = self.image.get_rect().width
self.rect.height = self.image.get_rect().height
self.walk_rate = 0
self.walk_flag = False
Tracker.instance().add_task(BossRingTask(self))
def main():
titleScreen = pygame.Surface(screenSize)
titleScreen.fill(black)
titleImg, titleRect = load_image('titlescreen.bmp', -1)
titleScreen.blit(titleImg, (50,50) )
screen.blit(titleScreen, (0,0))
while True:
screen.blit(titleScreen, (0,0))
clock.tick(20)
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
os.sys.exit()
if event.key == pygame.K_SPACE:
newGame = game()
newGame.mainLoop(mapList)
pygame.display.flip()
def valid_epoch(model, sess, valid_list, merged):
loss = 0.0
st, ed, times = 0, 1, 0
index = 0
while st < len(valid_list) and ed <= len(valid_list):
valid_batch = valid_list[st:ed]
rg_list = [
] ## this is the list of picture's a and b in the lab color space
black_list = [
] ## this is the list of picture's l in the lab color space
encode_list = []
for image_dir in valid_batch:
img, img_black = load_image(image_dir, FLAGS.picture_size)
img_encode = naive_encode(img[:, :, 1:], FLAGS.picture_size)
rg_list.append(img[:, :, 1:])
black_list.append(img_black)
encode_list.append(img_encode)
feed = {
model.x_: black_list,
model.y_: rg_list,
model.keep_prob: FLAGS.keep_prob,
model.encode: encode_list,
model.train: False
}
loss_, output = sess.run([model.loss, model.output], feed)
start_time = time.time()
decode_output = naive_decode(output[0], FLAGS.picture_size)
decode_time = time.time()
logging.debug("decode:" + str(decode_time - start_time))
for_display(black_list[0], rg_list[0], decode_output,
"./display/" + str(index))
logging.debug("displaytime:" + str(time.time() - decode_time))
index += 1
loss += loss_
st, ed = ed, ed + 1
times += 1
loss /= times
return loss
def gameplay(time_to_win=60,
hp=5,
weapon_1_time=2,
weapon_2_time=10,
level_of_difficulty=2):
global weapon, launch_time, the_current_time, time_of_1_weapon, time_of_2_weapon, \
count_hp, weapon_1_t, weapon_2_t, hearts, scope_weapon, screen
pause_flag = False
hearts = Hearts(hp)
weapon_1_t = weapon_1_time
weapon_2_t = weapon_2_time
count_hp = hp
secret = Secret()
launch_time = new_time()
all_sprites = pg.sprite.Group()
cursor_sprite = pg.sprite.Group()
laptops = return_laptop_sprite_group()
cursor = Scope(cursor_sprite)
lower_fon = return_lower_fon()
#
scope_weapon = pg.sprite.Sprite()
scope_weapon.image = load_image("scope_weapon.png")
scope_weapon.image = pg.transform.scale(scope_weapon.image, (50, 50))
scope_weapon.rect = scope_weapon.image.get_rect()
lower_fon.add(scope_weapon)
scope_weapon.rect.x = 96
scope_weapon.rect.y = 620
#
bot_interaction_flag = False
background_fon = Fon()
rivals = []
esc = PauseButton(740, 740)
opponent_1, opponent_2, opponent_3 = Enemy(all_sprites, level_of_difficulty, 50, 300), \
Enemy(all_sprites, level_of_difficulty, 300, 300), \
Enemy(all_sprites, level_of_difficulty, 550, 300)
rivals.append(opponent_1)
rivals.append(opponent_2)
rivals.append(opponent_3)
times = clock.tick() / FPS
the_current_time = new_time() - launch_time
while True:
for event in pg.event.get():
try:
if not bot_interaction_flag:
n = event
bot_interaction_flag = True
elif event.type == pg.QUIT:
pg.quit()
sys.exit()
elif event.type == 768:
if event.unicode == '':
if not pause_flag:
pause_flag = True
pause_time = the_current_time
else:
pause_flag = False
launch_time += the_current_time - pause_time
elif event.type == pg.KEYUP and int(
event.unicode) != weapon and not pause_flag:
if event.unicode == '1':
scope_weapon.rect.x = 96
scope_weapon.rect.y = 620
weapon = 1
elif event.unicode == '2':
scope_weapon.rect.x = 100
scope_weapon.rect.y = 730
weapon = 2
elif event.type == pg.MOUSEMOTION:
if event.pos[1] >= 600:
cursor.change_image('cursor.png')
else:
cursor.change_image('scope.png')
cursor.moving_cursor(event.pos)
elif event.type == pg.MOUSEBUTTONDOWN and not pause_flag:
if event.pos[1] < 600:
if weapon == 1:
if (int(weapon_1_t - the_current_time +
time_of_1_weapon)
) <= 0 and event.pos[1] < 300:
time_of_1_weapon = new_time() - launch_time
all_sprites.update(event, weapon=1)
else:
if (int(weapon_2_t - the_current_time +
time_of_2_weapon)) <= 0:
time_of_2_weapon = new_time() - launch_time
all_sprites.update(event, weapon=2)
if event.pos[0] >= 745 and event.pos[1] >= 610 and (
event.pos[0] <= 777 and event.pos[1] <= 652):
hearts.add_hp()
else:
if event.pos[0] <= 170 and event.pos[1] < 700:
scope_weapon.rect.x = 96
scope_weapon.rect.y = 620
weapon = 1
elif event.pos[0] <= 170 and event.pos[1] >= 700:
scope_weapon.rect.x = 100
scope_weapon.rect.y = 730
weapon = 2
except:
pass
secret.draw()
times = clock.tick() / FPS
if not pause_flag and times > 0:
for i in rivals:
i.add_time(times)
background_fon.draw_1_fon()
all_sprites.draw(screen)
background_fon.draw_2_fon()
laptops.draw(screen)
lower_fon.draw(screen)
the_current_time = new_time() - launch_time
if not pause_flag:
draw_time_to_win(int(time_to_win - the_current_time))
draw_time_of_restarting_weapons(
int(weapon_1_t - the_current_time + time_of_1_weapon),
int(weapon_2_t - the_current_time + time_of_2_weapon))
else:
draw_time_to_win(int(time_to_win - pause_time))
draw_time_of_restarting_weapons(
int(weapon_1_t - pause_time + time_of_1_weapon),
int(weapon_2_t - pause_time + time_of_2_weapon))
hearts.draw_hearts()
esc.draw()
if pause_flag:
esc.draw_pause()
if pg.mouse.get_focused():
pg.mouse.set_visible(False)
cursor_sprite.draw(screen)
else:
pg.mouse.set_visible(True)
pg.display.flip()
clock.tick(FPS)
if time_to_win - the_current_time < 0 and not pause_flag:
# возвращаем победу
pg.mouse.set_visible(True)
return win.welcome_window(True)
elif count_hp <= 0:
# возвращаем порожение
pg.mouse.set_visible(True)
return win.welcome_window(False)
def __init__(self):
Task.__init__(self)
self.image = load_image("./img/yourscore.png", -1)
self.rect = pygame.Rect(80, 80, self.image.get_rect().width, self.image.get_rect().height)
def __init__(self, filename, filename2, left, top):
Task.__init__(self)
self.is_jump_upping = False
self.jumping_count = 0
self.base_x = 0
self.last_jump_height = 0
base_images = []
base_images.append(load_image(filename))
base_images.append(load_image(filename2))
self.rect = pygame.Rect(left, top, 0, 0)
self.walk = {}
self.way = Way.right
self.walking = False
self.walkcount = 0
self.is_pressed_bullet_key = False
self.life = 9
surface = pygame.Surface((16, 16))
surface.blit(base_images[0], (0, 0), (0, 0, 16, 16))
surface.set_colorkey(surface.get_at((0, 0)), RLEACCEL)
surface = surface.convert()
self.walk.update({Motion.right_stop:surface})
surface = pygame.Surface((16, 16))
surface.blit(base_images[0], (0, 0), (16, 0, 16, 16))
surface.set_colorkey(surface.get_at((0, 0)), RLEACCEL)
surface = surface.convert()
self.walk.update({Motion.right_move:surface})
surface = pygame.Surface((16, 16))
surface.blit(base_images[0], (0, 0),(0, 16, 16, 16))
surface.set_colorkey(surface.get_at((0, 0)), RLEACCEL)
surface = surface.convert()
self.walk.update({Motion.left_stop:surface})
surface = pygame.Surface((16, 16))
surface.blit(base_images[0], (0, 0), (16, 16, 16, 16))
surface.set_colorkey(surface.get_at((0, 0)), RLEACCEL)
surface = surface.convert()
self.walk.update({Motion.left_move:surface})
surface = pygame.Surface((16, 16))
surface.blit(base_images[1],(0, 0), (0, 0, 16, 16))
surface.set_colorkey(surface.get_at((0, 0)), RLEACCEL)
surface = surface.convert()
self.walk.update({Motion.right_jump:surface})
surface = pygame.Surface((16, 16))
surface.blit(base_images[1], (0, 0), (16, 0, 16, 16))
surface.set_colorkey(surface.get_at((0, 0)), RLEACCEL)
surface = surface.convert()
self.walk.update({Motion.left_jump:surface})
self.image = self.walk[Motion.right_stop]
self.is_pressed_bullet_key = False
self.is_clear = False
self.clear_counter = 0
Tracker.instance().add_task(Balloon(self))
