Beispiel #1
0
	def set_tile_values(self, default, x, y, type=None, reset=True):
		if reset:
			self.tile[x][y] = {}
		if type is not None:
			if type == 'trap':
				temp_tile = game.tiles.find_trap()
			else:
				temp_tile = game.tiles.get_tile_from_type(default, type)
		else:
			temp_tile = game.tiles.get_tile(default)

		self.tile[x][y].update({'icon': temp_tile.icon, 'name': temp_tile.name, 'type': temp_tile.type, 'article': temp_tile.article})
		self.tile[x][y].update({'color': temp_tile.color, 'dark_color': temp_tile.dark_color})
		self.tile[x][y].update({'dark_back_color': temp_tile.dark_back_color})
		if temp_tile.blocked:
			self.tile[x][y].update({'blocked': True})
		if temp_tile.block_sight:
			self.tile[x][y].update({'block_sight': True})
		if temp_tile.flags:
			for i in temp_tile.flags:
				self.tile[x][y].update({i: True})

		back_lerp = round(libtcod.random_get_float(game.rnd, 0, 1), 1)
		back_color = libtcod.color_lerp(temp_tile.back_color_high, temp_tile.back_color_low, back_lerp)
		if temp_tile.color_low != libtcod.black:
			fore_lerp = round(libtcod.random_get_float(game.rnd, 0, 1), 1)
			fore_color = libtcod.color_lerp(temp_tile.color, temp_tile.color_low, fore_lerp)
		else:
			fore_color = temp_tile.color
		if self.tile_is_animated(x, y):
			self.tile[x][y].update({'back_light_color': temp_tile.back_color_high, 'back_dark_color': temp_tile.back_color_low, 'lerp': back_lerp})
		else:
			self.tile[x][y].update({'color': fore_color, 'back_light_color': back_color, 'back_dark_color': libtcod.color_lerp(libtcod.black, back_color, 0.2), 'lerp': back_lerp})
Beispiel #2
0
 def renderPlayerOverlay(self, frame, player, cell):
   
   visible = libtcod.map_is_in_fov(self.map, cell.x, cell.y)
     
   if visible:
     cell.discovered = True
     intensity = self.calculateIntensity(player, cell.x, cell.y)
     
     if cell.passable:
       color = libtcod.color_lerp(self.c_lightOpen, self.c_torch, self.a_torch)
     else:
       color = libtcod.color_lerp(self.c_lightWall, self.c_torch, self.a_torch)
   else:
     intensity = 1
     if not cell.discovered:
       color = libtcod.black
     else:
       if cell.passable:
         color = self.c_darkOpen
       else:
         color = self.c_darkWall
       
       rgb = 255 - ((cell.y * 255) / self.height)
       
       overlayColor = libtcod.Color(rgb, rgb, rgb)
       color = overlayColor * color
       
   frame.setBgColor(cell.x, cell.y - self.yOffset, color, libtcod.BKGND_ALPHA(intensity))
   
   y = player.y - self.yOffset
   x = player.x
   frame.putChar(x, y, '@', b'white')
Beispiel #3
0
    def generate_land(self):
        for x in range(self.width):
            for y in range(self.height):
            	f = [self.noise_zoom * x / self.width,
            	     self.noise_zoom * y / self.height]

                value = libtcod.noise_get_fbm(self.world_noise, f, self.noise_octaves, libtcod.NOISE_PERLIN)

                #Threshold
                c = ((value + 1.0) / 2.0)
                col = libtcod.color_lerp(libtcod.dark_green, libtcod.black, c)
                self.map_list[x][y].land_type = 'grass' 

                c = int((value + 1.0) / 2.0 * 200)
                c = c - int(self.dist(x,y))/1.5

                #This is a beach
                if c < 28:
                	col = libtcod.lightest_amber
                	self.map_list[x][y].land_type = 'beach'
                #This is water 
                if c < 20:
                    coef = self.dist(x,y) / 320
                    col = libtcod.color_lerp(libtcod.azure, libtcod.darkest_azure * (c/2), coef)
                    if c > 5:
                    	self.map_list[x][y].land_type = 'shallow_water'
                    else:
                    	self.map_list[x][y].land_type = 'deep_water'
                    	libtcod.map_set_properties(self.deepsea_map, x, y, False, True)
                
                if self.map_list[x][y].land_type == 'grass' or self.map_list[x][y].land_type == 'beach':
                    libtcod.map_set_properties(self.ground_map, x, y, False, True)

                self.map_list[x][y].color = col
                libtcod.image_put_pixel(self.world_img, x, y, self.map_list[x][y].color)
Beispiel #4
0
	def end_struct(self, struct, name):
		self.temp_tile.dark_color = libtcod.color_lerp(libtcod.black, self.temp_tile.color, 0.2)
		self.temp_tile.dark_back_color = libtcod.color_lerp(libtcod.black, self.temp_tile.back_color_low, 0.2)
		if self.temp_tile.type == 'trees1':
			self.temp_tile.icon = chr(5)
		if self.temp_tile.type == 'trees2':
			self.temp_tile.icon = chr(6)
		if self.temp_tile.name == 'stalagmite':
			self.temp_tile.icon = chr(24)
		if self.temp_tile.type == 'chest':
			self.temp_tile.icon = chr(20)
		game.tiles.add_to_list(self.temp_tile)
		return True
Beispiel #5
0
 def draw(self, in_sight, area):
     if in_sight:
         lt.console_set_char_foreground(area.con, self.row, self.col, self.f_color)
         lt.console_set_char_background(area.con, self.row, self.col, self.b_color)
         lt.console_set_char(area.con, self.row, self.col, self.char)
         self.explored = True
     elif self.explored:
         f_color = lt.color_lerp(area.fog, self.f_color, area.fog_density)
         b_color = lt.color_lerp(area.fog, self.b_color, area.fog_density)
         lt.console_set_char_background(area.con, self.row, self.col, b_color)
         lt.console_set_default_foreground(area.con, f_color)
         lt.console_put_char(area.con, self.row, self.col, self.char)
     else:
         lt.console_set_char_background(area.con, self.row, self.col, area.fog)
Beispiel #6
0
def render_tiles_animations(x, y, icon, light, dark, lerp):
	if libtcod.random_get_int(game.rnd, 1, 70) == 70:
		if libtcod.random_get_int(game.rnd, 0, 1) == 0:
			if lerp >= 0.1:
				lerp -= 0.1
			else:
				lerp += 0.1
		else:
			if lerp < 1.0:
				lerp += 0.1
			else:
				lerp -= 0.1
	front = libtcod.color_lerp(light, icon, lerp)
	back = libtcod.color_lerp(dark, light, lerp)
	return front, back, lerp
Beispiel #7
0
    def take_behavior_action(self):

        battle = combat.WorldBattle(date=g.WORLD.time_cycle.get_current_date(), location=(self.figure.wx, self.figure.wy),
                                    faction1_named=[self.figure], faction1_populations=[], faction2_named=[self.target], faction2_populations=[])
        g.game.add_message(battle.describe(), libtcod.color_lerp(g.PANEL_FRONT, self.figure.color, .3))

        self.has_attempted_kill = 1
Beispiel #8
0
 def update(self):
     super(Recalling, self).update()
     if self.duration > 0:
         self.entity.next_action = 100
         tile = self.entity.bg.tiles[(self.entity.x, self.entity.y)]
         self.entity.color = libtcod.color_lerp(tile.bg_color, self.color,
                                                1 - (self.duration / 10.0))
Beispiel #9
0
def create_smoke(pos, color=tcod.gray, age=0, grow=0.1, decay=0.1, direction=-1, speed=0.3, max_opacity=.75, interp_wind=True):
	_intensity = random.uniform(max_opacity*.25, max_opacity)
	_color = tcod.color_lerp(color, tcod.white, random.uniform(0, 0.3))
	
	if direction == -1:
		_velocity = [random.uniform(-speed, speed), random.uniform(-speed, speed), 0]
	else:
		_velocity = numbers.velocity(direction, speed)
	
	_effect = {'type': 'smoke',
	           'color': _color,
	           'intensity': _intensity*age,
	           'max_intensity': _intensity,
	           'decay': decay,
	           'grow': grow,
	           'disappear': False,
	           'pos': list(pos),
	           'float_pos': list(pos),
	           'interp_wind': interp_wind,
	           'velocity': [_velocity[0], _velocity[1], _velocity[2]],
	           'callback': process_smoke,
	           'draw_callback': draw_smoke,
	           'unregister_callback': clear_effect}
	
	register_effect(_effect)
def lerp_colors(colors):
    final_color = tcod.white
    i = 0
    for color in colors:
        i += 1
        final_color = tcod.color_lerp(final_color, color, 1.0 / i)
    return final_color
Beispiel #11
0
def PrecipGradMap(World):  # ------------------------------------------------------------ Print Map (Surface Temperature Gradient) white -> cold red -> warm --------------------------------
    for x in xrange(WORLD_WIDTH):
        for y in xrange(WORLD_HEIGHT):
            tempv = World[x][y].precip
            tempcolor = libtcod.color_lerp ( libtcod.white, libtcod.light_blue,tempv)
            libtcod.console_put_char_ex( 0, x, y + SCREEN_HEIGHT/2 - WORLD_HEIGHT/2, '\333' , tempcolor, libtcod.black)
    libtcod.console_flush()
    return
Beispiel #12
0
def tint_tile(x,y,color,coef):
	_view = get_active_view()
	
	_o_color = tcod.Color(int(_view['col_buffer'][1][0][y,x]),int(_view['col_buffer'][1][1][y,x]),int(_view['col_buffer'][1][2][y,x]))
	_n_color = tcod.color_lerp(_o_color,color,coef)
	
	_view['col_buffer'][1][0][y,x] = _n_color.r
	_view['col_buffer'][1][1][y,x] = _n_color.g
	_view['col_buffer'][1][2][y,x] = _n_color.b
Beispiel #13
0
 def update(self):
   super(Linked, self).update()
   t = self.entity.bg.tiles[(self.entity.x, self.entity.y)]
   if self.duration > 0:
     if t not in self.tiles:
       self.status.clone(self.entity)
       self.entity.get_attacked(self)
       self.end()
     else:
       t.bg_color = libtcod.color_lerp(libtcod.black, self.owner.original_color, 0.4)
Beispiel #14
0
 def update(self):
     super(Linked, self).update()
     t = self.entity.bg.tiles[(self.entity.x, self.entity.y)]
     if self.duration > 0:
         if t not in self.tiles:
             self.status.clone(self.entity)
             self.entity.get_attacked(self)
             self.end()
         else:
             t.bg_color = libtcod.color_lerp(libtcod.black,
                                             self.owner.original_color, 0.4)
def apply_screen_impact():
	""" |  Render the whole screen in the color set in gvar.screen_impact
		|  and fade out.
	"""
	if gvar.screen_impact is not None:
		color = libtcod.color_lerp(libtcod.black, gvar.screen_impact[0], float(gvar.screen_impact[1]))
		libtcod.console_set_default_background(gvar.con, color)
		libtcod.console_rect(gvar.con, 1, 1, gvar.SCREEN_WIDTH, gvar.SCREEN_HEIGHT, False, libtcod.BKGND_SET)
		gvar.screen_impact[1] -= 0.25
		if gvar.screen_impact[1] < 0:
			gvar.screen_impact = None
Beispiel #16
0
def TempGradMap(
    World
):  # ------------------------------------------------------------ Print Map (Surface Temperature Gradient) white -> cold red -> warm --------------------------------
    for x in xrange(WORLD_WIDTH):
        for y in xrange(WORLD_HEIGHT):
            tempv = World[x][y].temp
            tempcolor = libtcod.color_lerp(libtcod.white, libtcod.red, tempv)
            libtcod.console_put_char_ex(
                0, x, y + SCREEN_HEIGHT / 2 - WORLD_HEIGHT / 2, '\333',
                tempcolor, libtcod.black)
    libtcod.console_flush()
    return
Beispiel #17
0
 def draw(self, area):
     for col_offset in xrange(len(self.graphic)):
         for row_offset in xrange(len(self.graphic[0])):
             row = self.row + row_offset
             col = self.col + col_offset
             char = self.graphic[col_offset][row_offset]
             if lt.map_is_in_fov(area.fov_map, col, row):
                 lt.console_set_default_foreground(area.area.con, self.f_color)
                 lt.console_put_char(area.area.con, row, col, char)
             elif area[col][row].explored:
                 color = lt.color_lerp(area.fog, self.f_color, area.fog_density)
                 lt.console_set_default_foreground(area.con, color)
                 lt.console_put_char(area.con, row, col, char)
Beispiel #18
0
def color_lerp(lerp, descending, base=libtcod.black, light=libtcod.light_blue):
	if descending:
		lerp -= 0.001
		if lerp < 0.4:
			lerp = 0.4
			descending = False
	else:
		lerp += 0.001
		if lerp > 1.0:
			lerp = 1.0
			descending = True
	color = libtcod.color_lerp(base, light, lerp)
	return color, lerp, descending
def apply_screen_impact():
    """ |  Render the whole screen in the color set in gvar.screen_impact
		|  and fade out.
	"""
    if gvar.screen_impact is not None:
        color = libtcod.color_lerp(libtcod.black, gvar.screen_impact[0],
                                   float(gvar.screen_impact[1]))
        libtcod.console_set_default_background(gvar.con, color)
        libtcod.console_rect(gvar.con, 1, 1, gvar.SCREEN_WIDTH,
                             gvar.SCREEN_HEIGHT, False, libtcod.BKGND_SET)
        gvar.screen_impact[1] -= 0.25
        if gvar.screen_impact[1] < 0:
            gvar.screen_impact = None
