Esempio n. 1
0
int fh_any( dbref target, dbref player, FLAG flag, int fflags, int reset ) {
    /*
     * Never let God drop his own wizbit.
     */

    if( God( target ) && reset && ( flag == WIZARD ) &&
            !( fflags & FLAG_WORD2 ) && !( fflags & FLAG_WORD3 ) ) {
        notify( player, "You cannot make God mortal." );
        return 0;
    }
    /*
     * Otherwise we can go do it.
     */

    if( fflags & FLAG_WORD3 ) {
        if( reset ) {
            s_Flags3( target, Flags3( target ) & ~flag );
        } else {
            s_Flags3( target, Flags3( target ) | flag );
        }
    } else if( fflags & FLAG_WORD2 ) {
        if( reset ) {
            s_Flags2( target, Flags2( target ) & ~flag );
        } else {
            s_Flags2( target, Flags2( target ) | flag );
        }
    } else {
        if( reset ) {
            s_Flags( target, Flags( target ) & ~flag );
        } else {
            s_Flags( target, Flags( target ) | flag );
        }
    }
    return 1;
}
Esempio n. 2
0
char *flag_description( dbref player, dbref target ) {
    char *buff, *bp;

    FLAGENT *fp;

    int otype;

    FLAG fv;

    /*
     * Allocate the return buffer
     */

    otype = Typeof( target );
    bp = buff = alloc_mbuf( "flag_description" );

    /*
     * Store the header strings and object type
     */

    safe_mb_str( ( char * ) "Type: ", buff, &bp );
    safe_mb_str( ( char * ) object_types[otype].name, buff, &bp );
    safe_mb_str( ( char * ) " Flags:", buff, &bp );
    if( object_types[otype].perm != CA_PUBLIC ) {
        return buff;
    }
    /*
     * Store the type-invariant flags
     */

    for( fp = gen_flags; fp->flagname; fp++ ) {
        if( fp->flagflag & FLAG_WORD3 ) {
            fv = Flags3( target );
        } else if( fp->flagflag & FLAG_WORD2 ) {
            fv = Flags2( target );
        } else {
            fv = Flags( target );
        }
        if( fv & fp->flagvalue ) {
            if( ( fp->listperm & CA_WIZARD ) && !Wizard( player ) ) {
                continue;
            }
            if( ( fp->listperm & CA_GOD ) && !God( player ) ) {
                continue;
            }
            /*
             * don't show CONNECT on dark wizards to mortals
             */
            if( isPlayer( target ) && isConnFlag( fp ) &&
                    Can_Hide( target ) && Hidden( target ) &&
                    !See_Hidden( player ) ) {
                continue;
            }
            safe_mb_chr( ' ', buff, &bp );
            safe_mb_str( ( char * ) fp->flagname, buff, &bp );
        }
    }

    return buff;
}
Esempio n. 3
0
int fh_privileged( dbref target, dbref player, FLAG flag, int fflags, int reset ) {
    int has_it;

    if( !God( player ) ) {

        if( !isPlayer( player ) || ( player != Owner( player ) ) ) {
            return 0;
        }
        if( isPlayer( target ) ) {
            return 0;
        }

        if( fflags & FLAG_WORD3 ) {
            has_it = ( Flags3( player ) & flag ) ? 1 : 0;
        } else if( fflags & FLAG_WORD2 ) {
            has_it = ( Flags2( player ) & flag ) ? 1 : 0;
        } else {
            has_it = ( Flags( player ) & flag ) ? 1 : 0;
        }

        if( !has_it ) {
            return 0;
        }
    }
    return ( fh_any( target, player, flag, fflags, reset ) );
}
Esempio n. 4
0
void decompile_flags( dbref player, dbref thing, char *thingname ) {
    FLAG f1, f2, f3;

    FLAGENT *fp;

    /*
     * Report generic flags
     */

    f1 = Flags( thing );
    f2 = Flags2( thing );
    f3 = Flags3( thing );

    for( fp = gen_flags; fp->flagname; fp++ ) {

        /*
         * Skip if we shouldn't decompile this flag
         */

        if( fp->listperm & CA_NO_DECOMP ) {
            continue;
        }

        /*
         * Skip if this flag is not set
         */

        if( fp->flagflag & FLAG_WORD3 ) {
            if( !( f3 & fp->flagvalue ) ) {
                continue;
            }
        } else if( fp->flagflag & FLAG_WORD2 ) {
            if( !( f2 & fp->flagvalue ) ) {
                continue;
            }
        } else {
            if( !( f1 & fp->flagvalue ) ) {
                continue;
            }
        }

        /*
         * Skip if we can't see this flag
         */

        if( !check_access( player, fp->listperm ) ) {
            continue;
        }

        /*
         * We made it this far, report this flag
         */

        notify_check( player, player, MSG_PUP_ALWAYS|MSG_ME_ALL|MSG_F_DOWN, "@set %s=%s", strip_ansi( thingname ), fp->flagname );
    }
}
Esempio n. 5
0
int has_flag( dbref player, dbref it, char *flagname ) {
    FLAGENT *fp;

    FLAG fv;

    fp = find_flag( it, flagname );
    if( fp == NULL ) {	/* find_flag() uppercases the string */
        if( !strcmp( flagname, "PLAYER" ) ) {
            return isPlayer( it );
        }
        if( !strcmp( flagname, "THING" ) ) {
            return isThing( it );
        }
        if( !strcmp( flagname, "ROOM" ) ) {
            return isRoom( it );
        }
        if( !strcmp( flagname, "EXIT" ) ) {
            return isExit( it );
        }
        return 0;
    }
    if( fp->flagflag & FLAG_WORD3 ) {
        fv = Flags3( it );
    } else if( fp->flagflag & FLAG_WORD2 ) {
        fv = Flags2( it );
    } else {
        fv = Flags( it );
    }

    if( fv & fp->flagvalue ) {
        if( ( fp->listperm & CA_WIZARD ) && !Wizard( player ) ) {
            return 0;
        }
        if( ( fp->listperm & CA_GOD ) && !God( player ) ) {
            return 0;
        }
        /*
         * don't show CONNECT on dark wizards to mortals
         */
        if( isPlayer( it ) && isConnFlag( fp ) &&
                Can_Hide( it ) && Hidden( it ) && !See_Hidden( player ) ) {
            return 0;
        }
        return 1;
    }
    return 0;
}
Esempio n. 6
0
char *unparse_object( dbref player, dbref target, int obey_myopic ) {
    char *buf, *fp, *bp;

    int exam;

    buf = alloc_lbuf( "unparse_object" );
    if( target == NOTHING ) {
        strcpy( buf, "*NOTHING*" );
    } else if( target == HOME ) {
        strcpy( buf, "*HOME*" );
    } else if( target == AMBIGUOUS ) {
        strcpy( buf, "*VARIABLE*" );
    } else if( isGarbage( target ) ) {
        fp = unparse_flags( player, target );
        bp = buf;
        safe_sprintf( buf, &bp, "*GARBAGE*(#%d%s)", target, fp );
        free_sbuf( fp );
    } else if( !Good_obj( target ) ) {
        sprintf( buf, "*ILLEGAL*(#%d)", target );
    } else {
        if( obey_myopic ) {
            exam = MyopicExam( player, target );
        } else {
            exam = Examinable( player, target );
        }
        if( exam ||
                ( Flags( target ) & ( CHOWN_OK | JUMP_OK | LINK_OK |
                                      DESTROY_OK ) ) || ( Flags2( target ) & ABODE ) ) {

            /*
             * show everything
             */
            fp = unparse_flags( player, target );
            bp = buf;
            safe_sprintf( buf, &bp, "%s(#%d%s)", Name( target ), target, fp );
            free_sbuf( fp );
        } else {
            /*
             * show only the name.
             */
            strcpy( buf, Name( target ) );
        }
    }
    return buf;
}
Esempio n. 7
0
// Clones an object and returns the HS_DBREF of the new clone.
HS_DBREF CHSInterface::CloneThing(HS_DBREF model)
{
    HS_DBREF clone;

#ifdef PENNMUSH                 // No change in code between versions
    clone = new_object();

    // Copy the basic information from the model to the clone.
    memcpy(REFDB(clone), REFDB(model), sizeof(struct object));
    Owner(clone) = Owner(model);
    Name(clone) = NULL;

    // NULL-out some memory pointers we didn't really want copied.
    db[clone].list = NULL;

    // Now copy the pointer information.
    atr_cpy(clone, model);
    Locks(clone) = NULL;
    clone_locks(model, model, clone);
    Zone(clone) = Zone(model);
    Parent(clone) = Parent(model);
    Flags(clone) = clone_flag_bitmask("FLAG", Flags(model));
    set_name(clone, Name(model));
    s_Pennies(clone, Pennies(model));

#ifdef CREATION_TIMES
    /*
     * We give the clone the same modification time that its
     * other clone has, but update the creation time
     */
    db[clone].creation_time = time((time_t *) 0);
#endif

    db[clone].contents = db[clone].location = db[clone].next = NOTHING;
#endif

#if defined(TM3) || defined(MUX)
    clone = create_obj(Owner(model), Typeof(model),
                       Name(model), Pennies(model));

    //atr_free(clone);
    s_Name(clone, Name(model));
    s_Pennies(clone, Pennies(model));
    s_Parent(clone, Parent(model));
#ifdef TM3
    atr_cpy(Owner(clone), clone, model);
    s_Flags(clone, Flags(model));
    s_Flags2(clone, Flags2(model));
    s_Flags3(clone, Flags3(model));
#endif

#ifdef MUX
    atr_cpy(clone, model);
    s_Flags(clone, FLAG_WORD1, Flags(model));
    s_Flags(clone, FLAG_WORD2, Flags2(model));
    s_Flags(clone, FLAG_WORD3, Flags3(model));
    s_Home(clone, Home(model));
#endif
#endif

    return clone;
}
Esempio n. 8
0
File: db_rw.c Progetto: 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;
}
Esempio n. 9
0
/*
 * ---------------------------------------------------------------------------
 * * Return an lbuf pointing to the object name and possibly the db# and flags
 */
