[Engine/Fakemeta] 3rd Person (widok zza pleców)

Źródło
CS 1.6 Custom 3rd Person View - AlliedModders

Nie jestem autorem tej funkcji. Tylko tutaj wrzucam.

Wersja <engine>

Create_PlayerCamera( id )
{
    new entid;
    while( (entid = find_ent_by_class(entid, "PlayerCamera")) != 0)
        if( entity_get_edict( entid, EV_ENT_owner ) == id )
        {
            attach_view( id, entid );
            return;
        }
        
    entid = create_entity("info_target");
        
    if(entid)
    {
        entity_set_string(entid,EV_SZ_classname,"PlayerCamera");
        entity_set_model(entid,"models/w_usp.mdl");
        entity_set_int( entid, EV_INT_solid, SOLID_TRIGGER);
        entity_set_int( entid, EV_INT_movetype, MOVETYPE_FLY );
        
        entity_set_edict( entid, EV_ENT_owner, id );
        entity_set_int( entid, EV_INT_rendermode, kRenderTransTexture);
        entity_set_float( entid, EV_FL_renderamt, 0.0);
        attach_view( id, entid ); 
        entity_set_float( entid, EV_FL_nextthink, get_gametime() );
    }   
}

public Think_PlayerCamera( entid )
{
    new id = entity_get_edict( entid, EV_ENT_owner );
    
    //Kill our entity if we hit USE key
    new buttons = entity_get_int( id, EV_INT_button );
    if(buttons & IN_USE)
    {
        attach_view( id, id );
        remove_entity(entid);
        return;
    }

    new Float:origin[3], Float:angle[3], Float:vBack[3];
    entity_get_vector( id, EV_VEC_origin, origin );
    entity_get_vector( id, EV_VEC_v_angle, angle );

    angle_vector( angle, ANGLEVECTOR_FORWARD, vBack );

    origin[2] += 20.0;
    
    origin[0] += (-vBack[0] * 150.0);
    origin[1] += (-vBack[1] * 150.0);
    origin[2] += (-vBack[2] * 150.0);

    entity_set_origin( entid, origin );
    entity_set_vector( entid, EV_VEC_angles, angle );   
    
    entity_set_float( entid, EV_FL_nextthink, get_gametime() );
}

Wersja <fakemeta> + komenda

    new const g_sCamclass[] = "PlayerCamera";

    public plugin_init()
    {
        register_clcmd( "say /cam", "cmdCam" );
        register_forward( FM_Think, "Think_PlayerCamera" );
    }

    public cmdCam( id )
        Create_PlayerCamera( id );

    Create_PlayerCamera( id )
    {
        new iEnt; static const sClassname[] = "classname";
        while( ( iEnt = engfunc( EngFunc_FindEntityByString, iEnt, sClassname, g_sCamclass ) ) != 0 )
        {
            if( pev( iEnt, pev_owner) == id )
            {
                engfunc( EngFunc_SetView, id, iEnt );
                return;
            }
        }

        static const sInfo_target[] = "info_target";
        iEnt = engfunc( EngFunc_CreateNamedEntity, engfunc( EngFunc_AllocString, sInfo_target ) )

        if( !iEnt )
            return;
        
        static const sCam_model[] = "models/w_usp.mdl";
        set_pev( iEnt, pev_classname, g_sCamclass );
        engfunc( EngFunc_SetModel, iEnt, sCam_model );

        set_pev( iEnt, pev_solid, SOLID_TRIGGER );
        set_pev( iEnt, pev_movetype, MOVETYPE_FLY );
        set_pev( iEnt, pev_owner, id );

        set_pev( iEnt, pev_rendermode, kRenderTransTexture );
        set_pev( iEnt, pev_renderamt, 0.0 );

        engfunc( EngFunc_SetView, id, iEnt );
        set_pev( iEnt, pev_nextthink, get_gametime() );
    }

    public Think_PlayerCamera( iEnt )
    {
        static sClassname[32];
        pev( iEnt, pev_classname, sClassname, sizeof sClassname - 1 );

        if( !equal( sClassname, g_sCamclass ) )
            return FMRES_IGNORED;

        static iOwner;
        iOwner = pev( iEnt, pev_owner );

        if( !is_user_alive( iOwner ) )
            return FMRES_IGNORED;

        static iButtons;
        iButtons = pev( iOwner, pev_button );

        if( iButtons & IN_USE )
        {
            engfunc( EngFunc_SetView, iOwner, iOwner );
            engfunc( EngFunc_RemoveEntity, iEnt );
            return FMRES_IGNORED;
        }

        static Float:fOrigin[3], Float:fAngle[3];
        pev( iOwner, pev_origin, fOrigin );
        pev( iOwner, pev_v_angle, fAngle );

        static Float:fVBack[3];
        angle_vector( fAngle, ANGLEVECTOR_FORWARD, fVBack );

        fOrigin[2] += 20.0;

        fOrigin[0] += ( -fVBack[0] * 150.0 );
        fOrigin[1] += ( -fVBack[1] * 150.0 );
        fOrigin[2] += ( -fVBack[2] * 150.0 );

        engfunc( EngFunc_SetOrigin, iEnt, fOrigin );

        set_pev( iEnt, pev_angles, fAngle );
        set_pev( iEnt, pev_nextthink, get_gametime() );

        return FMRES_HANDLED;
    }

Niedługo opiszę. Akurat wrzucałem to kiedy już nie miałem siły...

Użytkownik Harsay edytował ten post 21.09.2010 07:37

engine.inc:

/* Sets Player's View Mode. */

native set_view(iIndex, ViewType);

owner niestety to zmienia tez przeźroczystość gracza

No cóż, nigdy nie używałem tej funkcji więc nie wiem za bardzo jak to działa. Jednakże ta funkcja posiada więcej opcji, ponieważ można ustawić kamerę z różnych stron.

Przeźroczystość zmienia, ale chyba tylko dla tego, kto ma taki widok, żeby mu postać nie zasłaniała.