Beispiel #20
0
def PrecipGradMap(
    World
):  # ------------------------------------------------------------ Print Map (Precipitation Gradient) white -> low blue -> high --------------------------------
    for x in xrange(WORLD_WIDTH):
        for y in xrange(WORLD_HEIGHT):
            tempv = World[x][y].precip
            tempcolor = libtcod.color_lerp(libtcod.white, libtcod.light_blue,
                                           tempv)
            libtcod.console_put_char_ex(
                0, x, y + SCREEN_HEIGHT / 2 - WORLD_HEIGHT / 2, '\333',
                tempcolor, libtcod.black)
    libtcod.console_flush()
    return
Beispiel #21
0
    def take_behavior_action(self):

        battle = combat.WorldBattle(date=g.WORLD.time_cycle.get_current_date(),
                                    location=(self.figure.wx, self.figure.wy),
                                    faction1_named=[self.figure],
                                    faction1_populations=[],
                                    faction2_named=[self.target],
                                    faction2_populations=[])
        g.game.add_message(
            battle.describe(),
            libtcod.color_lerp(g.PANEL_FRONT, self.figure.color, .3))

        self.has_attempted_kill = 1
Beispiel #22
0
    def process(self, game):
        visible =self.game.fov.is_visible(self.x, self.y)
        moved = False

        if visible:
            self.seen += 1
            self.color = tcod.color_lerp(tcod.dark_gray, self.orig_color,
                                         (self.seen % 50) / 100.0)
            if self.seen % 50 == 0:
                self.game.duplicate(self)

            if self.seen == 200:
                self.character = 'o'
                self.movement = 0.4

            elif self.seen == 400:
                self.character = 'O'
                self.movement = 0.6

            path = tcod.path_new_using_map(self.game.fov.fov, 1.0)
            tcod.path_compute(path, self.x, self.y, self.game.player.x,
                              self.game.player.y)

            if tcod.path_size(path) > 2:
                self.points += self.movement
                if self.points >= 1:
                    self.points -= 1
                    x, y = tcod.path_get(path, 1)
                    self.move(x - self.x, y - self.y)
                    moved = True
            tcod.path_delete(path)

        if not moved:
            self.points += self.movement
            if self.points >= 1:
                self.points -= 1
                movement = [
                    (0, 0),
                    (0, 1),
                    (0, -1),
                    (1, 0),
                    (-1, 0),
                    (1, 1),
                    (-1, -1),
                    (-1, 1),
                    (1, -1)
                ]
                self.move(*random.choice(movement))

        return True
Beispiel #23
0
def create_explosion(pos, force):
	alife.noise.create(pos, force*100, 'an explosion', 'a low rumble', skip_on_visual=False)
	
	create_light(pos, (255, 69, 0), force*6, 1, fade=3)
	create_smoke_cloud(pos,
	                   force*6,
	                   age=.8,
	                   factor_distance=True)

	for i in range(random.randint(1, 3)):
		create_smoke_streamer(pos,
		                      3+random.randint(0, 2),
		                      (force*2)+random.randint(3, 6),
		                      color=tcod.color_lerp(tcod.gray, tcod.crimson, random.uniform(0.1, 0.3)))
Beispiel #24
0
	def create_map_legend(self, con, mode=0):
		for x in range(game.WORLDMAP_WIDTH):
			for y in range(game.WORLDMAP_HEIGHT):
				if mode == 0:
					cellheight = libtcod.heightmap_get_value(game.heightmap, x, y)
				else:
					cellheight = self.hm_list[(y * game.WORLDMAP_WIDTH) + x]
				if cellheight >= game.terrain['Mountain Peak']['elevation']:
					# mountain peak
					bcolor = libtcod.color_lerp(libtcod.silver, libtcod.grey, (1.000 - cellheight) / 0.050)
				elif cellheight >= game.terrain['Mountains']['elevation']:
					# mountains
					bcolor = libtcod.color_lerp(libtcod.grey, libtcod.Color(40, 24, 12), (game.terrain['Mountain Peak']['elevation'] - cellheight) / 0.125)
				elif cellheight >= game.terrain['High Hills']['elevation']:
					# hills
					bcolor = libtcod.color_lerp(libtcod.Color(40, 24, 12), libtcod.Color(53, 33, 16), (game.terrain['Mountains']['elevation'] - cellheight) / 0.125)
				elif cellheight >= game.terrain['Low Hills']['elevation']:
					# forest
					bcolor = libtcod.color_lerp(libtcod.Color(53, 33, 16), libtcod.Color(40, 67, 25), (game.terrain['High Hills']['elevation'] - cellheight) / 0.125)
				elif cellheight >= game.terrain['Forest']['elevation']:
					# forest
					bcolor = libtcod.color_lerp(libtcod.Color(40, 67, 25), libtcod.Color(80, 134, 50), (game.terrain['Low Hills']['elevation'] - cellheight) / 0.345)
				elif cellheight >= game.terrain['Plains']['elevation']:
					# plains
					bcolor = libtcod.color_lerp(libtcod.Color(80, 134, 50), libtcod.Color(112, 150, 80), (game.terrain['Forest']['elevation'] - cellheight) / 0.090)
				elif cellheight >= game.terrain['Coast']['elevation']:
					# coast
					bcolor = libtcod.color_lerp(libtcod.Color(112, 150, 80), libtcod.Color(176, 176, 153), (game.terrain['Plains']['elevation'] - cellheight) / 0.020)
				elif cellheight >= game.terrain['Shore']['elevation']:
					# shallow water
					bcolor = libtcod.color_lerp(libtcod.Color(176, 176, 153), libtcod.Color(47, 67, 103), (game.terrain['Coast']['elevation'] - cellheight) / 0.010)
				elif cellheight >= game.terrain['Sea']['elevation']:
					# deep water
					bcolor = libtcod.color_lerp(libtcod.Color(47, 67, 103), libtcod.Color(8, 32, 72), (game.terrain['Shore']['elevation'] - cellheight) / 0.040)
				else:
					# ocean
					bcolor = libtcod.Color(8, 32, 72)
				libtcod.console_put_char_ex(con, x, y, ' ', bcolor, bcolor)
				if mode != 3:
					libtcod.image_put_pixel(self.map_image_small, x, y, bcolor)
				if mode == 0:
					self.hm_list[(y * game.WORLDMAP_WIDTH) + x] = float("{0:.4f}".format(cellheight))
Beispiel #25
0
def draw_hud(player):
	libtcod.console_set_foreground_color(0, libtcod.white)
	
	X, Y, W, H = 0, 40, 30, 10
	
	libtcod.console_set_background_color(0, libtcod.black)
	libtcod.console_rect(0, X, Y, W, H, True, libtcod.BKGND_SET)
	
	libtcod.console_put_char_ex(0, X + 1, Y + 1, player.symbol, player.color, libtcod.black)
	
	libtcod.console_print_left(0, X + 3, Y + 1, libtcod.BKGND_NONE, player.name)
	libtcod.console_print_left(0, X + 1, Y + 8, libtcod.BKGND_NONE, 'In {:s}'.format(player.map.name))
	
	for i in range(10):
		if i * player.max_health > player.health * 10:
			libtcod.console_put_char_ex(0, X + 1 + i, Y + 3, ' ', libtcod.black, libtcod.darker_red)
		
		elif (i+1) * player.max_health > player.health * 10:
			libtcod.console_put_char_ex(0, X + 1 + i, Y + 3, ' ', libtcod.black, libtcod.color_lerp(libtcod.darker_red, libtcod.red, 10.*player.health/player.max_health - i))
		
		else:
			libtcod.console_put_char_ex(0, X + 1 + i, Y + 3, ' ', libtcod.black, libtcod.red)
	
	for i in range(10):
		if player.energy > i:
			libtcod.console_put_char_ex(0, X + 1 + i, Y + 4, 'O', libtcod.blue + libtcod.white * 0.2, libtcod.black)
		
		else:
			libtcod.console_put_char_ex(0, X + 1 + i, Y + 4, 'O', libtcod.desaturated_blue * 0.5, libtcod.black)
	
	libtcod.console_print_left(0, X + 12, Y + 3, libtcod.BKGND_NONE, 'MH: - {}'.format(player.mainhand and player.mainhand.name or '-'))
	
	if player.mainhand:
		libtcod.console_put_char_ex(0, X + 16, Y + 3, player.mainhand.symbol, player.mainhand.color, libtcod.black)
	
	libtcod.console_print_left(0, X + 12, Y + 4, libtcod.BKGND_NONE, 'OH: - {}'.format(player.offhand and player.offhand.name or player.mainhand and player.mainhand.wield_twohands and player.mainhand.name or '-'))
	
	if player.offhand:
		libtcod.console_put_char_ex(0, X + 16, Y + 4, player.offhand.symbol, player.offhand.color, libtcod.black)
	
	elif player.mainhand and player.mainhand.wield_twohands:
		libtcod.console_put_char_ex(0, X + 16, Y + 4, player.mainhand.symbol, player.mainhand.color, libtcod.black)
	
	libtcod.console_print_left(0, X + 12, Y + 5, libtcod.BKGND_NONE, 'AR: - {}'.format(player.wearing  and player.wearing.name or '-'))
	
	if player.wearing:
		libtcod.console_put_char_ex(0, X + 16, Y + 5, player.wearing.symbol, player.wearing.color, libtcod.black)
	
	draw_messages(player)
Beispiel #26
0
	def _apply_splatters(self, base_color, coeff = 1):
		# total = 1
		
		# for key, value in self.splatters.items():
			# value = min(value, 1)
			
			# base_color += MATERIALS[key][0] * (MATERIALS[key][1] * value * coeff)
			# total += value * coeff
		
		# return base_color * (1. / total)
		
		amount = self.splatters['blood']
		color, alpha = MATERIALS['blood']
		
		return libtcod.color_lerp(base_color, color, amount * coeff * alpha)
Beispiel #27
0
def create_explosion(pos, force):
    alife.noise.create(pos,
                       force * 100,
                       'an explosion',
                       'a low rumble',
                       skip_on_visual=False)

    create_light(pos, (255, 69, 0), force * 6, 1, fade=3)
    create_smoke_cloud(pos, force * 6, age=.8, factor_distance=True)

    for i in range(random.randint(1, 3)):
        create_smoke_streamer(pos,
                              3 + random.randint(0, 2),
                              (force * 2) + random.randint(3, 6),
                              color=tcod.color_lerp(tcod.gray, tcod.crimson,
                                                    random.uniform(0.1, 0.3)))
Beispiel #28
0
def create_target_list():
	_menu_items = []
	for target_id in LIFE[SETTINGS['controlling']]['seen']:
		if LIFE[target_id]['dead']:
			continue
		
		if not _menu_items:
			SETTINGS['following'] = target_id
		
		_color = life.draw_life_icon(LIFE[target_id])[1]
		_menu_items.append(create_item('single',
		                               ' '.join(LIFE[target_id]['name']),
		                               None,
		                               target=target_id,
		                               color=(_color, tcod.color_lerp(_color, tcod.white, 0.5))))
	
	return _menu_items
Beispiel #29
0
def update_conway():
    global game_map
    map_width, map_height = map_size
    new_map = copy.deepcopy(blank_map)
    for x in range(map_width):
        for y in range(map_height):
            adjacent = get_adjacent(x, y)
            alive = len(adjacent) == 3 or (
                len(adjacent) == 2 and game_map[x][y])
            if alive:
                final_color = tcod.white
                i = 0
                for color in adjacent:
                    i += 1
                    final_color = tcod.color_lerp(final_color, color,
                                                  1.0 / i)
                # color = most_common(adjacent)
                new_map[x][y] = final_color
    game_map = new_map
def new_game():
	""" |  Start a new game
		|  Create a map, FOV Map and print Welcome Mesage
	"""
	from charactercreation import create_character
	from spawn import spawn_player

	gvar.game = gvar.Game()
	gvar.game.init_world()
	spawn_player([gvar.game.world.worldspace, 0])

	initialize_fov()
	color = libtcod.color_lerp(libtcod.white, libtcod.red, 0.9)
	render.message('Welcome, Child of the Unconquered Sun.', color)
	render.animate_background('main_menu', 0.5, reverse=True)
	ch = create_character()
	if ch == 'exit':
		main_menu()
	play_game()
Beispiel #31
0
	def end_struct(self, struct, name):
		skill_level = ['apprentice ', 'journeyman ', 'adept ', 'master ']
		self.temp_monster.dark_color = libtcod.color_lerp(libtcod.black, self.temp_monster.color, 0.3)
		self.temp_monster.health.nb_dices = self.temp_monster.level
		self.temp_monster.health.bonus = self.temp_monster.level
		if self.temp_monster.level == 1:
			self.temp_monster.flags.append('identified')
		game.monsters.add_to_list(self.temp_monster)
		if self.temp_monster.type == 'humanoid':
			for i in range(0, 4):
				self.new_monster = copy.deepcopy(self.temp_monster)
				self.new_monster.name = skill_level[i] + self.new_monster.name
				self.new_monster.level += (i * 2) + 1
				self.new_monster.attack_rating += ((i * 2) + 1) * 8
				self.new_monster.defense_rating += ((i * 2) + 1) * 8
				self.new_monster.health.nb_dices = self.new_monster.level
				self.new_monster.health.bonus = self.new_monster.level
				self.new_monster.damage.multiplier = i + 2
				game.monsters.add_to_list(self.new_monster)
		return True
