Pages: [1]
Author Topic: Sudden assertion error  (Read 640 times)
Posts: 6

View Profile
« on: March 28, 2012, 03:42:16 PM »

Hi, all of a sudden, I am getting an assertion error from Windows 7, and my program crashes. Has anyone ever encountered this?

Assertion failed: dat != ((void *)0) && (unsigned)(x) < (unsigned)dat->w && (uns
igned)(y) < (unsigned)dat->h, file src/console_c.c, line 334
Posts: 68

View Profile
« Reply #1 on: March 28, 2012, 04:01:18 PM »

What did you change recently? I'm thinking you are trying to pass the wrong kind of data to the function and that this causes the assertion error. Otherwise, I don't know for sure without some more details (code sample that causes it, backtrace, full error message and context)
Posts: 6

View Profile
« Reply #2 on: March 28, 2012, 04:10:33 PM »

I thought I had commented all changes out, but I will keep looking for data passed. IDLE gives no error, so I am  trying to figure out where the issue occurs.
Posts: 68

View Profile
« Reply #3 on: March 28, 2012, 04:15:32 PM »

I thought I had commented all changes out, but I will keep looking for data passed. IDLE gives no error, so I am  trying to figure out where the issue occurs.

If you're on one of the later dev versions (1.5.1) you're using console_get_char at some point. Check your code for calls to that Smiley
Posts: 6

View Profile
« Reply #4 on: March 28, 2012, 05:44:39 PM »

I will check the dev version, thanks. I exited from the error differently, and got more information from IDLE. Here is the error:

Traceback (most recent call last):
  File "C:\...\...\", line 350, in <module>
  File "C:\Users\Matt\Dropbox\Foxhound the Roguelike\", line 230, in render_all
    libtcod.console_set_back(con, x, y, color_dark_wall, libtcod.BKGND_SET)
  File "C:\Users\Matt\Dropbox\Foxhound the Roguelike\", line 478, in console_set_back
    _lib.TCOD_console_set_back(con, x, y, col, flag)
WindowsError: exception: breakpoint encountered

I guess what is odd to me is that I did not, as far as I know, modify these lines.

Here is my full code so far:
import pdb
import libtcodpy as libtcod
# Game to be
#actual size of the window
#size of the map
#parameters for dungeon generator
FOV_ALGO = 0  #default FOV algorithm
FOV_LIGHT_WALLS = True  #light walls or not
LIMIT_FPS = 20  #20 frames-per-second maximum
color_dark_wall = libtcod.Color(0, 0, 0)
color_light_wall = libtcod.Color(130, 110, 50)
color_dark_ground = libtcod.Color(0, 0, 0)
color_light_ground = libtcod.Color(200, 180, 50)
#We'll see if I can get some shadows...
color_shadow_wall = libtcod.Color(20, 20, 20)
color_shadow_ground = libtcod.Color(20, 20, 20)
class Tile:
    #a tile of the map and its properties
    def __init__(self, blocked, block_sight = None):
        self.blocked = blocked
        #all tiles start unexplored
        self.explored = False
        #by default, if a tile is blocked, it also blocks sight
        if block_sight is None: block_sight = blocked
        self.block_sight = block_sight
class Rect:
    #a rectangle on the map. used to characterize a room.
    def __init__(self, x, y, w, h):
        self.x1 = x
        self.y1 = y
        self.x2 = x + w
        self.y2 = y + h
    def center(self):
        center_x = (self.x1 + self.x2) / 2
        center_y = (self.y1 + self.y2) / 2
        return (center_x, center_y)
    def intersect(self, other):
        #returns true if this rectangle intersects with another one
        return (self.x1 <= other.x2 and self.x2 >= other.x1 and
                self.y1 <= other.y2 and self.y2 >= other.y1)
