def load_game(self):
#open the previously saved shelve and load the game data
# file = open('savegame.sav', 'rb')
# self.map = pickle.load(file)
# self.map.objects = pickle.load(file)
# self.player = pickle.load(file)
# self.map.player = self.player
# self.screen = Screen()
# self.screen.game_msgs = pickle.load(file)
# self.screen.fov_map = pickle.load(file)
# self.screen.fov_recompute = pickle.load(file)
# self.game_state = pickle.load(file)
# self.map.stairs = pickle.load(file)
file = shelve.open('savegame.s', 'r')
self.map = file['map']
self.map.objects = file['objects']
self.player = file['player']
self.screen.fov_map = file['fov_map']
self.screen.fov_recompute = file['fov_recompute']
self.screen.game_msgs = file['game_msgs']
self.game_state = file['game_state']
self.map.stairs = file['stairs']
file.close()
self.map.player = self.player
self.map.screen = self.screen
self.map.update_player_bindings()
self.map.initialize_fov()
libtcod.sys_set_fps(self.screen.LIMIT_FPS)
def __init__(self, app_name='test app', screen_width=None, screen_height=None): print '__init__' if screen_width is None: screen_width, screen_height = self.SCREEN_WIDTH, self.SCREEN_HEIGHT libtcod.console_init_root( screen_width, screen_height, app_name, False ) self.game_msgs = [] global message message = self.message self.game_state = 'playing' self.player_action = 'didnt-take-turn' x,y = None,None self.con = libtcod.console_new(self.MAP_WIDTH, self.MAP_HEIGHT) self.panel = libtcod.console_new(self.SCREEN_WIDTH, self.PANEL_HEIGHT) self.cursor = Cursor(self.con, 'X', 0,0) self.key = libtcod.Key() self.mouse = libtcod.Mouse() libtcod.sys_set_fps(self.LIMIT_FPS)
def init():
libtcod.console_set_custom_font('terminal12x12_gs_ro.png',
libtcod.FONT_TYPE_GREYSCALE |
libtcod.FONT_LAYOUT_ASCII_INROW)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT,
'basicroguelike', False)
libtcod.sys_set_fps(LIMIT_FPS)
def __init__(self, mouse=None, key=None):
# initialize the console
# set the font, and consoles
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(self.SCREEN_WIDTH, self.SCREEN_HEIGHT, 'python/libtcod tutorial', False)
self.con = libtcod.console_new(self.MAP_WIDTH, self.MAP_HEIGHT)
self.panel = libtcod.console_new(self.SCREEN_WIDTH, self.PANEL_HEIGHT)
libtcod.sys_set_fps(self.LIMIT_FPS)
# create the tile colors
self.color_dark_wall = libtcod.Color(0, 0, 100)
self.color_dark_ground = libtcod.Color(50, 50, 100)
self.color_light_wall = libtcod.Color(130, 110, 50)
self.color_light_ground = libtcod.Color(200, 180, 50)
# set the fov initially to None. This will be generated properly when the map is rendered
self.fov_map = None
self.fov_recompute = False
# set the mous and keyboard capture vars
self.mouse = mouse
self.key = key
# set the message console
self.game_msgs = []
def boot():
global SCREEN
framework.events.register_event('draw', blit)
tcod.console_set_custom_font(os.path.join('data', 'tiles', 'dejavu_wide12x12_gs_tc.png'),#,'consolas10x10_gs_tc.png')
flags=tcod.FONT_LAYOUT_TCOD|tcod.FONT_TYPE_GREYSCALE)
tcod.console_init_root(constants.WINDOW_WIDTH,
constants.WINDOW_HEIGHT,
constants.WINDOW_TITLE,
fullscreen='--fullscreen' in sys.argv,
renderer=tcod.RENDERER_GLSL)
tcod.console_set_keyboard_repeat(200, 0)
tcod.sys_set_fps(constants.FPS)
tcod.mouse_show_cursor(constants.SHOW_MOUSE)
SCREEN['c'] = numpy.zeros((constants.WINDOW_HEIGHT, constants.WINDOW_WIDTH), dtype=numpy.int32)
SCREEN['d'] = '0'*(constants.WINDOW_HEIGHT*constants.WINDOW_WIDTH)
SCREEN['r'] = []
SCREEN['f'] = []
SCREEN['f'].append(numpy.zeros((constants.WINDOW_HEIGHT, constants.WINDOW_WIDTH), dtype=numpy.int16))
SCREEN['f'].append(numpy.zeros((constants.WINDOW_HEIGHT, constants.WINDOW_WIDTH), dtype=numpy.int16))
SCREEN['f'].append(numpy.zeros((constants.WINDOW_HEIGHT, constants.WINDOW_WIDTH), dtype=numpy.int16))
SCREEN['b'] = []
SCREEN['b'].append(numpy.zeros((constants.WINDOW_HEIGHT, constants.WINDOW_WIDTH), dtype=numpy.int16))
SCREEN['b'].append(numpy.zeros((constants.WINDOW_HEIGHT, constants.WINDOW_WIDTH), dtype=numpy.int16))
SCREEN['b'].append(numpy.zeros((constants.WINDOW_HEIGHT, constants.WINDOW_WIDTH), dtype=numpy.int16))
def main_menu(self):
"""THE main menu, no other."""
LIMIT_FPS = 20
libtcod.sys_set_fps(LIMIT_FPS)
img = libtcod.image_load('main/lazor.png')
while not libtcod.console_is_window_closed():
#show the background image, at twice the regular console resolution
libtcod.image_blit_2x(img, 0, 0, 0)
#show the game's title, and credits
libtcod.console_set_default_foreground(0, color_menu_text)
libtcod.console_print_ex(0, SCREEN_WIDTH/2, 1, libtcod.BKGND_NONE, libtcod.CENTER, 'Laz0r Dodging Game')
libtcod.console_print_ex(0, SCREEN_WIDTH/2, 2, libtcod.BKGND_NONE, libtcod.CENTER, 'by magikmw')
#show options and wait for the player's choice
choice = menu('Choose an option:\n', ['Real-Time', 'Turn-Based', 'Highscores', 'Help', 'Quit.'], 18, -10)
if choice == 0: #new game
self.new_game('RT')
if choice == 1:
self.new_game('TB')
if choice == 2:
#TODO the highscore function call here
pass
if choice == 3:
#TODO help screen funcion call here
pass
if choice == 4: #quit
break
def __init__(self):
logg.info('Main loop initialization.')
logg.debug('Font size set to 8')
libtcod.console_set_custom_font('main/terminal8x8_gs_ro.png',
libtcod.FONT_LAYOUT_ASCII_INROW | libtcod.FONT_TYPE_GRAYSCALE)
logg.debug('Main console initialization.')
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT,
WINDOW_TITLE + ' v.' + VERSION, False,
renderer = libtcod.RENDERER_SDL)
logg.debug('Setting the FPS limit.')
libtcod.sys_set_fps(LIMIT_FPS)
logg.debug('Drawing console initialization.')
self.con = libtcod.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
#bottom panel console
logg.debug('Panels console initialization.')
self.top_panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
self.bottom_panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
logg.debug('Gamestate variables initialization')
self.entities=[]
self.player = None
self.gamestate = ""
self.player_action = None
self.map = None
self.random = libtcod.random_new()
self.score = 0
self.gamemode = ''
def main():
logging.basicConfig(filename='log.txt',level=logging.DEBUG,filemode='w')
logging.debug('start of main')
#initialize main console
font_file = 'data/fonts/terminal10x10_gs_tc.png'
libtcod.console_set_custom_font(font_file, libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(SCREEN_W,SCREEN_H,'GolemRL')
libtcod.sys_set_fps(LIMIT_FPS)
key = libtcod.Key()
mouse = libtcod.Mouse()
while not libtcod.console_is_window_closed():
libtcod.sys_check_for_event(libtcod.EVENT_ANY,key,mouse)
choice = main_menu()
if choice == 0:
seed = random.randrange(10000)
print 'Seed %i'%seed
logging.info('Starting new game with seed %i' % seed)
game = new_game()#seed)
game.play()
elif choice == 1:
game = load_game()
game.play()
elif choice == 2:
break
logging.debug('end of main')
return 0
def __init__(self):
self.screen = console.Screen(WIDTH, HEIGHT+5)
self.console = console.Console(WIDTH, HEIGHT, self.screen)
self.message_console = console.Console(WIDTH, 5, self.screen, (0,HEIGHT))
self.messages = text_display.MessageBox(self.message_console, 5, (10,0), 'msg')
self.fps_display = text_display.Label(self.message_console, (0,0), None)
self.terrain_registry = map.TerrainRegistry()
self.terrain_registry.load_from_file('data/terrain.yml')
self.map = map.Map(200,200, self.terrain_registry)
self.tc_events = events.TCODEventHandler()
self.events = events.EventHandler()
self.player = player.Player(4,5, self.map, combat.Adventurer.randomize())
self.player_stat = text_display.TextBox(self.message_console, 4, (0,1))
self.player.claim_display(self.player_stat)
player.ArrowHandler(self.player, self.tc_events)
self.actors = [self.player]
for x in range(40):
self.actors.append(overlay.AIActor(random.randrange(WIDTH), random.randrange(HEIGHT), self.map))
self.player.register_event('update', self.tick_actors)
self.objects = []
for x in range(50):
self.objects.append(overlay.Potion(random.randrange(WIDTH), random.randrange(HEIGHT), self.map))
tc.sys_set_fps(30)
def __init__(self, debug = False):
from harmless7drl import getCfg
self.width = getCfg( "tcod", "width", 80, int )
self.height = getCfg( "tcod", "height", 25, int )
self.fps_limit = 20
self.font_name = getCfg( "tcod", "font", "fonts/harmless-font-13x23.png" )
self.font_layout = {
"tcod": libtcod.FONT_LAYOUT_TCOD,
"ascii_incol": libtcod.FONT_LAYOUT_ASCII_INCOL,
"ascii_inrow": libtcod.FONT_LAYOUT_ASCII_INROW,
}[getCfg( "tcod", "fontlayout", "tcod" )]
self.title = 'Harmless7DRL'
self.colours = {
'white': libtcod.white,
'black': libtcod.black,
'red': libtcod.red,
'blue': libtcod.blue,
'cyan': libtcod.cyan,
'green': libtcod.green,
'magenta': libtcod.magenta,
'yellow': libtcod.yellow,
}
for key in self.colours.keys():
self.colours["bold-"+key] = self.colours[key]
for key in self.colours:
if "bold" not in key:
c = self.colours[key]
self.colours[key] = libtcod.Color( c.r & 0x80, c.g & 0x80, c.b & 0x80 )
from widgets import PrimaryColourRGB, SecondaryColourRGB, BorderColourRGB, HighlightPrimaryColourRGB, HighlightSecondaryColourRGB
self.colours[ "tcod-primary" ] = libtcod.Color( *PrimaryColourRGB )
self.colours[ "tcod-secondary" ] = libtcod.Color( *SecondaryColourRGB )
self.colours[ "tcod-primary-hl" ] = libtcod.Color( *HighlightPrimaryColourRGB )
self.colours[ "tcod-secondary-hl" ] = libtcod.Color( *HighlightSecondaryColourRGB )
self.colours[ "tcod-border" ] = libtcod.Color( *BorderColourRGB )
self.colours["bold-black"] = libtcod.Color( 0x80, 0x80, 0x80 )
self.keymap = {
libtcod.KEY_BACKSPACE: 'backspace',
libtcod.KEY_KP1: 'southwest',
libtcod.KEY_KP2: 'south',
libtcod.KEY_KP3: 'southeast',
libtcod.KEY_KP4: 'west',
libtcod.KEY_KP6: 'east',
libtcod.KEY_KP7: 'northwest',
libtcod.KEY_KP8: 'north',
libtcod.KEY_KP9: 'northeast',
libtcod.KEY_END: 'southwest',
libtcod.KEY_DOWN: 'south',
libtcod.KEY_PAGEDOWN: 'southeast',
libtcod.KEY_LEFT: 'west',
libtcod.KEY_RIGHT: 'east',
libtcod.KEY_HOME: 'northwest',
libtcod.KEY_UP: 'north',
libtcod.KEY_PAGEUP: 'northeast',
libtcod.KEY_ENTER: '\n',
libtcod.KEY_ESCAPE: 'escape',
}
libtcod.console_set_custom_font( self.font_name,
libtcod.FONT_TYPE_GREYSCALE | self.font_layout)
libtcod.console_init_root(self.width, self.height, self.title, False)
libtcod.sys_set_fps( self.fps_limit )
def main():
global key, mouse, map_, con
R.SCREEN_WIDTH = 100
R.SCREEN_HEIGHT = 80
libtcod.console_set_custom_font("data\ont_big.png",libtcod.FONT_LAYOUT_ASCII_INROW)
libtcod.console_init_root(R.SCREEN_WIDTH, R.SCREEN_HEIGHT, "Trader-RL", False)
libtcod.sys_set_fps(R.LIMIT_FPS)
con = libtcod.console_new(R.SCREEN_WIDTH, R.SCREEN_HEIGHT)
map_ = Map(R.MAP_WIDTH,R.MAP_HEIGHT)
map_.wind_gen.run_simulation(500)
mouse = libtcod.Mouse()
key = libtcod.Key()
while not libtcod.console_is_window_closed():
libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS|libtcod.EVENT_MOUSE, key, mouse)
render()
player_action = handle_keys()
if player_action == "exit":
break
handle_mouse()
def run():
os.putenv("SDL_VIDEO_CENTERED", "1")
if not os.path.exists('saves'):
os.makedirs('saves')
if not os.path.exists('maps'):
os.makedirs('maps')
libtcod.sys_set_fps(400)
Game()
def screen():
global con, panel
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_ASCII_INROW, 16,16)
libtcod.console_set_custom_font('menu_background1.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_ASCII_INROW, 16,16)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'Try not to Die!', False)
libtcod.sys_set_fps(LIMIT_FPS)
con = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
objects = []
def init(self): #init tcod & such
global turn_log
tcod.console_init_root(GAME_WIDTH,GAME_HEIGHT,'deth')
tcod.console_set_default_background(0, tcod.darkest_gray)
tcod.sys_set_fps(15)
turn_log = '\b'
self.menu()
def programSetup():
libtcod.console_set_custom_font(
const.fontName,
libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.sys_set_fps(const.fps)
libtcod.console_init_root(const.consoleWidth, const.consoleHeight,
'Stay in the Light')
libtcod.console_set_default_foreground(const.root, libtcod.white)
libtcod.console_clear(const.root)
gEngine.drawUILines()
def play_game():
tcod.console_init_root(settings.SCREEN_W, settings.SCREEN_H, 'SteamPocalypse')
tcod.sys_set_fps(20)
while not tcod.console_is_window_closed():
engine.engine.handle_input()
engine.engine.render_all()
def init_libtcod():
libtcod.console_set_custom_font(FONT_FILE_PATH,
libtcod.FONT_LAYOUT_ASCII_INROW |
libtcod.FONT_TYPE_GREYSCALE,
16, 34)
libtcod.console_init_root(settings.SCREEN_WIDTH,
settings.SCREEN_HEIGHT,
b'The Last Rogue',
settings.FULL_SCREEN)
fps = settings.FPS
libtcod.sys_set_fps(fps)
def __init__(self):
flags = libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD
libtcod.console_set_custom_font(self.font, flags)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'mprl', False)
libtcod.sys_set_fps(LIMIT_FPS)
self.con = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
self.panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
self.inv_window = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
self.hp_bar = UIBar('HP', libtcod.darker_red, libtcod.light_red)
def __init__(self, player_controls, conway_speed, map_size, fps, color,
paddle_size, seamless):
self.width, self.height = map_size
self.init_players(player_controls, paddle_size)
self.init_map(map_size, color)
(w, h) = map_size
tcod.console_init_root(w, h, config.GAME_TITLE, False)
tcod.sys_set_fps(fps)
self.conway_speed = conway_speed
self.ball = Ball(1, 1)
self.seamless = seamless
def game_initialize():
libtcod.console_set_custom_font('oryx_tiles3.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD, 32, 12)
libtcod.console_init_root(data.SCREEN_WIDTH, data.SCREEN_HEIGHT, 'MeFightRogues!', False, libtcod.RENDERER_SDL)
libtcod.sys_set_fps(data.LIMIT_FPS)
libtcod.console_map_ascii_codes_to_font(256 , 32, 0, 5) #map all characters in 1st row
libtcod.console_map_ascii_codes_to_font(256+32, 32, 0, 6) #map all characters in 2nd row
Game.con = libtcod.console_new(data.MAP_WIDTH,data.MAP_HEIGHT)
Game.panel = libtcod.console_new(data.SCREEN_WIDTH, data.PANEL_HEIGHT)
main_menu()
def renderer_init():
"""
Initialize libtcod and set up our basic consoles to draw into.
"""
global _con, _panel, _overlay, _last_frame_time
libtcod.console_set_custom_font('arial12x12.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(config.SCREEN_WIDTH, config.SCREEN_HEIGHT, 'python/libtcod tutorial', False)
libtcod.sys_set_fps(LIMIT_FPS)
_con = libtcod.console_new(config.MAP_PANEL_WIDTH, config.MAP_PANEL_HEIGHT)
_overlay = libtcod.console_new(config.MAP_PANEL_WIDTH, config.MAP_PANEL_HEIGHT)
_panel = libtcod.console_new(config.SCREEN_WIDTH, config.PANEL_HEIGHT)
_last_frame_time = time.time() * 1000
def init():
# init window
font = os.path.join(b'resources', b'consolas10x10_gs_tc.png')
libtcod.console_set_custom_font(font, libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(SCREEN_SIZE.x, SCREEN_SIZE.y, b'DalekRL')
libtcod.sys_set_fps(LIMIT_FPS)
# set default text palette # TODO: merge with UI class statics
libtcod.console_set_color_control(libtcod.COLCTRL_1,libtcod.red,libtcod.black)
libtcod.console_set_color_control(libtcod.COLCTRL_2,libtcod.dark_yellow,libtcod.black)
libtcod.console_set_color_control(libtcod.COLCTRL_3,libtcod.light_green,libtcod.black)
libtcod.console_set_color_control(libtcod.COLCTRL_4,libtcod.light_blue,libtcod.black)
libtcod.console_set_color_control(libtcod.COLCTRL_5,libtcod.purple,libtcod.black)
def __init__(self, title='Game'):
self.state = 1
self.map = None
self.rooms = []
self.numRooms = 0
self.objects = []
self.player = None
# Actual surface you see
l.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, title, False)
l.sys_set_fps(LIMIT_FPS)
# Hidden work surface for all the calculations/changes
self.canvas = l.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
# Secondary layer for field of vision purposes
self.fov = l.map_new(MAP_WIDTH, MAP_HEIGHT)
self.fovRecompute = True
# Set up game/map here
self.spawnPlayer()
self.makeMap()
for y in range(MAP_HEIGHT):
for x in range(MAP_WIDTH):
l.map_set_properties(self.fov,
x, y, not self.map[x][y].block_sight,
not self.map[x][y].blocked)
# Blit is what updates the main surface to your work surface
l.console_blit(self.canvas, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
while(self.state):
self.renderAll()
l.console_blit(self.canvas, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
l.console_flush()
# Remove old positions first
for obj in self.objects:
obj.clear()
action = self.handleKeys()
if action == 'exit':
self.state = 0
break
elif self.state == 1 and action != 'didnt-take-turn':
for obj in self.objects:
if obj.ai:
obj.ai.take_turn()
def main():
#actual size of the window
SCREEN_WIDTH = 80
SCREEN_HEIGHT = 50
LIMIT_FPS = 20 #20 frames-per-second maximum
raw_input("[INFO] Paina ENTER startataksesi.")
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'ROQUELIKE', False)
libtcod.sys_set_fps(LIMIT_FPS)
taso = Taso(0)
pelaaja = Liikkuja(1, 1, '@', taso)
print("[DEBUG] LOOPPI ALKAA")
while not libtcod.console_is_window_closed():
libtcod.console_set_default_foreground(0, libtcod.white)
print("[DEBUG] DRAW FUNKTIOTA KUTSUTAAN")
taso.kartta.draw(0)
pelaaja.draw(0)
libtcod.console_flush()
print("[DEBUG] odotetaan nappulaa")
nappula = libtcod.console_wait_for_keypress(True)
print("[DEBUG] Nappula saatu")
if nappula.vk == libtcod.KEY_ESCAPE:
return
elif nappula.vk == libtcod.KEY_RIGHT:
pelaaja.liiku((1, 0))
elif nappula.vk == libtcod.KEY_LEFT:
pelaaja.liiku((-1, 0))
elif nappula.vk == libtcod.KEY_UP:
pelaaja.liiku((0, -1))
elif nappula.vk == libtcod.KEY_DOWN:
pelaaja.liiku((0, 1))
else:
print("tuntematon nappain, ei virheita")
def main_init():
global con, con_char, inf,minmap, message_bar, date, ui, game_msgs
#libtcod.console_set_custom_font("dejavu16x16.png", libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_set_custom_font("data\ont_big.png",libtcod.FONT_LAYOUT_ASCII_INROW)
libtcod.console_init_root(R.SCREEN_WIDTH, R.SCREEN_HEIGHT, "Trader-RL", False)
libtcod.sys_set_fps(R.LIMIT_FPS)
con = R.con = libtcod.console_new(R.MAP_WIDTH, R.MAP_HEIGHT)
con_char = R.con_char = libtcod.console_new(R.MAP_WIDTH, R.MAP_HEIGHT)
inf = R.inf = libtcod.console_new(R.INFO_BAR_WIDTH, R.SCREEN_HEIGHT - R.PANEL_HEIGHT)
minmap = R.minmap = libtcod.console_new(R.INFO_BAR_WIDTH, R.PANEL_HEIGHT)
message_bar = R.message_bar = libtcod.console_new(R.PANEL_WIDTH, R.PANEL_HEIGHT)
game_msgs = R.game_msgs = []
ui = R.ui = UI.UI(con,game_msgs)
date = R.date = [0, [DAYS[0][0], 1, 1], [MONTHS[0][0], 1, 31], 1000];
def init(): global SYMBOL_MAP, KEYBOARD_MAP, CON, UI, MOUSE, KEY w = config.SCREEN_WIDTH h = config.SCREEN_HEIGHT ltc.sys_set_fps(config.FPS) #ltc.console_set_custom_font(config.TILE_SET, ltc.FONT_LAYOUT_ASCII_INROW | ltc.FONT_TYPE_GREYSCALE, 16, 16) ltc.console_set_custom_font(config.TILE_SET, ltc.FONT_LAYOUT_TCOD | ltc.FONT_TYPE_GREYSCALE, 32, 8) ltc.console_init_root(w, h, config.TITLE, False) KEYBOARD_MAP = dict([[v, k] for k, v in KEYBOARD_MAP.items()]) CON = ltc.console_new(w, h) UI = ltc.console_new(w, h) ltc.console_set_key_color(UI, ltc.purple) MOUSE = ltc.Mouse() KEY = ltc.Key()
def renderer_init():
"""
Initialize libtcod and set up our basic consoles to draw into.
"""
global _con, _panel, _overlay, _last_frame_time
libtcod.console_set_custom_font('arial12x12.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
# Map the dead space in the TCOD layout to [128...164]
# libtcod.console_map_ascii_codes_to_font(256, 21, 11, 1)
# libtcod.console_map_ascii_codes_to_font(277, 25, 0, 2)
libtcod.console_map_ascii_code_to_font(129, 12, 1)
libtcod.console_init_root(config.SCREEN_WIDTH, config.SCREEN_HEIGHT, 'Beyaz Dag', False)
libtcod.sys_set_fps(LIMIT_FPS)
_con = libtcod.console_new(config.MAP_PANEL_WIDTH, config.MAP_PANEL_HEIGHT)
_overlay = libtcod.console_new(config.MAP_PANEL_WIDTH, config.MAP_PANEL_HEIGHT)
_panel = libtcod.console_new(config.SCREEN_WIDTH, config.PANEL_HEIGHT)
_last_frame_time = time.time() * 1000
def __init__(self):
#GUI and map variables
self.SCREEN_WIDTH = 80
self.SCREEN_HEIGHT = 50
#MAP_X_SIZE and _Y_SIZE are the size of the map in chunks
self.MAP_X_SIZE = 200
self.MAP_Y_SIZE = 400
self.CHUNK_SIZE = 128
self.MAP_WIDTH = self.MAP_X_SIZE*self.CHUNK_SIZE
self.MAP_HEIGHT = self.MAP_Y_SIZE*self.CHUNK_SIZE
self.CAMERA_WIDTH = 80
self.CAMERA_HEIGHT = 49
self.LIMIT_FPS = 20
self.INFOBAR_HEIGHT = 1
self.ACTIONPANEL_WIDTH = 15
self.MENU_WIDTH = 20
self.GAME_FONT = 'arial10x10.png'
#We begin in the center of this chunk
self.PLAYER_START_X = 100
self.PLAYER_START_Y = 200
#Variable controlling frame interval for certain events
self.GAMESPEED = 5
#Minimum number of frames between player movements/actions
self.MAX_MOVESPEED = self.GAMESPEED/2
libtcod.console_set_custom_font(self.GAME_FONT, libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(self.SCREEN_WIDTH, self.SCREEN_HEIGHT, 'python/libtcod tutorial', False)
libtcod.sys_set_fps(self.LIMIT_FPS)
self.con = libtcod.console_new(self.SCREEN_WIDTH, self.SCREEN_HEIGHT)
#Game state and GUI control variables
self.show_menu = False
self.mode = "move"
self.cursor = None
self.time = "free"
self.player_wait = 0
self.npcs = []
self.player = None
self.camera = None
self.objects = []
self.map = None
self.infobar = libtcod.console_new(self.SCREEN_WIDTH, self.INFOBAR_HEIGHT)
self.menu = libtcod.console_new(self.MENU_WIDTH, self.SCREEN_HEIGHT)
def init_libtcod(terraform=False, window_size=WINDOW_SIZE, map_view_size=MAP_WINDOW_SIZE): global ITEM_WINDOW, CONSOLE_WINDOW, MESSAGE_WINDOW, PREFAB_WINDOW, X_CUTOUT_WINDOW, Y_CUTOUT_WINDOW _font_file = os.path.join(DATA_DIR, 'tiles', FONT) if '_incol' in FONT: _layout = tcod.FONT_LAYOUT_ASCII_INCOL elif '_inrow' in FONT: _layout = tcod.FONT_LAYOUT_ASCII_INROW if '_tiles' in FONT: _layout = _layout|tcod.FONT_TYPE_GRAYSCALE if '--worldmap' in sys.argv: MAP_WINDOW_SIZE[0] = 450 MAP_WINDOW_SIZE[1] = 450 window_size[0] = 450 window_size[1] = 450 tcod.console_set_custom_font(_font_file, _layout) tcod.console_init_root(window_size[0], window_size[1], WINDOW_TITLE, renderer=RENDERER) if terraform: PREFAB_WINDOW = tcod.console_new(PREFAB_WINDOW_SIZE[0],PREFAB_WINDOW_SIZE[1]) X_CUTOUT_WINDOW = tcod.console_new(X_CUTOUT_WINDOW_SIZE[0],X_CUTOUT_WINDOW_SIZE[1]) Y_CUTOUT_WINDOW = tcod.console_new(Y_CUTOUT_WINDOW_SIZE[0],Y_CUTOUT_WINDOW_SIZE[1]) PREFAB_CHAR_BUFFER[0] = numpy.zeros((PREFAB_WINDOW_SIZE[1], PREFAB_WINDOW_SIZE[0]), dtype=numpy.int8) PREFAB_CHAR_BUFFER[1] = numpy.zeros((PREFAB_WINDOW_SIZE[1], PREFAB_WINDOW_SIZE[0]), dtype=numpy.int8) X_CUTOUT_CHAR_BUFFER[0] = numpy.zeros((X_CUTOUT_WINDOW_SIZE[1], X_CUTOUT_WINDOW_SIZE[0]), dtype=numpy.int8) X_CUTOUT_CHAR_BUFFER[1] = numpy.zeros((X_CUTOUT_WINDOW_SIZE[1], X_CUTOUT_WINDOW_SIZE[0]), dtype=numpy.int8) Y_CUTOUT_CHAR_BUFFER[0] = numpy.zeros((Y_CUTOUT_WINDOW_SIZE[1], Y_CUTOUT_WINDOW_SIZE[0]), dtype=numpy.int8) Y_CUTOUT_CHAR_BUFFER[1] = numpy.zeros((Y_CUTOUT_WINDOW_SIZE[1], Y_CUTOUT_WINDOW_SIZE[0]), dtype=numpy.int8) tcod.console_set_keyboard_repeat(200, 0) tcod.sys_set_fps(FPS) for i in range(3): if terraform: PREFAB_RGB_BACK_BUFFER[i] = numpy.zeros((PREFAB_WINDOW_SIZE[1], PREFAB_WINDOW_SIZE[0]), dtype=numpy.int8) PREFAB_RGB_FORE_BUFFER[i] = numpy.zeros((PREFAB_WINDOW_SIZE[1], PREFAB_WINDOW_SIZE[0]), dtype=numpy.int8) X_CUTOUT_RGB_BACK_BUFFER[i] = numpy.zeros((X_CUTOUT_WINDOW_SIZE[1], X_CUTOUT_WINDOW_SIZE[0]), dtype=numpy.int8) X_CUTOUT_RGB_FORE_BUFFER[i] = numpy.zeros((X_CUTOUT_WINDOW_SIZE[1], X_CUTOUT_WINDOW_SIZE[0]), dtype=numpy.int8) Y_CUTOUT_RGB_BACK_BUFFER[i] = numpy.zeros((Y_CUTOUT_WINDOW_SIZE[1], Y_CUTOUT_WINDOW_SIZE[0]), dtype=numpy.int8) Y_CUTOUT_RGB_FORE_BUFFER[i] = numpy.zeros((Y_CUTOUT_WINDOW_SIZE[1], Y_CUTOUT_WINDOW_SIZE[0]), dtype=numpy.int8) SETTINGS['light mesh grid'] = numpy.meshgrid(range(map_view_size[0]), range(map_view_size[1]))
def __init__(self, screen_width, screen_height, fps_limit):
# store values
self.screen_width = screen_width
self.screen_height = screen_height
self.fps_limit = fps_limit
# turn on fps limit if > 0
if self.fps_limit > 0:
logger.log(logger.types.rendering, "FPS limiter set to " + str(self.fps_limit))
libtcod.sys_set_fps(self.fps_limit)
# import font
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
# root console / main window / 0
self.rootcon = libtcod.console_init_root(self.screen_width, self.screen_height, 'Ghreborn', False)
# init primary console
self.con = libtcod.console_new(self.screen_width, self.screen_height)
import libtcodpy as libtcod
from logic.menu_main import MenuMain
from logic.menu_manager import MenuManager
screen_width = 75
screen_height = 75
limit_fps = 30
menu_manager = MenuManager(MenuMain(screen_width, screen_height))
libtcod.console_disable_keyboard_repeat()
libtcod.console_set_custom_font('cp437_10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_ASCII_INROW)
libtcod.console_init_root(screen_width, screen_height, 'RogueP pre-dev', False)
libtcod.sys_set_fps(limit_fps)
while not libtcod.console_is_window_closed():
#behavior_manager.update_behaviors(entities)
if not menu_manager.loop(round(libtcod.sys_get_last_frame_length()*1000)):
break
libtcod.console_set_custom_font(_font, libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
except:
logging.error('Failed to load font!')
sys.exit()
else:
var.window_size = (80,50)
libtcod.console_set_custom_font(os.path.join('data','terminal16x16_aa_tc.png'), libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(var.window_size[0], var.window_size[1], 'Rogue Caves - %s' % __version__, False)
var.view = libtcod.console_new(var.window_size[0], var.window_size[1]-6)
var.tree = libtcod.console_new(var.window_size[0], var.window_size[1]-6)
var.splatter = libtcod.console_new(var.window_size[0], var.window_size[1]-6)
libtcod.console_set_key_color(var.splatter,libtcod.Color(0,0,0))
libtcod.console_set_key_color(var.tree,libtcod.Color(0,0,0))
var.log = libtcod.console_new(var.window_size[0], 6)
libtcod.console_set_keyboard_repeat(100,1)
libtcod.sys_set_fps(var.max_fps)
_logofile = open(os.path.join('data','logo.txt'),'r')
_y=18
for line in _logofile.readlines():
_i = 1
for char in line:
if char == '\n': continue
libtcod.console_set_char_foreground(0,_i,_y,libtcod.Color(_y*6,_y*6,_y*6))
#libtcod.console_print(0, _i, _y, char)
libtcod.console_set_char(0, _i, _y, char)
_i+=1
_y+=1
libtcod.console_print(0,(var.window_size[0]/2)-(len(__version__)/2),
28,
str(__version__))
#usr/bin/env/python3
import libtcodpy as tcod
#INITIALIZING CONSOLE AND STATING VARIABLES:
SCREEN_WIDTH = 72
SCREEN_HEIGHT = 42
FPS_LIMIT = 30
window_title = "Window Title"
fullscreen = False
tcod.console_set_custom_font(
"terminal16x16_gr_ro.png",
tcod.FONT_LAYOUT_ASCII_INROW | tcod.FONT_TYPE_GREYSCALE)
tcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, window_title, fullscreen)
tcod.sys_set_fps(FPS_LIMIT)
#MAIN LOOP:
while not tcod.console_is_window_closed():
tcod.console_flush()
'whamm', 'whammm', 'whap', 'zap', 'zlonk', 'zok', 'zowie', 'kerrrip'
]
#pickup message prefixes
pickup_prefix_msg = [
'nice', 'sweet', 'cool', 'yes', 'alright', 'that\'s it', 'super', 'amok',
'hey', 'neat', 'sick', 'woo', 'whoa', 'right on', 'yeah', 'good', 'great',
'not bad', 'superb', 'excellent'
]
#sets font and root console properties
libtcod.console_set_custom_font(
'terminal12x12.png',
libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_ASCII_INROW)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT,
'python/libtcod WASTEOID ' + VERSION, False,
libtcod.RENDERER_SDL)
libtcod.sys_set_fps(LIMIT_FPS) #FPS limit
#creates an offscreen console and a log panel
con = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
log_panel = libtcod.console_new(SCREEN_WIDTH, LOG_PANEL_HEIGHT)
#makes map and fov map - called fov_init to avoid confusion with fov_map object
make_map()
fov_init()
#sets regen rate for all Fighters
regen_timer = HEALTH_REGEN_RATE
#sets timers for basic needs
hunger_timer = HUNGER_RATE
thirst_timer = THIRST_RATE
fov_recompute = True
game_state = 'playing'
def start_console():
libtcod.console_init_root(WIDTH, HEIGHT, "FabSec", False,
libtcod.RENDERER_SDL)
libtcod.sys_set_fps(60)
#render_bar(1,1,BAR_WIDTH,'HP',player.body.hp,player.body.max_hp,libtcod.light_red,libtcod.darker_red) libtcod.console_set_default_foreground(panel,libtcod.light_gray) libtcod.console_print_ex(panel,1,0,libtcod.BKGND_NONE,libtcod.LEFT,get_names_under_mouse()) #blit the panel to the screen libtcod.console_blit(panel,0,0,SCREEN_WIDTH,PANEL_HEIGHT,0,0,PANEL_Y) #blit our off-screen console libtcod.console_blit(con,0,0,MAP_WIDTH,MAP_HEIGHT,0,0,0) ################################################################################################# libtcod.sys_set_fps(LIMIT_FPS) #creating our character object and components blarm = limbArm(name='bruiser left arm', hp=15, strength=15) brarm = limbArm(name='bruiser right arm', hp=15, strength=18) blleg = limbLeg(name='bruiser left leg', hp=20,strength=10,speed=3) brleg = limbLeg(name='bruiser left leg', hp=20,strength=10,speed=3) bhead = limbHead(name='bruiser head',hp=10) btorso= limbTorso(name='bruiser torso',hp=80) blms = [btorso,blarm,brarm,blleg,brleg,bhead] cbody = Body(limbs=blms) player = Object(0,0,'@','the ultimate warrior',libtcod.white,blocks = True, body=cbody) objects = [player]
self.map_arr[xx + self.room_size][yy +
self.room_size] = " "
##===============================================================================
def getMap(self):
##===============================================================================
return self.map_arr
#Just for testing ;)
if __name__ == "__main__":
Main_Console = libtcod.console_init_root(Game_Screen_Width,
Game_Screen_Height,
"Lost Horizon 0.0.1a", False)
libtcod.sys_set_fps(25)
map = GenDungeon(50, 50, var=50)
map_arr = map.getMap()
pix = libtcod.image_new(len(map_arr), len(map_arr))
for x in range(len(map_arr)):
for y in range(len(map_arr)):
if map_arr[x][y] == "#":
libtcod.image_put_pixel(pix, x, y, libtcod.dark_grey)
if map_arr[x][y] == " ":
libtcod.image_put_pixel(pix, x, y, libtcod.white)
while not libtcod.console_is_window_closed():
#libtcod.image_blit(pix,0,50,50,libtcod.BKGND_SET,1.0,1.0,0.0)
libtcod.image_blit_2x(pix, 0, 0, 0)
libtcod.console_flush()
key = libtcod.console_check_for_keypress(libtcod.KEY_PRESSED)
if key.vk == libtcod.KEY_ESCAPE:
def main():
player = Object(1, 1, '@', libtcod.red)
libtcod.console_set_custom_font(
'arial12x12.png',
libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
# specify screen size, title and whether or not fullscreen for root console
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'maze game', False)
# off-screen console for the map
con = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
# off-screen console for display panel
panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
# Only for real time, Frames per second
libtcod.sys_set_fps(LIMIT_FPS)
fov_map = libtcod.map_new(MAP_WIDTH, MAP_HEIGHT)
global compute_fov
compute_fov = False
cells = [[Cell() for y in range(MAP_COLS)] for x in range(MAP_ROWS)]
make_map(cells)
msgs = []
choice = 0
global move_count
move_count = 0
while True:
msgs.append(("Which algorithm would you like to generate the maze?",
libtcod.white))
msgs.append(("[1]. Kruskal's algorithm", libtcod.white))
msgs.append(("[2]. Prim's algorithm", libtcod.white))
msgs.append(("[3]. Binary tree method", libtcod.white))
msgs.append(("[4]. Random method", libtcod.white))
render_all(player, con, panel, fov_map, True, msgs)
libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
libtcod.console_flush()
msgs = []
form_messages = [
("Maze has been formed by Kruskal's method", libtcod.green),
("Maze has been formed by Prim's method", libtcod.green),
("Maze has been formed by Binary tree method", libtcod.green)
]
key = libtcod.console_wait_for_keypress(True)
if key.vk == libtcod.KEY_1:
choice = 1
if key.vk == libtcod.KEY_2:
choice = 2
if key.vk == libtcod.KEY_3:
choice = 3
if key.vk == libtcod.KEY_4:
choice = random.randint(0, 3)
if choice in [1, 2, 3]:
print "User's choice for maze generation is " + str(choice)
msgs.append(form_messages[choice - 1])
break
else:
msgs.append(("Sorry that is not an option!", libtcod.red))
msgs.append(("", libtcod.red))
if choice == 1:
(edges, cell_set, cell_list,
cells) = kruskal.init_variables(MAP_ROWS, MAP_COLS)
while cell_set.size() != 1:
cells = kruskal.generate_maze(edges, cell_set, cell_list, cells)
if choice == 2:
(wall_set, cells_finished,
cells) = prim.init_variables(MAP_ROWS, MAP_COLS)
while len(cells_finished) != MAP_ROWS * MAP_COLS:
cells = prim.generate_maze(wall_set, cells_finished, cells,
MAP_ROWS, MAP_COLS)
if choice == 3:
(cells) = bt.init_variables(MAP_ROWS, MAP_COLS)
for x in range(MAP_ROWS - 1, -1, -1):
for y in range(MAP_COLS):
cells = bt.generate_maze(cells, x, y, MAP_ROWS, MAP_COLS)
make_map(cells)
msgs = in_game_messages(msgs)
for y in xrange(MAP_HEIGHT):
for x in xrange(MAP_WIDTH):
libtcod.map_set_properties(fov_map, x, y, not map[x][y].wall,
not map[x][y].wall)
render_all(player, con, panel, fov_map, True, msgs)
libtcod.console_blit(con, 0, 0, MAP_WIDTH, MAP_HEIGHT, 0, 0, 0)
libtcod.console_flush()
global fog_of_war
fog_of_war = True
while not libtcod.console_is_window_closed():
if player.x == MAP_WIDTH - 2 and player.y == MAP_HEIGHT - 2:
msgs = []
msgs.append(
("Congratulations! You have won the game", libtcod.purple))
msgs.append(("", libtcod.white))
msgs.append(
("Displaying player's route in green", libtcod.light_green))
msgs.append(("", libtcod.white))
msgs.append(("Press any key to exit game now", libtcod.white))
render_all(player, con, panel, fov_map, False, msgs)
render_travelled(con)
libtcod.console_put_char_ex(con, 1, 1, 'S', libtcod.pink,
libtcod.black)
player.draw(con)
libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0,
0)
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
break
render_all(player, con, panel, fov_map, fog_of_war, msgs)
libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
libtcod.console_flush()
player.erase(con)
quit = keyboard_input(player, con)
if quit:
quit_msgs = []
quit_msgs.append(("Are you sure you want to quit?", libtcod.red))
quit_msgs.append(("", libtcod.red))
quit_msgs.append(("Enter Esc again to display solution and exit",
libtcod.white))
quit_msgs.append(("Enter any other key otherwise", libtcod.white))
render_all(player, con, panel, fov_map, True, quit_msgs)
libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0,
0)
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
if key.vk == libtcod.KEY_ESCAPE:
quit_msgs = []
quit_msgs.append(("Displaying solution in blue", libtcod.sky))
quit_msgs.append(("", libtcod.green))
quit_msgs.append((
"Displaying player's route (not overlapping with solution) in green",
libtcod.light_green))
quit_msgs.append(("", libtcod.green))
quit_msgs.append(
("Press any key to exit game now", libtcod.white))
render_all(player, con, panel, fov_map, False, quit_msgs)
render_travelled(con)
render_solution(cells, con)
player.draw(con)
libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0,
0, 0)
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
break
saveGame()
break
#monster turn
if gameState == "playing" and playerAction != "did-not-move":
for object in objects:
if object.ai:
object.ai.takeATurn()
#########################
# System Initialization #
#########################
libtcod.console_set_custom_font(
"arial10x10.png", libtcod.FONT_TYPE_GRAYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, GAME_TITLE,
False) #False here is for fullscreen
libtcod.sys_set_fps(FPS_LIMIT)
con = libtcod.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
objects = []
##############
# Game Start #
##############
if DEBUG:
newGame()
playGame()
else:
mainMenu()
FOV_LIGHT_WALLS = True
TORCH_RADIUS = 10
HEAL_AMOUNT = 16
LIGHTNING_RANGE = 5
LIGHTNING_DAMAGE = 40
CONFUSE_NUM_TURNS = 10
CONFUSE_RANGE = 10
FIREBALL_RADIUS = 3
FIREBALL_DAMAGE = 25
# Experience and level-ups
LEVEL_UP_BASE = 200
LEVEL_UP_FACTOR = 150
tcod.sys_set_fps(LIMIT_FPS)
con = tcod.console_new(MAP_WIDTH, MAP_HEIGHT)
panel = tcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
colour_dark_wall = tcod.Color(0, 30, 0)
colour_dark_ground = tcod.Color(20, 60, 20)
colour_light_wall = tcod.Color(130, 110, 50)
colour_light_ground = tcod.Color(200, 180, 50)
class Equipment:
# An object that can be equipped, yielding bonuses. Automatically adds the Item component.
def __init__(self, slot, power_bonus=0, defense_bonus=0, max_hp_bonus=0):
self.power_bonus = power_bonus
self.defense_bonus = defense_bonus
def new_game():
global player, inventory, party, game_state, map, view_x, view_y, con, game_dir, text_color, music_paused
music_paused = False
f = open("./init.txt", "r")
skipline(f)
game_dir = (f.readline())
f.close()
# We need to get the screen size (and eventually we'll get other game data here as well)
f = open(game_dir + "/init.txt", "r")
# game name is line 2 of these, in case I want to do something with it
skipline(f, 3)
welcome_text = f.readline()
skipline(f)
red = int(f.readline())
green = int(f.readline())
blue = int(f.readline())
skipline(f)
text_color = libtcod.Color(int(f.readline()), int(f.readline()),
int(f.readline()))
skipline(f)
view_x = int(f.readline())
view_y = int(f.readline())
skipline(f)
map = (f.readline()).rstrip()
skipline(f)
start_x = int(f.readline())
start_y = int(f.readline())
skipline(f)
player_color = libtcod.Color(int(f.readline()), int(f.readline()),
int(f.readline()))
f.close()
parsemap(map)
# Boilerplate to set up the window
LIMIT_FPS = 20 #20 frames-per-second maximum
libtcod.console_set_custom_font(
'dejavu16x16_gs_tc.png',
libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(view_x, view_y, 'RPG', False)
libtcod.sys_set_fps(LIMIT_FPS)
con = libtcod.console_new(view_x, view_y)
libtcod.console_set_default_background(con,
libtcod.Color(red, green, blue))
continue_game = menu("File:", ["New", "Continue"])
mixer.init()
if continue_game == 1:
try:
load_game()
except:
display_text("No save file found! Starting new game...")
continue_game = 0
if not continue_game:
display_text(welcome_text)
# Initialize the player -
player = Player(start_x,
start_y,
'@',
'player',
player_color, [], [],
blocks=True,
dir="up")
print map.music
if map.music != "none":
mixer.music.load(map.music)
mixer.music.set_volume(.5)
mixer.music.play(-1)
game_state = 'playing'
def get_input():
if var.output=='pygame':
for event in pygame.event.get():
if event.type == QUIT or event.type == KEYDOWN and event.key in [K_ESCAPE,K_q]:
if var.in_menu:
functions.destroy_menu(who=var.player)
else:
#var.world.save()
pygame.quit()
sys.exit()
elif event.type == KEYDOWN:
if event.key == K_UP:
var.input['up'] = True
var.menu_index-=1
elif event.key == K_DOWN:
var.input['down'] = True
var.menu_index+=1
elif event.key == K_LEFT:
var.input['left'] = True
elif event.key == K_RIGHT:
var.input['right'] = True
elif event.key == K_RETURN:
if var.in_menu:
functions.menu_select()
else:
var.player.enter()
var.buffer = [[0] * var.world_size[1] for i in range(var.world_size[0])]
region = (0,0,var.window_size[0]+1,var.window_size[1]+1)
var.view.setbrightness(0, region=region)
draw_screen(refresh=True)
elif event.key == K_w:
var.player.place_item(21,(0,-1))
elif event.key == K_a:
var.player.place_item(21,(-1,0))
elif event.key == K_d:
var.player.place_item(21,(1,0))
elif event.key == K_s:
var.player.place_item(21,(0,1))
elif event.key == K_v:
for pos in var.player.level.real_estate:
var.view.tint(b=255,region=(pos[0],pos[1],1,1))
elif event.key == K_b:
if var.player.in_building(name='storage') and not var.in_menu:
_building_owner = var.player.level.get_room('storage')['owner']
if _building_owner and _building_owner.in_building(name='storage'):
_menu = var.player.level.get_room_items('storage')
if len(_menu):
functions.build_menu(var.player.level.get_room_items('storage'),
who=var.player,
name='Shopping (Buy)',
trading=True,
callback=var.player.buy_item)
_building_owner.say('What would you like today?')
else:
_building_owner.say('I have nothing to sell!')
elif event.key == K_n:
if var.player.in_building(name='storage') and not var.in_menu:
_building_owner = var.player.level.get_room('storage')['owner']
if _building_owner and _building_owner.in_building(name='storage'):
functions.build_menu(var.player.items,
who=var.player,
name='Shopping (Sell)',
trading=True,
callback=var.player.sell_item,
sell_to=_building_owner)
_building_owner.say('What items do you have for me?')
elif event.key == K_i:
if len(var.player.items):
functions.build_menu(var.player.items,
name='Inventory',
callback=var.player.equip_item)
elif event.key == K_p:
var.world.get_stats()
elif event.key == K_1:
var.player.teleport(1)
elif event.key == K_2:
var.player.teleport(0)
elif event.key == K_3:
var.player.teleport(-1)
elif event.key == K_4:
var.player.teleport(-2)
elif event.key == K_5:
var.player.teleport(-3)
elif event.key == K_6:
var.player.teleport(-4)
elif event.key == K_j:
logging.debug('Taking screenshot...')
pygame.image.save(var.window._windowsurface, 'screenshot.jpg')
elif event.type == KEYUP:
if event.key == K_UP:
var.input['up'] = False
elif event.key == K_DOWN:
var.input['down'] = False
elif event.key == K_LEFT:
var.input['left'] = False
elif event.key == K_RIGHT:
var.input['right'] = False
elif event.key == K_z:
var.max_fps = 20
elif event.key == K_x:
var.max_fps = 60
elif event.key == K_c:
var.max_fps = 10
elif event.key == K_v:
for pos in var.player.level.real_estate:
var.view.setbrightness(0, region=(pos[0],pos[1],1,1))
elif event.type == MOUSEMOTION:
var.mouse_pos = var.view.getcoordinatesatpixel(event.pos)
elif event.type == MOUSEBUTTONDOWN:
for life in var.life:
if life.z == var.player.z:
if [life.pos[0]-var.camera[0],life.pos[1]-var.camera[1]] == list(var.mouse_pos):
print '='*8
print life.name
print 'Task: %s' % life.task
print 'Path: %s' % life.path
print 'Path dest: %s' % str(life.path_dest)
#print 'Path type: %s' % life.path_type
print 'Position: %s' % str(life.pos)
print 'Traits: %s' % life.traits
print 'Attracted to: %s' % life.attracted_to
print 'Likes: %s' % life.likes
print 'Dislikes: %s' % life.dislikes
#print [entry for entry in life.get_top_love_interests()]
for event in life.events:
print event['what'],event['score']
print '='*8
life.build_history()
#print 'Inventory: '
#for item in life.items:
# print item
for item in var.player.level.items[var.mouse_pos[0]+var.camera[0]][var.mouse_pos[1]+var.camera[1]]:
if [item['pos'][0]-var.camera[0],item['pos'][1]-var.camera[1]] == list(var.mouse_pos):
print item
else:
key = libtcod.console_check_for_keypress(flags=libtcod.KEY_PRESSED)
if key.vk == libtcod.KEY_UP:
var.input['up']=True
else:
var.input['up']=False
if key.vk == libtcod.KEY_DOWN:
var.input['down']=True
else:
var.input['down']=False
if key.vk == libtcod.KEY_LEFT:
var.input['left']=True
else:
var.input['left']=False
if key.vk == libtcod.KEY_RIGHT:
var.input['right']=True
else:
var.input['right']=False
if key.vk == libtcod.KEY_ENTER:
if var.in_menu:
functions.menu_select()
else:
var.player.enter()
var.buffer = [[0] * var.world_size[1] for i in range(var.world_size[0])]
region = (0,0,var.window_size[0]+1,var.window_size[1]+1)
libtcod.console_clear(var.view)
draw_screen(refresh=True)
if key.c == ord('x'):
var.max_fps=60
libtcod.sys_set_fps(var.max_fps)
if key.c == ord('z'):
var.max_fps=20
libtcod.sys_set_fps(var.max_fps)
if key.c == ord('c'):
var.max_fps=10
libtcod.sys_set_fps(var.max_fps)
if key.vk in [libtcod.KEY_ESCAPE] or key.c == ord('q'):
return True
tick()
return False
def play_game(player, entities, game_map, message_log, game_state, con, panel,
constants):
fov_recompute = True
fov_map = initialize_fov(game_map)
key = libtcod.Key()
mouse = libtcod.Mouse()
game_state = GameStates.PLAYERS_TURN
previous_game_state = game_state
targeting_item = None
libtcod.sys_set_fps(24)
while not libtcod.console_is_window_closed():
libtcod.sys_check_for_event(
libtcod.EVENT_KEY_PRESS | libtcod.EVENT_MOUSE, key, mouse)
if fov_recompute:
recompute_fov(fov_map, player.x, player.y, constants['fov_radius'],
constants['fov_light_walls'],
constants['fov_algorithm'])
render_all(con, panel, entities, player, game_map, fov_map,
fov_recompute, message_log, constants['screen_width'],
constants['screen_height'], constants['bar_width'],
constants['panel_height'], constants['panel_y'], mouse,
constants['colors'], game_state)
fov_recompute = False
libtcod.console_flush()
clear_all(con, entities)
action = handle_keys(key, game_state)
mouse_action = handle_mouse(mouse)
move = action.get('move')
pickup = action.get('pickup')
show_inventory = action.get('show_inventory')
drop_inventory = action.get('drop_inventory')
quick_inventory = action.get('quick_inventory')
inventory_index = action.get('inventory_index')
exit = action.get('exit')
fullscreen = action.get('fullscreen')
take_stairs = action.get('take_stairs')
level_up = action.get('level_up')
left_click = mouse_action.get('left_click')
right_click = mouse_action.get('right_click')
show_character_screen = action.get('show_character_screen')
quickslot_index = action.get('quickslot_index')
quick_slot = action.get('quick_use')
examine_entity = action.get('examine_entity')
enemies_afoot = False
for entity in entities:
if libtcod.map_is_in_fov(fov_map, entity.x,
entity.y) and entity.ai:
enemies_afoot = True
break
player_turn_results = []
if right_click and game_state == game_state.PLAYERS_TURN and not enemies_afoot:
(x, y) = mouse_action['right_click']
move_target = lambda: None
setattr(move_target, 'x', x)
setattr(move_target, 'y', y)
if game_map.tiles[x][y].explored:
game_state = game_state.CLICK_MOVE
if game_state == game_state.CLICK_MOVE:
if enemies_afoot:
game_state = game_state.ENEMY_TURN
if game_state != game_state.ENEMY_TURN:
if player.distance_to(move_target) < 1:
game_state = game_state.PLAYERS_TURN
else:
if player.move_astar(move_target,
entities,
game_map,
max_path=300,
check_explored=True):
fov_recompute = True
else:
game_state = game_state.PLAYERS_TURN
if (move or left_click or
(enemies_afoot
and right_click)) and game_state == GameStates.PLAYERS_TURN:
if move:
dx, dy = move
else:
if left_click:
target_x, target_y = mouse_action['left_click']
else:
target_x, target_y = mouse_action['right_click']
dx = target_x - player.x
dy = target_y - player.y
distance = math.sqrt(dx**2 + dy**2)
if distance != 0:
dx = int(round(dx / distance))
dy = int(round(dy / distance))
else:
dx = 0
dy = 0
destination_x = player.x + dx
destination_y = player.y + dy
if not game_map.is_blocked(destination_x, destination_y):
target = get_blocking_entities_at_location(
entities, destination_x, destination_y)
if target and target != player:
attack_results = player.fighter.attack(target)
player_turn_results.extend(attack_results)
elif target:
message_log.add_message(
Message('You take a short rest', libtcod.white))
else:
player.move(dx, dy)
fov_recompute = True
game_state = GameStates.ENEMY_TURN
if pickup and game_state == GameStates.PLAYERS_TURN:
for entity in entities:
if entity.item and entity.x == player.x and entity.y == player.y:
pickup_results = player.inventory.add_item(entity)
player_turn_results.extend(pickup_results)
break
else:
message_log.add_message(
Message('There is nothing here to pick up.',
libtcod.yellow))
if quick_slot:
for item in player.inventory.items:
if item.uID == player.quick_use.quick_list[quick_slot - 1]:
player_turn_results.extend(
player.inventory.use(item,
entities=entities,
fov_map=fov_map))
if show_inventory:
previous_game_state = game_state
game_state = GameStates.SHOW_INVENTORY
if drop_inventory:
previous_game_state = game_state
game_state = GameStates.DROP_INVENTORY
if examine_entity:
previous_game_state = game_state
game_state = GameStates.EXAMINE_SCREEN
if quick_inventory:
previous_game_state = game_state
game_state = GameStates.QUICK_USE
if inventory_index is not None and previous_game_state != GameStates.PLAYER_DEAD and inventory_index < len(
player.inventory.items):
item = player.inventory.items[inventory_index]
if game_state == GameStates.SHOW_INVENTORY:
player_turn_results.extend(
player.inventory.use(item,
entities=entities,
fov_map=fov_map))
elif game_state == GameStates.DROP_INVENTORY:
player_turn_results.extend(player.inventory.drop_item(item))
elif game_state == GameStates.QUICK_USE:
player_turn_results.extend(player.quick_use.add_item(0, item))
if take_stairs and game_state == GameStates.PLAYERS_TURN:
for entity in entities:
if entity.stairs and entity.x == player.x and entity.y == player.y:
entities = game_map.next_floor(player, message_log,
constants)
fov_map = initialize_fov(game_map)
fov_recompute = True
libtcod.console_clear(con)
break
else:
message_log.add_message(
Message('There are no stairs here.', libtcod.yellow))
if level_up:
if level_up == 'hp':
player.fighter.max_hp += 20
player.fighter.hp += 20
elif level_up == 'str':
player.fighter.base_power += 1
elif level_up == 'def':
player.fighter.base_defense += 1
game_state = previous_game_state
if show_character_screen:
previous_game_state = game_state
game_state = GameStates.CHARACTER_SCREEN
if game_state == GameStates.TARGETING:
if left_click:
target_x, target_y = left_click
item_use_results = player.inventory.use(targeting_item,
entities=entities,
fov_map=fov_map,
target_x=target_x,
target_y=target_y)
player_turn_results.extend(item_use_results)
elif right_click:
player_turn_results.append({'targeting_cancelled': True})
if exit:
if game_state in (GameStates.SHOW_INVENTORY,
GameStates.DROP_INVENTORY,
GameStates.CHARACTER_SCREEN,
GameStates.QUICK_USE, GameStates.EXAMINE_SCREEN):
game_state = previous_game_state
elif game_state == GameStates.TARGETING:
player_turn_results.append({'targeting_cancelled': True})
elif game_state == GameStates.LEVEL_UP:
level_up_menu(con, 'Level up! Choose a stat to raise:', player,
40, screen_width, screen_height)
else:
save_game(player, entities, game_map, message_log, game_state)
return True
if fullscreen:
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
# resolve and display the results
for player_turn_result in player_turn_results:
message = player_turn_result.get('message')
dead_entity = player_turn_result.get('dead')
item_added = player_turn_result.get('item_added')
item_consumed = player_turn_result.get('consumed')
item_dropped = player_turn_result.get('item_dropped')
targeting = player_turn_result.get('targeting')
targeting_cancelled = player_turn_result.get('targeting_cancelled')
equip = player_turn_result.get('equip')
xp = player_turn_result.get('xp')
evoked = player_turn_result.get('evoked')
item_slotted = player_turn_result.get('item_slotted')
if message:
message_log.add_message(message)
if dead_entity:
if dead_entity == player:
message, game_state = kill_player(dead_entity)
else:
message = kill_monster(dead_entity)
message_log.add_message(message)
if item_slotted:
game_state = GameStates.PLAYERS_TURN
if item_added:
entities.remove(item_added)
game_state = GameStates.ENEMY_TURN
if item_consumed or evoked:
game_state = GameStates.ENEMY_TURN
if item_dropped:
entities.append(item_dropped)
game_state = GameStates.ENEMY_TURN
if equip:
equip_results = player.equipment.toggle_equip(equip)
for equip_result in equip_results:
equipped = equip_result.get('equipped')
unequipped = equip_result.get('unequipped')
if equipped:
message_log.add_message(
Message('You equipped the {0}'.format(
equipped.name)))
if unequipped:
message_log.add_message(
Message('You unequipped the {0}'.format(
unequipped.name)))
game_state = GameStates.ENEMY_TURN
if targeting:
previous_game_state = GameStates.PLAYERS_TURN
game_state = GameStates.TARGETING
targeting_item = targeting
message_log.add_message(targeting_item.item.targeting_message)
if targeting_cancelled:
game_state = previous_game_state
message_log.add_message(Message('Targeting cancelled'))
if xp:
leveled_up = player.level.add_xp(xp)
message_log.add_message(
Message('You gain {0} experience points.'.format(xp)))
if leveled_up:
message_log.add_message(
Message(
'Your battle skills grow stronger! You reached level {0}'
.format(player.level.current_level) + '!',
libtcod.yellow))
previous_game_state = game_state
game_state = GameStates.LEVEL_UP
if game_state == GameStates.ENEMY_TURN or game_state == game_state.CLICK_MOVE:
# before anybody takes their turn
player_eot = player.fighter.EndofTurn()
process_turn(player, player_eot, message_log)
for entity in entities:
if entity.ai:
enemy_turn_results = entity.ai.take_turn(
player, fov_map, game_map, entities)
process_turn(player, enemy_turn_results, message_log)
# Manage conditions and end of turn effects
if entity.fighter:
enemy_turn_results = entity.fighter.EndofTurn()
process_turn(player, enemy_turn_results, message_log)
if game_state == GameStates.PLAYER_DEAD:
break
else:
if game_state != game_state.CLICK_MOVE:
game_state = GameStates.PLAYERS_TURN
def main():
constants = get_constants()
# libtcod.console_set_custom_font('consolas_unicode_16x16.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
# libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_set_custom_font(
'terminal16x16_gs_ro.png',
libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_ASCII_INROW)
libtcod.console_init_root(constants['screen_width'],
constants['screen_height'],
constants['window_title'], False)
con = libtcod.console_new(constants['screen_width'],
constants['screen_height'])
panel = libtcod.console_new(constants['screen_width'],
constants['panel_height'])
player = None
entities = []
game_map = None
message_log = None
game_state = None
show_main_menu = True
show_load_error_message = False
main_menu_background_image = libtcod.image_load('menu_background.png')
key = libtcod.Key()
mouse = libtcod.Mouse()
libtcod.sys_set_fps(24)
while not libtcod.console_is_window_closed():
libtcod.sys_check_for_event(
libtcod.EVENT_KEY_PRESS | libtcod.EVENT_MOUSE, key, mouse)
if show_main_menu:
main_menu(con, main_menu_background_image,
constants['screen_width'], constants['screen_height'])
if show_load_error_message:
message_box(con, 'No save game to load', 50,
constants['screen_width'],
constants['screen_height'])
libtcod.console_flush()
action = handle_main_menu(key)
new_game = action.get('new_game')
load_saved_game = action.get('load_game')
exit_game = action.get('exit')
if show_load_error_message and (new_game or load_saved_game
or exit_game):
show_load_error_message = False
elif new_game:
player, entities, game_map, message_log, game_state = get_game_variables(
constants)
game_state = GameStates.PLAYERS_TURN
show_main_menu = False
elif load_saved_game:
try:
player, entities, game_map, message_log, game_state = load_game(
)
show_main_menu = False
except FileNotFoundError:
show_load_error_message = True
elif exit_game:
break
else:
libtcod.console_clear(con)
play_game(player, entities, game_map, message_log, game_state, con,
panel, constants)
show_main_menu = True