hi !

ich habe mit hilfe von rockefellers tut ein vehicle-entity programmiert. jetzt bin ich dabei eine kollisionsabfrage zu erstellen. das habe ich mir irgendwie so gedacht :

void CFuncVehicle::FrontCheck( void)
{
TraceResult tr;
Vector VecAuto, VecWand;

VecAuto = pev->origin;
VecWand = pev->origin + gpGlobals->v_forward * 8192;
UTIL_TraceLine( VecAuto, VecWand, ignore_monsters, ENT(pev), &tr);
ALERT( at_console, "tr.flFraction*8192 : %f \n", (tr.flFraction*8192) );
if ((tr.flFraction * 8192) < 0.2)
{
//auto stop
pev->speed = 0;
ALERT( at_console, "Achtung Wand !\n", STRING(pev->target) );
}
if ((tr.flFraction * 8192) == 8192)
{
pev->speed = 0;
}
}

Das Problem ist jetzt aber, dass wenn man gegen die Wan gefahren ist, man bei jeder Bewegung wieder gestoppt wird mit der Meldung Achtung Wand. Nach einer Zeit hin und hergehakel ist man dann wieder aus der Wand raus, aber das ist auf die Dauer glaub ich zu nervig. Wie kann man das am besten bewerkstelligen ?

tu einfach SET_Origin, ein wenig elegant nach hinten =) Und spiegel den speed (pev->velocity) an der wand, wennde nit weißt wie, spiegel die velocity einfach: (-)!

Another1

...relaxing..atm =)
... und Schweiz suckt!

ich schreib mal auf, wie ich das ganze gemacht habe:

Quellcode:
void CFuncVehicle::CheckCollision ( void )
{
    // Creating Edge-Vectors!
// Options for Tracelines: ignore_monsters - We just want to see if there's a wall!

Vector vecSrcFrontRight, vecSrcFrontLeft, vecSrcBackRight, vecSrcBackLeft; // Source-Vectors
Vector vecEndFrontRight, vecEndFrontLeft, vecEndBackRight, vecEndBackLeft; // End-Vectors
Vector angles;
TraceResult tr1, tr2, tr3, tr4;

angles = pev->angles;

VehicleFixupAngles( angles );

UTIL_MakeVectors( angles );

// Calculating Source-Vectors
    vecSrcFrontLeft = pev->origin + (-(gpGlobals->v_right) * (m_width/2)) + (gpGlobals->v_forward * (m_length/2));
    vecSrcFrontRight = pev->origin + (gpGlobals->v_right * (m_width/2)) + (gpGlobals->v_forward * (m_length/2));
    vecSrcBackLeft = pev->origin + (-(gpGlobals->v_right) * (m_width/2)) + (-(gpGlobals->v_forward) * (m_length/2));
    vecSrcBackRight = pev->origin + (gpGlobals->v_right * (m_width/2)) + (-(gpGlobals->v_forward) * (m_length/2));

// Calculating End-Vectors
    vecEndFrontLeft = pev->origin + (-(gpGlobals->v_right) * (m_width/2 + 1)) + (gpGlobals->v_forward * (m_length/2 + 32));
    vecEndFrontRight = pev->origin + (gpGlobals->v_right * (m_width/2 + 1)) + (gpGlobals->v_forward * (m_length/2 + 32));
    vecEndBackLeft = pev->origin + (-(gpGlobals->v_right) * (m_width/2 + 1)) + (-(gpGlobals->v_forward) * (m_length/2 + 32));
    vecEndBackRight = pev->origin + (gpGlobals->v_right * (m_width/2 + 1)) + (-(gpGlobals->v_forward) * (m_length/2 + 32));

// lets shoot some TraceLines
UTIL_TraceLine( vecSrcFrontLeft, vecEndFrontLeft, ignore_monsters, ENT( pev ), &tr1 );
UTIL_TraceLine( vecSrcFrontRight, vecEndFrontRight, ignore_monsters, ENT( pev ), &tr2 );
UTIL_TraceLine( vecSrcBackLeft, vecEndBackLeft, ignore_monsters, ENT( pev ), &tr3 );
UTIL_TraceLine( vecSrcBackRight, vecEndBackRight, ignore_monsters, ENT( pev ), &tr4 );

if (tr1.flFraction < 1.0 || tr2.flFraction < 1.0 || tr3.flFraction < 1.0 || tr4.flFraction < 1.0)
{
CBaseEntity *pHit1 = CBaseEntity::Instance( tr1.pHit );
CBaseEntity *pHit2 = CBaseEntity::Instance( tr2.pHit );
CBaseEntity *pHit3 = CBaseEntity::Instance( tr3.pHit );
CBaseEntity *pHit4 = CBaseEntity::Instance( tr4.pHit );

if ( pHit1->IsBSPModel() || pHit2->IsBSPModel() || pHit3->IsBSPModel() || pHit4->IsBSPModel() )
{
ALERT ( at_console, "I think we hit a wall at: " );
pev->velocity.x = -(pev->velocity.x);
pev->velocity.y = -(pev->velocity.y);
pev->velocity.z = -(pev->velocity.z);
pev->speed = -(pev->speed);
ALERT (at_console, "%f - %f - %f\n", pev->velocity.x, pev->velocity.y, pev->velocity.z);
}
}
}