Beispiel #32
0
def render_floating_text_animations():
	fps = 8
	try:
		for i, value in enumerate(reversed(game.hp_anim)):
			if game.MAP_Y + value['y'] - game.cury - (value['turns'] / fps) > 0:
				libtcod.console_set_default_foreground(0, libtcod.color_lerp(libtcod.black, value['color'], 1 - ((value['turns'] / fps) * 0.2)))
				if 'player' in value:
					libtcod.console_print_ex(0, game.MAP_X + game.char.x - game.curx, game.MAP_Y + game.char.y - game.cury - (value['turns'] / fps), libtcod.BKGND_NONE, libtcod.CENTER, value['damage'])
				else:
					libtcod.console_print_ex(0, game.MAP_X + value['x'] - game.curx, game.MAP_Y + value['y'] - game.cury - (value['turns'] / fps), libtcod.BKGND_NONE, libtcod.CENTER, value['damage'])
				if value['turns'] <= fps * 1.5:
					libtcod.console_set_default_foreground(0, value['icon_color'])
					if 'player' in value:
						libtcod.console_print_ex(0, game.MAP_X + game.char.x - game.curx, game.MAP_Y + game.char.y - game.cury, libtcod.BKGND_NONE, libtcod.CENTER, value['icon'])
					else:
						libtcod.console_print_ex(0, game.MAP_X + value['x'] - game.curx, game.MAP_Y + value['y'] - game.cury, libtcod.BKGND_NONE, libtcod.CENTER, value['icon'])
			value.update({'turns': value['turns'] + 1})
			if value['turns'] > fps * 4:
				game.hp_anim.pop(len(game.hp_anim) - i - 1)
	except IndexError:
		print "Error in render floating text animations function"
		print game.hp_anim
Beispiel #33
0
def create_smoke(pos,
                 color=tcod.gray,
                 age=0,
                 grow=0.1,
                 decay=0.1,
                 direction=-1,
                 speed=0.3,
                 max_opacity=.75,
                 interp_wind=True):
    _intensity = random.uniform(max_opacity * .25, max_opacity)
    _color = tcod.color_lerp(color, tcod.white, random.uniform(0, 0.3))

    if direction == -1:
        _velocity = [
            random.uniform(-speed, speed),
            random.uniform(-speed, speed), 0
        ]
    else:
        _velocity = bad_numbers.velocity(direction, speed)

    _effect = {
        'type': 'smoke',
        'color': _color,
        'intensity': _intensity * age,
        'max_intensity': _intensity,
        'decay': decay,
        'grow': grow,
        'disappear': False,
        'pos': list(pos),
        'float_pos': list(pos),
        'interp_wind': interp_wind,
        'velocity': [_velocity[0], _velocity[1], _velocity[2]],
        'callback': process_smoke,
        'draw_callback': draw_smoke,
        'unregister_callback': clear_effect
    }

    register_effect(_effect)
Beispiel #34
0
def render_blotter():
    global blotter
    global took_turn
    
    reached_top = False
    y = PANEL_HEIGHT - 2
    for turn in range(len(blotter)):
        messages = blotter[turn]
        for message in range(len(messages)):
            (text, color) = messages[message]
            color = libtcod.color_lerp(color, libtcod.black, min(turn * 0.2, 1))
            libtcod.console_set_foreground_color(panel, color)
            y -= libtcod.console_height_left_rect(panel, STATS_WIDTH + 2, y, SCREEN_WIDTH - STATS_WIDTH - 3, 0, text)
            libtcod.console_print_left_rect(panel, STATS_WIDTH + 2, y+1, SCREEN_WIDTH - STATS_WIDTH - 3, 0, libtcod.BKGND_NONE, text)
            if y <= 1:
                reached_top = True
                break
        if reached_top:
            break

    if took_turn:
        blotter.insert(0,[])
    blotter = blotter[0:5]
Beispiel #35
0
def render_all():

    global fov_map, color_dark_wall, color_light_wall
    global color_dark_ground, color_light_ground
    global fov_recompute, fov_torchx

    if fov_recompute:
        #recompute FOV if needed (the player moved or something)
        fov_recompute = False
        libtcod.map_compute_fov(fov_map, player.x, player.y, TORCH_RADIUS,
                                FOV_LIGHT_WALLS, FOV_ALGO)

    #torch flickers (using noise generator)
    fov_torchx += 0.2
    tdx = [fov_torchx + 20.0]
    dx = libtcod.noise_get(fov_noise, tdx) * 1.5
    tdx[0] += 30.0
    dy = libtcod.noise_get(fov_noise, tdx) * 1.5
    di = 0.2 * libtcod.noise_get(fov_noise, [fov_torchx])

    # Iterate through rendering queue
    for y in range(MAP_HEIGHT):
        for x in range(MAP_WIDTH):
            visible = libtcod.map_is_in_fov(fov_map, x, y)
            wall = map[x, y].block_sight  # check if tile is a wall
            if not visible:
                # if it's not visible right now, the player can only
                # see it if it's explored
                if map[x, y].explored:
                    # It's out of the player's FOV
                    if wall:
                        libtcod.console_set_char_background(con, x, y,
                                                            color_dark_wall,
                                                            libtcod.BKGND_SET)
                    else:
                        libtcod.console_set_char_background(con, x, y,
                                                            color_dark_ground,
                                                            libtcod.BKGND_SET)
            else:
            # It's visible
                if wall:
                    base = color_dark_wall
                    light = color_light_wall
                else:
                    base = color_dark_ground
                    light = color_light_ground

                #Let the torch actually flicker
                r = float(x - player.x + dx) * (x - player.x + dx) + \
                         (y - player.y + dy) * (y - player.y + dy)
                if r < SQUARED_TORCH_RADIUS:
                    l = (SQUARED_TORCH_RADIUS - r) / SQUARED_TORCH_RADIUS + di
                    if l < 0.0:
                        l = 0.0
                    elif l > 1.0:
                        l = 1.0
                    # alter base colors to simulate flickering torch
                    base = libtcod.color_lerp(base, light, l)
                # actually draw the visible tile
                libtcod.console_set_char_background(con, x, y, base,
                                                    libtcod.BKGND_SET)
                #since it's visible, it's explored
                map[x, y].explored = True

    # Draw all objects in the list
    for object in objects:
        if object != player:
            object.draw()
    player.draw()

    # Blit the contents of con to the root console
    libtcod.console_blit(con, 0, 0, MAP_WIDTH, MAP_HEIGHT, 0, 0, 0)

    # Prepare to render the GUI panel
    libtcod.console_set_default_background(panel, libtcod.black)
    libtcod.console_clear(panel)

    # Print the game messages
    y = 1
    for (line, color) in game_msgs:
        libtcod.console_set_default_foreground(panel, color)
        libtcod.console_set_alignment(panel, libtcod.LEFT)
        libtcod.console_print(panel, MSG_X, y, line)
        y += 1

    # Show the player's stats
    render_bar(1, 1, BAR_WIDTH, 'HP', player.fighter.hp, player.fighter.max_hp,
               libtcod.light_red, libtcod.darker_red)

    libtcod.console_set_alignment(panel, libtcod.LEFT)
    libtcod.console_print(panel, 1, 3,
                          'Dungeon level {}'.format(str(dungeon_level)))

    # Display names of objects under the mouse
    libtcod.console_set_default_foreground(panel, libtcod.light_grey)
    libtcod.console_print(panel, 1, 0, get_names_under_mouse())

    # Blit the contents of "panel" to the root console
    libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0,
                         PANEL_Y)
Beispiel #36
0
    def render(self, map, view_centre, fov_entity):
        """Render map.
        
        Arguments:
        map - map to render
        view_centre - world location to centre map on when rendering
        fov_entity - entity to use for fov calculation
        
        """
        # Generate field of view map
        fov_map = map.generate_fov_map(fov_entity)

        # Calculate bounds for rendering
        half_xsize = int(self.width / 2)
        half_ysize = int(self.height / 2)

        x0 = view_centre[0] - half_xsize
        y0 = view_centre[1] - half_ysize
        x1 = view_centre[0] + half_xsize + 1
        y1 = view_centre[1] + half_ysize + 1

        for y in range(y0, y1):
            for x in range(x0, x1):

                tile = map.tiles[x][y]
                visible = libtcod.map_is_in_fov(fov_map, x, y)

                # Calculate offset onto screen and render
                xt = self.x_offset + x - x0
                yt = self.y_offset + y - y0

                if not visible:
                    if tile.seen:
                        # 70% desaturation
                        greyscale = int(tile.bcolour.r * 0.3 +
                                        tile.bcolour.g * 0.59 +
                                        tile.bcolour.b * 0.11)
                        nonviscolour = libtcod.color_lerp(
                            tile.bcolour,
                            libtcod.Color(greyscale, greyscale, greyscale),
                            0.7)
                        libtcod.console_set_char_background(
                            0, xt, yt, nonviscolour, libtcod.BKGND_SET)
                        libtcod.console_put_char(0, xt, yt, ' ',
                                                 libtcod.BKGND_NONE)
                    else:
                        libtcod.console_set_char_background(
                            0, xt, yt, libtcod.black, libtcod.BKGND_SET)
                        libtcod.console_put_char(0, xt, yt, ' ',
                                                 libtcod.BKGND_NONE)
                else:
                    tile.seen = True
                    libtcod.console_set_char_background(
                        0, xt, yt, tile.bcolour, libtcod.BKGND_SET)

                    # Render entities in the world first
                    if tile.entity:
                        libtcod.console_set_default_foreground(
                            0, tile.entity.colour)
                        libtcod.console_put_char(0, xt, yt, tile.entity.char,
                                                 libtcod.BKGND_NONE)
                    elif tile.inventory:
                        libtcod.console_set_default_foreground(
                            0, tile.inventory.colour)
                        libtcod.console_put_char(0, xt, yt,
                                                 tile.inventory.char,
                                                 libtcod.BKGND_NONE)
                    elif tile.type == TileType.DOOR:
                        libtcod.console_set_default_foreground(
                            0, tile.door.colour)
                        libtcod.console_put_char(0, xt, yt, tile.door.char,
                                                 libtcod.BKGND_NONE)
                    elif tile.type == TileType.WINDOW:
                        libtcod.console_set_default_foreground(
                            0, tile.window.colour)
                        libtcod.console_put_char(0, xt, yt, tile.window.char,
                                                 libtcod.BKGND_NONE)
                    elif not tile.blocks_movement:
                        libtcod.console_set_default_foreground(
                            0, libtcod.black)
                        libtcod.console_put_char(0, xt, yt, '.',
                                                 libtcod.BKGND_NONE)
