[fysiks]

Originally Posted by Natsheh I think you got a point or I should do floatround?

Well, simply rounding the values will give you a tolerance of ±0.5 units. Doing it with the arbitrary tolerance allows you to make it more or less sensitive than that.

[CrazY.]

I don't exactly need this way, what I need is detect the touch between two env_beam entities, I thought intersect was what I needed but it seems a lot complex.


Anyway, it only output true now.

public task_beam()
{
	new Float:b1_start_pos[3], Float:b1_end_pos[3];
	new Float:b2_start_pos[3], Float:b2_end_pos[3];

	Beam_GetStartPos(g_beam1, b1_start_pos);
	Beam_GetEndPos(g_beam1, b1_end_pos);

	Beam_GetStartPos(g_beam2, b2_start_pos);
	Beam_GetEndPos(g_beam2, b2_end_pos);

	new ret = DoesVectorsIntersect(b1_start_pos, b1_end_pos, b2_start_pos, b2_end_pos)
	if (ret == INTERSECT_3D)
		client_print(0, print_center, "intersect = TRUE");
	else
		client_print(0, print_center, "intersect = FALSE");

	server_print("A, init{%f, %f, %f}, end{%f, %f, %f}", b1_start_pos[0], b1_start_pos[1], b1_start_pos[2], b1_end_pos[0], b1_end_pos[1], b1_end_pos[2])
	server_print("B, init{%f, %f, %f}, end{%f, %f, %f}", b2_start_pos[0], b2_start_pos[1], b2_start_pos[2], b2_end_pos[0], b2_end_pos[1], b2_end_pos[2])
	server_print("Return value, %d", ret)
}

DoesVectorsIntersect(const Float:fV1Init[3], const Float:fV1Final[3], const Float:fV2Init[3], const Float:fV2Final[3], Float:tolerance=1.0, Float:fPoint[3]={0.0, 0.0, 0.0})
{
    new Float:fFactorV1[3], Float:fFactorV2[3], g_return;
    
    for(new Float:X, Float:YV1, Float:YV2, i; i < 3; i++)
    {
          fFactorV1[i] = (fV1Final[DIMENSIONS[i][0]] - fV1Init[DIMENSIONS[i][0]]) / (fV1Final[DIMENSIONS[i][1]] - fV1Init[DIMENSIONS[i][1]]);
          fFactorV2[i] = (fV2Final[DIMENSIONS[i][0]] - fV2Init[DIMENSIONS[i][0]]) / (fV2Final[DIMENSIONS[i][1]] - fV2Init[DIMENSIONS[i][1]]);
          
          X = ((fV2Final[DIMENSIONS[i][0]] - fV1Final[DIMENSIONS[i][0]]) + (fFactorV2[i] * fV2Final[DIMENSIONS[i][1]]) - (fFactorV1[i] * fV1Final[DIMENSIONS[i][1]])) / (fFactorV2[i] - fFactorV1[i]);
          YV1 = (fFactorV1[i] * (fV1Final[DIMENSIONS[i][1]] - X) + fV1Final[DIMENSIONS[i][0]]);
          YV2 = (fFactorV2[i] * (fV2Final[DIMENSIONS[i][1]] - X) + fV2Final[DIMENSIONS[i][0]]);
          if( YV1 == YV2 || ((YV1 - tolerance) <= YV2 <= (YV1 + tolerance)) || ((YV2 - tolerance) <= YV1 <= (YV2 + tolerance)) )
           {
                   fPoint[DIMENSIONS[i][1]] = X;
                   switch( i )
                   {
                          case 0: g_return |= INTERSECT_YX;
                          case 2: g_return |= INTERSECT_XZ;
                          case 1: g_return |= INTERSECT_ZY;
                   }
           }

           
    }
    return g_return;
}

debug:

A, init{-450.867889, 2570.177246, 164.031250}, end{-92.027336, 2574.887207, 164.031250
B, init{-92.523963, 2483.333984, 164.031250}, end{-449.984649, 2485.209960, 164.031250
Return value, 7

[Natsheh]

This should return either INTERSECT_XZ or INTERSECT_ZY seems there is a wrong order in calculation.

This is strange I'll do some testing and come with feedback but what you suggested you can't check if env_beam hits with tracelines or entity collisions.

[anderpp]

yeah ;d


I explain to you, MP. Solved.