def regenerate_map(player, map_width, map_height, max_rooms, min_room_size, max_room_size, min_npcs,
max_npcs, colors, entities, floor_number, message_x, message_width, message_height,
preserve_messages=False):
""" Fully resets the game map without closing the window. """
# Reinitialize the tile map
game_map = GameMap(map_width, map_height)
# Remove all entities except the player
entities.clear()
entities.append(player)
# Generate a new game map
generate_all(game_map, map_width, map_height, max_rooms, min_room_size, max_room_size, min_npcs, max_npcs,
colors, entities, floor_number)
# Reset the message log
if not preserve_messages:
message_log = MessageLog(message_x, message_width, message_height)
else:
message_log = None
# Set up the fov_map for the new game map and recalculate it
fov_recalculate = True
fov_map = initialize_fov(game_map)
return game_map, fov_recalculate, fov_map, message_log
def test_reconstr(self):
testdir = '.test/'
datadir = gen.generate_all('repeatCopy', testdir, 7,
15, 3, 5,
11, 6, 9,
23,
train_nrepeat_low=2, train_nrepeat_high=10,
valid_nrepeat_low=11, valid_nrepeat_high=20)
traintensor, validtensor = gen.reconstruct_tensor(datadir)
f = h5py.File(P.join(datadir, 'tensor.hdf5'), 'r')
truetrain, truevalid = f['train'], f['valid']
self.assertTrue((traintensor==truetrain).all())
self.assertTrue((validtensor==truevalid).all())
def main(args):
# Device Configuration for Multi-GPU Environment #
device = torch.device(
f'cuda:{args.gpu_num}' if torch.cuda.is_available() else 'cpu')
# Fix Seed for Reproducibility #
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
# Samples and Weights Path #
paths = [args.samples_path, args.weights_path]
for path in paths:
make_dirs(path)
# Prepare Data Loader #
train_div2k_loader = get_div2k_loader(sort='train',
batch_size=args.batch_size,
image_size=args.image_size,
upscale_factor=args.upscale_factor,
crop_size=args.crop_size,
patch_size=args.patch_size,
patch=args.patch,
flip=args.flip,
rotate=args.rotate)
val_div2k_loader = get_div2k_loader(sort='val',
batch_size=args.val_batch_size,
image_size=args.image_size,
upscale_factor=args.upscale_factor,
crop_size=args.crop_size)
print("val_div2k ", val_div2k_loader)
# Prepare Networks #
if args.model == 'edsr':
edsr = EDSR(channels=args.channels,
features=args.dim,
num_residuals=args.num_residuals,
scale_factor=args.upscale_factor).to(device)
else:
raise NotImplementedError
D = Discriminator(in_channels=args.channels,
ndf=args.dim,
linear_dim=args.linear_dim,
out_dim=args.out_dim,
disc_type=args.disc_type).to(device)
if args.phase == 'train':
if args.model == 'edsr':
train_srcnns(train_div2k_loader, val_div2k_loader, edsr, device,
args)
elif args.phase == 'inference':
if args.model == 'edsr':
edsr_weight_path = os.path.join(
args.weights_path,
'{}_Epoch_{}.pkl'.format(edsr.__class__.__name__,
args.num_epochs))
edsr.load_state_dict(torch.load(edsr_weight_path))
inference(val_div2k_loader,
edsr,
args.upscale_factor,
args.num_epochs,
args.inference_path,
device,
save_combined=False)
elif args.phase == 'generate':
generate_all(val_div2k_loader, device, args)
else:
raise NotImplementedError
import asyncio
from aiogram import Bot, types
from aiogram.dispatcher import Dispatcher
from aiogram.utils import executor
from config import tg_token
from query import query
from generate import generate_all
from timer import event
from objects import Tasks, UnusualTasks
import database
import time
import keyboard
generate = generate_all()
timers = []
constants = database.table("constants").select_all()
constants = {field: value for field, value in constants}
tasks = Tasks()
unusual_tasks = UnusualTasks()
DELAY = 30
bot = Bot(token=tg_token)
dp = Dispatcher(bot)
### --- ### --- ### ---- TASK ---- ### --- ### --- ###
@dp.message_handler(commands=['orf'])
async def new_orf(message: types.Message):
msg, kb = unusual_tasks.orthoepy(message.chat.id).new()
def main():
# Limit the FPS
tcod.sys_set_fps(max_fps)
# Set the font to be used
tcod.console_set_custom_font('terminal8x8_gs_as.png', tcod.FONT_TYPE_GREYSCALE | tcod.FONT_LAYOUT_ASCII_INCOL)
# Create the screen
tcod.console_init_root(screen_width, screen_height, 'Rogue', False)
con = tcod.console_new(screen_width, screen_height)
panel = tcod.console_new(screen_width, screen_height)
# Generate the tile map
game_map = GameMap(map_width, map_height)
# Initialize the player and the entities list
player = Player(player_stats[0], player_stats[1], player_stats[2], player_stats[3], player_stats[4], game_map.tiles,
screen_width // 2, screen_height // 2, '@', colors.get("player"), "player", True)
entities.append(player)
# Represents the current dungeon floor
floor_number = 1
# Generate the rest of the game map
generate_all(game_map, map_width, map_height, max_rooms, min_room_size, max_room_size, min_npcs, max_npcs, colors,
entities, floor_number)
# Initialize user input
key = tcod.Key()
mouse = tcod.Mouse()
# Initialize the game state
game_state = GameStates.PLAYER_TURN
# Initialize the message log
message_log = MessageLog(message_x, message_width, message_height)
# Determine whether or not the FOV needs to be recalculated
fov_recalculate = True
fov_map = initialize_fov(game_map)
# Game loop
while not tcod.console_is_window_closed():
# Update key and mouse with the user inputs
tcod.sys_check_for_event(tcod.EVENT_KEY_PRESS, key, mouse)
if fov_recalculate:
calculate_fov(fov_map, player.x, player.y, fov_radius, fov_light_walls, fov_algorithm)
# Render everything
render_all(con, panel, message_log, entities, game_map, fov_map, fov_recalculate, screen_width, screen_height,
bar_width,
panel_height, panel_y, debug)
fov_recalculate = False
# Apply the updates on screen
tcod.console_flush()
# Clear the entities in preparation for updates
clear_all(con, entities)
# Handle key presses
action = handle_keys(key)
move = action.get("move")
use = action.get("use")
exit = action.get("exit")
fullscreen = action.get("fullscreen")
reset = action.get("reset")
regenerate = action.get("regenerate")
player_turn_results = []
if move and game_state == GameStates.PLAYER_TURN:
dx, dy = move
if not game_map.is_blocked(player.x + dx, player.y + dy):
player.move(game_map.tiles, dx, dy)
fov_recalculate = True
target = enty.get_entity_at_location(player.x + dx, player.y + dy, entities)
if target != -1:
player_turn_results.extend(player.attack(target))
game_state = GameStates.ENEMY_TURN
if use and game_state == GameStates.PLAYER_TURN:
if player.inventory[use - 1] is not None:
player_turn_results.extend(player.inventory[use - 1].use(entities))
if exit:
return True
if fullscreen:
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
if reset: # Reset the game
player, game_state, regen_values = reset_map(game_map, map_width, map_height, max_rooms, min_room_size,
max_room_size, min_npcs, max_npcs, colors, entities, message_x,
message_width, message_height)
game_map, fov_recalculate, fov_map, message_log = regen_values
if regenerate and debug: # Properly generate a new game map
game_map, fov_recalculate, fov_map, message_log = regenerate_map(player, map_width, map_height, max_rooms,
min_room_size, max_room_size, min_npcs,
max_npcs, colors, entities, floor_number,
message_x, message_width, message_height)
# Handle the player turn results
for result in player_turn_results:
dead_attacker = result.get("dead")
if dead_attacker:
message_log.add_message(Message("You have killed the {0}".format(dead_attacker.name)))
dead_attacker.kill(game_map.tiles)
message_log.add_message(Message("{0} XP granted".format(dead_attacker.xp)))
level_up = player.add_xp(dead_attacker.xp).get("level up")
if level_up:
message_log.add_message(Message("You reached level {0}".format(level_up[0])))
message_log.add_message(Message(level_up[1]))
entities.remove(dead_attacker)
damaged_entity = result.get("damaged")
if damaged_entity:
message_log.add_message(
Message("You attacked the {0} for {1} damage".format(damaged_entity[0], damaged_entity[1])))
pickup_used = result.get("pickup_used")
if pickup_used:
message_log.add_message(Message(pickup_used[0]))
if pickup_used[1].deletes:
pickup_used[1].delete(player)
next_floor = result.get("next_floor")
if next_floor:
message_log.add_message(Message("You have advanced to floor {0}".format(next_floor + 1)))
floor_number += 1
game_map, fov_recalculate, fov_map, null = regenerate_map(player, map_width, map_height,
max_rooms, min_room_size,
max_room_size, min_npcs, max_npcs,
colors, entities, floor_number,
message_x, message_width,
message_height, preserve_messages=True)
# Enemy turn (really every entity that is not the player)
if game_state == GameStates.ENEMY_TURN:
enemy_turn_results = enty.entity_turn(entities, fov_map, game_map)
game_state = GameStates.PLAYER_TURN
# Handle the entity turn results
for result in enemy_turn_results:
dead = result.get("dead")
if dead:
game_state = player.kill(game_map.tiles)
message_log.add_message(Message("You have died"))
message_log.add_message(Message("GAME OVER"))
break
damaged_entity = result.get("damaged")
if damaged_entity:
message_log.add_message(
Message("The {0} attacked you for {1} damage".format(damaged_entity[0], damaged_entity[1])))
pickup_failed = result.get("pickup_failed")
if pickup_failed:
message_log.add_message(
Message("You cannot pick up the {0} since your inventory is full".format(pickup_failed[0])))
pickup_success = result.get("pickup_success")
if pickup_success:
message_log.add_message(Message("You picked up the {0}".format(pickup_success[0])))
pickup_success[1].kill(game_map.tiles)
entities.remove(pickup_success[1])
upgrade_used = result.get("upgrade_used")
if upgrade_used:
message_log.add_message(Message(upgrade_used[0]))
message_log.add_message(Message(upgrade_used[1]))
upgrade_used[2].kill(game_map.tiles)
entities.remove(upgrade_used[2])