Beispiel #37
0
def inventory(con, player, game, width=80, height=43):
    """
    TODO:
        Add in highlighting for Weapons and Equipment consoles
        Add in keyboard arrow selection support
        Add in "drop" mode, drop items from inventory
        Fix Weapons and Equipment keyboard handling
        Fix duplication bug when equipping items (fixed)
        Fix take off weapon confirmation when equipping an item (fixed)
        2 handed code needs work (?)
        keyboard input is sluggish. Might have to update libtcod to fix

    :param con: Destination console (not used atm)
    :param player: The main player object
    :param game: The main game object
    :param width: width of the inventory screen
    :param height: height of the inventory screen
    :return: An item that has been used (potion, scroll, etc..)
    """
    equip_height = 14
    wield_height = 8
    compare_height = height - (equip_height - wield_height)-(wield_height*2)

    r, g, b = libtcod.white
    equip_y = wield_height
    compare_y = equip_height + wield_height

    inventory_window = game.gEngine.console_new(width/2, height)
    game.gEngine.console_set_default_foreground(inventory_window, r, g, b)
    game.gEngine.console_print_frame(inventory_window, 0, 0, width/2, height, True)
    game.gEngine.console_set_default_background(inventory_window, 0, 0, 0)

    equipment_window = game.gEngine.console_new(width/2, equip_height)
    game.gEngine.console_set_default_foreground(equipment_window, r, g, b)
    game.gEngine.console_print_frame(equipment_window, 0, 0, width/2, equip_height, True)
    game.gEngine.console_set_default_background(equipment_window, 0, 0, 0)

    wielded_window = game.gEngine.console_new(width/2, wield_height)
    game.gEngine.console_set_default_foreground(wielded_window, r, g, b)
    game.gEngine.console_print_frame(wielded_window, 0, 0, width/2, wield_height, True)
    game.gEngine.console_set_default_background(wielded_window, 0, 0, 0)

    compare_window = game.gEngine.console_new(width/2, compare_height)
    game.gEngine.console_set_default_foreground(compare_window, r, g, b)
    game.gEngine.console_print_frame(compare_window, 0, 0, width/2, compare_height, True)
    game.gEngine.console_set_default_background(compare_window, 0, 0, 0)

    check_boxes = []
    slots = ['Torso    ',
             'Head     ',
             'Hands    ',
             'Legs     ',
             'Feet     ',
             'Arms     ',
             'Shoulders',
             'Back     ']
    #self.buttons.append(Button(self, self.option_labels[0], self.width//6-5, self.height/2-1, True))
    exit_button = Button(label='Exit', game=game, x_pos=(width/2)-9, y_pos=height-6,
                         window=inventory_window, dest_x=width/2, dest_y=0)
    drop_button = Button(label='Drop', game=game, x_pos=1, y_pos=height-6,
                         window=inventory_window, dest_x=width/2, dest_y=0)
    if len(player.fighter.inventory) == 0:
        inventory_items = ['Inventory is empty.']
    else:
        inventory_items = []
        for x in range(len(player.fighter.inventory)):
            check_boxes.append(CheckBox(x=1, y=x+3))
            i = color_text(player.fighter.inventory[x].name.capitalize(),player.fighter.inventory[x].color)
            if player.fighter.inventory[x].item.check_stackable:
                i += ' (%d)' % player.fighter.inventory[x].item.qty
            inventory_items.append(i)
    i_header = 'Inventory'
    i_header_size = len(i_header)
    i_header_pos = (width/4)-(i_header_size/2)

    w_header = 'Weapons'
    w_header_size = len(w_header)
    w_header_pos = (width/8) - (w_header_size/2)

    e_header = 'Equipment'
    e_header_size = len(e_header)
    e_header_pos = (width/8) - (e_header_size/2)

    c_header = 'Compare/Examine'
    c_header_size = len(c_header)
    c_header_pos = (width/8) - (c_header_size/2)

    return_item = None
    key = libtcod.console_check_for_keypress()
    current_selection = 0
    master_check = CheckBox(1, 30, "Check/Uncheck All")
    while key.vk != libtcod.KEY_ESCAPE:
        game.gEngine.console_flush()
        # get input just after flush
        key = libtcod.console_check_for_keypress(True)
        mouse = libtcod.mouse_get_status()
        exit_input = exit_button.display(mouse)
        drop_input = drop_button.display(mouse)

        game.gEngine.console_blit(inventory_window, 0, 0, width/2, height, 0, (width/2), 0, 1.0, 1.0)
        game.gEngine.console_blit(wielded_window, 0, 0, width/2, height, 0, 0, 0, 1.0, 1.0)
        game.gEngine.console_blit(equipment_window, 0, 0, width/2, height, 0, 0, equip_y, 1.0, 1.0)
        game.gEngine.console_blit(compare_window, 0, 0, width/2, height, 0, 0, compare_y, 1.0, 1.0)

        game.gEngine.console_clear(inventory_window)
        game.gEngine.console_clear(wielded_window)
        game.gEngine.console_clear(equipment_window)
        game.gEngine.console_clear(compare_window)

        # set up draw screen
        r, g, b = libtcod.white
        game.gEngine.console_set_default_foreground(inventory_window, r, g, b)
        game.gEngine.console_print_frame(inventory_window, 0, 0, width/2, height, True)

        game.gEngine.console_set_default_foreground(equipment_window, r, g, b)
        game.gEngine.console_print_frame(equipment_window, 0, 0, width/2, equip_height, True)

        game.gEngine.console_set_default_foreground(wielded_window, r, g, b)
        game.gEngine.console_print_frame(wielded_window, 0, 0, width/2, wield_height, True)

        game.gEngine.console_set_default_foreground(compare_window, r, g, b)
        game.gEngine.console_print_frame(compare_window, 0, 0, width/2, compare_height, True)

        # ========================================================================
        # print inventory
        # ========================================================================
        game.gEngine.console_print(inventory_window, i_header_pos, 0, i_header)
        letter_index = ord('a')
        if len(player.fighter.inventory) > 0:
            y = 1
            for i in range(len(inventory_items)):
                text = '  (' + chr(letter_index) + ') ' + inventory_items[i]
                if current_selection == y - 1:
                    r, g, b = libtcod.color_lerp(player.fighter.inventory[i].color, libtcod.blue, 0.5)
                    game.gEngine.console_set_default_background(inventory_window, r, g, b)
                else:
                    game.gEngine.console_set_default_background(inventory_window, 0, 0, 0)
                game.gEngine.console_print_ex(inventory_window, 1, y+2, libtcod.BKGND_SET, libtcod.LEFT, text)
                y += 1
                letter_index += 1
        game.gEngine.console_set_default_background(inventory_window, 0, 0, 0)
        game.gEngine.console_print(inventory_window, 1, 31, 'Gold: ' + color_text(str(player.fighter.money), libtcod.gold))

        # ========================================================================
        # print equipped weapons
        # ========================================================================
        game.gEngine.console_print(wielded_window, w_header_pos, 0, w_header)
        index = ord('1')
        if player.fighter.wielded[0] is None:
            text = '(' + chr(index) + ') ' + 'Left Hand : ' + color_text('Empty', libtcod.darker_gray)
        else:
            t = color_text(player.fighter.wielded[0].name.capitalize(), player.fighter.wielded[0].color)
            text = '(' + chr(index) + ') ' + 'Left Hand : ' + t
        index += 1
        game.gEngine.console_print(wielded_window, 1, 2, text)
        if player.fighter.wielded[1] is None:
            text = '(' + chr(index) + ') ' + 'Right Hand: ' + color_text('Empty', libtcod.darker_gray)
        else:
            t = color_text(player.fighter.wielded[1].name.capitalize(), player.fighter.wielded[1].color)
            text = '(' + chr(index) + ') ' + 'Right Hand: ' + t
        index += 1
        game.gEngine.console_print(wielded_window, 1, 3, text)

        item = player.fighter.wielded[0]
        if item:
            damage = '%dd%d+%d' % (item.item.equipment.damage.nb_dices, item.item.equipment.damage.nb_faces, item.item.equipment.damage.addsub)
            text = 'Damage   (total): ' + color_text(damage, libtcod.green)
            game.gEngine.console_print(wielded_window, 1, 4, text)
            accuracy = item.item.equipment.accuracy
            accuracy += game.player.fighter.get_skill(item.item.equipment.damage_type).get_bonus()
            text = 'Accuracy (total): ' + color_text(str(accuracy), libtcod.green)
            game.gEngine.console_print(wielded_window, 1, 5, text)

        # ========================================================================
        # print equipped armor
        # ========================================================================
        game.gEngine.console_print(equipment_window, e_header_pos, 0, e_header)
        i = 0
        game.gEngine.console_set_alignment(equipment_window, libtcod.LEFT)
        armor_bonus = 0
        armor_penalty = 0
        for item in player.fighter.equipment:
            text = '(' + chr(index) + ') ' + slots[i] + ': '
            if item is None:
                text += color_text('Empty', libtcod.darker_gray)
            else:
                text += color_text(item.name.capitalize(), item.color)
                armor_bonus += item.item.equipment.bonus
                armor_penalty += item.item.equipment.penalty
            game.gEngine.console_print(equipment_window, 1, i+2, text)
            i += 1
            index += 1
        c = color_text(str(armor_bonus), libtcod.green)
        text = 'Total Armor Bonus  :  ' + c
        game.gEngine.console_print(equipment_window, 1, i+2, text)
        c = color_text(str(armor_penalty), libtcod.red)
        text = 'Total Armor Penalty: -' + c
        game.gEngine.console_print(equipment_window, 1, i+3, text)
        game.gEngine.console_print(compare_window, c_header_pos, 0, c_header)

        # ========================================================================
        # handle mouse input
        # ========================================================================
        mc = master_check.update(mouse, width)
        master_check.render(inventory_window, game)
        if not mc:
            for box in check_boxes:
                box.update(mouse, width)
                box.render(inventory_window, game)
        else:
            for box in check_boxes:
                box.set_checked(master_check.get_checked())
                box.render(inventory_window, game)

        # Inventory input
        if mouse.cx >= width/2+3 and mouse.cx < width-2:  # inventory screen dims
            if (mouse.cy-3) < len(player.fighter.inventory) and mouse.cy-3 >= 0:
                #if mouse.cy-3 <= len(player.fighter.inventory):
                    item = player.fighter.inventory[mouse.cy-3]
                    current_selection = mouse.cy-3
                    if item.item.equipment:
                        game.gEngine.console_print(compare_window, 1, 2, 'Name    : ' + color_text(item.name.capitalize(), item.color))
                        game.gEngine.console_print(compare_window, 1, 3, 'Type    : ' + item.item.equipment.type.capitalize())
                        if item.item.equipment.type == 'melee':
                            damage = '%dd%d+%d' % (item.item.equipment.damage.nb_dices, item.item.equipment.damage.nb_faces, item.item.equipment.damage.addsub )
                            game.gEngine.console_print(compare_window, 1, 4, 'Damage  : ' + damage)
                            game.gEngine.console_print(compare_window, 1, 5, 'Accuracy: ' + str(item.item.equipment.accuracy))
                            game.gEngine.console_print(compare_window, 1, 7, 'Skill   : ' + item.item.equipment.damage_type)
                        else:
                            game.gEngine.console_print(compare_window, 1, 4, 'Armor   : ' + str(item.item.equipment.bonus))
                            game.gEngine.console_print(compare_window, 1, 5, 'Penalty : ' + str(item.item.equipment.penalty))
                            game.gEngine.console_print(compare_window, 1, 7, 'Location: ' + item.item.equipment.location.capitalize())
                        game.gEngine.console_print(compare_window, 1, 6, 'Value   : ' + str(item.item.value))
                    if item.item.spell:
                        game.gEngine.console_print(compare_window, 1, 2, 'Name  : ' + color_text(item.name.capitalize(), item.color))
                        game.gEngine.console_print(compare_window, 1, 3, 'Type  : ' + item.item.spell.type.capitalize())
                        game.gEngine.console_print(compare_window, 1, 4, 'Power : ' + str(item.item.spell.min) + '-' + str(item.item.spell.max))
                        game.gEngine.console_print(compare_window, 1, 5, 'Range : ' + str(item.item.spell.range))
                        game.gEngine.console_print(compare_window, 1, 6, 'Radius: ' + str(item.item.spell.radius))
                        game.gEngine.console_print(compare_window, 1, 7, 'Value : ' + str(item.item.value))
                    if mouse.lbutton_pressed and item.item.spell:
                        i_n = color_text(item.name.capitalize(), item.color)
                        message = 'Do you want to use %s?' % i_n
                        w = len(message)+2
                        d_box = DialogBox(game, w, 10, width/4, height/2, message, type='option', con=inventory_window)
                        confirm = d_box.display_box()
                        if confirm == 1:  # make sure if the player uses a scroll or potion, we exit inventory
                            d_box.destroy_box()
                            # Remember to remove consoles in reverse order of creation to avoid OOB errors
                            return_item = item
                            break
                        else:
                            d_box.destroy_box()
                    if mouse.lbutton_pressed and item.item.equipment:
                        i_n = color_text(item.name.capitalize(), item.color)
                        message = 'Do you want to put %s on?' % i_n
                        w = len(message)+2
                        d_box = DialogBox(game, w, 10, width/4, height/2, message, type='option', con=inventory_window)
                        confirm = d_box.display_box()
                        if confirm == 1:
                            item.item.use(game.player.fighter.inventory, game.player, game)
                            d_box.destroy_box()
                            inventory_items = []
                            check_boxes = []
                            for x in range(len(player.fighter.inventory)):
                                check_boxes.append(CheckBox(x=1, y=x+3))
                                i = color_text(player.fighter.inventory[x].name.capitalize(),player.fighter.inventory[x].color)
                                if player.fighter.inventory[x].item.check_stackable:
                                    i += ' (%d)' % player.fighter.inventory[x].item.qty
                                inventory_items.append(i)
            else:
                current_selection = None
        # game.gEngine.console_set_default_background(inventory_window, 0, 0, 0)
        # Wielded
        elif mouse.cx >= 0 and mouse.cx <= ((width/2)-2):  # inventory screen dims
            if (mouse.cy-2) < len(player.fighter.wielded):
                item = player.fighter.wielded[mouse.cy-2]
                if item is not None:
                    if item.item.equipment:
                        game.gEngine.console_print(compare_window, 1, 2, 'Name    : ' + color_text(item.name.capitalize(), item.color))
                        game.gEngine.console_print(compare_window, 1, 3, 'Type    : ' + item.item.equipment.type.capitalize())
                        damage = '%dd%d+%d' % (item.item.equipment.damage.nb_dices, item.item.equipment.damage.nb_faces, item.item.equipment.damage.addsub )
                        game.gEngine.console_print(compare_window, 1, 4, 'Damage  : ' + damage)
                        game.gEngine.console_print(compare_window, 1, 5, 'Accuracy: ' + str(item.item.equipment.accuracy))
                        game.gEngine.console_print(compare_window, 1, 6, 'Value   : ' + str(item.item.value))

        # Equipment
            elif (mouse.cy-2)-equip_y < len(player.fighter.equipment):
                item = player.fighter.equipment[mouse.cy-2-equip_y]
                if item is not None:
                    if item.item.equipment:
                        game.gEngine.console_print(compare_window, 1, 2, 'Name    : ' + color_text(item.name.capitalize(), item.color))
                        game.gEngine.console_print(compare_window, 1, 3, 'Type    : ' + item.item.equipment.type.capitalize())
                        game.gEngine.console_print(compare_window, 1, 4, 'Armor   : ' + str(item.item.equipment.bonus))
                        game.gEngine.console_print(compare_window, 1, 5, 'Penalty : ' + str(item.item.equipment.penalty))
                        game.gEngine.console_print(compare_window, 1, 6, 'Value   : ' + str(item.item.value))
            if mouse.lbutton_pressed and item is not None:
                i_n = color_text(item.name.capitalize(), item.color)
                message = 'Do you want to take %s off?' % i_n
                w = len(message)+2
                d_box = DialogBox(game, w, 10, width/4, height/2, message, type='option', con=inventory_window)
                confirm = d_box.display_box()
                if confirm == 1:
                    item.item.equipment.un_equip(game.player, item)
                    d_box.destroy_box()
                    inventory_items = []
                    check_boxes = []
                    for x in range(len(player.fighter.inventory)):
                        check_boxes.append(CheckBox(x=1, y=x+3))
                        i = color_text(player.fighter.inventory[x].name.capitalize(),player.fighter.inventory[x].color)
                        if player.fighter.inventory[x].item.check_stackable:
                            i += ' (%d)' % player.fighter.inventory[x].item.qty
                        inventory_items.append(i)
                    i = 0
                    for x in player.fighter.wielded:
                        if x == item:
                            player.fighter.wielded[i] = None
                        i += 1
                    i = 0
                    for x in player.fighter.equipment:
                        if x == item:
                            player.fighter.equipment[i] = None
                        i += 1

        # keyboard input
        # keeps similar feel to old inventory if using the keys
        # keyboard input is sluggish as balls for some reason, need to look into it more
        index = key.c - ord('a')
        if key:
            if index >= 0 and index < len(inventory_items):
                return_item = player.fighter.inventory[index]
                break
            index = key.c - ord('1')
            if index >= 0 and index <= 1:
                return_item = player.fighter.wielded[index]
                break
            elif index >= 2 and index <= 10:
                return_item = player.fighter.equipment[index-2]
                break
            if key.vk == libtcod.KEY_DOWN:
                if current_selection is None:
                    current_selection = 0
                current_selection += 1
                if current_selection > len(inventory_items):
                    current_selection = 0
            if key.vk == libtcod.KEY_UP:
                if current_selection is None:
                    current_selection = 0
                current_selection -= 1
                if current_selection < 0:
                    current_selection = len(inventory_items)
        # ========================================================================
        # handle buttons
        # ========================================================================
        for i in drop_input:
            if i != -1:
                message = 'Drop all selected items?'
                w = len(message)+2
                d_box = DialogBox(game, w, 10, width/2-w/2, height/2-5, message, type='option', con=inventory_window)
                confirm = d_box.display_box()
                if confirm == 1:
                    d_box.destroy_box()
                    master_check.set_checked(False)
                    items_to_drop = []
                    for box in check_boxes:
                        if box.get_checked():
                            items_to_drop.append(player.fighter.inventory[box.y-3])
                    for item_to_drop in items_to_drop:
                        if item_to_drop:
                            item_to_drop.objects = game.objects
                            item_to_drop.item.drop(player.fighter.inventory, player, False)
                            item_to_drop.send_to_back()
                    check_boxes = []
                    inventory_items = []
                    for x in range(len(player.fighter.inventory)):
                        check_boxes.append(CheckBox(x=1, y=x+3))
                        inventory_items.append(color_text(player.fighter.inventory[x].name.capitalize(),
                                                          player.fighter.inventory[x].color))
                else:
                    d_box.destroy_box()
        # ========================================================================
        # handle exit button
        # ========================================================================

        for i in exit_input:
            if i != -1:
                key.vk = libtcod.KEY_ESCAPE
                break
    # Remember to remove consoles in reverse order of creation to avoid OOB errors
    drop_button.destroy_button()
    exit_button.destroy_button()
    game.gEngine.console_remove_console(compare_window)
    game.gEngine.console_remove_console(wielded_window)
    game.gEngine.console_remove_console(equipment_window)
    game.gEngine.console_remove_console(inventory_window)

    return return_item