Das ganze Stück code schiesst vier Tracelines: Vorne Rechts nach vorne, Vorne Links nach vorne, Hinten Rechts nach hinten und Hinten Links nach hinten. Ich habe das ganze mit vieren gemacht, damit man am ende auch möglicherweise, wenn einer der auftriffswinkel zu flach ist, dass das Fahrzeug einfach gedreht wird. Die Tracelines sind bei mir 32 Units lang, aber du kannst sie natürlich noch ändern... ich habe das ganze im moment nur zu Debug-Zwecken so lang. Du kannst aber trotzdem noch beim fahren bei einer Drehung seitlich in ein Wand rein. Dann musst du noch seitliche Kollisionsabfragen machen und dann statt der velocity die y-winkel ändern

also ich habs jetzt so probiert :

void CFuncVehicle::FrontCheck ( void )
{
Vector vecSrcFrontRight, vecSrcFrontLeft, vecSrcBackRight, vecSrcBackLeft; // Source-Vectors
Vector vecEndFrontRight, vecEndFrontLeft, vecEndBackRight, vecEndBackLeft; // End-Vectors
Vector vecSrcRightFront, vecSrcRightBack, vecSrcLeftFront, vecSrcLeftBack; // dito
Vector vecEndRightFront, vecEndRightBack, vecEndLeftFront, vecEndLeftBack; // dito

Vector angles;
TraceResult tr1, tr2, tr3, tr4, tr5, tr6, tr7, tr8;
int m_width = 192;
angles = pev->angles;

FixupAngles( angles );

UTIL_MakeVectors( angles );

// Calculating Source-Vectors
vecSrcFrontLeft = pev->origin + (-(gpGlobals->v_right) * (m_width/2)) + (gpGlobals->v_forward * (m_length/2));
vecSrcFrontRight = pev->origin + (gpGlobals->v_right * (m_width/2)) + (gpGlobals->v_forward * (m_length/2));
vecSrcBackLeft = pev->origin + (-(gpGlobals->v_right) * (m_width/2)) + (-(gpGlobals->v_forward) * (m_length/2));
vecSrcBackRight = pev->origin + (gpGlobals->v_right * (m_width/2)) + (-(gpGlobals->v_forward) * (m_length/2));

vecSrcRightFront = pev->origin + (gpGlobals->v_forward * (m_length/2)) + (gpGlobals->v_right * (m_width/2));
vecSrcLeftFront = pev->origin + (-(gpGlobals->v_forward) * (m_length/2)) + (gpGlobals->v_right * (m_width/2));
vecSrcRightBack = pev->origin + (gpGlobals->v_forward * (m_length/2)) + (-(gpGlobals->v_right) * (m_width/2));
vecSrcLeftBack = pev->origin + (-(gpGlobals->v_forward) * (m_length/2)) + (-(gpGlobals->v_right) * (m_width/2));

// Calculating End-Vectors
vecEndFrontLeft = pev->origin + (-(gpGlobals->v_right) * (m_width/2 + 1)) + (gpGlobals->v_forward * (m_length/2 + 100));
vecEndFrontRight = pev->origin + (gpGlobals->v_right * (m_width/2 + 1)) + (gpGlobals->v_forward * (m_length/2 + 100));
vecEndBackLeft = pev->origin + (-(gpGlobals->v_right) * (m_width/2 + 1)) + (-(gpGlobals->v_forward) * (m_length/2 + 100));
vecEndBackRight = pev->origin + (gpGlobals->v_right * (m_width/2 + 1)) + (-(gpGlobals->v_forward) * (m_length/2 + 100));

vecEndRightFront = pev->origin + (gpGlobals->v_forward * (m_length/2 +1)) + (gpGlobals->v_right * (m_length/2 +32));
vecEndLeftFront = pev->origin + (-(gpGlobals->v_forward) * (m_length/2 +1)) + (gpGlobals->v_right * (m_length/2 +32));
vecEndRightBack = pev->origin + (gpGlobals->v_forward * (m_length/2 +1)) + (-(gpGlobals->v_right) * (m_length/2 +32));
vecEndLeftBack = pev->origin + (-(gpGlobals->v_forward) * (m_length/2 +1)) + (-(gpGlobals->v_right) * (m_length/2 +32));

// lets shoot some TraceLines
UTIL_TraceLine( vecSrcFrontLeft, vecEndFrontLeft, ignore_monsters, ENT( pev ), &tr1 );
UTIL_TraceLine( vecSrcFrontRight, vecEndFrontRight, ignore_monsters, ENT( pev ), &tr2 );
UTIL_TraceLine( vecSrcBackLeft, vecEndBackLeft, ignore_monsters, ENT( pev ), &tr3 );
UTIL_TraceLine( vecSrcBackRight, vecEndBackRight, ignore_monsters, ENT( pev ), &tr4 );

UTIL_TraceLine( vecSrcRightFront, vecEndRightFront, ignore_monsters, ENT( pev ), &tr5);
UTIL_TraceLine( vecSrcRightBack, vecEndRightBack, ignore_monsters, ENT( pev ), &tr7);
UTIL_TraceLine( vecSrcLeftFront, vecEndLeftFront, ignore_monsters, ENT( pev ), &tr6);
UTIL_TraceLine( vecSrcLeftBack, vecEndLeftBack, ignore_monsters, ENT( pev ), &tr8);

if (tr1.flFraction < 1.0 || tr2.flFraction < 1.0 || tr3.flFraction < 1.0 || tr4.flFraction < 1.0 || tr5.flFraction < 1.0 || tr6.flFraction < 1.0 || tr7.flFraction < 1.0 || tr8.flFraction < 1.0)
{
CBaseEntity *pHit1 = CBaseEntity::Instance( tr1.pHit );
CBaseEntity *pHit2 = CBaseEntity::Instance( tr2.pHit );
CBaseEntity *pHit3 = CBaseEntity::Instance( tr3.pHit );
CBaseEntity *pHit4 = CBaseEntity::Instance( tr4.pHit );
CBaseEntity *pHit5 = CBaseEntity::Instance( tr5.pHit );
CBaseEntity *pHit6 = CBaseEntity::Instance( tr6.pHit );
CBaseEntity *pHit7 = CBaseEntity::Instance( tr7.pHit );
CBaseEntity *pHit8 = CBaseEntity::Instance( tr8.pHit );

if ( pHit1->IsBSPModel() || pHit2->IsBSPModel() || pHit3->IsBSPModel() || pHit4->IsBSPModel() )
{
ALERT ( at_console, "Mauer bei: " );
pev->velocity.x = -(pev->velocity.x);
pev->velocity.y = -(pev->velocity.y);
pev->velocity.z = -(pev->velocity.z);
pev->speed = -(pev->speed);
ALERT (at_console, "%f - %f - %f\n", pev->velocity.x, pev->velocity.y, pev->velocity.z);

ALERT( at_console, "tr1 : %f \n", (tr1.flFraction*8192) );
ALERT( at_console, "tr2 : %f \n", (tr2.flFraction*8192) );
ALERT( at_console, "tr3 : %f \n", (tr3.flFraction*8192) );
ALERT( at_console, "tr4 : %f \n", (tr4.flFraction*8192) );
}
if ( pHit5->IsBSPModel() || pHit6->IsBSPModel() || pHit7->IsBSPModel() || pHit8->IsBSPModel() )
{
ALERT ( at_console, "Seitliche Mauer bei: " );
pev->angles.x = -(pev->angles.x);
pev->angles.y = -(pev->angles.y);
pev->angles.z = -(pev->angles.z);
pev->speed = -(pev->speed);
ALERT (at_console, "%f - %f - %f\n", pev->angles.x, pev->angles.y, pev->angles.z);

ALERT( at_console, "RechtsVorne : %f \n", (tr5.flFraction*8192) );
ALERT( at_console, "LinksVorne : %f \n", (tr6.flFraction*8192) );
ALERT( at_console, "RechtsHinten : %f \n", (tr7.flFraction*8192) );
ALERT( at_console, "LinksHinten : %f \n", (tr8.flFraction*8192) );
}
}
}

aber irgendwie funktioniert das auch noch nicht so. ist das mit den vektoren so richtig ? also das zeug mit

vecEndRightFront = pev->origin...

du musst dran denken, dass ich bei mir noch drei zusätzliche Variablen habe: m_height, m_width und m_length (m_height ist nicht die "Height above track"-Variable - die habe ich umbenannt - nein, das sind alles Variablen, die ich neu eingeführt habe für WC (WorldCraft) Wenn ich meins fertig habe, sage ich bescheid, aber ich muss erstmal sehen, dass ich mein auf Rampen fahren und wieder runterkommen fertig bekomme...