def storyScreen(console):
libtcod.console_set_default_background(console, STORY_BACKGROUND_COLOUR1)
libtcod.console_clear(console)
done = False
counter = 0
blinkOn = True
blinkSpeed = 10
while not done and not libtcod.console_is_window_closed():
key = libtcod.console_check_for_keypress(True)
if not key.vk == libtcod.KEY_NONE:
done = True
#print the story message
libtcod.console_set_default_foreground(console, STORY_FOREGROUND_COLOUR1)
libtcod.console_print_rect(console, 1, 3, SCREEN_WIDTH, SCREEN_HEIGHT, STORY_TEXT1)
if(blinkOn):
libtcod.console_set_default_foreground(console, SPLASH_FOREGROUND_COLOUR3)
libtcod.console_print_rect(console, 16, 22, SCREEN_WIDTH, SCREEN_HEIGHT, "press any key")
# blit the panel to the screen
libtcod.console_blit(console, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT-(2*1), 0, 0, 1)
libtcod.console_flush()
counter += 1
if counter >= blinkSpeed:
counter = 0
blinkOn = not blinkOn
libtcod.console_clear(console)
libtcod.console_clear(console)
def draw_stat_panel():
# draw the boundary of the panel with a gold line
old_foreground_color = libtcod.console_get_default_foreground(stat_con)
libtcod.console_set_default_foreground(stat_con, libtcod.gold)
libtcod.console_vline(stat_con, STAT_PANEL_WIDTH - 1, 0, STAT_PANEL_HEIGHT)
libtcod.console_set_default_foreground(stat_con, old_foreground_color)
# A string with a red over black word, using predefined color control codes
libtcod.console_set_color_control(libtcod.COLCTRL_1, libtcod.red,
libtcod.black)
libtcod.console_set_color_control(libtcod.COLCTRL_2, libtcod.green,
libtcod.black)
libtcod.console_print(
stat_con, 1, 1, "Position: %c(%s, %s)%c" %
(libtcod.COLCTRL_1, player.x, player.y, libtcod.COLCTRL_STOP))
libtcod.console_print(stat_con, 1, 2,
"Defense: %s" % player.fighter.defense)
libtcod.console_print(stat_con, 1, 3, "Power: %s" % player.fighter.power)
render_bar(stat_con, 1, 4, STAT_PANEL_WIDTH - 2, 'HP', player.fighter.hp,
player.fighter.max_hp, libtcod.darker_green, libtcod.dark_red)
libtcod.console_print(
stat_con, 1, 5, "Mouse: %c(%s, %s)%c" %
(libtcod.COLCTRL_1, mouse.cx - STAT_PANEL_WIDTH, mouse.cy,
libtcod.COLCTRL_STOP))
libtcod.console_print(stat_con, 1, 7,
"Current depth: " + str(current_depth))
libtcod.console_print(
stat_con, 1, 10,
"Mouse %ctarget%c:" % (libtcod.COLCTRL_2, libtcod.COLCTRL_STOP))
libtcod.console_print_rect(stat_con, 1, 11, STAT_PANEL_WIDTH - 2, 0,
("%c" + get_names_under_mouse() + "%c") %
(libtcod.COLCTRL_2, libtcod.COLCTRL_STOP))
def character_description(typ, id): libtcod.console_set_default_foreground(0, libtcod.white) libtcod.console_set_default_background(0, libtcod.black) libtcod.console_rect(0, 1, 11, 52, 10, True, libtcod.BKGND_SET) if typ == 'race': libtcod.console_print_rect(0, 2, 12, 50, 10, game.RACE_DESC[id]) if typ == 'class': libtcod.console_print_rect(0, 2, 12, 50, 10, game.CLASS_DESC[id])
def render_bar(self, con, x, y, w, value, max_value, bar_bg_color, bar_fg_color, text_color): ratio = int(w*(float(value)/max_value)) libtcod.console_set_default_background(con, bar_fg_color) libtcod.console_rect(con, x, y, ratio, 1, False, libtcod.BKGND_SET) libtcod.console_set_default_background(con, bar_bg_color) libtcod.console_rect(con, x+ratio, y, w-ratio, 1, False, libtcod.BKGND_SET) libtcod.console_set_default_background(con, text_color) libtcod.console_print_rect(con, x+1, y, w, 1, "%03d / %03d" % (value, max_value))
def menu(header, options, width, options_params=None):
if len(options) > 26:
raise ValueError('Cannot have a menu with more than 26 options.')
# calculate total height for the header (after auto-wrap)
# and one line per option
header_height = libtcod.console_get_height_rect(
con, 0, 0, width, SCREEN_HEIGHT, header
)
height = len(options) + header_height
# create an off-screen console that represents the menu's window
window = libtcod.console_new(width, height)
# print the header, with auto-wrap
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect(window, 0, 0, width, height, header)
# print all the options
y = header_height
letter_index = ord('a')
longest_text = 0
for option_text in options:
text = '(' + chr(letter_index) + ') ' + option_text
libtcod.console_print(window, 0, y, text)
y += 1
letter_index += 1
if len(text) > longest_text:
longest_text = len(text)
# draw a line between the letter and the option
libtcod.console_vline(window, 3, header_height,
height, libtcod.BKGND_LIGHTEN)
if options_params:
y = header_height
last_char_x = longest_text
# draw a line between the letter and the option
libtcod.console_vline(window, last_char_x, header_height,
height, libtcod.BKGND_LIGHTEN)
for param in options_params:
libtcod.console_print(window, last_char_x+1, y, str(param))
y += 1
if len(str(param)) > longest_text:
longest_text = len(str(param))
# blit the contents of "window" to the root console
x = SCREEN_WIDTH / 2 - width / 2
y = SCREEN_HEIGHT / 2 - height / 2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
# present the root console to the player
libtcod.console_flush()
def loadingScreen(console, message): libtcod.console_set_default_background(console, libtcod.Color(0, 0, 0)) libtcod.console_clear(console) #print the splash messages libtcod.console_set_default_foreground(console, libtcod.Color(200, 200, 200)) libtcod.console_print_rect(console, 4, 8, SCREEN_WIDTH, SCREEN_HEIGHT, message) # blit the panel to the screen libtcod.console_blit(console, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT-(2*4), 0, 0, 4) libtcod.console_flush()
def menu(header, options, width):
global key
global mouse
if len(options) > 26:
raise ValueError('Cannot have a menu with more than 26 options!')
# Calculate total height for the header (after auto-wrap)
# and one line per option
header_height = libtcod.console_get_height_rect(con, 0, 0, width,
SCREEN_HEIGHT, header)
if header == '':
header_height = 0
height = len(options) + header_height
# Create an off-screen console that represents the menu's window
window = libtcod.console_new(width, height)
# Print the header, with auto-wrap
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_set_alignment(window, libtcod.LEFT)
libtcod.console_set_default_background(window, libtcod.BKGND_NONE)
libtcod.console_print_rect(window, 0, 0, width, height, header)
# Print all the options
y = header_height
letter_index = ord('a')
for option_text in options:
text = '({}) {}'.format(chr(letter_index), option_text)
libtcod.console_print(window, 0, y, text)
y += 1
letter_index += 1
# Blit the contents of "window" to the root console
x = int(round(SCREEN_WIDTH / 2 - width / 2))
y = int(round(SCREEN_HEIGHT / 2 - height / 2))
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
# Present the root console to the player and wait for a key-press
libtcod.console_flush()
libtcod.sys_wait_for_event(libtcod.EVENT_KEY_PRESS, key, mouse, False)
if key.vk == libtcod.KEY_ENTER and key.lalt:
#(special case) Alt+Enter: toggle fullscreen
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
# Convert the ASCII code to an index; if it corresponds to an
# option, return it
index = key.c - ord('a')
if index >= 0 and index < len(options):
return index
return None
def menu(header, options, width):
global key
global mouse
if len(options) > 26:
raise ValueError('Cannot have a menu with more than 26 options!')
# Calculate total height for the header (after auto-wrap)
# and one line per option
header_height = libtcod.console_get_height_rect(con, 0, 0, width,
SCREEN_HEIGHT, header)
if header == '':
header_height = 0
height = len(options) + header_height
# Create an off-screen console that represents the menu's window
window = libtcod.console_new(width, height)
# Print the header, with auto-wrap
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_set_alignment(window, libtcod.LEFT)
libtcod.console_set_default_background(window, libtcod.BKGND_NONE)
libtcod.console_print_rect(window, 0, 0, width, height, header)
# Print all the options
y = header_height
letter_index = ord('a')
for option_text in options:
text = '({}) {}'.format(chr(letter_index), option_text)
libtcod.console_print(window, 0, y, text)
y += 1
letter_index += 1
# Blit the contents of "window" to the root console
x = int(round(SCREEN_WIDTH / 2 - width / 2))
y = int(round(SCREEN_HEIGHT / 2 - height / 2))
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
# Present the root console to the player and wait for a key-press
libtcod.console_flush()
libtcod.sys_wait_for_event(libtcod.EVENT_KEY_PRESS, key, mouse, False)
if key.vk == libtcod.KEY_ENTER and key.lalt:
#(special case) Alt+Enter: toggle fullscreen
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
# Convert the ASCII code to an index; if it corresponds to an
# option, return it
index = key.c - ord('a')
if index >= 0 and index < len(options):
return index
return None
def menu(header, options, width, highlighted=[]):
"""Basic, general-purpose menu.
Allows the user to choose from up to 26 text options."""
if len(options) > 26:
raise ValueError("Cannot have a menu with more than 26 options.")
# calculate total height for the header (after auto-wrap) and one line per
# option
if header == "":
header_height = 0
else:
header_height = tcod.console_get_height_rect(0, 0, 0, width, SCREEN_HEIGHT, header)
height = len(options) + header_height
# create an off-screen console that represents the menu's window
window = tcod.console_new(width, height)
# print the header, with auto-wrap
tcod.console_set_default_foreground(window, tcod.white)
tcod.console_print_rect(window, 0, 0, width, height, header)
# print all the options
y = header_height
letter_index = ord("a")
for option_text in options:
text = "(" + chr(letter_index) + ") " + option_text
tcod.console_print(window, 0, y, text)
y += 1
letter_index += 1
for index in highlighted:
w = len(options[index]) + 4
tcod.console_set_default_background(window, tcod.grey)
y = index + header_height
tcod.console_rect(window, 0, y, w, 1, False, flag=tcod.BKGND_SET)
# blit the contents of "window" to the root console
x = SCREEN_WIDTH // 2 - width // 2
y = SCREEN_HEIGHT // 2 - height // 2
tcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
# present the root console to the player and wait for a key-press
tcod.console_flush()
tcod.sys_wait_for_event(tcod.EVENT_KEY_PRESS, key, mouse, True)
# special case: changing to/from fullscreen
if key.vk == tcod.KEY_F11:
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
elif key.vk == tcod.KEY_ESCAPE:
return "escape"
else:
# convert the ASCII code to an index; if it corresponds to an option,
# return it
index = key.c - ord("a")
if index >= 0 and index < len(options):
return index
return None
def start_new_round(self, winner_of_last_round=None):
"""starts a new round of pong
says who won, shows a countdown, moves the ball to the center, resets the players
at the end, wipes the conway sim and resumes play """
# lets do stuff in an off-screen console, so we can use transparency
# so the player can see the map
con = tcod.console_new(self.width, self.height)
time_elapsed = 0.0 # in seconds
x = self.width / 2
tcod.console_set_alignment(con, tcod.CENTER)
while self.alive and not tcod.console_is_window_closed() and \
time_elapsed < 3.0:
y = self.height / 2
if winner_of_last_round:
tcod.console_set_default_foreground(con,
winner_of_last_round.color)
player_num = self.players.index(winner_of_last_round) + 1
string = "Player %d scores!" % player_num
height = tcod.console_get_height_rect(con, x, y, self.width,
self.height, string)
tcod.console_print_rect(con, x, y, self.width, height, string)
y += height
tcod.console_set_default_foreground(con, tcod.white)
string = "New round starting in %d seconds..." % int(3 - time_elapsed)
height = tcod.console_get_height_rect(con, x, y, self.width,
self.height, string)
tcod.console_print_rect(con, x, y, self.width, height, string)
self.handle_input()
self.update_conway()
self.render_all()
tcod.console_blit(con, 0, 0, 0, 0, 0, 0, 0, 1.0, 0.75)
tcod.console_flush()
time_elapsed += tcod.sys_get_last_frame_length()
# delete tcod console we created
tcod.console_delete(con)
#reset the ball
self.ball = Ball(1, 1)
#reset the player positions
for player in self.players:
player.top = self.height / 2
# wipe the conway simulation (by creating a new one)
self.init_map(self.conway.size, self.conway.color)
def test_console_printing(console, fg, bg):
libtcodpy.console_set_background_flag(console,
libtcodpy.BKGND_SET)
assert (libtcodpy.console_get_background_flag(console) ==
libtcodpy.BKGND_SET)
libtcodpy.console_set_alignment(console, libtcodpy.LEFT)
assert (libtcodpy.console_get_alignment(console) ==
libtcodpy.LEFT)
libtcodpy.console_print(console, 0, 0, 'print')
libtcodpy.console_print_ex(console, 0, 0, libtcodpy.BKGND_SET,
libtcodpy.LEFT, 'print ex')
assert (libtcodpy.console_print_rect(
console, 0, 0, 8, 8, 'print rect') > 0
)
assert (libtcodpy.console_print_rect_ex(
console, 0, 0, 8, 8, libtcodpy.BKGND_SET, libtcodpy.LEFT,
'print rect ex') > 0
)
assert (libtcodpy.console_get_height_rect(
console, 0, 0, 8, 8, 'get height') > 0
)
libtcodpy.console_set_color_control(libtcodpy.COLCTRL_1, fg, bg)
def print_rec(self, layer):
libtcod.console_set_color_control(libtcod.COLCTRL_2, libtcod.turquoise, libtcod.black)
libtcod.console_set_color_control(libtcod.COLCTRL_3, libtcod.gray, libtcod.black)
if not self.hidden:
libtcod.console_print_rect(result_display, Category.pc[0] + layer, Category.pc[1], 30 - Category.pc[0], 30, "{:c}{}:{:c}".format(libtcod.COLCTRL_2, self.name, libtcod.COLCTRL_STOP))
libtcod.console_print(result_display, Category.pc[0], Category.pc[1], "{:c}{}{:c}".format(libtcod.COLCTRL_3, '|' * layer, libtcod.COLCTRL_STOP))
Category.pc[1] += libtcod.console_get_height_rect(result_display, Category.pc[0] + layer, Category.pc[1], 30 - Category.pc[0], 30, "{:c}{}:{:c}".format(libtcod.COLCTRL_2, self.name, libtcod.COLCTRL_STOP))
glist = self.get()
for g in glist:
libtcod.console_print_rect(result_display, Category.pc[0] + layer, Category.pc[1], 30 - Category.pc[0], 30, "{}".format(g))
libtcod.console_print(result_display, Category.pc[0], Category.pc[1], "{:c}{}{:c}".format(libtcod.COLCTRL_3, '|' * layer, libtcod.COLCTRL_STOP))
Category.pc[1] += libtcod.console_print_rect(result_display, Category.pc[0] + layer, Category.pc[1], 30 - Category.pc[0], 30, "{}".format(g))
for s in self.sub:
s.print_rec(layer + 1)
if not len(glist):
for s in self.sub:
s.print_rec(layer + 1)
def menu(header, options, width):
if len(options) > 26:
raise ValueError('Cannot have a menu with more than 26 options.')
#calculate total height for the header (after auto-wrap) and one line per option
header_height = libtcod.console_get_height_rect(con, 0, 0, width, SCREEN_HEIGHT, header)
if header == '':
header_height = 0
height = len(options) + header_height
#create an off-screen console that represents the menu's window
window = libtcod.console_new(width, height)
#print the header, with auto-wrap
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect(window, 0, 0, width, height, header)
#print all the options
y = header_height
letter_index = ord('a')
for option_text in options:
text = '(' + chr(letter_index) + ') ' + option_text
libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
y += 1
letter_index += 1
#blit the contents of "window" to the root console
x = SCREEN_WIDTH / 2 - width / 2
y = SCREEN_HEIGHT / 2 - height / 2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
#present the root console to the player and wait for a key-press
libtcod.console_flush()
key = libtcod.console_wait_for_keypress(True)
if key.vk == libtcod.KEY_ENTER and key.lalt: # (special case) Alt+Enter: toggle fullscreen
libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
#convert the ASCII code to an index; if it corresponds to an option, return it
index = key.c - ord('a')
if index >= 0 and index < len(options):
return index
return None
def pick_direction():
(w, h) = (20, 2)
window = tcod.console_new(w, h)
tcod.console_set_default_foreground(window, tcod.white)
text = "Pick a direction."
tcod.console_print_rect(window, 0, 0, w, h, text)
x = SCREEN_WIDTH // 2 - w // 2
y = SCREEN_HEIGHT // 2 - h // 2
tcod.console_blit(window, 0, 0, w, h, 0, x, y, 1.0, 0.7)
tcod.console_flush()
global key
tcod.sys_wait_for_event(tcod.EVENT_KEY_PRESS, key, mouse, True)
# special case: changing to/from fullscreen
if key.vk == tcod.KEY_F11:
tcod.console_set_fullscreen(not tcod.console_is_fullscreen())
else:
key_pressed = game.get_key(key)
if key_pressed in direction_keys:
return direction_keys[key_pressed]
elif key_pressed == tcod.KEY_ESCAPE or tcod.console_is_window_closed():
return None
def renderAll(objects, player, con, panel, infobar):
# draw objects without actors first
for object in objects:
if not object.actor:
object.graphic.draw(con)
for object in objects:
if object.actor:
object.graphic.draw(con)
libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, GAME_HEIGHT, 0, 0, GAME_Y)
# do panel stuff
libtcod.console_set_default_background(panel, PANEL_BACKGROUND_COLOUR)
libtcod.console_clear(panel)
# print the current game message
libtcod.console_set_default_foreground(panel, getMessageColour())
libtcod.console_print_rect(panel, 1, 1, SCREEN_WIDTH-1, PANEL_HEIGHT, getMessage())
# blit the panel to the screen
libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y)
# do info bar stuff
libtcod.console_set_default_background(infobar, INFO_BAR_BACKGROUND_COLOUR)
libtcod.console_clear(infobar)
# print their current money and the time
libtcod.console_set_default_foreground(infobar, getMoneyColour(player.actor.money))
libtcod.console_print_rect(infobar, SCREEN_WIDTH/2 - 3, 0, SCREEN_WIDTH, INFO_BAR_HEIGHT, "$"+str(player.actor.money))
libtcod.console_set_default_foreground(infobar, getTimeColour())
libtcod.console_print_rect(infobar, SCREEN_WIDTH/2 + 3, 0, SCREEN_WIDTH, INFO_BAR_HEIGHT, getTimeString())
libtcod.console_blit(infobar, 0, 0, SCREEN_WIDTH, INFO_BAR_HEIGHT, 0, 0, INFO_BAR_Y)
def splashScreen(console):
libtcod.console_set_default_background(console, SPLASH_BACKGROUND_COLOUR)
libtcod.console_clear(console)
done = False
counter = 0
blinkOn = True
blinkSpeed = 10
while not done and not libtcod.console_is_window_closed():
key = libtcod.console_check_for_keypress(True)
if not key.vk == libtcod.KEY_NONE:
done = True
#print the splash messages
libtcod.console_set_default_foreground(console, SPLASH_FOREGROUND_COLOUR1)
libtcod.console_print_rect(console, 4, 5, SCREEN_WIDTH, SCREEN_HEIGHT, "SWORD SHOP")
libtcod.console_set_default_foreground(console, SPLASH_FOREGROUND_COLOUR2)
libtcod.console_print_rect(console, 4, 8, SCREEN_WIDTH, SCREEN_HEIGHT, "by luke david\n fitzpatrick")
if(blinkOn):
libtcod.console_set_default_foreground(console, SPLASH_FOREGROUND_COLOUR3)
libtcod.console_print_rect(console, 16, 13, SCREEN_WIDTH, SCREEN_HEIGHT, "press any key")
# blit the panel to the screen
libtcod.console_blit(console, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT-(2*6), 0, 0, 6)
libtcod.console_flush()
counter += 1
if counter >= blinkSpeed:
counter = 0
blinkOn = not blinkOn
libtcod.console_clear(console)
def draw_stat_panel():
# draw the boundary of the panel with a gold line
old_foreground_color = libtcod.console_get_default_foreground(stat_con)
libtcod.console_set_default_foreground(stat_con, libtcod.gold)
libtcod.console_vline(stat_con, STAT_PANEL_WIDTH - 1, 0, STAT_PANEL_HEIGHT)
libtcod.console_set_default_foreground(stat_con, old_foreground_color)
# A string with a red over black word, using predefined color control codes
libtcod.console_set_color_control(libtcod.COLCTRL_1, libtcod.red, libtcod.black)
libtcod.console_set_color_control(libtcod.COLCTRL_2, libtcod.green, libtcod.black)
libtcod.console_print(stat_con, 1, 1,
"Position: %c(%s, %s)%c" % (libtcod.COLCTRL_1, player.x, player.y, libtcod.COLCTRL_STOP))
libtcod.console_print(stat_con, 1, 2, "Defense: %s" % player.fighter.defense)
libtcod.console_print(stat_con, 1, 3, "Power: %s" % player.fighter.power)
render_bar(stat_con, 1, 4, STAT_PANEL_WIDTH - 2, 'HP', player.fighter.hp, player.fighter.max_hp,
libtcod.darker_green, libtcod.dark_red)
libtcod.console_print(stat_con, 1, 5, "Mouse: %c(%s, %s)%c" % (
libtcod.COLCTRL_1, mouse.cx - STAT_PANEL_WIDTH, mouse.cy, libtcod.COLCTRL_STOP))
libtcod.console_print(stat_con, 1, 7, "Current depth: " + str(current_depth))
libtcod.console_print(stat_con, 1, 10, "Mouse %ctarget%c:" % (libtcod.COLCTRL_2, libtcod.COLCTRL_STOP))
libtcod.console_print_rect(stat_con, 1, 11, STAT_PANEL_WIDTH - 2, 0,
("%c" + get_names_under_mouse() + "%c") % (libtcod.COLCTRL_2, libtcod.COLCTRL_STOP))
def menu(self, header, options, width, back_color=libtcod.black, fore_color=libtcod.white):
if self.con is None: self.con = 0
if len(options) > 26: raise ValueError('too many items')
con = self.con
header_height = libtcod.console_get_height_rect(con, 0,0, width, self.SCREEN_HEIGHT, header)
height = len(options) + header_height
window = libtcod.console_new(width, height)
print 'window id is:', window
print
libtcod.console_set_default_foreground(window, fore_color)
libtcod.console_print_rect(window, 0,0, width,height, header)
y = header_height
for option_text in zip('abcdefghijklmnopqrstuvwxyz', options):
text = '(%s) %s' % option_text
libtcod.console_print(window, 0, y, text)
y += 1
x = self.SCREEN_WIDTH/2 - width/2
y = self.SCREEN_HEIGHT/2 - height/2
libtcod.console_blit(window, 0,0, width,height, 0, x,y, 1.0, 0.9)
key = libtcod.Key()
mouse = libtcod.Mouse()
libtcod.console_flush()
libtcod.sys_wait_for_event(libtcod.KEY_PRESSED, key, mouse, True)
libtcod.console_clear(window)
libtcod.console_blit(window, 0,0, width,height, 0, x,y, 1.0, 0.9)
libtcod.console_delete(window)
libtcod.console_flush()
index = key.c - ord('a')
if index >= 0 and index < len(options): return index
return None
def draw(self, color=rl.white):
oldColor = rl.console_get_default_foreground(0) # Store old color.
rl.console_set_default_foreground(0, color) # Apply window's color.
# Draw the corners.
rl.console_put_char_ex(0, self.x, self.y, rl.CHAR_DNW,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, self.x + self.w - 1, self.y, rl.CHAR_DNE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, self.x, self.y + self.h - 1, rl.CHAR_DSW,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, self.x + self.w - 1,
self.y + self.h - 1, rl.CHAR_DSE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
# Draw the walls.
for i in range(self.y + 1, self.y + self.h - 1):
rl.console_put_char_ex(0, self.x, i, rl.CHAR_DVLINE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, self.x + self.w - 1, i, rl.CHAR_DVLINE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
for i in range(self.x + 1, self.x + self.w - 1):
rl.console_put_char_ex(0, i, self.y, rl.CHAR_DHLINE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, i, self.y + self.h - 1, rl.CHAR_DHLINE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
if self.title != None: # Draw the title, if present.
rl.console_print(0, self.x + 2, self.y, " {0} ".format(self.title))
rl.console_set_default_foreground(
0, oldColor) # Revert color before drawing rest of window.
rl.console_print_rect(0, self.x + 2, self.y + 1, self.w - 4,
self.h - 2, self.text) # Draw the inner text.
def draw(self, color=rl.white):
if self.subBox != None: # If there is a sub-box, draw that instead.
self.subBox.draw()
return
rl.console_rect(0, self.x, self.y, self.w, self.h,
True) # Reset background color for the box.
# Draw the corners.
rl.console_put_char_ex(0, self.x, self.y, rl.CHAR_DNW,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, self.x + self.w - 1, self.y, rl.CHAR_DNE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, self.x, self.y + self.h - 1, rl.CHAR_DSW,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, self.x + self.w - 1,
self.y + self.h - 1, rl.CHAR_DSE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
# Draw the walls.
for i in range(self.y + 1, self.y + self.h - 1):
rl.console_put_char_ex(0, self.x, i, rl.CHAR_DVLINE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, self.x + self.w - 1, i, rl.CHAR_DVLINE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
for i in range(self.y + 1, self.y + self.h - 4):
rl.console_put_char_ex(0, self.dividerX, i, rl.CHAR_DVLINE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
for i in range(self.x + 1, self.x + self.w - 1):
rl.console_put_char_ex(0, i, self.y, rl.CHAR_DHLINE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, i, self.y + self.h - 1, rl.CHAR_DHLINE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, i, self.y + self.h - 4, rl.CHAR_DHLINE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
# Draw the dividing joints between sections.
rl.console_put_char_ex(0, self.dividerX, self.y, rl.CHAR_DTEES,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, self.dividerX, self.y + self.h - 4,
rl.CHAR_DTEEN,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, self.x, self.y + self.h - 4,
rl.CHAR_DTEEE,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
rl.console_put_char_ex(0, self.x + self.w - 1, self.y + self.h - 4,
rl.CHAR_DTEEW,
rl.console_get_default_foreground(0),
rl.console_get_default_background(0))
if self.title != None: # Draw the title, if present.
rl.console_print(0, self.x + 2, self.y, " {0} ".format(self.title))
# Draw every option and its current value (or "..." if it leads to a new menu).
for i, option in enumerate(
self.menuObj[self.optOffset:min(self.optOffset +
self.optCap, len(self.menuObj)
)]): # Draw the options.
if option[0] == None:
rl.console_print(0, self.x + 4, self.y + 1 + i,
option[3][0][3])
else:
rl.console_print(0, self.x + 4, self.y + 1 + i, option[0])
if isinstance(option[3], list):
rl.console_print(0, self.dividerX + 2, self.y + 1 + i, "...")
else:
rl.console_print(
0, self.dividerX + 2, self.y + 1 + i,
str(option[3])[0:min(len(str(option[3])), 76 -
self.dividerX)])
# Draw the description of the current option or the current input, whichever is needed.
color = "" # The color to draw the input in. Or more specifically, the ascii mid-string color change code. Since the default is white, by default nothing needs to be done here.
if self.inputMode != "":
if self.inputIsValid(
self.currentInput, self.menuObj[self.selectedOption][1],
self.menuObj[self.selectedOption]
[4]) == False: # If the input isn't valid, make the color red.
color = chr(rl.COLCTRL_FORE_RGB) + chr(255) + chr(64) + chr(64)
if self.inputMode == "Text":
rl.console_print(
0, 2, self.y + self.h - 3,
"Input the new value. Max length is {0}\n{2}{1}{3}".format(
self.menuObj[self.selectedOption][4],
self.currentInput[
self.inputOffset:min(self.inputOffset +
76, len(self.currentInput))],
color, chr(rl.COLCTRL_STOP)))
elif self.inputMode == "Number":
rl.console_print(
0, 2, self.y + self.h - 3,
"Input the new value. Max value is {0}\n{2}{1}{3}".format(
self.menuObj[self.selectedOption][4],
self.currentInput[
self.inputOffset:min(self.inputOffset +
76, len(self.currentInput))],
color, chr(rl.COLCTRL_STOP)))
else:
rl.console_print_rect(0, 2, self.y + self.h - 3, 76, 2,
self.menuObj[self.selectedOption][2])
rl.console_print(0, self.x + 2,
self.y + 1 + self.selectedOption - self.optOffset,
chr(rl.CHAR_ARROW2_E))
# Draw input cursor.
if self.inputMode != "":
rl.console_set_char_background(
0, 2 + self.cursorPos - self.inputOffset, self.y + self.h - 2,
rl.white)
rl.console_set_char_foreground(
0, 2 + self.cursorPos - self.inputOffset, self.y + self.h - 2,
rl.black)
# Draw scroll arrows as needed.
if int(time.clock() * 2) % 2 == 0:
if self.optOffset > 0:
rl.console_print(0, self.x + int(self.w / 2), self.y,
chr(rl.CHAR_ARROW2_N))
if self.optOffset + self.optCap < len(self.menuObj):
rl.console_print(0, self.x + int(self.w / 2),
self.y + self.h - 1, chr(rl.CHAR_ARROW2_S))
if self.inputOffset > 0:
rl.console_print(0, self.x, self.y + self.h - 2,
chr(rl.CHAR_ARROW2_W))
if self.inputOffset < len(self.currentInput) - 75:
rl.console_print(0, self.x + self.w - 1, self.y + self.h - 2,
chr(rl.CHAR_ARROW2_E))
def update(self):
self.add_border()
libtcod.console_print_rect(self.dialog_con, 1, 1, self.width - 2,
self.height, self.prompt_text)
libtcod.console_blit(self.dialog_con, 0, 0, 0, 0, self.target_con,
self.x, self.y)
def refresh(self):
# First, handle the flow of combat or the active animation.
if self.animPhase == 2: # If the blinking box phase is active, handle that.
if time.time() >= self.animStarted + 0.5: # If a second has passed since this animation phase started, end it.
self.animPhase = 0
if self.checkBattleStatus() != None: # If the battle is won or lost, change the current scene.
return self.checkBattleStatus()
self.advanceTurn() # Move to the next turn.
else: # If there is no animation going on, handle the flow of combat.
if self.turnOrder[0].isAI(): # If it's an enemy's turn, act according to their AI.
self.parseTurnResults(self.turnOrder[0].aiAct(self.party,self.enemies)) # Execute the enemy AI, thne add the result to the log.
elif len(self.moveBoxes) == 0: # Otherwise, it must be the player's turn. If there aren't any move boxes open, open one.
self.moveBoxes.append(bx.SelectBox(22,3,-1,-1,None,self.turnOrder[0].getOptions(),-1))
# Now on to the actual display.
rl.console_clear(0) # Fill the window with the background color.
for i,box in enumerate(self.partyBoxes): # Display the party boxes. Only the boxes themselves for now.
if len(self.party) <= i or self.party[i].isDead(): # Draw a gray box if party member is not present or dead.
box.draw(rl.darker_gray)
else: # Otherwise, draw normal stats, aside from the bars.
rl.console_print(0, 12, i*6+1, self.party[i].getHPLine()) # Draw HP.
rl.console_print(0, 12, i*6+2, self.party[i].getAPLine()) # Draw AP.
rl.console_print(0, 12, i*6+3, self.party[i].getMPLine()) # Draw MP.
rl.console_print(0, 2, i*6+4, self.party[i].getStatusLine(18)) # Draw status effects.
if len(self.party) <= i or self.party[i].getHP() <= 0: # Draw a red box if party member is unconscious.
box.draw(rl.darker_red)
elif self.animPhase == 2 and (self.animTarget == i or self.animTarget == ALL_ALLIES) and int((time.time() - self.animStarted) * 8) % 2 == 0: # If the current animPhase is 2, this is the current animation target, and the time since the animation started dictates the box should be dark red, make it dark red.
pass
else: # Otherwise, draw the normal party box.
box.draw(rl.sky)
for i,box in enumerate(self.enemyBoxes): # Display the enemy boxes. Only the boxes themselves for now.
if len(self.enemies) <= i or self.enemies[i].getHP() <= 0: # Draw a gray box if enemy is not present or KO'd.
box.draw(rl.darker_gray)
elif self.animPhase == 2 and (self.animTarget - 4 == i or self.animTarget == ALL_ENEMIES) and int((time.time() - self.animStarted) * 8) % 2 == 0: # If the current animPhase is 2, this is the current animation target, and the time since the animation started dictates the box should be dark red, make it dark red.
rl.console_print(0, 61, i*4+2, self.enemies[i].getStatusLine(18)) # Draw status effects.
else:
box.draw(rl.crimson) # Otherwise, draw the normal party box.
rl.console_print(0, 61, i*4+2, self.enemies[i].getStatusLine(18)) # Draw status effects.
self.infoBox.draw(rl.white) # Draw the combat log box.
self.turnBox.draw(rl.white) # Draw the X's Turn box.
rl.console_print_ex(0, 31, 1, rl.BKGND_NONE, rl.CENTER, "{0}".format(self.turnOrder[0].getColoredName())) # Draw whose turn it is.
numBattlers = 0 # The number of conscious actors in the fight that will be shown in the turn order box (as such, this should never exceed 7).
actorList = "" # The list of conscious actors in the fight, in the order they appear in turnOrder.
for actor in self.turnOrder: # For each actor...
if numBattlers < 8 and actor.getHP() > 0: # If they're conscious and the turn order box isn't already filled up...
numBattlers += 1 # Increase the size of the box by one.
actorList += actor.getColoredName()+"\n" # Add the battler to the list.
self.turnOrderBox.setHeight(numBattlers+2) # Adjust the turn order box's size to match the amount of conscious battlers.
self.turnOrderBox.draw(rl.white) # Draw the turn order box.
rl.console_set_char(0, 42, 1, ">") # Draw the cursor in the turn order box. Purely aesthetic.
rl.console_print(0, 44, 1, actorList) # Draw the list of conscious battlers in the turn order box.
y = 11 # The line to draw the current log entry at.
for msg in self.log: # Draw the lines of the log, advancing y as appropriate.
rl.console_set_char(0, 24, y, ">") # Draw something to indicate when a log line starts. This ensures it is clear when one entry ends and a new one begins.
rl.console_print_rect(0, 26, y, 31, 12, msg) # Draw the log line.
y += rl.console_get_height_rect(0, 0, 0, 31, 12, msg) # Lower the y coordinate.
# Once all that is drawn, draw the background image.
rl.image_blit_rect(self.image, 0, 0, 0, 80, 24, rl.BKGND_SET) # Display the battle background image.
rl.console_set_default_foreground(0, rl.white) # Sets the foreground (text) color to white.
rl.console_set_default_background(0, rl.black) # Sets the background color to black.
# However, only after that should the actual stats be drawn. This is so the life bar backgrounds can override the background image.
for i,box in enumerate(self.partyBoxes): # Display the party boxes.
if not len(self.party) <= i and not self.party[i].isDead(): # Don't draw stats if party member is not present or dead (should still show if merely KO'd.
rl.console_print(0, 2, i*6+1, self.party[i].getHPBar()) # Draw HP bar.
rl.console_print(0, 2, i*6+2, self.party[i].getAPBar()) # Draw AP bar.
rl.console_print(0, 2, i*6+3, self.party[i].getMPBar()) # Draw MP bar.
for i,box in enumerate(self.enemyBoxes): # Display the enemy boxes.
if not len(self.enemies) <= i and not self.enemies[i].getHP() <= 0: # Don't draw stats if enemy is not present or KO'd.
rl.console_print(0, 61, i*4+1, self.enemies[i].getHPBar()) # Draw HP bar.
rl.console_print(0, 67, i*4+1, self.enemies[i].getAPBar()) # Draw AP bar.
rl.console_print(0, 73, i*4+1, self.enemies[i].getMPBar()) # Draw MP bar.
for i,box in enumerate(self.moveBoxes): # Draw all the move boxes, the current one being yellow. Since this can overlap the enemy stats, this must be drawn after that.
if i+1 == len(self.moveBoxes):
box.draw(rl.yellow)
else:
box.draw(rl.white)
def print_description(self, console, x, y, width):
print_height = 1
if self.str_requirement != 0:
if player.instance.player_stats.str < self.str_requirement:
libtcod.console_set_default_foreground(console, libtcod.red)
else:
libtcod.console_set_default_foreground(console,
libtcod.dark_green)
libtcod.console_print(
console, x, y + print_height,
'Strength Required: ' + str(self.str_requirement))
print_height += 1
libtcod.console_set_default_foreground(console, libtcod.white)
libtcod.console_print(console, x, y + print_height,
'Slot: ' + self.slot)
print_height += 1
if self.subtype is not None:
libtcod.console_print(console, x, y + print_height,
'Category: ' + self.subtype)
print_height += 1
print_height += 1
if self.level_progression is not None and self.level_progression != 0:
libtcod.console_print(
console, x, y + print_height,
'Level: ' + str(self.level) + '/' + str(self.max_level))
print_height += 1
if self.armor_bonus != 0:
libtcod.console_print(console, x, y + print_height,
'Armor: ' + str(self.armor_bonus))
print_height += 1
if self.weapon_dice is not None and self.weapon_dice != '0d0':
r = main.dice_range(self.weapon_dice, normalize_size=4)
libtcod.console_print(console, x, y + print_height,
'Damage: ' + str(r[0]) + '-' + str(r[1]))
print_height += 1
if self.str_dice is not None and self.str_dice > 0:
r = main.dice_range(str(self.str_dice) + 'd' +
str(player.instance.player_stats.str),
normalize_size=4)
libtcod.console_print(
console, x, y + print_height,
'Strength Bonus: ' + str(r[0]) + '-' + str(r[1]))
print_height += 1
if self.accuracy_bonus != 0:
acc_str = 'Accuracy: '
if self.accuracy_bonus > 0:
acc_str += '+'
libtcod.console_print(console, x, y + print_height,
acc_str + str(self.accuracy_bonus))
print_height += 1
if self.crit_bonus != 1.0:
acc_str = 'Crit: x'
libtcod.console_print(console, x, y + print_height,
acc_str + str(self.crit_bonus))
print_height += 1
if self.attack_delay != 0:
attacks = max(
round(
float(player.instance.fighter.attack_speed()) /
float(self.attack_delay), 1), 1.0)
libtcod.console_print(console, x, y + print_height,
'Attack Speed: ' + str(attacks))
print_height += 1
if self.evasion_bonus != 0:
libtcod.console_print(console, x, y + print_height,
'Evade: ' + str(self.evasion_bonus))
print_height += 1
if self.guaranteed_shred_bonus != 0:
libtcod.console_print(
console, x, y + print_height,
'Auto-shred: ' + str(self.guaranteed_shred_bonus))
print_height += 1
if self.max_hp_bonus != 0:
libtcod.console_print(console, x, y + print_height,
'Bonus HP: ' + str(self.max_hp_bonus))
print_height += 1
if self.pierce_bonus != 0:
libtcod.console_print(console, x, y + print_height,
'Pierce: ' + str(self.pierce_bonus))
print_height += 1
if self.shred_bonus != 0:
libtcod.console_print(console, x, y + print_height,
'Shred: ' + str(self.shred_bonus))
print_height += 1
if self.spell_power_bonus != 0:
libtcod.console_print(
console, x, y + print_height,
'Spell Power: ' + str(self.spell_power_bonus))
print_height += 1
if self.spell_resist_bonus != 0:
libtcod.console_print(
console, x, y + print_height,
'Spell Resist: ' + str(self.spell_resist_bonus))
print_height += 1
if self.sh_max > 0:
libtcod.console_print(console, x, y + print_height,
'Shield: ' + str(self.sh_max))
print_height += 1
if self.sh_recovery > 0:
libtcod.console_print(console, x, y + print_height,
'Recovery Time: ' + str(self.sh_recovery))
print_height += 1
if self.sh_raise_cost > 0:
libtcod.console_print(console, x, y + print_height,
'Raise Cost: ' + str(self.sh_raise_cost))
print_height += 1
if self.weight != 0:
libtcod.console_print(console, x, y + print_height,
'Weight: ' + str(self.weight))
print_height += 1
if self.break_chance > 0:
libtcod.console_print(
console, x, y + print_height, 'It has a ' +
str(self.break_chance) + '%%' + ' chance to break when used.')
print_height += 1
for r in self.resistances:
libtcod.console_print(console, x, y + print_height,
'Resist %s' % r)
print_height += 1
if self.ctrl_attack_desc:
libtcod.console_set_default_foreground(console, libtcod.azure)
text = 'Ctrl+attack: ' + self.ctrl_attack_desc
h = libtcod.console_get_height_rect(console, x,
y + print_height, width,
main.SCREEN_HEIGHT(), text)
libtcod.console_print_rect(console, x, y + print_height + 1, width,
h, text)
print_height += h + 1
libtcod.console_set_default_foreground(console, libtcod.white)
if hasattr(self, 'spell_list') and self.spell_list is not None:
libtcod.console_set_default_foreground(console, libtcod.azure)
libtcod.console_print(console, x, y + print_height, 'Spells:')
libtcod.console_set_default_foreground(console, libtcod.white)
for spell in self.flat_spell_list:
level = self.spell_list[
spell] # dictionaries don't preserve order - flat lists do
spell_data = spells.library[spell]
if level == 0:
libtcod.console_set_default_foreground(
console, libtcod.gray)
libtcod.console_print(
console, x, y + print_height,
"- " + spell_data.name.title() + " " + str(level) + "/" +
str(spell_data.max_level))
libtcod.console_set_default_foreground(console, libtcod.white)
print_height += 1
return print_height
def look():
game.message.new('Looking... (Arrow keys to move cursor, ESC to exit)', game.turns)
util.render_map()
dx = game.char.x - game.curx
dy = game.char.y - game.cury
key = libtcod.Key()
while not libtcod.console_is_window_closed():
libtcod.console_set_default_background(0, libtcod.white)
libtcod.console_rect(0, game.MAP_X + dx, dy + 1, 1, 1, False, libtcod.BKGND_SET)
libtcod.console_flush()
text = ""
libtcod.sys_wait_for_event(libtcod.EVENT_KEY_PRESS, key, libtcod.Mouse(), True)
dx, dy = key_check(key, dx, dy)
if key.vk == libtcod.KEY_ESCAPE:
del game.message.log[len(game.message.log) - 1]
util.render_message_panel()
break
if dx < 0:
dx = 0
if dy < 0:
dy = 0
if dx == game.MAP_WIDTH:
dx -= 1
if dy == game.MAP_HEIGHT:
dy -= 1
px = dx + game.curx
py = dy + game.cury
# create a list with the names of all objects at the cursor coordinates
if dx in range(game.MAP_WIDTH - 1) and dy in range(game.MAP_HEIGHT - 1) and game.current_map.tile_is_explored(px, py):
names = [obj for obj in game.current_map.objects if obj.x == px and obj.y == py]
prefix = 'you see '
if not libtcod.map_is_in_fov(game.fov_map, px, py):
prefix = 'you remember seeing '
for i in range(len(names) - 1, -1, -1):
if names[i].entity is not None:
names.pop(i)
if (px, py) == (game.char.x, game.char.y):
text = 'you see yourself'
elif names == []:
if game.current_map.tile_is_invisible(px, py):
text = prefix + 'a floor'
else:
text = prefix + game.current_map.tile[px][py]['article'] + game.current_map.tile[px][py]['name']
elif len(names) > 1:
text = prefix
for i in range(len(names)):
if i == len(names) - 1:
text += ' and '
elif i > 0:
text += ', '
if names[i].item is not None:
text += names[i].item.get_name(True)
if names[i].entity is not None:
text += names[i].entity.get_name(True)
else:
if names[0].item is not None:
text = prefix + names[0].item.get_name(True)
if names[0].entity is not None:
text = prefix + names[0].entity.get_name(True)
libtcod.console_set_default_foreground(game.con, libtcod.light_yellow)
libtcod.console_rect(game.con, 0, 0, game.MAP_WIDTH, 2, True, libtcod.BKGND_NONE)
libtcod.console_print_rect(game.con, 0, 0, game.MAP_WIDTH - 18, game.MAP_HEIGHT, text)
libtcod.console_blit(game.con, 0, 0, game.MAP_WIDTH, game.MAP_HEIGHT, 0, game.MAP_X, game.MAP_Y)
game.draw_map = True
def console_print_rect(self,con,x,y,width,height,fmt):
if con == 0:
libtcod.console_print_rect(con,x,y,width,height,fmt)
else:
libtcod.console_print_rect(self.mConsole[con-1],x,y,width,height,fmt)
def handle_keys():
global farm, key, mouse, panel_console, show_panel, entities
if key.vk != libtcod.KEY_NONE:
viewport_dx = 0
viewport_dy = 0
# vertical movement
for case in switch(key.vk):
if case(libtcod.KEY_UP): pass
if case(libtcod.KEY_KP8): pass
if case(libtcod.KEY_HOME): pass
if case(libtcod.KEY_KP7): pass
if case(libtcod.KEY_PAGEUP): pass
if case(libtcod.KEY_KP9):
viewport_dy -= 1
break
if case(libtcod.KEY_DOWN): pass
if case(libtcod.KEY_KP2): pass
if case(libtcod.KEY_END): pass
if case(libtcod.KEY_KP1): pass
if case(libtcod.KEY_PAGEDOWN): pass
if case(libtcod.KEY_KP3):
viewport_dy += 1
break
# horizontal movement
for case in switch(key.vk):
if case(libtcod.KEY_LEFT): pass
if case(libtcod.KEY_KP4): pass
if case(libtcod.KEY_HOME): pass
if case(libtcod.KEY_KP7): pass
if case(libtcod.KEY_END): pass
if case(libtcod.KEY_KP1):
viewport_dx -= 1
break
if case(libtcod.KEY_RIGHT): pass
if case(libtcod.KEY_KP6): pass
if case(libtcod.KEY_PAGEUP): pass
if case(libtcod.KEY_KP9): pass
if case(libtcod.KEY_PAGEDOWN): pass
if case(libtcod.KEY_KP3):
viewport_dx += 1
break
if viewport_dx != 0 or viewport_dy != 0:
farm.viewport.move(viewport_dx, viewport_dy)
if key.vk == libtcod.KEY_ESCAPE:
return True #exit game
elif key.vk == libtcod.KEY_BACKSPACE and (key.lctrl or key.rctrl):
farm.generate()
entities = []
place_ants(3)
farm.place_entities(entities)
else:
key_char = chr(key.c)
for case in switch(key_char):
if case('i'):
show_panel = not show_panel
if mouse.lbutton_pressed:
(x,y) = (mouse.cx + farm.viewport.x, mouse.cy + farm.viewport.y)
entity_list = []
# Check for an ant?
for entity in entities:
if entity.x == x and entity.y == y:
entity_list.append(str.format("{}\n---------------\nAnt ID: {}\nPosition: ({},{})\nState: {}", entity.name, id(entity), x, y, entity.state))
if len(entity_list) != 0:
libtcod.console_clear(panel_console)
libtcod.console_print_rect(panel_console, 2, 2, PANEL_WIDTH-4, 10, "\n\n".join(entity_list))
def render_map():
# recompute FOV if needed (the player moved or something)
libtcod.console_rect(0, game.MAP_X, game.MAP_Y, game.MAP_WIDTH, game.MAP_HEIGHT, True)
if game.fov_recompute:
find_map_viewport()
fov_radius()
initialize_fov(True)
libtcod.map_compute_fov(game.fov_map, game.char.x, game.char.y, game.FOV_RADIUS, game.FOV_LIGHT_WALLS, game.FOV_ALGO)
game.fov_recompute = False
# 'torch' animation
if game.fov_torch:
game.fov_torchx += 0.2
tdx = [game.fov_torchx + 20.0]
dx = libtcod.noise_get(game.fov_noise, tdx, libtcod.NOISE_SIMPLEX) * 1.5
tdx[0] += 30.0
dy = libtcod.noise_get(game.fov_noise, tdx, libtcod.NOISE_SIMPLEX) * 1.5
di = 0.4 * libtcod.noise_get(game.fov_noise, [game.fov_torchx], libtcod.NOISE_SIMPLEX)
# go through all tiles, and set their background color according to the FOV
for y in range(game.MAP_HEIGHT):
for x in range(game.MAP_WIDTH):
px = x + game.curx
py = y + game.cury
if not libtcod.map_is_in_fov(game.fov_map, px, py):
if game.draw_map and game.current_map.tile_is_explored(px, py):
if game.current_map.tile_is_animated(px, py):
libtcod.console_put_char_ex(game.con, x, y, game.current_map.tile[px][py]['icon'], game.current_map.tile[px][py]['dark_color'], game.current_map.tile[px][py]['dark_back_color'])
else:
libtcod.console_put_char_ex(game.con, x, y, game.current_map.tile[px][py]['icon'], game.current_map.tile[px][py]['dark_color'], game.current_map.tile[px][py]['back_dark_color'])
else:
if not game.fov_torch:
if 'animate' in game.current_map.tile[px][py] or 'duration' in game.current_map.tile[px][py]:
(front, back, game.current_map.tile[px][py]['lerp']) = render_tiles_animations(px, py, game.current_map.tile[px][py]['color'], game.current_map.tile[px][py]['back_light_color'], game.current_map.tile[px][py]['back_dark_color'], game.current_map.tile[px][py]['lerp'])
libtcod.console_put_char_ex(game.con, x, y, game.current_map.tile[px][py]['icon'], front, back)
elif game.draw_map:
libtcod.console_put_char_ex(game.con, x, y, game.current_map.tile[px][py]['icon'], game.current_map.tile[px][py]['color'], game.current_map.tile[px][py]['back_light_color'])
else:
base = game.current_map.tile[px][py]['back_light_color']
r = float(px - game.char.x + dx) * (px - game.char.x + dx) + (py - game.char.y + dy) * (py - game.char.y + dy)
if r < game.SQUARED_TORCH_RADIUS:
l = (game.SQUARED_TORCH_RADIUS - r) / game.SQUARED_TORCH_RADIUS + di
if l < 0.0:
l = 0.0
elif l > 1.0:
l = 1.0
base = libtcod.color_lerp(base, libtcod.gold, l)
libtcod.console_put_char_ex(game.con, x, y, game.current_map.tile[px][py]['icon'], game.current_map.tile[px][py]['color'], base)
if not game.current_map.tile_is_explored(px, py):
game.current_map.tile[px][py].update({'explored': True})
# draw all objects in the map (if in the map viewport), except the player who his drawn last
for obj in reversed(game.current_map.objects):
if obj.y in range(game.cury, game.cury + game.MAP_HEIGHT) and obj.x in range(game.curx, game.curx + game.MAP_WIDTH) and game.current_map.tile_is_explored(obj.x, obj.y) and obj.name != 'player':
if game.draw_map and obj.entity is not None:
if libtcod.map_is_in_fov(game.fov_map, obj.x, obj.y) and not obj.entity.is_identified():
skill = game.player.find_skill('Mythology')
if (game.player.skills[skill].level * 0.8) + 20 >= roll_dice(1, 100):
obj.entity.flags.append('identified')
game.message.new('You properly identify the ' + obj.entity.unidentified_name + ' as ' + obj.entity.get_name(True) + '.', game.turns)
game.player.skills[skill].gain_xp(3)
if obj.entity is not None and not obj.entity.is_identified():
obj.draw(game.con, libtcod.white)
else:
obj.draw(game.con)
game.char.draw(game.con)
libtcod.console_blit(game.con, 0, 0, game.MAP_WIDTH, game.MAP_HEIGHT, 0, game.MAP_X, game.MAP_Y)
game.draw_map = False
# move the player if using mouse
if game.mouse_move:
if mouse_auto_move() and not libtcod.path_is_empty(game.path):
game.char.x, game.char.y = libtcod.path_walk(game.path, True)
game.fov_recompute = True
game.player_move = True
else:
items_at_feet()
game.mouse_move = False
# check where is the mouse cursor if not in the act of moving while using the mouse
if not game.mouse_move:
(mx, my) = (game.mouse.cx - game.MAP_X, game.mouse.cy - 1)
px = mx + game.curx
py = my + game.cury
game.path_dx = -1
game.path_dy = -1
if my in range(game.MAP_HEIGHT) and mx in range(game.MAP_WIDTH):
libtcod.console_set_char_background(0, mx + game.MAP_X, my + 1, libtcod.white, libtcod.BKGND_SET)
if game.current_map.tile_is_explored(px, py) and not game.current_map.tile_is_blocked(px, py):
game.path_dx = px
game.path_dy = py
if game.mouse.lbutton_pressed:
target = [obj for obj in game.current_map.objects if obj.y == py and obj.x == px and obj.entity]
if target:
mouse_auto_attack(px, py, target[0])
else:
game.mouse_move = mouse_auto_move()
# draw a line between the player and the mouse cursor
if not game.current_map.tile_is_blocked(game.path_dx, game.path_dy):
libtcod.path_compute(game.path, game.char.x, game.char.y, game.path_dx, game.path_dy)
for i in range(libtcod.path_size(game.path)):
x, y = libtcod.path_get(game.path, i)
if (y - game.cury) in range(game.MAP_HEIGHT) and (x - game.curx) in range(game.MAP_WIDTH):
libtcod.console_set_char_background(0, game.MAP_X + x - game.curx, game.MAP_Y + y - game.cury, libtcod.desaturated_yellow, libtcod.BKGND_SET)
libtcod.console_set_default_foreground(0, libtcod.light_yellow)
libtcod.console_print_rect(0, game.MAP_X, game.MAP_Y, game.MAP_WIDTH - 18, game.MAP_HEIGHT, get_names_under_mouse())
if game.debug.enable:
libtcod.console_print_ex(0, game.MAP_X + game.MAP_WIDTH - 1, game.MAP_Y, libtcod.BKGND_NONE, libtcod.RIGHT, str(game.gametime.hour) + ':' + str(game.gametime.minute).rjust(2, '0') + ' (%3d fps)' % libtcod.sys_get_fps())
if game.hp_anim:
render_floating_text_animations()
def write_wrap(self, x, y, w, h, txt):
libtcodpy.console_print_rect(self._panel, x, y, w, h, txt)
def paragraph(self, text):
self.line += libtcod.console_print_rect(0, 10, self.line, TEXT_WIDTH,
0, text)
self.line += 1
def char_info_window(c):
# c == character
width = CHAR_INFO_WIDTH
header = "Character Information"
char_attrs = [
('Name', c.name),
('Level', c.level),
('XP', c.xp)
]
if c.combatant:
combat_attrs = [
('HP', c.combatant.hp),
('Max HP', c.combatant.max_hp),
('Attack power', c.combatant.power),
('Defense power', c.combatant.defense)
]
if c.caster:
caster_attrs = [
('MP', c.caster.mp),
('Max MP', c.caster.max_mp),
('Hot/Cold factor', c.caster.hot_cold),
('Wet/Dry factor', c.caster.wet_dry)
]
# calculate total height for the header
# (after auto-wrap) and one line per attr,
# plus 2 for each section header
# (because of the preceding empty line), 4 extra in total
header_height = libtcod.console_get_height_rect(
con, 0, 0, width, SCREEN_HEIGHT, header
)
height = len(char_attrs + combat_attrs + caster_attrs) + header_height + 4
# create an off-screen console that represents the menu's window
window = libtcod.console_new(width, height)
# print the header, with auto-wrap
libtcod.console_set_default_foreground(window, libtcod.white)
libtcod.console_print_rect(window, 0, 0, width, height, header)
# print all the attributes
y = header_height
for attr in char_attrs:
text = attr[0] + ': ' + str(attr[1])
libtcod.console_print(window, 0, y, text)
y += 1
y += 1 # empty line
libtcod.console_print(window, 0, y, 'Combat attributes')
y += 1
for attr in combat_attrs:
text = attr[0] + ': ' + str(attr[1])
libtcod.console_print(window, 0, y, text)
y += 1
y += 1 # empty line
libtcod.console_print(window, 0, y, 'Caster attributes')
y += 1
for attr in caster_attrs:
text = attr[0] + ': ' + str(attr[1])
libtcod.console_print(window, 0, y, text)
y += 1
# blit the contents of "window" to the root console
x = SCREEN_WIDTH / 2 - width / 2
y = SCREEN_HEIGHT / 2 - height / 2
libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
# present the root console to the player
libtcod.console_flush()
def paragraph(self, text):
self.line += libtcod.console_print_rect(0, 10, self.line, TEXT_WIDTH, 0, text)
self.line += 1
def change_settings(box, width, height, blitmap=False): confirm, cancel = False, False lerp = 1.0 descending = True current = 0 fonts = sorted(game.fonts, reverse=True) font = 0 if game.setting_font == 'large': font = 2 elif game.setting_font == 'medium': font = 1 history = game.setting_history fullscreen = ['on', 'off'] fs = 0 if game.setting_fullscreen == 'off': fs = 1 key = libtcod.Key() libtcod.console_print_rect(box, 2, 2, width - 4, 2, '(You may need to restart the game for the changes to take effect)') libtcod.console_print(box, 2, 5, 'Font size: ') libtcod.console_print(box, 2, 6, 'Message history size: ') libtcod.console_print(box, 2, 7, 'Fullscreen: ') while not confirm and not cancel: color, lerp, descending = color_lerp(lerp, descending) # font size setting if current == 0: libtcod.console_set_default_foreground(box, libtcod.white) libtcod.console_set_default_background(box, color) else: libtcod.console_set_default_foreground(box, libtcod.grey) libtcod.console_set_default_background(box, libtcod.black) libtcod.console_rect(box, 26, 5, 13, 1, True, libtcod.BKGND_SET) libtcod.console_print_ex(box, 32, 5, libtcod.BKGND_SET, libtcod.CENTER, fonts[font].capitalize()) # message history size setting if current == 1: libtcod.console_set_default_foreground(box, libtcod.white) libtcod.console_set_default_background(box, color) else: libtcod.console_set_default_foreground(box, libtcod.grey) libtcod.console_set_default_background(box, libtcod.black) libtcod.console_rect(box, 26, 6, 13, 1, True, libtcod.BKGND_SET) libtcod.console_print_ex(box, 32, 6, libtcod.BKGND_SET, libtcod.CENTER, str(history)) # full screen mode if current == 2: libtcod.console_set_default_foreground(box, libtcod.white) libtcod.console_set_default_background(box, color) else: libtcod.console_set_default_foreground(box, libtcod.grey) libtcod.console_set_default_background(box, libtcod.black) libtcod.console_rect(box, 26, 7, 13, 1, True, libtcod.BKGND_SET) libtcod.console_print_ex(box, 32, 7, libtcod.BKGND_SET, libtcod.CENTER, fullscreen[fs].capitalize()) for i in range(5, 8): libtcod.console_set_default_foreground(box, libtcod.white) libtcod.console_print_ex(box, 25, i, libtcod.BKGND_NONE, libtcod.LEFT, chr(27)) libtcod.console_print_ex(box, 39, i, libtcod.BKGND_NONE, libtcod.LEFT, chr(26)) if blitmap: libtcod.console_blit(box, 0, 0, width, height, 0, ((game.MAP_WIDTH - width) / 2) + game.MAP_X, (game.MAP_HEIGHT - height) / 2, 1.0, 1.0) else: libtcod.console_blit(box, 0, 0, width, height, 0, (game.SCREEN_WIDTH - width) / 2, (game.SCREEN_HEIGHT - height) / 2, 1.0, 1.0) libtcod.console_flush() libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, libtcod.Mouse()) if key.vk == libtcod.KEY_LEFT or key.vk == libtcod.KEY_RIGHT or key.vk == libtcod.KEY_UP or key.vk == libtcod.KEY_DOWN: lerp = 1.0 descending = True if key.vk == libtcod.KEY_LEFT: if current == 0: font -= 1 if font == -1: font = len(fonts) - 1 if current == 1: history -= 50 if history == 0: history = 1000 if current == 2: if fs == 0: fs = 1 else: fs = 0 elif key.vk == libtcod.KEY_RIGHT: if current == 0: font += 1 if font == len(fonts): font = 0 if current == 1: history += 50 if history > 1000: history = 50 if current == 2: if fs == 0: fs = 1 else: fs = 0 elif key.vk == libtcod.KEY_UP: current -= 1 if current == -1: current = 2 elif key.vk == libtcod.KEY_DOWN: current += 1 if current == 3: current = 0 elif key.vk == libtcod.KEY_ESCAPE: cancel = True elif key.vk == libtcod.KEY_ENTER: confirm = True if confirm: game.setting_history = history game.setting_fullscreen = fullscreen[fs] if game.setting_fullscreen == 'on': libtcod.console_set_fullscreen(True) else: libtcod.console_set_fullscreen(False) if blitmap: game.message.trim_history() IO.save_settings(fonts[font], str(history), fullscreen[fs])