Beispiel #38
0
	def end_struct(self, struct, name):
		self.temp_suffix.dark_color = libtcod.color_lerp(libtcod.black, self.temp_suffix.color, 0.3)
		game.suffix.add_to_list(self.temp_suffix)
		return True
Beispiel #39
0
	def end_struct(self, struct, name):
		self.temp_item.dark_color = libtcod.color_lerp(libtcod.black, self.temp_item.color, 0.3)
		game.baseitems.add_to_list(self.temp_item)
		return True
Beispiel #40
0
    #return libtcod.color_gen_map(color_list, color_keys)
    return Color.color_map(color_list, color_keys)


def segment_number(number, times):
    num_list = []
    for x in range(1, times + 1):
        num_list.append((float(number) / float(times)) * x)
    print "Number: {0}\n Times: {1}\n Result: {2}\n".format(
        number, times, num_list)
    return num_list


heat_map_colors = [
    libtcod.yellow,
    libtcod.color_lerp(libtcod.yellow, libtcod.amber, 0.5),
    libtcod.color_lerp(libtcod.yellow, libtcod.amber, 0.5), libtcod.amber,
    libtcod.color_lerp(libtcod.amber, libtcod.orange, 0.5),
    libtcod.color_lerp(libtcod.amber, libtcod.orange, 0.5), libtcod.orange,
    libtcod.color_lerp(libtcod.orange, libtcod.flame, 0.5),
    libtcod.color_lerp(libtcod.orange, libtcod.flame, 0.5), libtcod.flame,
    libtcod.color_lerp(libtcod.flame, libtcod.red, 0.5),
    libtcod.color_lerp(libtcod.flame, libtcod.red, 0.5), libtcod.red,
    libtcod.color_lerp(libtcod.red, libtcod.crimson, 0.5),
    libtcod.color_lerp(libtcod.red, libtcod.crimson, 0.5), libtcod.crimson,
    libtcod.color_lerp(libtcod.crimson, libtcod.pink, 0.5),
    libtcod.color_lerp(libtcod.crimson, libtcod.pink, 0.5), libtcod.pink,
    libtcod.color_lerp(libtcod.pink, libtcod.magenta, 0.5),
    libtcod.color_lerp(libtcod.pink, libtcod.magenta, 0.5), libtcod.magenta,
    libtcod.color_lerp(libtcod.magenta, libtcod.fuchsia, 0.5),
    libtcod.color_lerp(libtcod.magenta, libtcod.fuchsia, 0.5), libtcod.fuchsia,
Beispiel #41
0
def shop(con,
         player,
         game,
         container=None,
         bg=None,
         header=None,
         width=80,
         height=50,
         splash=False):
    """
    TODO:
        Make sure you cannot buy items if it were to put you over inventory limit - Done
        Attach this to a shopkeeper to control splash and inventory.
        Add a buyback screen to buy back things sold by accident

    :param con: Destination Console (not used atm)
    :param player: The Player Object
    :param game: The main game object
    :param container: The contents of the store
    :param bg: The background image to use
    :param header: The title of the store
    :param width: width of the shop
    :param height: height of the shop
    :param splash: Whether or not to display the splash screen
    :return: Nothing
    """
    if bg:
        dark_bg = game.gEngine.image_load(bg)
        bg = game.gEngine.image_load(bg)
        w, h = game.gEngine.image_get_size(dark_bg)
        for y in range(w):
            for x in range(h):
                col = game.gEngine.image_get_pixel(dark_bg, y, x)
                col = libtcod.color_lerp(col, libtcod.black, 0.9)
                #col = libtcod.color_lerp(col, libtcod.light_azure, 0.2)
                r, g, b = col
                game.gEngine.image_put_pixel(dark_bg, y, x, r, g, b)

    shop_height = 28
    compare_height = height - shop_height
    s_options = []
    s_gold = []
    s_size = 0
    if container:
        for obj in container:
            obj_text = color_text(obj.name.capitalize(), obj.color)
            ob_value = color_text(obj.item.value, libtcod.gold)
            ob_value = '(%s)' % ob_value
            s_gold.append(ob_value)
            opt = '[%s] ' % obj_text
            s_options.append(opt)
            if len(obj.name) + 2 > s_size:
                s_size = len(obj.name) + 2
    r, g, b = libtcod.white
    compare_y = shop_height

    inventory_window = game.gEngine.console_new(width / 2, height)
    game.gEngine.console_set_default_foreground(inventory_window, r, g, b)
    game.gEngine.console_print_frame(inventory_window, 0, 0, width / 2, height,
                                     True)

    shop_window = game.gEngine.console_new(width / 2, shop_height)
    game.gEngine.console_set_default_foreground(shop_window, r, g, b)
    game.gEngine.console_print_frame(shop_window, 0, 0, width / 2, shop_height,
                                     True)

    compare_window = game.gEngine.console_new(width / 2, compare_height)
    game.gEngine.console_set_default_foreground(compare_window, r, g, b)
    game.gEngine.console_print_frame(compare_window, 0, 0, width / 2,
                                     compare_height, True)

    i_check_boxes = []
    s_check_boxes = []

    exit_button = Button(label='Exit',
                         game=game,
                         x_pos=(width / 2) - 9,
                         y_pos=height - 6,
                         window=inventory_window,
                         dest_x=width / 2,
                         dest_y=0)

    sell_button = Button(label='Sell',
                         game=game,
                         x_pos=1,
                         y_pos=height - 6,
                         window=inventory_window,
                         dest_x=width / 2,
                         dest_y=0)

    buy_button = Button(label='Buy',
                        game=game,
                        x_pos=1,
                        y_pos=compare_height - 6,
                        window=compare_window,
                        dest_x=0,
                        dest_y=compare_y)

    if len(player.fighter.inventory) == 0:
        inventory_items = ['Inventory is empty.']
    else:
        inventory_items = []
        for x in range(len(player.fighter.inventory)):
            i_check_boxes.append(CheckBox(x=1, y=x + 1))
            i = color_text(player.fighter.inventory[x].name.capitalize(),
                           player.fighter.inventory[x].color)
            if player.fighter.inventory[x].item.check_stackable:
                i += ' (%d)' % player.fighter.inventory[x].item.qty
            inventory_items.append(i)
    for x in range(len(container)):
        s_check_boxes.append(CheckBox(x=1, y=x + 1))

    i_header = 'Inventory'
    i_header_size = len(i_header)
    i_header_pos = (width / 4) - (i_header_size / 2)

    if header:
        s_header = header
    else:
        s_header = 'Shop'
    s_header_size = len(s_header)
    s_header_pos = (width / 4) - (s_header_size / 2)

    c_header = 'Compare/Examine'
    c_header_size = len(c_header)
    c_header_pos = (width / 4) - (c_header_size / 2)

    key = libtcod.console_check_for_keypress()
    mouse = libtcod.mouse_get_status()
    current_selection = 0
    s_current_selection = 0
    i_master_check = CheckBox(1, 30, "Check/Uncheck All")
    s_master_check = CheckBox(1, 26, "Check/Uncheck All")
    fade = 1
    if splash:
        splash_screen = game.gEngine.console_new(width, height)
    while key.vk != libtcod.KEY_ESCAPE:
        game.gEngine.console_flush()
        # get input just after flush
        key = libtcod.console_check_for_keypress(True)
        mouse = libtcod.mouse_get_status()
        exit_input = exit_button.display(mouse)
        sell_input = sell_button.display(mouse)
        buy_input = buy_button.display(mouse)

        game.gEngine.console_blit(inventory_window, 0, 0, width / 2, height, 0,
                                  (width / 2), 0, 1.0, 1.0)
        game.gEngine.console_blit(shop_window, 0, 0, width / 2, shop_height, 0,
                                  0, 0, 1.0, 1.0)
        game.gEngine.console_blit(compare_window, 0, 0, width / 2,
                                  compare_height, 0, 0, compare_y, 1.0, 1.0)
        if splash:
            if bg:
                if fade > 0:
                    game.gEngine.console_blit(splash_screen, 0, 0, width,
                                              height, 0, 0, 0, fade, fade)
                    game.gEngine.image_blit_2x(bg, splash_screen, 0, 0, 0, 0)
                    fade -= 0.045
                else:
                    fade = 0
        game.gEngine.console_clear(inventory_window)
        game.gEngine.console_clear(shop_window)
        game.gEngine.console_clear(compare_window)

        # set up draw screen
        r, g, b = libtcod.white

        # ========================================================================
        # print inventory
        # ========================================================================
        if bg:
            game.gEngine.image_blit_2x(dark_bg, inventory_window, 0, 0, width,
                                       0)
        game.gEngine.console_set_default_foreground(inventory_window, r, g, b)
        game.gEngine.console_print_frame(inventory_window, 0, 0, width / 2,
                                         height, False)
        game.gEngine.console_print(inventory_window, i_header_pos, 0, i_header)
        if len(player.fighter.inventory) > 0:
            letter_index = ord('a')
            y = 1
            for i in range(len(inventory_items)):
                text = '  (' + chr(letter_index) + ') ' + inventory_items[i]
                if current_selection == y - 1:
                    r, g, b = libtcod.color_lerp(
                        player.fighter.inventory[i].color, libtcod.blue, 0.5)
                    game.gEngine.console_set_default_background(
                        inventory_window, r, g, b)
                else:
                    game.gEngine.console_set_default_background(
                        inventory_window, 0, 0, 0)
                game.gEngine.console_print_ex(inventory_window, 1, y,
                                              libtcod.BKGND_SET, libtcod.LEFT,
                                              text)
                y += 1
                letter_index += 1
        game.gEngine.console_set_default_background(inventory_window, 0, 0, 0)
        game.gEngine.console_print(
            inventory_window, 1, 31,
            'Gold: ' + color_text(str(player.fighter.money), libtcod.gold))
        r, g, b = libtcod.white

        # ========================================================================
        # Print Shop Window
        # ========================================================================
        if bg:
            game.gEngine.image_blit_2x(dark_bg, shop_window, 0, 0)
        game.gEngine.console_set_default_foreground(shop_window, r, g, b)
        game.gEngine.console_print_frame(shop_window, 0, 0, width / 2,
                                         shop_height, False)
        game.gEngine.console_print(shop_window, s_header_pos, 0, s_header)
        if len(s_options) > 0:
            letter_index = ord('0')
            y = 1
            for i in range(len(s_options)):
                text = '  (' + chr(letter_index) + ') ' + s_options[i]
                if s_current_selection == y - 1:
                    rr, gg, bb = libtcod.color_lerp(container[i].color,
                                                    libtcod.blue, 0.5)
                    game.gEngine.console_set_default_background(
                        shop_window, rr, gg, bb)
                else:
                    game.gEngine.console_set_default_background(
                        shop_window, 0, 0, 0)
                game.gEngine.console_print_ex(shop_window, 1, y,
                                              libtcod.BKGND_SET, libtcod.LEFT,
                                              text)
                game.gEngine.console_print_ex(shop_window, s_size + 10, y,
                                              libtcod.BKGND_SET, libtcod.RIGHT,
                                              s_gold[i])
                y += 1
                letter_index += 1
            game.gEngine.console_set_default_background(
                inventory_window, 0, 0, 0)
            r, g, b = libtcod.white

        # ========================================================================
        # Print Compare Window
        # ========================================================================
        if bg:
            game.gEngine.image_blit_2x(dark_bg,
                                       compare_window,
                                       0,
                                       0,
                                       sx=0,
                                       sy=compare_y * 2)
        game.gEngine.console_set_default_foreground(compare_window, r, g, b)
        game.gEngine.console_print_frame(compare_window, 0, 0, width / 2,
                                         compare_height, False)
        game.gEngine.console_print(compare_window, c_header_pos, 0, c_header)

        # ========================================================================
        # handle mouse input
        # ========================================================================
        #Render check boxes
        #inventory check boxes
        i_mc = i_master_check.update(mouse, width)
        i_master_check.render(inventory_window, game)
        sell_value = 0
        if not i_mc:
            for box in i_check_boxes:
                box.update(mouse, width)
                box.render(inventory_window, game)
                if box.get_checked():
                    sell_value += player.fighter.inventory[box.y -
                                                           1].item.value / 2
        else:
            for box in i_check_boxes:
                box.set_checked(i_master_check.get_checked())
                box.render(inventory_window, game)
                if box.get_checked():
                    sell_value += player.fighter.inventory[box.y -
                                                           1].item.value / 2
        game.gEngine.console_print(
            inventory_window, 1, 32,
            'Sell Value: ' + color_text(str(sell_value), libtcod.gold))

        #Shop check boxes
        s_mc = s_master_check.update(mouse)
        s_master_check.render(shop_window, game)
        buy_value = 0
        if not s_mc:
            for box in s_check_boxes:
                box.update(mouse)
                box.render(shop_window, game)
                if box.get_checked():
                    buy_value += container[box.y - 1].item.value
        else:
            for box in s_check_boxes:
                box.set_checked(s_master_check.get_checked())
                box.render(shop_window, game)
                if box.get_checked():
                    buy_value += container[box.y - 1].item.value
        game.gEngine.console_print(
            shop_window, 1, 25,
            'Buy Value: ' + color_text(str(buy_value), libtcod.gold))

        # Inventory input
        if mouse.cx >= width / 2 + 3 and mouse.cx < width - 2:  # inventory screen dims
            if (mouse.cy - 1) < len(
                    player.fighter.inventory) and mouse.cy - 1 >= 0:
                item = player.fighter.inventory[mouse.cy - 1]
                current_selection = mouse.cy - 1
                game.gEngine.console_set_default_background(
                    compare_window, 0, 0, 0)
                if item.item.equipment:
                    game.gEngine.console_print_ex(
                        compare_window, 1, 2, libtcod.BKGND_SET, libtcod.LEFT,
                        'Name    : ' +
                        color_text(item.name.capitalize(), item.color))
                    game.gEngine.console_print_ex(
                        compare_window, 1, 3, libtcod.BKGND_SET, libtcod.LEFT,
                        'Type    : ' + item.item.equipment.type.capitalize())
                    if item.item.equipment.type == 'melee':
                        damage = '%dd%d+%d' % (
                            item.item.equipment.damage.nb_dices,
                            item.item.equipment.damage.nb_faces,
                            item.item.equipment.damage.addsub)
                        game.gEngine.console_print_ex(compare_window, 1, 4,
                                                      libtcod.BKGND_SET,
                                                      libtcod.LEFT,
                                                      'Damage  : ' + damage)
                        game.gEngine.console_print_ex(
                            compare_window, 1, 5, libtcod.BKGND_SET,
                            libtcod.LEFT,
                            'Accuracy: ' + str(item.item.equipment.accuracy))
                        game.gEngine.console_print_ex(
                            compare_window, 1, 7, libtcod.BKGND_SET,
                            libtcod.LEFT,
                            'Skill   : ' + item.item.equipment.damage_type)
                    else:
                        game.gEngine.console_print_ex(
                            compare_window, 1, 4, libtcod.BKGND_SET,
                            libtcod.LEFT,
                            'Armor   : ' + str(item.item.equipment.bonus))
                        game.gEngine.console_print_ex(
                            compare_window, 1, 5, libtcod.BKGND_SET,
                            libtcod.LEFT,
                            'Penalty : ' + str(item.item.equipment.penalty))
                        game.gEngine.console_print_ex(
                            compare_window, 1, 7, libtcod.BKGND_SET,
                            libtcod.LEFT, 'Location: ' +
                            item.item.equipment.location.capitalize())
                    game.gEngine.console_print_ex(
                        compare_window, 1, 6, libtcod.BKGND_SET, libtcod.LEFT,
                        'Value   : ' + str(item.item.value))
                if item.item.spell:
                    game.gEngine.console_print_ex(
                        compare_window, 1, 2, libtcod.BKGND_SET, libtcod.LEFT,
                        'Name  : ' +
                        color_text(item.name.capitalize(), item.color))
                    game.gEngine.console_print_ex(
                        compare_window, 1, 3, libtcod.BKGND_SET, libtcod.LEFT,
                        'Type  : ' + item.item.spell.type.capitalize())
                    game.gEngine.console_print_ex(
                        compare_window, 1, 4, libtcod.BKGND_SET, libtcod.LEFT,
                        'Power : ' + str(item.item.spell.min) + '-' +
                        str(item.item.spell.max))
                    game.gEngine.console_print_ex(
                        compare_window, 1, 5, libtcod.BKGND_SET, libtcod.LEFT,
                        'Range : ' + str(item.item.spell.range))
                    game.gEngine.console_print_ex(
                        compare_window, 1, 6, libtcod.BKGND_SET, libtcod.LEFT,
                        'Radius: ' + str(item.item.spell.radius))
                    game.gEngine.console_print_ex(
                        compare_window, 1, 7, libtcod.BKGND_SET, libtcod.LEFT,
                        'Value : ' + str(item.item.value))
                if mouse.lbutton_pressed:
                    i_n = color_text(item.name.capitalize(), item.color)
                    price = color_text(item.item.value / 2, libtcod.gold)
                    message = 'Sell %s for %s?' % (i_n, price)
                    w = len(message) + 2
                    d_box = DialogBox(game,
                                      w,
                                      10,
                                      width / 4,
                                      height / 2,
                                      message,
                                      type='option',
                                      con=inventory_window)
                    confirm = d_box.display_box()
                    if confirm == 1:
                        player.fighter.money += item.item.value / 2
                        player.fighter.inventory.remove(item)
                        inventory_items = []
                        i_check_boxes = []
                        for x in range(len(player.fighter.inventory)):
                            i_check_boxes.append(CheckBox(x=1, y=x + 1))
                            i = color_text(
                                player.fighter.inventory[x].name.capitalize(),
                                player.fighter.inventory[x].color)
                            if player.fighter.inventory[
                                    x].item.check_stackable:
                                i += ' (%d)' % player.fighter.inventory[
                                    x].item.qty
                            inventory_items.append(i)

        # shop input
        if mouse.cx >= 0 and mouse.cx < width / 2 - 2:  # shop screen dims
            if (mouse.cy - 1) < len(container) and mouse.cy - 1 >= 0:
                item = container[mouse.cy - 1]
                s_current_selection = mouse.cy - 1
                game.gEngine.console_set_default_background(
                    compare_window, 0, 0, 0)
                if item.item.equipment:
                    game.gEngine.console_print_ex(
                        compare_window, 1, 2, libtcod.BKGND_SET, libtcod.LEFT,
                        'Name    : ' +
                        color_text(item.name.capitalize(), item.color))
                    game.gEngine.console_print_ex(
                        compare_window, 1, 3, libtcod.BKGND_SET, libtcod.LEFT,
                        'Type    : ' + item.item.equipment.type.capitalize())
                    if item.item.equipment.type == 'melee':
                        damage = '%dd%d+%d' % (
                            item.item.equipment.damage.nb_dices,
                            item.item.equipment.damage.nb_faces,
                            item.item.equipment.damage.addsub)
                        game.gEngine.console_print_ex(compare_window, 1, 4,
                                                      libtcod.BKGND_SET,
                                                      libtcod.LEFT,
                                                      'Damage  : ' + damage)
                        game.gEngine.console_print_ex(
                            compare_window, 1, 5, libtcod.BKGND_SET,
                            libtcod.LEFT,
                            'Accuracy: ' + str(item.item.equipment.accuracy))
                        game.gEngine.console_print_ex(
                            compare_window, 1, 7, libtcod.BKGND_SET,
                            libtcod.LEFT,
                            'Skill   : ' + item.item.equipment.damage_type)
                    else:
                        game.gEngine.console_print_ex(
                            compare_window, 1, 4, libtcod.BKGND_SET,
                            libtcod.LEFT,
                            'Armor   : ' + str(item.item.equipment.bonus))
                        game.gEngine.console_print_ex(
                            compare_window, 1, 5, libtcod.BKGND_SET,
                            libtcod.LEFT,
                            'Penalty : ' + str(item.item.equipment.penalty))
                        game.gEngine.console_print_ex(
                            compare_window, 1, 7, libtcod.BKGND_SET,
                            libtcod.LEFT, 'Location: ' +
                            item.item.equipment.location.capitalize())
                    game.gEngine.console_print_ex(
                        compare_window, 1, 6, libtcod.BKGND_SET, libtcod.LEFT,
                        'Value   : ' + str(item.item.value))

                if item.item.spell:
                    game.gEngine.console_print_ex(
                        compare_window, 1, 2, libtcod.BKGND_SET, libtcod.LEFT,
                        'Name  : ' +
                        color_text(item.name.capitalize(), item.color))
                    game.gEngine.console_print_ex(
                        compare_window, 1, 3, libtcod.BKGND_SET, libtcod.LEFT,
                        'Type  : ' + item.item.spell.type.capitalize())
                    game.gEngine.console_print_ex(
                        compare_window, 1, 4, libtcod.BKGND_SET, libtcod.LEFT,
                        'Power : ' + str(item.item.spell.min) + '-' +
                        str(item.item.spell.max))
                    game.gEngine.console_print_ex(
                        compare_window, 1, 5, libtcod.BKGND_SET, libtcod.LEFT,
                        'Range : ' + str(item.item.spell.range))
                    game.gEngine.console_print_ex(
                        compare_window, 1, 6, libtcod.BKGND_SET, libtcod.LEFT,
                        'Radius: ' + str(item.item.spell.radius))
                    game.gEngine.console_print_ex(
                        compare_window, 1, 7, libtcod.BKGND_SET, libtcod.LEFT,
                        'Value : ' + str(item.item.value))

                if mouse.lbutton_pressed and mouse.cx >= 3:
                    if len(player.fighter.inventory) >= 26:
                        if not item.item.check_stackable():
                            message = 'Not enough inventory space!'
                            w = len(message) + 2
                            d_box = DialogBox(game,
                                              w,
                                              10,
                                              width / 2 - w / 2,
                                              height / 2 - 5,
                                              message,
                                              type='dialog',
                                              con=inventory_window)
                            d_box.display_box()
                        else:
                            pass
                    elif item.item.value > player.fighter.money:
                        message = 'Not enough money!'
                        w = len(message) + 2
                        d_box = DialogBox(game,
                                          w,
                                          10,
                                          width / 2 - w / 2,
                                          height / 2 - 5,
                                          message,
                                          type='dialog',
                                          con=inventory_window)
                        d_box.display_box()
                        s_master_check.set_checked(False)
                        for box in s_check_boxes:
                            box.set_checked(s_master_check.get_checked())
                    else:
                        i_n = color_text(item.name.capitalize(), item.color)
                        price = color_text(item.item.value, libtcod.gold)
                        message = 'Buy %s for %s?' % (i_n, price)
                        w = len(message) + 2
                        d_box = DialogBox(game,
                                          w,
                                          10,
                                          width / 4,
                                          height / 2,
                                          message,
                                          type='option',
                                          con=inventory_window)
                        confirm = d_box.display_box()
                        if confirm == 1:
                            player.fighter.money -= item.item.value
                            #player.fighter.inventory.append(item)
                            item.item.pick_up(player.fighter.inventory)
                            container.remove(item)
                            inventory_items = []
                            i_check_boxes = []
                            for x in range(len(player.fighter.inventory)):
                                i_check_boxes.append(CheckBox(x=1, y=x + 1))
                                i = color_text(
                                    player.fighter.inventory[x].name.
                                    capitalize(),
                                    player.fighter.inventory[x].color)
                                if player.fighter.inventory[
                                        x].item.check_stackable:
                                    i += ' (%d)' % player.fighter.inventory[
                                        x].item.qty
                                inventory_items.append(i)
                            s_check_boxes = []
                            s_options = []
                            if container:
                                for obj in container:
                                    obj_text = color_text(
                                        obj.name.capitalize(), obj.color)
                                    ob_value = color_text(
                                        obj.item.value, libtcod.gold)
                                    ob_value = '(%s)' % ob_value
                                    s_gold.append(ob_value)
                                    opt = '[%s] ' % obj_text
                                    s_options.append(opt)
                                    if len(obj.name) + 2 > s_size:
                                        s_size = len(obj.name) + 2
                            for x in range(len(container)):
                                s_check_boxes.append(CheckBox(x=1, y=x + 1))

        # keyboard input
        index = key.c - ord('a')
        if key:
            if key.vk == libtcod.KEY_DOWN:
                if current_selection is None:
                    current_selection = 0
                current_selection += 1
                if current_selection > len(inventory_items):
                    current_selection = 0
            if key.vk == libtcod.KEY_UP:
                if current_selection is None:
                    current_selection = 0
                current_selection -= 1
                if current_selection < 0:
                    current_selection = len(inventory_items)
        # ========================================================================
        # handle buttons
        # ========================================================================

        # ========================================================================
        # Sell Button
        # ========================================================================
        for i in sell_input:
            if i != -1:
                message = 'Sell all selected items?'
                w = len(message) + 2
                d_box = DialogBox(game,
                                  w,
                                  10,
                                  width / 2 - w / 2,
                                  height / 2 - 5,
                                  message,
                                  type='option',
                                  con=inventory_window)
                confirm = d_box.display_box()
                if confirm == 1:
                    d_box.destroy_box()
                    i_master_check.set_checked(False)
                    items_to_sell = []
                    for box in i_check_boxes:
                        if box.get_checked():
                            items_to_sell.append(
                                player.fighter.inventory[box.y - 1])
                    for item_to_sell in items_to_sell:
                        if item_to_sell:
                            player.fighter.money += item_to_sell.item.value / 2
                            player.fighter.inventory.remove(item_to_sell)
                    i_check_boxes = []
                    inventory_items = []
                    for x in range(len(player.fighter.inventory)):
                        i_check_boxes.append(CheckBox(x=1, y=x + 1))
                        inventory_items.append(
                            color_text(
                                player.fighter.inventory[x].name.capitalize(),
                                player.fighter.inventory[x].color))
                else:
                    d_box.destroy_box()

        # ========================================================================
        # buy button
        # ========================================================================
        for i in buy_input:
            if i != -1:
                n = 0
                for box in s_check_boxes:
                    if box.get_checked():
                        n += 1
                if len(player.fighter.inventory) + n > 26:
                    message = 'Not enough inventory space!'
                    w = len(message) + 2
                    d_box = DialogBox(game,
                                      w,
                                      10,
                                      width / 2 - w / 2,
                                      height / 2 - 5,
                                      message,
                                      type='dialog',
                                      con=inventory_window)
                    d_box.display_box()
                elif buy_value > player.fighter.money:
                    message = 'Not enough money!'
                    w = len(message) + 2
                    d_box = DialogBox(game,
                                      w,
                                      10,
                                      width / 2 - w / 2,
                                      height / 2 - 5,
                                      message,
                                      type='dialog',
                                      con=inventory_window)
                    d_box.display_box()
                    s_master_check.set_checked(False)
                    for box in s_check_boxes:
                        box.set_checked(s_master_check.get_checked())
                else:
                    message = 'Buy all selected items?'
                    w = len(message) + 2
                    d_box = DialogBox(game,
                                      w,
                                      10,
                                      width / 2 - w / 2,
                                      height / 2 - 5,
                                      message,
                                      type='option',
                                      con=inventory_window)
                    confirm = d_box.display_box()
                    if confirm == 1:
                        #d_box.destroy_box()
                        s_master_check.set_checked(False)
                        items_to_buy = []
                        for box in s_check_boxes:
                            if box.get_checked():
                                items_to_buy.append(container[box.y - 1])
                        for item_to_buy in items_to_buy:
                            if item_to_buy:
                                container.remove(item_to_buy)
                                player.fighter.money -= item_to_buy.item.value
                                #player.fighter.inventory.append(item_to_buy)
                                item_to_buy.item.pick_up(
                                    player.fighter.inventory)

                        s_check_boxes = []
                        s_options = []
                        if container:
                            for obj in container:
                                obj_text = color_text(obj.name.capitalize(),
                                                      obj.color)
                                ob_value = color_text(obj.item.value,
                                                      libtcod.gold)
                                ob_value = '(%s)' % ob_value
                                s_gold.append(ob_value)
                                opt = '[%s] ' % obj_text
                                s_options.append(opt)
                                if len(obj.name) + 2 > s_size:
                                    s_size = len(obj.name) + 2
                        for x in range(len(container)):
                            s_check_boxes.append(CheckBox(x=1, y=x + 1))

                        i_check_boxes = []
                        inventory_items = []
                        for x in range(len(player.fighter.inventory)):
                            i_check_boxes.append(CheckBox(x=1, y=x + 1))
                            i = color_text(
                                player.fighter.inventory[x].name.capitalize(),
                                player.fighter.inventory[x].color)
                            if player.fighter.inventory[
                                    x].item.check_stackable:
                                i += ' (%d)' % player.fighter.inventory[
                                    x].item.qty
                            inventory_items.append(i)
            #else:
                    d_box.destroy_box()

        # ========================================================================
        # handle exit button
        # ========================================================================

        for i in exit_input:
            if i != -1:
                key.vk = libtcod.KEY_ESCAPE
                break
    # Remember to remove consoles in reverse order of creation to avoid OOB errors
    if splash:
        game.gEngine.console_remove_console(splash_screen)
    buy_button.destroy_button()
    sell_button.destroy_button()
    exit_button.destroy_button()
    game.gEngine.console_remove_console(compare_window)
    game.gEngine.console_remove_console(shop_window)
    game.gEngine.console_remove_console(inventory_window)

    return
Beispiel #42
0
def inventory(con, player, game, width=80, height=43):
    """
    TODO:
        Add in highlighting for Weapons and Equipment consoles
        Add in keyboard arrow selection support
        Add in "drop" mode, drop items from inventory
        Fix Weapons and Equipment keyboard handling
        Fix duplication bug when equipping items (fixed)
        Fix take off weapon confirmation when equipping an item (fixed)
        2 handed code needs work (?)
        keyboard input is sluggish. Might have to update libtcod to fix

    :param con: Destination console (not used atm)
    :param player: The main player object
    :param game: The main game object
    :param width: width of the inventory screen
    :param height: height of the inventory screen
    :return: An item that has been used (potion, scroll, etc..)
    """
    equip_height = 14
    wield_height = 8
    compare_height = height - (equip_height - wield_height) - (wield_height *
                                                               2)

    r, g, b = libtcod.white
    equip_y = wield_height
    compare_y = equip_height + wield_height

    inventory_window = game.gEngine.console_new(width / 2, height)
    game.gEngine.console_set_default_foreground(inventory_window, r, g, b)
    game.gEngine.console_print_frame(inventory_window, 0, 0, width / 2, height,
                                     True)
    game.gEngine.console_set_default_background(inventory_window, 0, 0, 0)

    equipment_window = game.gEngine.console_new(width / 2, equip_height)
    game.gEngine.console_set_default_foreground(equipment_window, r, g, b)
    game.gEngine.console_print_frame(equipment_window, 0, 0, width / 2,
                                     equip_height, True)
    game.gEngine.console_set_default_background(equipment_window, 0, 0, 0)

    wielded_window = game.gEngine.console_new(width / 2, wield_height)
    game.gEngine.console_set_default_foreground(wielded_window, r, g, b)
    game.gEngine.console_print_frame(wielded_window, 0, 0, width / 2,
                                     wield_height, True)
    game.gEngine.console_set_default_background(wielded_window, 0, 0, 0)

    compare_window = game.gEngine.console_new(width / 2, compare_height)
    game.gEngine.console_set_default_foreground(compare_window, r, g, b)
    game.gEngine.console_print_frame(compare_window, 0, 0, width / 2,
                                     compare_height, True)
    game.gEngine.console_set_default_background(compare_window, 0, 0, 0)

    check_boxes = []
    slots = [
        'Torso    ', 'Head     ', 'Hands    ', 'Legs     ', 'Feet     ',
        'Arms     ', 'Shoulders', 'Back     '
    ]
    #self.buttons.append(Button(self, self.option_labels[0], self.width//6-5, self.height/2-1, True))
    exit_button = Button(label='Exit',
                         game=game,
                         x_pos=(width / 2) - 9,
                         y_pos=height - 6,
                         window=inventory_window,
                         dest_x=width / 2,
                         dest_y=0)
    drop_button = Button(label='Drop',
                         game=game,
                         x_pos=1,
                         y_pos=height - 6,
                         window=inventory_window,
                         dest_x=width / 2,
                         dest_y=0)
    if len(player.fighter.inventory) == 0:
        inventory_items = ['Inventory is empty.']
    else:
        inventory_items = []
        for x in range(len(player.fighter.inventory)):
            check_boxes.append(CheckBox(x=1, y=x + 3))
            i = color_text(player.fighter.inventory[x].name.capitalize(),
                           player.fighter.inventory[x].color)
            if player.fighter.inventory[x].item.check_stackable:
                i += ' (%d)' % player.fighter.inventory[x].item.qty
            inventory_items.append(i)
    i_header = 'Inventory'
    i_header_size = len(i_header)
    i_header_pos = (width / 4) - (i_header_size / 2)

    w_header = 'Weapons'
    w_header_size = len(w_header)
    w_header_pos = (width / 8) - (w_header_size / 2)

    e_header = 'Equipment'
    e_header_size = len(e_header)
    e_header_pos = (width / 8) - (e_header_size / 2)

    c_header = 'Compare/Examine'
    c_header_size = len(c_header)
    c_header_pos = (width / 8) - (c_header_size / 2)

    return_item = None
    key = libtcod.console_check_for_keypress()
    current_selection = 0
    master_check = CheckBox(1, 30, "Check/Uncheck All")
    while key.vk != libtcod.KEY_ESCAPE:
        game.gEngine.console_flush()
        # get input just after flush
        key = libtcod.console_check_for_keypress(True)
        mouse = libtcod.mouse_get_status()
        exit_input = exit_button.display(mouse)
        drop_input = drop_button.display(mouse)

        game.gEngine.console_blit(inventory_window, 0, 0, width / 2, height, 0,
                                  (width / 2), 0, 1.0, 1.0)
        game.gEngine.console_blit(wielded_window, 0, 0, width / 2, height, 0,
                                  0, 0, 1.0, 1.0)
        game.gEngine.console_blit(equipment_window, 0, 0, width / 2, height, 0,
                                  0, equip_y, 1.0, 1.0)
        game.gEngine.console_blit(compare_window, 0, 0, width / 2, height, 0,
                                  0, compare_y, 1.0, 1.0)

        game.gEngine.console_clear(inventory_window)
        game.gEngine.console_clear(wielded_window)
        game.gEngine.console_clear(equipment_window)
        game.gEngine.console_clear(compare_window)

        # set up draw screen
        r, g, b = libtcod.white
        game.gEngine.console_set_default_foreground(inventory_window, r, g, b)
        game.gEngine.console_print_frame(inventory_window, 0, 0, width / 2,
                                         height, True)

        game.gEngine.console_set_default_foreground(equipment_window, r, g, b)
        game.gEngine.console_print_frame(equipment_window, 0, 0, width / 2,
                                         equip_height, True)

        game.gEngine.console_set_default_foreground(wielded_window, r, g, b)
        game.gEngine.console_print_frame(wielded_window, 0, 0, width / 2,
                                         wield_height, True)

        game.gEngine.console_set_default_foreground(compare_window, r, g, b)
        game.gEngine.console_print_frame(compare_window, 0, 0, width / 2,
                                         compare_height, True)

        # ========================================================================
        # print inventory
        # ========================================================================
        game.gEngine.console_print(inventory_window, i_header_pos, 0, i_header)
        letter_index = ord('a')
        if len(player.fighter.inventory) > 0:
            y = 1
            for i in range(len(inventory_items)):
                text = '  (' + chr(letter_index) + ') ' + inventory_items[i]
                if current_selection == y - 1:
                    r, g, b = libtcod.color_lerp(
                        player.fighter.inventory[i].color, libtcod.blue, 0.5)
                    game.gEngine.console_set_default_background(
                        inventory_window, r, g, b)
                else:
                    game.gEngine.console_set_default_background(
                        inventory_window, 0, 0, 0)
                game.gEngine.console_print_ex(inventory_window, 1, y + 2,
                                              libtcod.BKGND_SET, libtcod.LEFT,
                                              text)
                y += 1
                letter_index += 1
        game.gEngine.console_set_default_background(inventory_window, 0, 0, 0)
        game.gEngine.console_print(
            inventory_window, 1, 31,
            'Gold: ' + color_text(str(player.fighter.money), libtcod.gold))

        # ========================================================================
        # print equipped weapons
        # ========================================================================
        game.gEngine.console_print(wielded_window, w_header_pos, 0, w_header)
        index = ord('1')
        if player.fighter.wielded[0] is None:
            text = '(' + chr(index) + ') ' + 'Left Hand : ' + color_text(
                'Empty', libtcod.darker_gray)
        else:
            t = color_text(player.fighter.wielded[0].name.capitalize(),
                           player.fighter.wielded[0].color)
            text = '(' + chr(index) + ') ' + 'Left Hand : ' + t
        index += 1
        game.gEngine.console_print(wielded_window, 1, 2, text)
        if player.fighter.wielded[1] is None:
            text = '(' + chr(index) + ') ' + 'Right Hand: ' + color_text(
                'Empty', libtcod.darker_gray)
        else:
            t = color_text(player.fighter.wielded[1].name.capitalize(),
                           player.fighter.wielded[1].color)
            text = '(' + chr(index) + ') ' + 'Right Hand: ' + t
        index += 1
        game.gEngine.console_print(wielded_window, 1, 3, text)

        item = player.fighter.wielded[0]
        if item:
            damage = '%dd%d+%d' % (item.item.equipment.damage.nb_dices,
                                   item.item.equipment.damage.nb_faces,
                                   item.item.equipment.damage.addsub)
            text = 'Damage   (total): ' + color_text(damage, libtcod.green)
            game.gEngine.console_print(wielded_window, 1, 4, text)
            accuracy = item.item.equipment.accuracy
            accuracy += game.player.fighter.get_skill(
                item.item.equipment.damage_type).get_bonus()
            text = 'Accuracy (total): ' + color_text(str(accuracy),
                                                     libtcod.green)
            game.gEngine.console_print(wielded_window, 1, 5, text)

        # ========================================================================
        # print equipped armor
        # ========================================================================
        game.gEngine.console_print(equipment_window, e_header_pos, 0, e_header)
        i = 0
        game.gEngine.console_set_alignment(equipment_window, libtcod.LEFT)
        armor_bonus = 0
        armor_penalty = 0
        for item in player.fighter.equipment:
            text = '(' + chr(index) + ') ' + slots[i] + ': '
            if item is None:
                text += color_text('Empty', libtcod.darker_gray)
            else:
                text += color_text(item.name.capitalize(), item.color)
                armor_bonus += item.item.equipment.bonus
                armor_penalty += item.item.equipment.penalty
            game.gEngine.console_print(equipment_window, 1, i + 2, text)
            i += 1
            index += 1
        c = color_text(str(armor_bonus), libtcod.green)
        text = 'Total Armor Bonus  :  ' + c
        game.gEngine.console_print(equipment_window, 1, i + 2, text)
        c = color_text(str(armor_penalty), libtcod.red)
        text = 'Total Armor Penalty: -' + c
        game.gEngine.console_print(equipment_window, 1, i + 3, text)
        game.gEngine.console_print(compare_window, c_header_pos, 0, c_header)

        # ========================================================================
        # handle mouse input
        # ========================================================================
        mc = master_check.update(mouse, width)
        master_check.render(inventory_window, game)
        if not mc:
            for box in check_boxes:
                box.update(mouse, width)
                box.render(inventory_window, game)
        else:
            for box in check_boxes:
                box.set_checked(master_check.get_checked())
                box.render(inventory_window, game)

        # Inventory input
        if mouse.cx >= width / 2 + 3 and mouse.cx < width - 2:  # inventory screen dims
            if (mouse.cy - 3) < len(
                    player.fighter.inventory) and mouse.cy - 3 >= 0:
                #if mouse.cy-3 <= len(player.fighter.inventory):
                item = player.fighter.inventory[mouse.cy - 3]
                current_selection = mouse.cy - 3
                if item.item.equipment:
                    game.gEngine.console_print(
                        compare_window, 1, 2, 'Name    : ' +
                        color_text(item.name.capitalize(), item.color))
                    game.gEngine.console_print(
                        compare_window, 1, 3,
                        'Type    : ' + item.item.equipment.type.capitalize())
                    if item.item.equipment.type == 'melee':
                        damage = '%dd%d+%d' % (
                            item.item.equipment.damage.nb_dices,
                            item.item.equipment.damage.nb_faces,
                            item.item.equipment.damage.addsub)
                        game.gEngine.console_print(compare_window, 1, 4,
                                                   'Damage  : ' + damage)
                        game.gEngine.console_print(
                            compare_window, 1, 5,
                            'Accuracy: ' + str(item.item.equipment.accuracy))
                        game.gEngine.console_print(
                            compare_window, 1, 7,
                            'Skill   : ' + item.item.equipment.damage_type)
                    else:
                        game.gEngine.console_print(
                            compare_window, 1, 4,
                            'Armor   : ' + str(item.item.equipment.bonus))
                        game.gEngine.console_print(
                            compare_window, 1, 5,
                            'Penalty : ' + str(item.item.equipment.penalty))
                        game.gEngine.console_print(
                            compare_window, 1, 7, 'Location: ' +
                            item.item.equipment.location.capitalize())
                    game.gEngine.console_print(
                        compare_window, 1, 6,
                        'Value   : ' + str(item.item.value))
                if item.item.spell:
                    game.gEngine.console_print(
                        compare_window, 1, 2, 'Name  : ' +
                        color_text(item.name.capitalize(), item.color))
                    game.gEngine.console_print(
                        compare_window, 1, 3,
                        'Type  : ' + item.item.spell.type.capitalize())
                    game.gEngine.console_print(
                        compare_window, 1, 4,
                        'Power : ' + str(item.item.spell.min) + '-' +
                        str(item.item.spell.max))
                    game.gEngine.console_print(
                        compare_window, 1, 5,
                        'Range : ' + str(item.item.spell.range))
                    game.gEngine.console_print(
                        compare_window, 1, 6,
                        'Radius: ' + str(item.item.spell.radius))
                    game.gEngine.console_print(
                        compare_window, 1, 7,
                        'Value : ' + str(item.item.value))
                if mouse.lbutton_pressed and item.item.spell:
                    i_n = color_text(item.name.capitalize(), item.color)
                    message = 'Do you want to use %s?' % i_n
                    w = len(message) + 2
                    d_box = DialogBox(game,
                                      w,
                                      10,
                                      width / 4,
                                      height / 2,
                                      message,
                                      type='option',
                                      con=inventory_window)
                    confirm = d_box.display_box()
                    if confirm == 1:  # make sure if the player uses a scroll or potion, we exit inventory
                        d_box.destroy_box()
                        # Remember to remove consoles in reverse order of creation to avoid OOB errors
                        return_item = item
                        break
                    else:
                        d_box.destroy_box()
                if mouse.lbutton_pressed and item.item.equipment:
                    i_n = color_text(item.name.capitalize(), item.color)
                    message = 'Do you want to put %s on?' % i_n
                    w = len(message) + 2
                    d_box = DialogBox(game,
                                      w,
                                      10,
                                      width / 4,
                                      height / 2,
                                      message,
                                      type='option',
                                      con=inventory_window)
                    confirm = d_box.display_box()
                    if confirm == 1:
                        item.item.use(game.player.fighter.inventory,
                                      game.player, game)
                        d_box.destroy_box()
                        inventory_items = []
                        check_boxes = []
                        for x in range(len(player.fighter.inventory)):
                            check_boxes.append(CheckBox(x=1, y=x + 3))
                            i = color_text(
                                player.fighter.inventory[x].name.capitalize(),
                                player.fighter.inventory[x].color)
                            if player.fighter.inventory[
                                    x].item.check_stackable:
                                i += ' (%d)' % player.fighter.inventory[
                                    x].item.qty
                            inventory_items.append(i)
            else:
                current_selection = None
        # game.gEngine.console_set_default_background(inventory_window, 0, 0, 0)
        # Wielded
        elif mouse.cx >= 0 and mouse.cx <= (
            (width / 2) - 2):  # inventory screen dims
            if (mouse.cy - 2) < len(player.fighter.wielded):
                item = player.fighter.wielded[mouse.cy - 2]
                if item is not None:
                    if item.item.equipment:
                        game.gEngine.console_print(
                            compare_window, 1, 2, 'Name    : ' +
                            color_text(item.name.capitalize(), item.color))
                        game.gEngine.console_print(
                            compare_window, 1, 3, 'Type    : ' +
                            item.item.equipment.type.capitalize())
                        damage = '%dd%d+%d' % (
                            item.item.equipment.damage.nb_dices,
                            item.item.equipment.damage.nb_faces,
                            item.item.equipment.damage.addsub)
                        game.gEngine.console_print(compare_window, 1, 4,
                                                   'Damage  : ' + damage)
                        game.gEngine.console_print(
                            compare_window, 1, 5,
                            'Accuracy: ' + str(item.item.equipment.accuracy))
                        game.gEngine.console_print(
                            compare_window, 1, 6,
                            'Value   : ' + str(item.item.value))

        # Equipment
            elif (mouse.cy - 2) - equip_y < len(player.fighter.equipment):
                item = player.fighter.equipment[mouse.cy - 2 - equip_y]
                if item is not None:
                    if item.item.equipment:
                        game.gEngine.console_print(
                            compare_window, 1, 2, 'Name    : ' +
                            color_text(item.name.capitalize(), item.color))
                        game.gEngine.console_print(
                            compare_window, 1, 3, 'Type    : ' +
                            item.item.equipment.type.capitalize())
                        game.gEngine.console_print(
                            compare_window, 1, 4,
                            'Armor   : ' + str(item.item.equipment.bonus))
                        game.gEngine.console_print(
                            compare_window, 1, 5,
                            'Penalty : ' + str(item.item.equipment.penalty))
                        game.gEngine.console_print(
                            compare_window, 1, 6,
                            'Value   : ' + str(item.item.value))
            if mouse.lbutton_pressed and item is not None:
                i_n = color_text(item.name.capitalize(), item.color)
                message = 'Do you want to take %s off?' % i_n
                w = len(message) + 2
                d_box = DialogBox(game,
                                  w,
                                  10,
                                  width / 4,
                                  height / 2,
                                  message,
                                  type='option',
                                  con=inventory_window)
                confirm = d_box.display_box()
                if confirm == 1:
                    item.item.equipment.un_equip(game.player, item)
                    d_box.destroy_box()
                    inventory_items = []
                    check_boxes = []
                    for x in range(len(player.fighter.inventory)):
                        check_boxes.append(CheckBox(x=1, y=x + 3))
                        i = color_text(
                            player.fighter.inventory[x].name.capitalize(),
                            player.fighter.inventory[x].color)
                        if player.fighter.inventory[x].item.check_stackable:
                            i += ' (%d)' % player.fighter.inventory[x].item.qty
                        inventory_items.append(i)
                    i = 0
                    for x in player.fighter.wielded:
                        if x == item:
                            player.fighter.wielded[i] = None
                        i += 1
                    i = 0
                    for x in player.fighter.equipment:
                        if x == item:
                            player.fighter.equipment[i] = None
                        i += 1

        # keyboard input
        # keeps similar feel to old inventory if using the keys
        # keyboard input is sluggish as balls for some reason, need to look into it more
        index = key.c - ord('a')
        if key:
            if index >= 0 and index < len(inventory_items):
                return_item = player.fighter.inventory[index]
                break
            index = key.c - ord('1')
            if index >= 0 and index <= 1:
                return_item = player.fighter.wielded[index]
                break
            elif index >= 2 and index <= 10:
                return_item = player.fighter.equipment[index - 2]
                break
            if key.vk == libtcod.KEY_DOWN:
                if current_selection is None:
                    current_selection = 0
                current_selection += 1
                if current_selection > len(inventory_items):
                    current_selection = 0
            if key.vk == libtcod.KEY_UP:
                if current_selection is None:
                    current_selection = 0
                current_selection -= 1
                if current_selection < 0:
                    current_selection = len(inventory_items)
        # ========================================================================
        # handle buttons
        # ========================================================================
        for i in drop_input:
            if i != -1:
                message = 'Drop all selected items?'
                w = len(message) + 2
                d_box = DialogBox(game,
                                  w,
                                  10,
                                  width / 2 - w / 2,
                                  height / 2 - 5,
                                  message,
                                  type='option',
                                  con=inventory_window)
                confirm = d_box.display_box()
                if confirm == 1:
                    d_box.destroy_box()
                    master_check.set_checked(False)
                    items_to_drop = []
                    for box in check_boxes:
                        if box.get_checked():
                            items_to_drop.append(
                                player.fighter.inventory[box.y - 3])
                    for item_to_drop in items_to_drop:
                        if item_to_drop:
                            item_to_drop.objects = game.objects
                            item_to_drop.item.drop(player.fighter.inventory,
                                                   player, False)
                            item_to_drop.send_to_back()
                    check_boxes = []
                    inventory_items = []
                    for x in range(len(player.fighter.inventory)):
                        check_boxes.append(CheckBox(x=1, y=x + 3))
                        inventory_items.append(
                            color_text(
                                player.fighter.inventory[x].name.capitalize(),
                                player.fighter.inventory[x].color))
                else:
                    d_box.destroy_box()
        # ========================================================================
        # handle exit button
        # ========================================================================

        for i in exit_input:
            if i != -1:
                key.vk = libtcod.KEY_ESCAPE
                break
    # Remember to remove consoles in reverse order of creation to avoid OOB errors
    drop_button.destroy_button()
    exit_button.destroy_button()
    game.gEngine.console_remove_console(compare_window)
    game.gEngine.console_remove_console(wielded_window)
    game.gEngine.console_remove_console(equipment_window)
    game.gEngine.console_remove_console(inventory_window)

    return return_item