UTF8 *unparse_object(dbref player, dbref target, bool obey_myopic, bool bAddColor)
{
    UTF8 *buf = alloc_lbuf("unparse_object");
    if (NOPERM <= target && target < 0)
    {
        mux_strncpy(buf, aszSpecialDBRefNames[-target], LBUF_SIZE-1);
    }
    else if (!Good_obj(target))
    {
        mux_sprintf(buf, LBUF_SIZE, T("*ILLEGAL*(#%d)"), target);
    }
    else
    {
        bool exam;
        if (obey_myopic)
        {
            exam = MyopicExam(player, target);
        }
        else
        {
            exam = Examinable(player, target);
        }

        // Leave and extra 100 bytes for the dbref and flags at the end and
        // color at the beginning if necessary..
        //
        mux_field fldName = StripTabsAndTruncate( Moniker(target), buf,
                                                  LBUF_SIZE-100, LBUF_SIZE-100);
        UTF8 *bp = buf + fldName.m_byte;

#if defined(FIRANMUX)
        if (  fldName.m_column == fldName.m_byte
           && bAddColor)
        {
            // There is no color in the name, so look for @color, or highlight.
            //
            UTF8 *buf2 = alloc_lbuf("unparse_object.color");
            UTF8 *bp2  = buf2;

            UTF8 *pLetters = AcquireColorLetters(player, target);
            if (NULL != pLetters)
            {
                safe_str(LettersToBinary(pLetters), buf2, &bp2);
                free_lbuf(pLetters);
                pLetters = NULL;
            }
            else
            {
                safe_str((UTF8 *)COLOR_INTENSE, buf2, &bp2);
            }

            *bp = '\0';
            safe_str(buf, buf2, &bp2);
            safe_str((UTF8 *)COLOR_RESET, buf2, &bp2);

            // Swap buffers.
            //
            free_lbuf(buf);
            buf = buf2;
            bp  = bp2;
        }
#else
        UNUSED_PARAMETER(bAddColor);
#endif // FIRANMUX

        if (  exam
           || (Flags(target) & (CHOWN_OK | JUMP_OK | LINK_OK | DESTROY_OK))
           || (Flags2(target) & ABODE))
        {
            // Show everything.
            //
            UTF8 *fp = decode_flags(player, &(db[target].fs));

            safe_str(T("(#"), buf, &bp);
            safe_ltoa(target, buf, &bp);
            safe_str(fp, buf, &bp);
            safe_chr(')', buf, &bp);

            free_sbuf(fp);
        }
        *bp = '\0';
    }
    return buf;
}
Esempio n. 10
0
char *unparse_flags( dbref player, dbref thing ) {
    char *buf, *bp, *s;

    FLAGENT *fp;

    int flagtype;

    FLAG fv, flagword, flag2word, flag3word;

    buf = bp = s = alloc_sbuf( "unparse_flags" );
    *bp = '\0';

    if( !Good_obj( player ) || !Good_obj( thing ) ) {
        strcpy( buf, "#-2 ERROR" );
        return buf;
    }
    flagword = Flags( thing );
    flag2word = Flags2( thing );
    flag3word = Flags3( thing );
    flagtype = ( flagword & TYPE_MASK );
    if( object_types[flagtype].lett != ' ' ) {
        safe_sb_chr( object_types[flagtype].lett, buf, &bp );
    }

    for( fp = gen_flags; fp->flagname; fp++ ) {
        if( fp->flagflag & FLAG_WORD3 ) {
            fv = flag3word;
        } else if( fp->flagflag & FLAG_WORD2 ) {
            fv = flag2word;
        } else {
            fv = flagword;
        }
        if( fv & fp->flagvalue ) {

            if( ( fp->listperm & CA_WIZARD ) && !Wizard( player ) ) {
                continue;
            }
            if( ( fp->listperm & CA_GOD ) && !God( player ) ) {
                continue;
            }

            /*
             * don't show CONNECT on dark wizards to mortals
             */

            if( ( flagtype == TYPE_PLAYER ) && isConnFlag( fp ) &&
                    Can_Hide( thing ) && Hidden( thing ) &&
                    !See_Hidden( player ) ) {
                continue;
            }

            /*
             * Check if this is a marker flag and we're at the
             * beginning of a buffer. If so, we need to insert a
             * separator character first so we don't end up
             * running the dbref number into the flags.
             */
            if( ( s == bp ) && isMarkerFlag( fp ) ) {
                safe_sb_chr( MARK_FLAG_SEP, buf, &bp );
            }

            safe_sb_chr( fp->flaglett, buf, &bp );
        }
    }

    *bp = '\0';
    return buf;
}