Example #1
0
RLEVEL RxLevel(dbref thing)
{
    const UTF8 *buff = atr_get_raw(thing, A_RLEVEL);
    if (  NULL == buff
       || strlen((char *)buff) != 17)
    {
        switch (Typeof(thing))
        {
        case TYPE_ROOM:
            return(mudconf.def_room_rx);

        case TYPE_PLAYER:
            return(mudconf.def_player_rx);

        case TYPE_EXIT:
            return(mudconf.def_exit_rx);

        default:
            return(mudconf.def_thing_rx);
        }
    }

    int i;
    RLEVEL rx = 0;
    for (i = 0; mux_isxdigit(buff[i]); i++)
    {
        rx = 16 * rx + mux_hex2dec(buff[i]);
    }
    return rx;
}
Example #2
0
RLEVEL TxLevel(dbref thing)
{
    const UTF8 *buff = atr_get_raw(thing, A_RLEVEL);
    if (  NULL == buff
       || strlen((char *)buff) != 17)
    {
        switch (Typeof(thing))
        {
        case TYPE_ROOM:
            return(mudconf.def_room_tx);

        case TYPE_PLAYER:
            return(mudconf.def_player_tx);

        case TYPE_EXIT:
            return(mudconf.def_exit_tx);

        default:
            return(mudconf.def_thing_tx);
        }
    }

    // Skip the first field.
    //
    int i;
    for (i = 0; buff[i] && !mux_isspace(buff[i]); i++)
    {
        ; // Nothing.
    }

    RLEVEL tx = 0;
    if (buff[i])
    {
        // Skip space found above.
        //
        i++;

        // Decode second field.
        //
        for ( ; mux_isxdigit(buff[i]); i++)
        {
            tx = 16 * tx + mux_hex2dec(buff[i]);
        }
    }
    return tx;
}
Example #3
0
File: db_rw.c Project: chazu/btmux
static int db_write_object(FILE * f, dbref i, int db_format, int flags)
{
	ATTR *a;
	char *got, *as;
	dbref aowner;
	int ca, aflags, save, j;
	BOOLEXP *tempbool;

	if(!(flags & V_ATRNAME))
		putstring(f, Name(i));
	putref(f, Location(i));
	if(flags & V_ZONE)
		putref(f, Zone(i));
	putref(f, Contents(i));
	putref(f, Exits(i));
	if(flags & V_LINK)
		putref(f, Link(i));
	putref(f, Next(i));
	if(!(flags & V_ATRKEY)) {
		got = atr_get(i, A_LOCK, &aowner, &aflags);
		tempbool = parse_boolexp(GOD, got, 1);
		free_lbuf(got);
		putboolexp(f, tempbool);
		if(tempbool)
			free_bool(tempbool);
	}
	putref(f, Owner(i));
	if(flags & V_PARENT)
		putref(f, Parent(i));
	if(!(flags & V_ATRMONEY))
		putref(f, Pennies(i));
	putref(f, Flags(i));
	if(flags & V_XFLAGS)
		putref(f, Flags2(i));
	if(flags & V_3FLAGS)
		putref(f, Flags3(i));
	if(flags & V_POWERS) {
		putref(f, Powers(i));
		putref(f, Powers2(i));
	}
	/*
	 * write the attribute list 
	 */

	if((!(flags & V_GDBM)) || (mudstate.panicking == 1)) {
		for(ca = atr_head(i, &as); ca; ca = atr_next(&as)) {
			save = 0;
			a = atr_num(ca);
			if(a)
				j = a->number;
			else
				j = -1;

			if(j > 0) {
				switch (j) {
				case A_NAME:
					if(flags & V_ATRNAME)
						save = 1;
					break;
				case A_LOCK:
					if(flags & V_ATRKEY)
						save = 1;
					break;
				case A_LIST:
				case A_MONEY:
					break;
				default:
					save = 1;
				}
			}
			if(save) {
				got = atr_get_raw(i, j);
				fprintf(f, ">%d\n", j);
				putstring(f, got);
			}
		}
		fprintf(f, "<\n");
	}
	return 0;
}
Example #4
0
void do_dbclean( dbref player, dbref cause, int key ) {
    VATTR *vp, *vpx;

    dbref i, end;

    int ca, n_oldtotal, n_oldtop, n_deleted, n_renumbered, n_objt, n_atrt,
        got;
    char *as, *str;

    int *used_table;

    ATTR **new_table;

    UFUN *ufp;

    CMDENT *cmdp;

    ADDENT *addp;

    raw_broadcast( 0, "GAME: Cleaning database. Game may freeze for a few minutes." );

    used_table = ( int * ) XCALLOC( mudstate.attr_next, sizeof( int ),
                                    "dbclean.used_table" );

    n_oldtotal = mudstate.attr_next;
    n_oldtop = anum_alc_top;
    n_deleted = n_renumbered = n_objt = n_atrt = 0;

    /*
     * Non-user-defined attributes are always considered used.
     */

    for( i = 0; i < A_USER_START; i++ ) {
        used_table[i] = i;
    }

    /*
     * Walk the database. Mark all the attribute numbers in use.
     */

    atr_push();
    DO_WHOLE_DB( i ) {
        for( ca = atr_head( i, &as ); ca; ca = atr_next( &as ) ) {
            used_table[ca] = ca;
        }
    }
    atr_pop();

    /*
     * Walk the vattr table. If a number isn't in use, zorch it.
     */

    vp = vattr_first();
    while( vp ) {
        vpx = vp;
        vp = vattr_next( vp );
        if( used_table[vpx->number] == 0 ) {
            anum_set( vpx->number, NULL );
            hashdelete( vpx->name, &mudstate.vattr_name_htab );
            XFREE( vpx, "dbclean.vpx" );
            n_deleted++;
        }
    }

    /*
     * The user-defined function, added command, and hook structures embed
     * * attribute numbers. Clean out the ones we've deleted, resetting them
     * * to the *Invalid (A_TEMP) attr.
     */

    for( ufp = ( UFUN * ) hash_firstentry( &mudstate.ufunc_htab );
            ufp != NULL; ufp = ( UFUN * ) hash_nextentry( &mudstate.ufunc_htab ) ) {
        if( used_table[ufp->atr] == 0 ) {
            ufp->atr = A_TEMP;
        }
    }
    for( cmdp = ( CMDENT * ) hash_firstentry( &mudstate.command_htab );
            cmdp != NULL;
            cmdp = ( CMDENT * ) hash_nextentry( &mudstate.command_htab ) ) {
        if( cmdp->pre_hook ) {
            if( used_table[cmdp->pre_hook->atr] == 0 ) {
                cmdp->pre_hook->atr = A_TEMP;
            }
        }
        if( cmdp->post_hook ) {
            if( used_table[cmdp->post_hook->atr] == 0 ) {
                cmdp->post_hook->atr = A_TEMP;
            }
        }
        if( cmdp->userperms ) {
            if( used_table[cmdp->userperms->atr] == 0 ) {
                cmdp->userperms->atr = A_TEMP;
            }
        }
        if( cmdp->callseq & CS_ADDED ) {
            for( addp = ( ADDENT * ) cmdp->info.added;
                    addp != NULL; addp = addp->next ) {
                if( used_table[addp->atr] == 0 ) {
                    addp->atr = A_TEMP;
                }
            }
        }
    }

    /*
     * Walk the table we've created of used statuses. When we find free
     * * slots, walk backwards to the first used slot at the end of the
     * * table. Write the number of the free slot into that used slot.
     */

    for( i = A_USER_START, end = mudstate.attr_next - 1;
            ( i < mudstate.attr_next ) && ( i < end ); i++ ) {
        if( used_table[i] == 0 ) {
            while( ( end > i ) && ( used_table[end] == 0 ) ) {
                end--;
            }
            if( end > i ) {
                used_table[end] = used_table[i] = i;
                end--;
            }
        }
    }

    /*
     * Renumber the necessary attributes in the vattr tables.
     */

    for( i = A_USER_START; i < mudstate.attr_next; i++ ) {
        if( used_table[i] != i ) {
            vp = ( VATTR * ) anum_get( i );
            if( vp ) {
                vp->number = used_table[i];
                vp->flags |= AF_DIRTY;
                anum_set( used_table[i], ( ATTR * ) vp );
                anum_set( i, NULL );
                n_renumbered++;
            }
        }
    }

    /*
     * Now we walk the database. For every object, if we have an attribute
     * * we're renumbering (the slot number is not equal to the array value
     * * at that slot), we delete the old attribute and add the new one.
     */

    atr_push();
    DO_WHOLE_DB( i ) {
        got = 0;
        for( ca = atr_head( i, &as ); ca; ca = atr_next( &as ) ) {
            if( used_table[ca] != ca ) {
                str = atr_get_raw( i, ca );
                atr_add_raw( i, used_table[ca], str );
                atr_clr( i, ca );
                n_atrt++;
                got = 1;
            }
        }
        if( got ) {
            n_objt++;
        }
    }
    atr_pop();

    /*
     * The new end of the attribute table is the first thing we've
     * * renumbered.
     */

    for( end = A_USER_START;
            ( ( end == used_table[end] ) && ( end < mudstate.attr_next ) ); end++ );
    mudstate.attr_next = end;

    /*
     * We might be able to shrink the size of the attribute table.
     * * If the current size of the table is less than the initial
     * * size, shrink it back down to the initial size.
     * * Otherwise, shrink it down so it's the current top plus the
     * * initial size, as if we'd just called anum_extend() for it.
     */

    if( anum_alc_top > mudconf.init_size + A_USER_START ) {
        if( mudstate.attr_next < mudconf.init_size + A_USER_START ) {
            end = mudconf.init_size + A_USER_START;
        } else {
            end = mudstate.attr_next + mudconf.init_size;
        }
        if( end < anum_alc_top ) {
            new_table = ( ATTR ** ) XCALLOC( end + 1, sizeof( ATTR * ),
                                             "dbclean.new_table" );
            for( i = 0; i < mudstate.attr_next; i++ ) {
                new_table[i] = anum_table[i];
            }
            XFREE( anum_table, "dbclean.anum_table" );
            anum_table = new_table;
            anum_alc_top = end;
        }
    }

    /*
     * Go through the function and added command tables again, and
     * * take care of the attributes that got renumbered.
     */

    for( ufp = ( UFUN * ) hash_firstentry( &mudstate.ufunc_htab );
            ufp != NULL; ufp = ( UFUN * ) hash_nextentry( &mudstate.ufunc_htab ) ) {
        if( used_table[ufp->atr] != ufp->atr ) {
            ufp->atr = used_table[ufp->atr];
        }
    }
    for( cmdp = ( CMDENT * ) hash_firstentry( &mudstate.command_htab );
            cmdp != NULL;
            cmdp = ( CMDENT * ) hash_nextentry( &mudstate.command_htab ) ) {
        if( cmdp->pre_hook ) {
            if( used_table[cmdp->pre_hook->atr] !=
                    cmdp->pre_hook->atr )
                cmdp->pre_hook->atr =
                    used_table[cmdp->pre_hook->atr];
        }
        if( cmdp->post_hook ) {
            if( used_table[cmdp->post_hook->atr] !=
                    cmdp->post_hook->atr )
                cmdp->post_hook->atr =
                    used_table[cmdp->post_hook->atr];
        }
        if( cmdp->userperms ) {
            if( used_table[cmdp->userperms->atr] !=
                    cmdp->userperms->atr )
                cmdp->userperms->atr =
                    used_table[cmdp->userperms->atr];
        }
        if( cmdp->callseq & CS_ADDED ) {
            for( addp = ( ADDENT * ) cmdp->info.added;
                    addp != NULL; addp = addp->next ) {
                if( used_table[addp->atr] != addp->atr ) {
                    addp->atr = used_table[addp->atr];
                }
            }
        }
    }

    /*
     * Clean up.
     */

    XFREE( used_table, "dbclean.used_table" );

    if( anum_alc_top != n_oldtop ) {
        notify_check( player, player, MSG_PUP_ALWAYS|MSG_ME_ALL|MSG_F_DOWN, "Cleaned %d user attribute slots (reduced to %d): %d deleted, %d renumbered (%d objects and %d individual attrs touched). Table size reduced from %d to %d.", n_oldtotal - A_USER_START, mudstate.attr_next - A_USER_START, n_deleted, n_renumbered, n_objt, n_atrt, n_oldtop, anum_alc_top );
    } else {
        notify_check( player, player, MSG_PUP_ALWAYS|MSG_ME_ALL|MSG_F_DOWN, "Cleaned %d attributes (now %d): %d deleted, %d renumbered (%d objects and %d individual attrs touched).", n_oldtotal, mudstate.attr_next, n_deleted, n_renumbered, n_objt, n_atrt );
        
    }

    raw_broadcast( 0, "GAME: Database cleaning complete." );

}