[Pixel_Outlaw]

Pixel_Outlaw

Pixel_Outlaw

Show Pixel_Outlaw's last posts.

Show general stats for Pixel_Outlaw.

• 
• Administrator
• Hero Member
• Score: 7
• Posts: 970
• Bullet Hell

[Point Distance]

I think that we as a community should start a compilation of usefull formulas/algorithems. I'm think some along the lines of basic movement and computation. Many formulas can be used in any programming language so I would sudgest posting them in psudo-code.

Ok well I would be an idiot if I made this thread and didn't contribute.

Point Distance formula: Gives length between point a snd b
Uses: AI,circular collision detection
______________________________________________________________
x1= first x
y1= first y
x2= second x
y2= second y

point_distance(x1,y1,x2,y2)

// get the x difference
x_distance=Abs(x1-x2)

// get the y difference
y_distance=Abs(y1-y2)

// find the difference using pythagroin therom
distance=sqr((x_distance*x_distance)+(y_distance*y_distance))

Return distance


_________________________________________________________



Point Angle: Gives angle between two points
Uses: AI, Homing missles, Chasing behaviors
_________________________________________________________

point_direction(x1,y1,x2,y2)
      
angle= ATan2(y2-y1,x2-x1)
If angle<0
angle:+ 360
End If
      
Return angle

      
   

[oNyx]

oNyx

oNyx

Show oNyx's last posts.

Show general stats for oNyx.

• 
• Full Member
• Score: 0
• Posts: 129
• 弾幕

Uhm... sqrt is a pretty expensive operation. For circle-circle collision detection you arent interested in the exact distance. You only need to know if the squared distance is bigger than the sum of the radii squared. You also dont need something like abs, because after squaring it it will be positive either way.

public boolean intersects(Sphere s){
   return (r+s.r)*(r+s.r)>(x-s.x)*(x-s.x)+(y-s.y)*(y-s.y);
}
(Dont start a discussion that one should use ">=" instead. Its a question of which definition you use. For me an intersection is if there is one point which is inside of both circles. Feel free to disagree. In a game it doesnt make a visible differene anyways.)

[Pixel_Outlaw]

Pixel_Outlaw

Pixel_Outlaw

Show Pixel_Outlaw's last posts.

Show general stats for Pixel_Outlaw.

• 
• Administrator
• Hero Member
• Score: 7
• Posts: 970
• Bullet Hell

Oh you're right! I didn't remember that abs would not be necessary. I failed my highschool trig/alg2 class. So I had to write these myself. Thanks!

Anyone  else have any good algorithems?

[RedKnight]

RedKnight

RedKnight

Show RedKnight's last posts.

Show general stats for RedKnight.

• 
• Jr. Member
• Score: 0
• Posts: 98
• Treasure!

[C/C++]

Basic Bullet class.

Double  X, Y, Spd, Dir;

then you run your bullet like this.


void OBJECT::Move(void)
{
 double sSpeed   = (Interval * Spd);
 double rDir     = DegreeToRadiant(Dir);

 X += (sSpeed * sin(rDir));
 Y += (sSpeed * cos(rDir));
}





It should be more easier to code.
if you can wrapped it up in vector.




vector<BULLET> Bullets.

void AddBullet( double x, double y, double spd, double dir)
{
 Bullets.push_back( BULLET( x, y, spd, dir));
}



and all of these idea.
I got it from reverse enginering Kenta cho BulletML.

 

 



These convert Radiants into Degree and vice versa.

inline float RadiantToDegree(float rRadiant)
{
 return( rRadiant * ( 180 / PI));
}


inline float DegreeToRadiant( float rDegree)
{
 return( rDegree / ( 57.295776));
}




Distance between two 3d vectors.
You can remove the Z to make it 2d.

inline float                   Distance(VECTOR3D VecX, VECTOR3D VecY)
{
 double tDistance = sqrt((VecX.Vec[0] - VecY.Vec[0]) * (VecX.Vec[0] - VecY.Vec[0]) +
                         (VecX.Vec[1] - VecY.Vec[1]) * (VecX.Vec[1] - VecY.Vec[1]) +
                         (VecX.Vec[2] - VecY.Vec[2]) * (VecX.Vec[2] - VecY.Vec[2]));

 return tDistance;
}

sqrt slowwww??
My badd.
I've been working with quake 3 bsp mapping and is quite fast.
 but remember to use "inline"
 and importantly use "C/C++"



Check this function

bool __declspec( dllexport) InsidePolygon(VECTOR3D vIntersection, VECTOR3D Poly[], long verticeCount)
{
 const double MATCH_FACTOR = 0.9999;
       double Angle        = 0.0;
 VECTOR3D     vA;
 VECTOR3D     vB;

 for (int i = 0; i < verticeCount; i++)
 {
  vA = Poly - vIntersection;

  vB = Poly[(i + 1) % verticeCount] - vIntersection;

  Angle += AngleBetweenVectors(vA, vB);
 }

 if(Angle >= (MATCH_FACTOR * (2.0 * PI)) )
 return true;

 return false;
}


VECTOR3D vIntersection  => is the 2d vector.... just say this is our "bullet"
VECTOR3D Poly[]            => the collection of our 4 point square

This test if the vIntersection is in the poly box by checking all the angle together.
since all together our angle should come up about 360 degree.

[pixelizr]

pixelizr

pixelizr

Show pixelizr's last posts.

Show general stats for pixelizr.

• 
• Sr. Member
• Score: 0
• Posts: 272

Regarding the distance formula, I do know that in C++, there is a function called hypot(). You could use that to directly compute the distance between points. Does anyone know if hypot() is slower than two multiplications?

I personally don't use vectors for bullets. I use lists. From what I know, it takes a long time to remove and insert elements in the middle of vectors; while it takes just constant time in lists to do the same operation. I imagine this to be important when you need to delete bullets, since deletion can happen anywhere in the list. The advantage of vectors is constant time random access, though I don't think you need that if you iterate across all bullets; an iterator will work just fine.

I also don't use a function similar to AddBullet() as you have mentioned, since it only contains a single push_back call. I just directly call the push_back function rather than wrapping it inside a function.

[oNyx]

oNyx

oNyx

Show oNyx's last posts.

Show general stats for oNyx.

• 
• Full Member
• Score: 0
• Posts: 129
• 弾幕

>sqrt slowwww??

Relatively. If its called 2k times per frame it can surely make a difference of a few frames. Well, that is if its cpu bound.

---

When in doubt compare the performance for yourself.

In java you have ArrayList and LinkedList for example. Inserting/removing elements from an ArrayList is slower, but iterating over it is faster (and random access is *way* faster). Fast enough to offset the add/remove difference even if you would add/remove the same amount bullets you're iterating over. I was acutally quite surprised by that.

Under usual (game) circumstances you add/remove way less than you iterate. So, an ArrayList is certainly the better choice.

[RedKnight]

RedKnight

RedKnight

Show RedKnight's last posts.

Show general stats for RedKnight.

• 
• Jr. Member
• Score: 0
• Posts: 98
• Treasure!

Relatively. If its called 2k times per frame it can surely make a difference of a few frames. Well, that is if its cpu bound.

Well that happens when you called it 2k times. ( is that 2000 times ) 
there's also another alternative solution
and that is

double tDistance = (VecX.Vec[0] - VecY.Vec[0]) * (VecX.Vec[0] - VecY.Vec[0]) +
                          (VecX.Vec[1] - VecY.Vec[1]) * (VecX.Vec[1] - VecY.Vec[1]) +
                          (VecX.Vec[2] - VecY.Vec[2]) * (VecX.Vec[2] - VecY.Vec[2]);

without the square root.

and there's also a "Manhattan" distance

Dist = abs( V1.X-V2.X) + abs( V1.Y-V2.Y) + abs( V1.Z, V2.Z)