# Player stance vars
class Object:
    #this is a generic object: the player, a monster, an item, the stairs...
    #it's always represented by a character on screen.
    def __init__(self, x, y, char, color):
        self.x = x
        self.y = y
        self.char = char
        self.color = color
        self.stance = STANCE_STANDING
    def move(self, dx, dy):
        #move by the given amount, if the destination is not blocked
        if not map[self.x + dx][self.y + dy].blocked:
            self.x += dx
            self.y += dy
    def draw(self):
        #only show if it's visible to the player
        if libtcod.map_is_in_fov(fov_map, self.x, self.y):
            #set the color and then draw the character that represents this object at its position
            libtcod.console_set_foreground_color(con, self.color)
            libtcod.console_put_char(con, self.x, self.y, self.char, libtcod.BKGND_NONE)

    def change_stance(self, stance):
#trying to have player be able to change stances...
        self.stance = stance

    def clear(self):
        #erase the character that represents this object
        libtcod.console_put_char(con, self.x, self.y, ' ', libtcod.BKGND_NONE)
def create_room(room):
    global map
    #go through the tiles in the rectangle and make them passable
    for x in range(room.x1 + 1, room.x2):
        for y in range(room.y1 + 1, room.y2):
            map[x][y].blocked = False
            map[x][y].block_sight = False
def create_h_tunnel(x1, x2, y):
    global map
    #horizontal tunnel. min() and max() are used in case x1>x2
    for x in range(min(x1, x2), max(x1, x2) + 1):
        map[x][y].blocked = False
        map[x][y].block_sight = False
def create_v_tunnel(y1, y2, x):
    global map
    #vertical tunnel
    for y in range(min(y1, y2), max(y1, y2) + 1):
        map[x][y].blocked = False
        map[x][y].block_sight = False
def make_map():
    global map, player
    #fill map with "blocked" tiles
    map = [[ Tile(True)
        for y in range(MAP_HEIGHT) ]
            for x in range(MAP_WIDTH) ]
    rooms = []
    num_rooms = 0
    for r in range(MAX_ROOMS):
        #random width and height
        w = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
        h = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE)
        #random position without going out of the boundaries of the map
        x = libtcod.random_get_int(0, 0, MAP_WIDTH - w - 1)
        y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h - 1)
        #"Rect" class makes rectangles easier to work with
        new_room = Rect(x, y, w, h)
        #run through the other rooms and see if they intersect with this one
        failed = False
        for other_room in rooms:
            if new_room.intersect(other_room):
                failed = True
        if not failed:
            #this means there are no intersections, so this room is valid
            #"paint" it to the map's tiles
            #center coordinates of new room, will be useful later
            (new_x, new_y) =
            if num_rooms == 0:
                #this is the first room, where the player starts at
                player.x = new_x
                player.y = new_y
                #all rooms after the first:
                #connect it to the previous room with a tunnel
                #center coordinates of previous room
                (prev_x, prev_y) = rooms[num_rooms-1].center()
                #draw a coin (random number that is either 0 or 1)
                if libtcod.random_get_int(0, 0, 1) == 1:
                    #first move horizontally, then vertically
                    create_h_tunnel(prev_x, new_x, prev_y)
                    create_v_tunnel(prev_y, new_y, new_x)
                    #first move vertically, then horizontally
                    create_v_tunnel(prev_y, new_y, prev_x)
                    create_h_tunnel(prev_x, new_x, new_y)
            #finally, append the new room to the list
            num_rooms += 1
def render_all():
    global fov_map, color_dark_wall, color_light_wall
    global color_dark_ground, color_light_ground
    global fov_recompute
    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)
        #go through all tiles, and set their background color according to the FOV
        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
                if not visible:
                    #trying to make it so can only see things in FOV, not have a "memory" of explored area
                    if wall:
                            libtcod.console_set_back(con, x, y, color_dark_wall, libtcod.BKGND_SET)
                            libtcod.console_set_back(con, x, y, color_dark_ground, libtcod.BKGND_SET)
                    #it's visible
                    if wall:
                        libtcod.console_set_back(con, x, y, color_light_wall, libtcod.BKGND_SET )
                        libtcod.console_set_back(con, x, y, color_light_ground, libtcod.BKGND_SET )
                    #since it's visible, explore it
                    map[x][y].explored = True
    #draw all objects in the list
    for object in objects:
    #blit the contents of "con" to the root console
    libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
