src/hcode/btech/p.map.bits.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	map_load_bits (FILE *f, MAP *map)
void	map_save_bits (FILE *f, MAP *map, mapobj *obj)
void	set_hex_enterable (MAP *map, int x, int y)
void	set_hex_mine (MAP *map, int x, int y)
void	unset_hex_enterable (MAP *map, int x, int y)
void	unset_hex_mine (MAP *map, int x, int y)
int	is_mine_hex (MAP *map, int x, int y)
int	is_hangar_hex (MAP *map, int x, int y)
void	clear_hex_bits (MAP *map, int bits)
int	bit_size (MAP *map)

---

Function Documentation

int bit_size

(

MAP *

map

)

Definition at line 212 of file map.bits.c.

References grab_us_an_array(), MAP::map_height, MAP::map_width, MAP::mapobj, realnum, and TYPE_BITS.

Referenced by debug_check_stuff().

{
        int xs = map->map_width;
        int ys = map->map_height;
        int i, s = 0;
        unsigned char **foo;

        if(!map->mapobj[TYPE_BITS])
                return 0;
        foo = grab_us_an_array(map);
        for(i = 0; i < ys; i++)
                if(foo[i])
                        s += realnum(xs);
        return s;
}

void clear_hex_bits	(	MAP *	map,
		int	bits
	)

Definition at line 183 of file map.bits.c.

References btissetbit, btunsetbit, grab_us_an_array(), MAP::map_height, MAP::map_width, MAP::mapobj, and TYPE_BITS.

Referenced by recalculate_minefields(), and recursively_updatelinks().

{
        int xs = map->map_width;
        int ys = map->map_height;
        int i, j;
        unsigned char **foo;

        if(!map->mapobj[TYPE_BITS])
                return;
        foo = grab_us_an_array(map);
        for(i = 0; i < ys; i++)
                if(foo[i])
                        for(j = 0; j < xs; j++) {
                                switch (bits) {
                                case 1:
                                case 2:
                                        if(btissetbit(foo, j, i, bits))
                                                btunsetbit(foo, j, i, bits);
                                        break;
                                case 0:
                                        if(btissetbit(foo, j, i, 1))
                                                btunsetbit(foo, j, i, 1);
                                        if(btissetbit(foo, j, i, 2))
                                                btunsetbit(foo, j, i, 2);
                                        break;
                                }
                        }
}

int is_hangar_hex	(	MAP *	map,
		int	x,
		int	y
	)

Definition at line 169 of file map.bits.c.

References BIT_HANGAR, btissetbit, grab_us_an_array(), MAP::mapobj, TYPE_BITS, and y.

Referenced by steppable_base_check().

{
        unsigned char **foo;

        if(!map)
                return 0;
        if(!map->mapobj[TYPE_BITS])
                return 0;
        foo = grab_us_an_array(map);
        if(!foo[y])
                return 0;
        return (btissetbit(foo, x, y, BIT_HANGAR));
}

int is_mine_hex	(	MAP *	map,
		int	x,
		int	y
	)

Definition at line 155 of file map.bits.c.

References BIT_MINE, btissetbit, grab_us_an_array(), MAP::mapobj, TYPE_BITS, and y.

Referenced by add_mine(), possible_mine_poof(), possibly_remove_mines(), and show_mines_in_hex().

{
        unsigned char **foo;

        if(!map)
                return 0;
        if(!map->mapobj[TYPE_BITS])
                return 0;
        foo = grab_us_an_array(map);
        if(!foo[y])
                return 0;
        return (btissetbit(foo, x, y, BIT_MINE));
}

void map_load_bits	(	FILE *	f,
		MAP *	map
	)

Definition at line 45 of file map.bits.c.

References CHELO, Create, MAP::map_height, MAP::map_width, and realnum.

Referenced by load_mapobjs().

{
        int xs = map->map_width;
        int ys = map->map_height;
        unsigned char **foo;
        int tmp, i;

        Create(foo, unsigned char *, ys);
        CHELO(foo, sizeof(unsigned char *), ys, f);

        for(i = 0; i < ys; i++)
                if(foo[i]) {
                        Create(foo[i], unsigned char, realnum(xs));
                        CHELO(foo[i], sizeof(unsigned char), realnum(xs), f);
                }
}

void map_save_bits	(	FILE *	f,
		MAP *	map,
		mapobj *	obj
	)

Definition at line 62 of file map.bits.c.

References c, CHESA, mapobj_struct::datai, MAP::map_height, MAP::map_width, outbyte, realnum, and TYPE_BITS.

Referenced by save_mapobjs().

{
        int tmp;
        int i, j, c, tc = 0;
        unsigned char **foo;
        int xs = map->map_width;
        int ys = map->map_height;
        unsigned char tmpb;

#define outbyte(a) tmpb=(a);fwrite(&tmpb, 1, 1, f);
        foo = (unsigned char **) ((void *) obj->datai);
        /* First, we clean up our act */
        for(i = 0; i < ys; i++) {
                c = 0;
                if(foo[i]) {
                        for(j = 0; j < realnum(xs); j++)
                                if(foo[i][j])
                                        c++;
                        if(!c) {
                                free((void *) foo[i]);
                                foo[i] = NULL;
                        } else
                                tc += c;
                }
        }
        if(!tc) {
                /* We don't want to save worthless shit */
                /* On other hand, cleaning us out of memory would take too
                   much trouble compared to the worth. Therefore, during next
                   cleanup (reboot), this structure does a disappearance act. */
                return;
        }
        outbyte(TYPE_BITS + 1);
        CHESA(foo, sizeof(unsigned char *), ys, f);

        for(i = 0; i < ys; i++)
                if(foo[i])
                        CHESA(foo[i], sizeof(unsigned char), realnum(xs), f);
}

void set_hex_enterable	(	MAP *	map,
		int	x,
		int	y
	)

Definition at line 123 of file map.bits.c.

References BIT_HANGAR, btsetbit, and grab_us_an_array().

Referenced by add_links().

{
        unsigned char **foo;

        foo = grab_us_an_array(map);
        btsetbit(foo, x, y, BIT_HANGAR);
}

void set_hex_mine	(	MAP *	map,
		int	x,
		int	y
	)

Definition at line 131 of file map.bits.c.

References BIT_MINE, btsetbit, and grab_us_an_array().

Referenced by add_mine_on_map().

{
        unsigned char **foo;

        foo = grab_us_an_array(map);
        btsetbit(foo, x, y, BIT_MINE);
}

void unset_hex_enterable	(	MAP *	map,
		int	x,
		int	y
	)

Definition at line 139 of file map.bits.c.

References BIT_HANGAR, btunsetbit, and grab_us_an_array().

{
        unsigned char **foo;

        foo = grab_us_an_array(map);
        btunsetbit(foo, x, y, BIT_HANGAR);
}

void unset_hex_mine	(	MAP *	map,
		int	x,
		int	y
	)

Definition at line 147 of file map.bits.c.

References BIT_MINE, btunsetbit, and grab_us_an_array().

Referenced by make_mine_explode().

{
        unsigned char **foo;

        foo = grab_us_an_array(map);
        btunsetbit(foo, x, y, BIT_MINE);
}

---