I also don't use a function similar to AddBullet() as you have mentioned, since it only contains a single push_back call. I just directly call the push_back function rather than wrapping it inside a function.

Well I have made everything dumb down to simple.
maybe it is my who like to organize my codes to classic C style perfection.
 


int AddBullet( lua_State * State)
{
 if( lua_gettop( State) > 0)
 {
  AddBullet( lua_tonumber( State, 1),
                lua_tonumber( State, 2),
                lua_tonumber( State, 3),
                lua_tonumber( State, 4));
 }

 return 0;
}
 

you see,This is the same function.
for lua.


I have also plan to ported everything in the main game loop over the Lua.
So I can easilly change it contents to my liking.

[Landon_Fox]

Landon_Fox

Landon_Fox

Show Landon_Fox's last posts.

Show general stats for Landon_Fox.

• 
• Newbie
• Score: 0
• Posts: 1

Sqrt is actually VERY slow.  Not only does it work in doubles and not floats, it computes out accuracy to every significant digit stored in the number.  No only are you hit for conversion, you only really need two or three significant digits to make it look good on a display.

So just do what I did and make your own sqrt function using lookup tables!  This speedup as enough to let me dump 4000 particles on the screen before I had slowdown.

Code:

// Initialization
for (i=0; i<10000; i++) {
SqrtTableLow[i] = (float)sqrt( (float)i/100.f );
SqrtTableMedium[i] = (float)sqrt( (float)i );
SqrtTableHigh[i] = (float)sqrt( (float)i*100.f );
}

// The functions
float FASTMATH::Sqrt(int Value) {
if (Value < 0) {
Value *= -1;
if (Value < 10000)
return -1 * SqrtTableMedium[Value];
else if (Value < 1000000)
return -1 * SqrtTableHigh[Value/100];
else
return -1 * SqrtTableHigh[9999];
}
else if (Value < 10000)
return SqrtTableMedium[Value];
else if (Value < 1000000)
return SqrtTableHigh[Value/100];
else
return SqrtTableHigh[9999];

}

// Alternate function
float FASTMATH::Sqrt(float Value) {
if (Value < 0) {
Value *= -1;
if (Value < 100)
return -1 * SqrtTableLow[(int)(Value*100.0f)];
else if (Value < 10000)
return -1 * SqrtTableMedium[(int)Value];
else if (Value < 1000000)
return -1 * SqrtTableHigh[(int)(Value/100.0f)];
else
return -1 * SqrtTableHigh[9999];
}
else if (Value < 100)
return SqrtTableLow[(int)(Value*100.0f)];
else if (Value < 10000)
return SqrtTableMedium[(int)Value];
else if (Value < 1000000)
return SqrtTableHigh[(int)(Value/100.0f)];
else
return SqrtTableHigh[9999];
}

[relsoft]

relsoft

relsoft

Visit relsoft's website.

Show relsoft's last posts.

Show general stats for relsoft.

• 
• jelly
• Editor
• Sr. Member
• Score: 4
• Posts: 418

Some 2d collision helper functions. Code is in Freebasic.

Get a a 2d normal of a line segment.

Code:

private sub get_2dnormal (seg as segment_type, s as integer)
   
    if s then
    seg.normal.x = -(seg.y2-seg.y1)  'negate to get the other normal
    seg.normal.y = (seg.x2-seg.x1) 'erase negatio here if you want the other
                                    'normal
    else
    seg.normal.x = (seg.y2-seg.y1)  'negate to get the other normal
    seg.normal.y = -(seg.x2-seg.x1) 'erase negatio here if you want the other
                                    'normal
    end if
    normalize (seg.normal)
end sub

Get the midpoint of a line:

Code:

private function midpoint (seg as segment_type) as point_type
   
    dim leng as single
    dim v as vector2d
    dim half_leng as integer
    dim p as point_type
    leng = get_length ( seg )
    v.x = seg.x2 - seg.x1
    v.y = seg.y2 - seg.y1
    normalize (v)
    half_leng = leng / 2
    p.x = seg.x1 + ( v.x * half_leng)
    p.y = seg.y1 + ( v.y * half_leng)
   
    return p
   
end function

To check if a point is inside a convex poly...
Pseudocode......

Code:

    dim as integer sameside = 1
for every  point in the polygon...
        'check if point is inside the poly
        dim as single dota
        dim as vector2d v
        v.x = any_point_in_line.x - mypoint.x
        v.y = any_point_in_line.y - mypoint.y
        dota = dot(v, line.normal)       
        dim as integer p_side = 0
        if dota >=0 then p_side = 1       
        sameside = sameside and p_side       
loop

Now it would be just a matter of checking whether sameside <> 0.

Ive attached demo which uses the above and some additions. Like bouncing on an arbitrary line. :*)
Move the mouse inside the rotating poly to check for the function.  I'm open for questions regarding the bounce method. :*)

Demo includes the source.


[attachment lost, please re-upload]

[ELLioT]

ELLioT

ELLioT

Visit ELLioT's website.

Show ELLioT's last posts.

Show general stats for ELLioT.

• 
• Newbie
• Score: 0
• Posts: 21

Some helpful 2D function I often used. It can be used in vector games ( but not only ) to check collision between entities boundaries or with bullets trajectories.

Code:

;-------------------------------------------------------------------------------
; Check 2 Segments intersection
; in :
;    a0x, a0y, a1x, a1y : coords of 1st segment
;    a2x, a2y, a3x, a3y : coords of 2nd segment
; out :
;    -
; return : True if segments intersect, else False
;-------------------------------------------------------------------------------
Function SegIntersect(a0x%, a0y%, a1x%, a1y%, a2x%, a2y%, a3x%, a3y%)

    v0x% = -(a1y - a0y)
    v0y% = +(a1x - a0x)

    s1% = ((a2x - a0x) * v0x + (a2y - a0y) * v0y) >= 0
    s2% = ((a3x - a0x) * v0x + (a3y - a0y) * v0y) >= 0

    If Not(s1 Xor s2) Then
        Return False
    EndIf

    v0x% = -(a3y - a2y)
    v0y% = +(a3x - a2x)

    s1% = ((a0x - a2x) * v0x + (a0y - a2y) * v0y) >= 0
    s2% = ((a1x - a2x) * v0x + (a1y - a2y) * v0y) >= 0

    If s1 Xor s2 Then
        Return True
    EndIf

    Return False

End Function ; SegIntersect()

[motorherp]

motorherp

motorherp

Show motorherp's last posts.

Show general stats for motorherp.

• 
• Administrator
• Hero Member
• Score: 10
• Posts: 724
• shmupet

I personally don't use vectors for bullets. I use lists. From what I know, it takes a long time to remove and insert elements in the middle of vectors; while it takes just constant time in lists to do the same operation. I imagine this to be important when you need to delete bullets, since deletion can happen anywhere in the list. The advantage of vectors is constant time random access, though I don't think you need that if you iterate across all bullets; an iterator will work just fine.

Using a list will also give you poor performance for a bullet system were you're dealing with large quantities of small objects with minimal processing on each.  In fact I'd venture as far to say that your performance with a list is going to be worse than a vector for these circumstances.  There's several reasons for this.  You'll be very frequently creating a destroying lots of very small objects.  For a start all these memory allocations and deallocations will directly impact on your performance but this will also fragment your memory something rotten reducing performance in the longer term.  Its also a poor use of memory since the sizes you are allocating dont significantly outweigh the size of the header which gets created with an allocation meaning that you'll be chewing up more memory this way.  More importantly though is the impact a list has when you wish to iterate through all your bullets to update and render them.  To go from one bullet to the next not only requires a dereference but also means thrashing your cache since they're going to be scattered all over the place in memory.  Since you've got a lot of bullets and each one only requires minimal processing, this will easily become the dominant usage of your time here which can be saved by using a vector instead.

You're quite right about deletions and insertions being slow in a vector but you really dont want all these allocations and de-allocations going on all the time anyway so the trick is to create your own management system which side steps this need.  Therefore here's my code snippet for efficient bullet management which gets the best of both worlds (written in lazy c++):

Code:

class Bullet
{
   float  m_x, m_y;
   float  m_vx, m_vy;
   bool  m_alive;

   void  Update();
}

class Battery
{
   vector<Bullet>   m_bullets;
   vector<int>   m_freeBullets;

   int   AddBullet();
   void   FreeBullet();
   Bullet&   GetBullet(int id);
   void   UpdateBullets();
}


int Battery::AddBullet()
{
   int id = -1;

   if(m_freeBullets.size())
   {
      id = m_freeBullets.back();
      m_freeBullets.pop_back();
   }
   else
   {
      id = m_bullets.size();
      Bullet newBullet;
      m_bullets.push_back(newBullet);
   }
   
   m_bullets[id].m_active = true;
   return id;
}


void Battery::FreeBullet(int id)
{
   m_bullets[id].m_active = false;
   m_freeBullets.push_back(id);
}


Bullet& Batter::GetBullet(int id)
{
   return m_bullets[id];
}


void Battery::UpdateBullets()
{
   for(int i = 0; i < m_bullets.size(); ++i)
   {
      if(m_bullets[i].m_active)   { m_bullets[i].Update(); }
   }
}

If you're going to implement this for yourself I'd recommend reserving a good size qauntity in both vectors during Battery creation and also put in debug error checking since such a system could go badly wrong if used incorrectly.

[Techbear]

Techbear

Techbear

Show Techbear's last posts.

Show general stats for Techbear.

• 
• Newbie
• Score: 0
• Posts: 11

These two functions convert between rgb values and hsv values.  If you want your ships to be different, but blightly colored, or of you want a background that color-cycles smoothly, use these.

Code:

//*************************************************************************
void HSVtoRGB(float h, float s, float v, float &r, float &g, float &b)
{
    int i;
    float f, p, q, t,hTemp;
 
    if( s == 0.0 || h == -1.0) // s==0? Totally unsaturated = grey so R,G and B all equal value
    {
      r = g = b = v;
      return;
    }
    hTemp = h/60.0f;
    i = (int)floor( hTemp );                 // which sector
    f = hTemp - i;                      // how far through sector
    p = v * ( 1 - s );
    q = v * ( 1 - s * f );
    t = v * ( 1 - s * ( 1 - f ) );
 
    switch( i ) 
    {
    case 0:{r = v;g = t;b = p;break;}
    case 1:{r = q;g = v;b = p;break;}
    case 2:{r = p;g = v;b = t;break;}
    case 3:{r = p;g = q;b = v;break;} 
    case 4:{r = t;g = p;b = v;break;}
    case 5:{r = v;g = p;b = q;break;}
    }
}
 
//*************************************************************************
void RGBtoHSV(float r, float g, float b, float &h, float &s, float &v)
 {
    float mn=r,mx=r;
    int maxVal=0;
 
    if (g > mx){ mx=g;maxVal=1;}
    if (b > mx){ mx=b;maxVal=2;} 
    if (g < mn) mn=g;
    if (b < mn) mn=b; 
    float  delta = mx - mn;
 
    v = mx; 
    if( mx != 0 )
      s = delta / mx; 
    else 
    {
      s = 0;
      h = 0;
      return;
    }
    if (s==0.0f)
    {
      h=-1;
      return;
    }
    else
    { 
      switch (maxVal)
      {
      case 0:{h = ( g - b ) / delta;break;}         // yel < h < mag
      case 1:{h = 2 + ( b - r ) / delta;break;}     // cyan < h < yel
      case 2:{h = 4 + ( r - g ) / delta;break;}     // mag < h < cyan
      }
    }
 
    h *= 60;
    if( h < 0 ) h += 360;
}

[Techbear]

Techbear

Techbear

Show Techbear's last posts.

Show general stats for Techbear.

• 
• Newbie
• Score: 0
• Posts: 11

This piece of code is a Catmull-Rom spline.  I love it because 1) the curved line it describes passes thru the control points, unlike a b-spline, and 2) if you use it for enemy ship paths, it results in nice curves with smooth velocity changes.

It takes four points, and the value t is 0.0 - 1.0, and represents how far you are between the middle two points.

Code:

//*************************************************************************
void PointOnCurve(TPoint &out, float t, TPoint p0, TPoint p1, TPoint p2, TPoint p3)
{
float t2 = t * t;
float t3 = t2 * t;
out.x = 0.5f * ( ( 2.0f * p1.x ) +
( -p0.x + p2.x ) * t +
( 2.0f * p0.x - 5.0f * p1.x + 4 * p2.x - p3.x ) * t2 +
( -p0.x + 3.0f * p1.x - 3.0f * p2.x + p3.x ) * t3 );
out.y = 0.5f * ( ( 2.0f * p1.y ) +
( -p0.y + p2.y ) * t +
( 2.0f * p0.y - 5.0f * p1.y + 4 * p2.y - p3.y ) * t2 +
( -p0.y + 3.0f * p1.y - 3.0f * p2.y + p3.y ) * t3 );
}

[the2bears]

the2bears

the2bears

Visit the2bears's website.

Show the2bears's last posts.

Show general stats for the2bears.

• 
• Administrator
• Hero Member
• Score: 8
• Posts: 1,491

These two functions convert between rgb values and hsv values.  If you want your ships to be different, but blightly colored, or of you want a background that color-cycles smoothly, use these.

I was just thinking about looking for this very conversion    Thanks!

Bill

[Pixel_Outlaw]

Pixel_Outlaw

Pixel_Outlaw

Show Pixel_Outlaw's last posts.

Show general stats for Pixel_Outlaw.

• 
• Administrator
• Hero Member
• Score: 7
• Posts: 970
• Bullet Hell

Really, this thread should be a core thread. Lots and lots of good snippets here.

RGB and HSV conversion is VERY helpfull. HSV is what we use in real live but RGB is the programming standard. I would argue that if we used the HSV model in compilers as a standard some hommade games would have better color paletts. Colors would probably share light or value and saturation and just vary in hue. That's why there is so many saturated pure colors in games such as RGB(255,0,0). It's like the compiler writers wanted to burn out retnas because saturation and light were not easly found.

How I do rant sometimes...

[Slackluster]

Slackluster

Slackluster

Visit Slackluster's website.

Show Slackluster's last posts.

Show general stats for Slackluster.

• 
• Newbie
• Score: 0
• Posts: 40

Good stuff so far!  I have a few contributions.  Some of these functions call each other so you are going to need to make them static member functions of your Vector2 class or declare them at the top of the header file.

Code:

// 2d line segment intersection test
// returns true and sets the point of intersection if segments intersect
inline bool LineSegmentIntersection
(
    const Vector2& segment1a, const Vector2& segment1b,
    const Vector2& segment2a, const Vector2& segment2b,
    Vector2& intersectionPoint
)
{
    const Vector2 delta1 = segment1b - segment1a;
    const Vector2 delta2 = segment2b - segment2a;
    const Vector2 delta3 = segment1a - segment2a;
    const float d = delta1.Cross(delta2);
    const float ud1 = delta2.Cross(delta3);

    if (d > 0)
    {
        if (ud1 < 0 || ud1 > d)
            return false; // outside bounds of segment 1

        const float ud2 = delta1.Cross(delta3);
        if (ud2 < 0 || ud2 > d)
            return false; // outside bounds of segment 2
    }
    else if (d < 0)
    {
        if (ud1 > 0 || ud1 < d)
            return false; // outside bounds of segment 1

        const float ud2 = delta1.Cross(delta3);
        if (ud2 > 0 || ud2 < d)
            return false; // outside bounds of segment 2
    }
    else // d == 0
        return false; // segments are parallel

    // compute intersection point
    intersectionPoint = segment1a + (ud1/d) * delta1;
    return true;
}

// 2d point distance from line segment test
// returns the distance between line segment and point
inline float DistanceFromLineSegement
(
    const Vector2& lineStart, const Vector2& lineEnd,
    const Vector2& point
)
{
    const Vector2 deltaPos(lineEnd - lineStart);
    const float deltaPosMagSquared = deltaPos.MagnitudeSquared();
    const Vector2 deltaStart(point - lineStart);
    const float dp = deltaStart.DotProduct(deltaPos);

    if (dp >= deltaPosMagSquared)
        return (point - lineEnd).Magnitude();
    else if (dp <= 0)
        return (point - lineStart).Magnitude();
    else
    {
        const Vector2 pointNearest(lineStart + deltaPos * (dp / deltaPosMagSquared));
        return (point - pointNearest).Magnitude();
    }
}

// 2d line segment intersection test
// faster then the full line segment test if you don’t need the intersection point
// returns true if finite line segments intersect
inline bool LineSegmentIntersection
(
    const Vector2& segment1a, const Vector2& segment1b,
    const Vector2& segment2a, const Vector2& segment2b
)
{
    const Vector2 d1a1b = segment1a - segment1b;
    const Vector2 d1b2a = segment1b - segment2a;
    const Vector2 d1b2b = segment1b - segment2b;

    if (IsClockwise(d1a1b, d1b2a) == IsClockwise(d1a1b, d1b2b))
        return false;

    const Vector2 d1a2a = segment1a - segment2a;
    const Vector2 d2a2b = segment2a - segment2b;

    return (IsClockwise(d1a2a, d2a2b) != IsClockwise(d1b2a, d2a2b));
}

// 2d point inside polygon test
// returns true if point is inside clockwise winding polygon
inline bool InsidePolygon
(
    const Vector2* vertexList,
    int vertexCount,
    const Vector2& point
)
{
    for (int i = 0; i < vertexCount - 1; ++i)
    {
        if (!IsClockwise(vertexList[i], vertexList[i+1], point))
            return false;
    }

    return IsClockwise(vertexList[vertexCount - 1], vertexList[0], point);
}

// 2d clockwise winding test
// returns true if verts form clockwise triangle
inline bool IsClockwise
(
    const Vector2& v1,
    const Vector2& v2,
    const Vector2& v3
)
{
    const Vector2 d1 = v1 - v2;
    const Vector2 d2 = v2 - v3;
    return IsClockwise(d1, d2);
}

// 2d clockwise winding test
// returns true if directions are winding clockwise
inline bool IsClockwise(const Vector2& d1, const Vector2& d2)
{
    return (d1.y*d2.x > d2.y*d1.x);
}

[OMNICYPHER]

OMNICYPHER

OMNICYPHER

Show OMNICYPHER's last posts.

Show general stats for OMNICYPHER.

• 
• Newbie
• Score: 0
• Posts: 8

heres some homing missile code using dot product:

Code:

//make vector pointing from missile to target

targetDir.x = (targetPos.x - missilePos.x);
targetDir.y = (targetPos.y - missilePos.y);

//rotate missile 90 deg from (x,y) to (y,-x)
//then if the dot product says its perpendicular, it actually means its parallel
//if the line from missile to target is parallel with the angle of the missile,
//the missile is pointing at the target//

if ( missileVelocity.y * targetDir.x - missileVelocity.x * targetDir.y > 0 )     
missileAngle -= TURN_SPEED;
else
missileAngle += TURN_SPEED;

//polar to cartesian conversion

missileVelocity.x = missileSpeed * cos(missileAngle); 
missileVelocity.y = missileSpeed * sin(missileAngle);

//update missiles cartesian position

missilePos.x += missileVelocity.x;
missilePos.y += missileVelocity.y;