def handle_keys():
    global fov_recompute
    #key = libtcod.console_check_for_keypress()  #real-time
    key = libtcod.console_wait_for_keypress(True)  #turn-based
    if key.vk == libtcod.KEY_ENTER and key.lalt:
        #Alt+Enter: toggle fullscreen
        libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
    elif key.vk == libtcod.KEY_ESCAPE:
        return True  #exit game

# Special keys
# Stance
    if key.vk == libtcod.KEY_CHAR:
        if key.c == ord('c') and player.change_stance == STANCE_STANDING:
            fov_recompute = True

        elif key.c == ord('c') and player.change_stance == STANCE_CROUCHING:
            fov_recompute = True

        elif key.c == ord('p') and player.change_stance == STANCE_STANDING or STANCE_CROUCHING:
            fov_recompute = True
        elif key.c == ord('c' or 'p') and player.change_stance == STANCE_PRONE:
            fov_recompute = True
    #movement keys
    if libtcod.console_is_key_pressed(libtcod.KEY_UP):
        player.move(0, -1)
        fov_recompute = True
    elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
        player.move(0, 1)
        fov_recompute = True
    elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
        player.move(-1, 0)
        fov_recompute = True
    elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
        player.move(1, 0)
        fov_recompute = True

    elif libtcod.console_is_key_pressed(libtcod.KEY_END):
        player.move(1, -1)
        fov_recompute = True

    elif libtcod.console_is_key_pressed(libtcod.KEY_PAGEDOWN):
        player.move(1, 1)
        fov_recompute = True

    elif libtcod.console_is_key_pressed(libtcod.KEY_HOME):
        player.move(-1, -1)
        fov_recompute = True

    elif libtcod.console_is_key_pressed(libtcod.KEY_PAGEUP):
        player.move(-1, 1)
        fov_recompute = True

# Initialization & Main Loop
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)
con = libtcod.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)

#create object representing the player
player = Object(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, '@', libtcod.white)
#create an NPC
npc = Object(SCREEN_WIDTH/2 - 5, SCREEN_HEIGHT/2, '@', libtcod.yellow)
#the list of objects with those two
objects = [npc, player]
#generate map (at this point it's not drawn to the screen)
#create the FOV map, according to the generated map
fov_map = libtcod.map_new(MAP_WIDTH, MAP_HEIGHT)
for y in range(MAP_HEIGHT):
    for x in range(MAP_WIDTH):
        libtcod.map_set_properties(fov_map, x, y, not map[x][y].block_sight, not map[x][y].blocked)
fov_recompute = True
while not libtcod.console_is_window_closed():
    #render the screen
    #erase all objects at their old locations, before they move
    for object in objects:
    #handle keys and exit game if needed
    exit = handle_keys()
    if exit:

Posts: 19

View Profile
« Reply #5 on: March 29, 2012, 07:43:32 PM »

What the assertion means is that you are passing an x or y that is greater than the width or height of your console.   When I was debugging the python wrapper on Mac, I ran several recent 7DRLs written with it to test it.  I encountered that assert from several of them.  My conclusion was that they were written only using the release version of the library, in which case this assert is ignored and everything proceeds just fine.  When I built the library in release rather than debug, they worked fine.

For my own code, I have a wrapper function around the library calls that does that check for me and bails out if it fails, rather than calling into the library, so that I am free to run a debug library and still occasionally try to draw stuff out of bounds.  This is helpful for me since I am drawing a few objects larger than one character, so while I'm checking that they are at least partially within my viewport before I start to draw, the whole object might be partially clipped.
Posts: 6

View Profile
« Reply #6 on: March 30, 2012, 01:14:14 AM »

Journeyman, ok, that explains it. It for whatever reason does not like that I changed my screen height for the root console. I need to figure out why my offscreen console is not blitting to the portion I accounted for when I changed the screen height. As soon as I changed it back, it was working again... thanks!
Pages: [1]
Jump to: