BlitzCoder Code Database

BlitzCoder Essentials

•Home Page
•About BlitzCoder
•Contributors
•Terms of Use
•Email Us

Main Areas

•BlitzCoder Chat
•Discussions
•Articles/Tutorials
•Code Database
•Link Database
•Showcase Area
•Worklogs
•Competitions

Special Areas

•Undocumented

Other Blitz Sites

•Blitz Basic Home
•Blitz Showcase
•BlitzPlay Library

BlitzCoder Code Archives Page

Main Codes Page

"Vector Matrix Conversion - 2D Angle <-> Coords", by thechange

Basically 4 functions to convert from X/Y coordinates to Length/Angle and vise versa. A must for 2D space shooters and related mathematics. The major part of the code contains fun games/examples on how to use the functions, including 2D space physics.

Code

; *-------------------------------------*
; I                                     I
; I  Vector Conversion Routines - VX 3  I
; I                                     I
; *-------------------------------------*

;-[ Sub ]--------------------------------------------------------------------------------------------------------1-2-0--

Function GetVectorX# ( Distance# , Angle# )  ; Get horizontal size of vector using distance and angle
    Return Sin( Angle ) * Distance
  End Function

Function GetVectorY# ( Distance# , Angle# )  ; Get vertical size of vector using distance and angle
    Return Sin( Angle - 90 ) * Distance
  End Function

Function GetLength# ( X# , Y# )  ; Get true length of a vector
    Return Sqr ( X * X + Y * Y )
  End Function

Function GetAngle# ( X# , Y# )  ; Get true angle of a vector
    Return -ATan2 ( X , Y ) + 180
  End Function

;
  ; Vector Help
  ; -----------------------------------------------------------------------------------------------------------------;
    ;
    ; There are different ways of using vectors. The most common vector is simply having an X and Y.
    ; These would be used to, for example, calculate a ship's displacement. Imagine a matrix or grid
    ; with (0,0) as the center. When visualizing, a vector would always be drawn from this point.
    ; Another way is to use Angle and Length. Angle would be the angle of the line from (0,0) to
    ; (X,Y). And Length being the actual distance between these points. The graph below displays:
    ;
    ;               T
    ;             *
    ;            /I
    ;           / I
    ;          /  I
    ;     v   /   I
    ;        /    I  y
    ;       /     I
    ;      /      I
    ;     /       I
    ;    /a       I
    ;   *---------*
    ; V             B
    ;        x
    ;
    ; Line VB (x) represents the length of 'x'
    ; Line BT (y) represents the length of 'y'
    ; Line VT (v) represents the length of the vector
    ; Angle 'a' represents the angle of the vector
    ;
    ;                          X
    ; Native vector notation: ---
    ;                          Y
    ;
    ; Default pythagoras formula applies to this triangle: x^2 + y^2 = v^2
    ; There are also various Sin, Cos and Tan formulas to apply.
    ;
    ; The first example below is a representation of the above.
  ;
  ; Vector Function Usage Examples
  ; -----------------------------------------------------------------------------------------------------------------;
    ;
    ; Example of displaying a true vector
    ; ------------------------------------------------------------------------------------------------------------ ;
    ; Move your mouse to alternate the vector

Graphics 640 , 480
    SetBuffer BackBuffer()  ; Double buffering, e.g. draw to invisible buffer and swap to visible when done

X1 = GraphicsWidth() / 2   ; Center of screen is center of vector
    Y1 = GraphicsHeight() / 2  ;

MoveMouse X1 + 100 , Y1 - 100  ; Put mouse in a spot to resemble the graph in the vector help

Repeat  ; Main loop
      Cls  ; Clear screen each frame

X2 = MouseX()  ; Use mouse for vector coordinates
      Y2 = MouseY()  ;

Length = GetLength( X2-X1 , Y2-Y1 )  ; Calculate true length of the vector
      Angle = GetAngle( X2-X1 , Y2-Y1 )  ; And true angle

Color 0 , 127 , 255  ; Display relevant info
      Text 0 , 0 * FontHeight() , "X Length: " + (X2-X1)
      Text 0 , 1 * FontHeight() , "Y Length: " + (Y2-Y1)
      Text 0 , 2 * FontHeight() , "Vector Length: " + Length
      Text 0 , 3 * FontHeight() , "Vector Angle: " + Angle

X2 = X1 + GetVectorX( Length , Angle )  ; REcalculate vector coordinates, to demonstrate using GetVector
      Y2 = Y1 + GetVectorY( Length , Angle )  ; The vector is drawn from center of screen

Color 0 , 255 , 0
      Line X1 , Y1 , X2 , Y2  ; Draw vector line (v)

Color 255 , 255 , 0
      Line X1 , Y1 , X2 , Y1  ; Draw the horizontal line (x)
      Line X2 , Y2 , X2 , Y1  ; Draw the vertical line (y)

Flip  ; Using double buffering so, display all
    Until GetKey()  ; Until any ASCII keypress

EndGraphics
    End

; Specific example for GetLength and GetAngle
    ; ------------------------------------------------------------------------------------------------------------ ;
    ; Demonstrates 'ashies' (grey dots) floating around.

Graphics 640 , 480
    SetBuffer BackBuffer()
    SeedRnd MilliSecs()  ; Randomize

Const TotalDots = 100  ; Total number of dots to create

Type Dot  ; Ashy
      Field PosX#  ; All ashies have unique positions
      Field PosY#  ;
      Field LastAngle%  ; And an angle to remember where they're going
      Field Color%  ; Also a color
    End Type

Local Dot.Dot  ; Creating a collection of dots

For Counter = 1 To TotalDots  ; Creating the dolly dots
      Dot = New Dot
      Dot\PosX = Rnd( 0 , GraphicsWidth() )   ; Random position on screen
      Dot\PosY = Rnd( 0 , GraphicsHeight() )  ;
      Dot\LastAngle = Rnd( 0 , 359 )  ; Random direction to begin with
      Dot\Color = Rnd( 64 , 255 )  ; And a random color (grey shade)
    Next

Repeat
      Cls
      For Dot = Each Dot  ; Iterate through all dots

Repeat
          IncX# = Rnd( -5 , 5 )  ; Get random horizontal increment
          IncY# = Rnd( -5 , 5 )  ; Get random vertical increment
          Length = GetLength( IncX , IncY )  ; Calculate the real length of the line (size of the vector)
          Angle = GetAngle( IncX , IncY )  ; Calculate the real angle
        Until Length >= 2 And Length <= 5 And Abs ( Dot\LastAngle - Angle ) <= 10
        ; Repeat calculating until we get a line with length between 2 and 5
        ; and an angle that differs no more than 10 degrees from the current angle
        ; This technique is very slow but demonstrates the purpose

Dot\LastAngle = Angle  ; Remember the current angle

Dot\PosX = Dot\PosX + IncX  ; Update the dot's horizontal position by the new increment
        If Dot\PosX < 0 Then Dot\PosX = Dot\PosX + GraphicsWidth()  ; But if it goes off-screen, make it warp
        If Dot\PosX > GraphicsWidth() Then Dot\PosX = Dot\PosX - GraphicsWidth()

Dot\PosY = Dot\PosY + IncY  ; Same for vertical position
        If Dot\PosY < 0 Then Dot\PosY = Dot\PosY + GraphicsHeight()
        If Dot\PosY > GraphicsHeight() Then Dot\PosY = Dot\PosY - GraphicsHeight()

Color Dot\Color , Dot\Color , Dot\Color  ; Pick da color
        Plot Dot\PosX , Dot\PosY  ; Plot the dot, you can use writepixel too

Next
      Flip
    Until GetKey()

Delete Each Dot  ; Wipe them out
    EndGraphics
    End

; Specific example for GetVectorX and GetVectorY
    ; ------------------------------------------------------------------------------------------------------------ ;
    ; Demonstrates 'fishies' (nibbles/lines) wondering about with various speeds, sizes and colors.

Graphics 640 , 480
    SetBuffer BackBuffer()
    SeedRnd MilliSecs()

Const TotalNibbles = 20  ; Total number of nibbles to create

Type Nibble  ; Fishy
      Field TailX#  ; Fishy has head and tail
      Field TailY#  ; Program uses tail for positioning
      Field Speed%  ; Fishy has speed
      Field Heading%  ; Fishy has angle or heading
      Field Size%   ; Fishy has size, e.g. difference between head and tail
      Field Color%  ; And color (simple grey scale)
    End Type

Local Nibble.Nibble  ; Our collection of nibbles

For Counter = 1 To TotalNibbles  ; Create nibbles
      Nibble = New Nibble
      Nibble\TailX = Rnd( 0 , GraphicsWidth() )   ; Random position within screen boundaries
      Nibble\TailY = Rnd( 0 , GraphicsHeight() )  ;
      Nibble\Speed = Rnd( 2 , 5 )  ; Random speed
      Nibble\Heading = Rnd( 0 , 359 )  ; Random heading to start with
      Nibble\Size = Rnd( 5 , 10 )  ; Random size too
      Nibble\Color = Rnd( 64 , 255 )  ; And random shade
    Next

Repeat
      Cls
      For Nibble = Each Nibble  ; Iterate through all nibbles

Nibble\Heading = Nibble\Heading + Rnd( -10 , 10 )  ; Randomly alternate heading with max 10 degrees
        If Nibble\Heading < 0 Then Nibble\Heading = Nibble\Heading + 360  ; Keep angle in range of 0 and 359
        If Nibble\Heading > 359 Then Nibble\Heading = Nibble\Heading - 360

Nibble\TailX = Nibble\TailX + GetVectorX( Nibble\Speed , Nibble\Heading )  ; Update position
        If Nibble\TailX < 0 Then Nibble\TailX = Nibble\TailX + GraphicsWidth()  ; Warp if off-screen
        If Nibble\TailX >= GraphicsWidth() Then Nibble\TailX = Nibble\TailX - GraphicsWidth()

Nibble\TailY = Nibble\TailY + GetVectorY( Nibble\Speed , Nibble\Heading )  ; Same for vertical
        If Nibble\TailY < 0 Then Nibble\TailY = Nibble\TailY + GraphicsHeight()
        If Nibble\TailY >= GraphicsHeight() Then Nibble\TailY = Nibble\TailY - GraphicsHeight()

HeadX# = Nibble\TailX + GetVectorX( Nibble\Size , Nibble\Heading )  ; Calculate head based on tail
        HeadY# = Nibble\TailY + GetVectorY( Nibble\Size , Nibble\Heading )  ;  (can go off-screen)
        Color Nibble\Color , Nibble\Color , Nibble\Color  ; Nibble color
        Line Nibble\TailX , Nibble\TailY , HeadX , HeadY  ; Line from tail to head

Next
      Flip
    Until GetKey()

Delete Each Nibble
    EndGraphics
    End

; Example of space physics using vector translation (Method A)
    ; ------------------------------------------------------------------------------------------------------------ ;
    ; Demonstrates the use of angle, thrust, heading and velocity

Graphics 640 , 480
    SetBuffer BackBuffer()

; Keyboard scancodes
    Const KeyCursorUp%    = 200
    Const KeyCursorDown%  = 208
    Const KeyCursorLeft%  = 203
    Const KeyCursorRight% = 205
    Const KeyEscape%      =   1
    Const KeySpace%       =  57

; Craft specifications
    Const ThrustMax# = 0.1  ; Maximum thrust speed
    Const SpeedMax# = 5     ; Maximum allowed velocity
    Const RotateMax# = 4    ; Maximum rotation speed (degrees)

; Craft related
    PosX# = GraphicsWidth() / 2   ; Start at center of screen
    PosY# = GraphicsHeight() / 2  ;
    Thrust#  = 0  ; Current thrust speed - in the direction of where the ship is pointing at
    Angle%   = 0  ; Current angle (rotation) - where the ship is pointing at
    Speed#   = 0  ; Current actual speed of the ship
    Heading% = 0  ; Current heading - where the ship is moving towards (degrees)

; Logic related
    Local Thrusting% = False  ; Thrusts forwards/backwards when True, automatically decelerates thrust when False
    Local VelocityX# = 0  ; Temporary variables for calculating the new velocity vector
    Local VelocityY# = 0  ;

Repeat
      Cls

If KeyDown( KeyCursorLeft ) Then Angle = Angle - RotateMax  ; Rotate anti-clockwise
      If KeyDown( KeyCursorRight ) Then Angle = Angle + RotateMax  ; Rotate clockwise
      If Angle < 0 Then Angle = Angle + 360  ; Make sure angle is in range of 0-359 (shift)
      If Angle > 359 Then Angle = Angle - 360

Thrusting = False  ; Automatically decelerate thrust - reset thrusting flag
      If KeyDown( KeyCursorUp ) Then  ; Cursor up held down
        Thrust = ThrustMax  ; Start thrusting forwards at max speed
        Thrusting = True  ; Do not decelerate thrust
      EndIf
      If KeyDown( KeyCursorDown ) Then  ; Cursor down held down
        Thrust = -ThrustMax  ; Start thrusting backwards at max speed
        Thrusting = True  ; Do not decelerate thrust
      EndIf
      If Not Thrusting Then Thrust = 0  ; Automatically decelerate thrusting when not thrusting (on request)

; Note:
      ;   Speed & Heading = Current velocity vector [ VelocityX VelocityY ]
      ;   Thrust & Angle = Current thrust vector [ ThrustX ThrustY ]
      VelocityX = GetVectorX( Speed , Heading ) + GetVectorX( Thrust , Angle )  ; The new velocity vector is the sum of
      VelocityY = GetVectorY( Speed , Heading ) + GetVectorY( Thrust , Angle )  ; the current velocity and thrust vector
      Speed = GetLength( VelocityX , VelocityY )   ; Translate back to speed and heading
      Heading = GetAngle( VelocityX , VelocityY )  ;
      If Speed > SpeedMax Then Speed = SpeedMax  ; Limit speed to maximum

If KeyDown( KeySpace ) Then Speed = 0  ; Handbrake

PosX = PosX + GetVectorX( Speed , Heading )  ; Update horizontal position with current horizontal velocity inc.
      If PosX < 0 Then PosX = PosX + GraphicsWidth()  ; Warp if off-screen
      If PosX >= GraphicsWidth() Then PosX = PosX - GraphicsWidth()
      PosY = PosY + GetVectorY( Speed , Heading )  ; Same for vertical
      If PosY < 0 Then PosY = PosY + GraphicsHeight()
      If PosY >= GraphicsHeight() Then PosY = PosY - GraphicsHeight()

Color 0 , 127 , 255  ; Additional information
      Oval PosX - 10 , PosY - 10 , 21 , 21 , True
      Text 0 , 0 * FontHeight() , "X: " + Int(PosX) + " Y: " + Int(PosY)
      Color 127 , 255 , 127
      Line PosX , PosY , PosX + GetVectorX( 10 , Heading ) , PosY + GetVectorY( 10 , Heading )
      Text 0 , 1 * FontHeight() , "Speed: " + Int(Speed) + " Heading: " + Heading
      Color 255 , 255 , 255
      Line PosX , PosY , PosX + GetVectorX( 20 , Angle ) , PosY + GetVectorY( 20 , Angle )
      Text 0 , 2 * FontHeight() , "Thrust: " + Thrusting + " Angle: " + Angle

Flip
    Until KeyDown( KeyEscape )

EndGraphics
    End

; Example of space physics using vector translation (Method B)
    ; ------------------------------------------------------------------------------------------------------------ ;
    ; Demonstrates the use of native thrust and velocity vectors

Graphics 640 , 480
    SetBuffer BackBuffer()

; Craft related
    PosX# = GraphicsWidth() / 2   ; Start at center of screen
    PosY# = GraphicsHeight() / 2  ;
    ThrustX#   = 0  ; Native vector for thrust
    ThrustY#   = 0  ;
    VelocityX# = 0  ; Native vector for velocity
    VelocityY# = 0  ;
    Angle%     = 0  ; Current angle (degrees)

; Logic related
    Local Thrusting% = False  ; Thrusts forwards/backwards when True, automatically decelerates thrust when False
    Local Speed#    ; Temporary variables for calculation
    Local Heading%  ;

Repeat
      Cls

Thrusting = False  ; Automatically decelerate thrust - reset thrusting flag

If KeyDown( KeyCursorUp ) Then  ; Cursor up held down
        ThrustX = GetVectorX( ThrustMax , Angle )  ; Start thrusting forwards at max speed
        ThrustY = GetVectorY( ThrustMax , Angle )  ;
        Thrusting = True  ; Do not decelerate thrust
      EndIf

If KeyDown( KeyCursorDown ) Then  ; Cursor down held down
        ThrustX = GetVectorX( -ThrustMax , Angle )  ; Start thrusting backwards at max speed
        ThrustY = GetVectorY( -ThrustMax , Angle )  ;
        Thrusting = True  ; Do not decelerate thrust
      EndIf

If Not Thrusting Then
        ThrustX = 0  ; Automatically decelerate thrusting when not thrusting (on request)
        ThrustY = 0  ;
      EndIf

VelocityX = VelocityX + ThrustX  ; The new velocity vector is the sum of the current velocity and thrust vector
      VelocityY = VelocityY + ThrustY  ;

Speed = GetLength( VelocityX , VelocityY )   ; Calculate actual speed
      Heading = GetAngle( VelocityX , VelocityY )  ; Calculate actual heading

If Speed > SpeedMax Then Speed = SpeedMax    ; Limit speed to maximum

If KeyDown( KeySpace ) Then Speed = 0        ; Handbrake

VelocityX = GetVectorX( Speed , Heading )    ; Translate back to native velocity vector
      VelocityY = GetVectorY( Speed , Heading )    ;

PosX = PosX + VelocityX  ; Update horizontal position with current horizontal velocity increment
      If PosX < 0 Then PosX = PosX + GraphicsWidth()  ; Warp if off-screen
      If PosX >= GraphicsWidth() Then PosX = PosX - GraphicsWidth()

PosY = PosY + VelocityY  ; Same for vertical
      If PosY < 0 Then PosY = PosY + GraphicsHeight()
      If PosY >= GraphicsHeight() Then PosY = PosY - GraphicsHeight()

Color 0 , 127 , 255  ; Additional information
      Oval PosX - 10 , PosY - 10 , 21 , 21 , True
      Text 0 , 0 * FontHeight() , "X: " + Int(PosX) + " Y: " + Int(PosY)

Color 127 , 255 , 127
      Line PosX , PosY , PosX + GetVectorX( 10 , Heading ) , PosY + GetVectorY( 10 , Heading )
      Text 0 , 1 * FontHeight() , "Speed: " + Int(Speed) + " Heading: " + Heading

Color 255 , 255 , 255
      Line PosX , PosY , PosX + GetVectorX( 20 , Angle ) , PosY + GetVectorY( 20 , Angle )
      Text 0 , 2 * FontHeight() , "Thrust: " + Thrusting + " Angle: " + Angle

Flip
    Until KeyDown( KeyEscape )

EndGraphics
    End

Code software created by Krylar's Kreations