Convert js joystick script to c# but not working

Question

I tried convert exaple touch screen joystick script in java to c# ,but not working. Original in js:

 //////////////////////////////////////////////////////////////
 // Joystick.js
 // Penelope iPhone Tutorial
 //
 // Joystick creates a movable joystick (via GUITexture) that 
 // handles touch input, taps, and phases. Dead zones can control
 // where the joystick input gets picked up and can be normalized.
 //
 // Optionally, you can enable the touchPad property from the editor
 // to treat this Joystick as a TouchPad. A TouchPad allows the finger
 // to touch down at any point and it tracks the movement relatively 
 // without moving the graphic
 //////////////////////////////////////////////////////////////
 
 #pragma strict
 
 @script RequireComponent( GUITexture )
 
 // A simple class for bounding how far the GUITexture will move
 class Boundary 
 {
     var min : Vector2 = Vector2.zero;
     var max : Vector2 = Vector2.zero;
 }
 
 static private var joysticks : Joystick[];                    // A static collection of all joysticks
 static private var enumeratedJoysticks : boolean = false;
 static private var tapTimeDelta : float = 0.3;                // Time allowed between taps
 
 var touchPad : boolean;                                     // Is this a TouchPad?
 var touchZone : Rect;
 var deadZone : Vector2 = Vector2.zero;                        // Control when position is output
 var normalize : boolean = false;                             // Normalize output after the dead-zone?
 var position : Vector2;                                     // [-1, 1] in x,y
 var tapCount : int;                                            // Current tap count
 
 private var lastFingerId = -1;                                // Finger last used for this joystick
 private var tapTimeWindow : float;                            // How much time there is left for a tap to occur
 private var fingerDownPos : Vector2;
 private var fingerDownTime : float;
 private var firstDeltaTime : float = 0.5;
 
 private var gui : GUITexture;                                // Joystick graphic
 private var defaultRect : Rect;                                // Default position / extents of the joystick graphic
 private var guiBoundary : Boundary = Boundary();            // Boundary for joystick graphic
 private var guiTouchOffset : Vector2;                        // Offset to apply to touch input
 private var guiCenter : Vector2;                            // Center of joystick
 
 function Start()
 {
     // Cache this component at startup instead of looking up every frame    
     gui = GetComponent( GUITexture );
     
     // Store the default rect for the gui, so we can snap back to it
     defaultRect = gui.pixelInset;    
     
     defaultRect.x += transform.position.x * Screen.width;// + gui.pixelInset.x; // -  Screen.width * 0.5;
     defaultRect.y += transform.position.y * Screen.height;// - Screen.height * 0.5;
     
     transform.position.x = 0.0;
     transform.position.y = 0.0;
         
     if ( touchPad )
     {
         // If a texture has been assigned, then use the rect ferom the gui as our touchZone
         if ( gui.texture )
             touchZone = defaultRect;
     }
     else
     {                
         // This is an offset for touch input to match with the top left
         // corner of the GUI
         guiTouchOffset.x = defaultRect.width * 0.5;
         guiTouchOffset.y = defaultRect.height * 0.5;
         
         // Cache the center of the GUI, since it doesn't change
         guiCenter.x = defaultRect.x + guiTouchOffset.x;
         guiCenter.y = defaultRect.y + guiTouchOffset.y;
         
         // Let's build the GUI boundary, so we can clamp joystick movement
         guiBoundary.min.x = defaultRect.x - guiTouchOffset.x;
         guiBoundary.max.x = defaultRect.x + guiTouchOffset.x;
         guiBoundary.min.y = defaultRect.y - guiTouchOffset.y;
         guiBoundary.max.y = defaultRect.y + guiTouchOffset.y;
     }
 }
 
 function Disable()
 {
     gameObject.SetActive(false);
     enumeratedJoysticks = false;
 }
 
 function ResetJoystick()
 {
     // Release the finger control and set the joystick back to the default position
     gui.pixelInset = defaultRect;
     lastFingerId = -1;
     position = Vector2.zero;
     fingerDownPos = Vector2.zero;
     
     if ( touchPad )
         gui.color.a = 0.025;    
 }
 
 function IsFingerDown() : boolean
 {
     return (lastFingerId != -1);
 }
     
 function LatchedFinger( fingerId : int )
 {
     // If another joystick has latched this finger, then we must release it
     if ( lastFingerId == fingerId )
         ResetJoystick();
 }
 
 function Update()
 {    
     if ( !enumeratedJoysticks )
     {
         // Collect all joysticks in the game, so we can relay finger latching messages
         joysticks = FindObjectsOfType( Joystick ) as Joystick[];
         enumeratedJoysticks = true;
     }    
         
     var count = Input.touchCount;
     
     // Adjust the tap time window while it still available
     if ( tapTimeWindow > 0 )
         tapTimeWindow -= Time.deltaTime;
     else
         tapCount = 0;
     
     if ( count == 0 )
         ResetJoystick();
     else
     {
         for(var i : int = 0;i < count; i++)
         {
             var touch : Touch = Input.GetTouch(i);            
             var guiTouchPos : Vector2 = touch.position - guiTouchOffset;
     
             var shouldLatchFinger = false;
             if ( touchPad )
             {                
                 if ( touchZone.Contains( touch.position ) )
                     shouldLatchFinger = true;
             }
             else if ( gui.HitTest( touch.position ) )
             {
                 shouldLatchFinger = true;
             }        
     
             // Latch the finger if this is a new touch
             if ( shouldLatchFinger && ( lastFingerId == -1 || lastFingerId != touch.fingerId ) )
             {
                 
                 if ( touchPad )
                 {
                     gui.color.a = 0.15;
                     
                     lastFingerId = touch.fingerId;
                     fingerDownPos = touch.position;
                     fingerDownTime = Time.time;
                 }
                 
                 lastFingerId = touch.fingerId;
                 
                 // Accumulate taps if it is within the time window
                 if ( tapTimeWindow > 0 )
                     tapCount++;
                 else
                 {
                     tapCount = 1;
                     tapTimeWindow = tapTimeDelta;
                 }
                                             
                 // Tell other joysticks we've latched this finger
                 for ( var j : Joystick in joysticks )
                 {
                     if ( j != this )
                         j.LatchedFinger( touch.fingerId );
                 }                        
             }                
     
             if ( lastFingerId == touch.fingerId )
             {    
                 // Override the tap count with what the iPhone SDK reports if it is greater
                 // This is a workaround, since the iPhone SDK does not currently track taps
                 // for multiple touches
                 if ( touch.tapCount > tapCount )
                     tapCount = touch.tapCount;
                 
                 if ( touchPad )
                 {    
                     // For a touchpad, let's just set the position directly based on distance from initial touchdown
                     position.x = Mathf.Clamp( ( touch.position.x - fingerDownPos.x ) / ( touchZone.width / 2 ), -1, 1 );
                     position.y = Mathf.Clamp( ( touch.position.y - fingerDownPos.y ) / ( touchZone.height / 2 ), -1, 1 );
                 }
                 else
                 {                    
                     // Change the location of the joystick graphic to match where the touch is
                     gui.pixelInset.x =  Mathf.Clamp( guiTouchPos.x, guiBoundary.min.x, guiBoundary.max.x );
                     gui.pixelInset.y =  Mathf.Clamp( guiTouchPos.y, guiBoundary.min.y, guiBoundary.max.y );        
                 }
                 
                 if ( touch.phase == TouchPhase.Ended || touch.phase == TouchPhase.Canceled )
                     ResetJoystick();                    
             }            
         }
     }
     
     if ( !touchPad )
     {
         // Get a value between -1 and 1 based on the joystick graphic location
         position.x = ( gui.pixelInset.x + guiTouchOffset.x - guiCenter.x ) / guiTouchOffset.x;
         position.y = ( gui.pixelInset.y + guiTouchOffset.y - guiCenter.y ) / guiTouchOffset.y;
     }
     
     // Adjust for dead zone    
     var absoluteX = Mathf.Abs( position.x );
     var absoluteY = Mathf.Abs( position.y );
     
     if ( absoluteX < deadZone.x )
     {
         // Report the joystick as being at the center if it is within the dead zone
         position.x = 0;
     }
     else if ( normalize )
     {
         // Rescale the output after taking the dead zone into account
         position.x = Mathf.Sign( position.x ) * ( absoluteX - deadZone.x ) / ( 1 - deadZone.x );
     }
         
     if ( absoluteY < deadZone.y )
     {
         // Report the joystick as being at the center if it is within the dead zone
         position.y = 0;
     }
     else if ( normalize )
     {
         // Rescale the output after taking the dead zone into account
         position.y = Mathf.Sign( position.y ) * ( absoluteY - deadZone.y ) / ( 1 - deadZone.y );
     }
 }

My c# version:

 using UnityEngine;
 using System.Collections;
 
 
 [RequireComponent(typeof(GUITexture))]
 public class js : MonoBehaviour {
 
     static Joystick[] joysticks;                    // A static collection of all joysticks
     static bool enumeratedJoysticks = false;
     static float tapTimeDelta = 0.3;                // Time allowed between taps
     
     public bool touchPad;                                     // Is this a TouchPad?
     public Rect touchZone;
     public Vector2 deadZone = Vector2.zero;                        // Control when position is output
     public bool normalize = false;                             // Normalize output after the dead-zone?
     public Vector2 position;                                     // [-1, 1] in x,y
     public int tapCount;                                            // Current tap count
     
     int lastFingerId = -1;                                // Finger last used for this joystick
     float tapTimeWindow;                            // How much time there is left for a tap to occur
     Vector2 fingerDownPos;
     float fingerDownTime;
     float firstDeltaTime = 0.5;
     
     GUITexture gui;                                // Joystick graphic
     Rect defaultRect;                                // Default position / extents of the joystick graphic        // Boundary for joystick graphic
     Vector2 guiTouchOffset;                        // Offset to apply to touch input
     Vector2 guiCenter;    
     Vector2 min = Vector2.zero;
     Vector2 max = Vector2.zero;
     // Use this for initialization
 
     void Start () {
         gui = GetComponent( GUITexture );
         
         // Store the default rect for the gui, so we can snap back to it
         defaultRect = gui.pixelInset;    
         
         defaultRect.x += transform.position.x * Screen.width;// + gui.pixelInset.x; // -  Screen.width * 0.5;
         defaultRect.y += transform.position.y * Screen.height;// - Screen.height * 0.5;
         
         transform.position.x = 0.0;
         transform.position.y = 0.0;
         
         if ( touchPad )
         {
             // If a texture has been assigned, then use the rect ferom the gui as our touchZone
             if ( gui.texture )
                 touchZone = defaultRect;
         }
         else
         {                
             // This is an offset for touch input to match with the top left
             // corner of the GUI
             guiTouchOffset.x = defaultRect.width * 0.5;
             guiTouchOffset.y = defaultRect.height * 0.5;
             
             // Cache the center of the GUI, since it doesn't change
             guiCenter.x = defaultRect.x + guiTouchOffset.x;
             guiCenter.y = defaultRect.y + guiTouchOffset.y;
             
             // Let's build the GUI boundary, so we can clamp joystick movement
             min.x = defaultRect.x - guiTouchOffset.x;
             max.x = defaultRect.x + guiTouchOffset.x;
             min.y = defaultRect.y - guiTouchOffset.y;
             max.y = defaultRect.y + guiTouchOffset.y;
         }
     }
 
     void Disable()
     {
         gameObject.SetActive(false);
         enumeratedJoysticks = false;
     }
 
     void ResetJoystick()
     {
         // Release the finger control and set the joystick back to the default position
         gui.pixelInset = defaultRect;
         lastFingerId = -1;
         position = Vector2.zero;
         fingerDownPos = Vector2.zero;
         
         if ( touchPad )
             gui.color.a = 0.025;    
     }
     
     void IsFingerDown()
     {
         return (lastFingerId != -1);
     }
     
     void LatchedFinger( int fingerId )
     {
         // If another joystick has latched this finger, then we must release it
         if ( lastFingerId == fingerId )
             ResetJoystick();
     }
     
     // Update is called once per frame
     void Update () {
         if ( !enumeratedJoysticks )
         {
             // Collect all joysticks in the game, so we can relay finger latching messages
             joysticks = FindObjectsOfType( Joystick ) as Joystick[];
             enumeratedJoysticks = true;
         }    
         
         count = Input.touchCount;
         
         // Adjust the tap time window while it still available
         if ( tapTimeWindow > 0 )
             tapTimeWindow -= Time.deltaTime;
         else
             tapCount = 0;
         
         if ( count == 0 )
             ResetJoystick();
         else
         {
             for(int i = 0;i < count; i++)
             {
                 Touch touch = Input.GetTouch(i);            
                 Vector2 guiTouchPos = touch.position - guiTouchOffset;
                 
                 var shouldLatchFinger = false;
                 if ( touchPad )
                 {                
                     if ( touchZone.Contains( touch.position ) )
                         shouldLatchFinger = true;
                 }
                 else if ( gui.HitTest( touch.position ) )
                 {
                     shouldLatchFinger = true;
                 }        
                 
                 // Latch the finger if this is a new touch
                 if ( shouldLatchFinger && ( lastFingerId == -1 || lastFingerId != touch.fingerId ) )
                 {
                     
                     if ( touchPad )
                     {
                         gui.color.a = 0.15;
                         
                         lastFingerId = touch.fingerId;
                         fingerDownPos = touch.position;
                         fingerDownTime = Time.time;
                     }
                     
                     lastFingerId = touch.fingerId;
                     
                     // Accumulate taps if it is within the time window
                     if ( tapTimeWindow > 0 )
                         tapCount++;
                     else
                     {
                         tapCount = 1;
                         tapTimeWindow = tapTimeDelta;
                     }
                     
                     // Tell other joysticks we've latched this finger
                     for (Joystick j in joysticks )
                     {
                         if ( j != this )
                             j.LatchedFinger( touch.fingerId );
                     }                        
                 }                
                 
                 if ( lastFingerId == touch.fingerId )
                 {    
                     // Override the tap count with what the iPhone SDK reports if it is greater
                     // This is a workaround, since the iPhone SDK does not currently track taps
                     // for multiple touches
                     if ( touch.tapCount > tapCount )
                         tapCount = touch.tapCount;
                     
                     if ( touchPad )
                     {    
                         // For a touchpad, let's just set the position directly based on distance from initial touchdown
                         position.x = Mathf.Clamp( ( touch.position.x - fingerDownPos.x ) / ( touchZone.width / 2 ), -1, 1 );
                         position.y = Mathf.Clamp( ( touch.position.y - fingerDownPos.y ) / ( touchZone.height / 2 ), -1, 1 );
                     }
                     else
                     {                    
                         // Change the location of the joystick graphic to match where the touch is
                         gui.pixelInset.x =  Mathf.Clamp( guiTouchPos.x, min.x, max.x );
                         gui.pixelInset.y =  Mathf.Clamp( guiTouchPos.y, min.y, max.y );        
                     }
                     
                     if ( touch.phase == TouchPhase.Ended || touch.phase == TouchPhase.Canceled ){
                         ResetJoystick();                    
                 }
                 }
             }
         }
         
         if ( !touchPad )
         {
             // Get a value between -1 and 1 based on the joystick graphic location
             position.x = ( gui.pixelInset.x + guiTouchOffset.x - guiCenter.x ) / guiTouchOffset.x;
             position.y = ( gui.pixelInset.y + guiTouchOffset.y - guiCenter.y ) / guiTouchOffset.y;
         }
         
         // Adjust for dead zone    
         var absoluteX = Mathf.Abs( position.x );
         var absoluteY = Mathf.Abs( position.y );
         
         if ( absoluteX < deadZone.x )
         {
             // Report the joystick as being at the center if it is within the dead zone
             position.x = 0;
         }
         else if ( normalize )
         {
             // Rescale the output after taking the dead zone into account
             position.x = Mathf.Sign( position.x ) * ( absoluteX - deadZone.x ) / ( 1 - deadZone.x );
         }
         
         if ( absoluteY < deadZone.y )
         {
             // Report the joystick as being at the center if it is within the dead zone
             position.y = 0;
         }
         else if ( normalize )
         {
             // Rescale the output after taking the dead zone into account
             position.y = Mathf.Sign( position.y ) * ( absoluteY - deadZone.y ) / ( 1 - deadZone.y );
         }
     }
 }

Answer 1

You took a shot at it, but there were a large number of syntax errors to be fixed. Here is a script that compiles. I did not compare it to the original, nor did test the result. I just took your script and walked through it fixing all the problems pointed out by the compiler. Notes:

It is 'foreach' in C#
You cannot directly assign to the intividual components of transform.position, guiTexture.pixelInset, and GUI.color. You must use a temporary variable as assign all components.
The script must be named 'Joystick', or you must change the type used for the 'joysticks' variable.

You can use the generic versions of GetComponent() and FindObjectsOfType()

using UnityEngine; using System.Collections;

[RequireComponent(typeof(GUITexture))] public class Joystick : MonoBehaviour {

   static Joystick[] joysticks;                    // A static collection of all joysticks
     static bool enumeratedJoysticks = false;
     static float tapTimeDelta = 0.3f;                // Time allowed between taps
     
     public bool touchPad;                                     // Is this a TouchPad?
     public Rect touchZone;
     public Vector2 deadZone = Vector2.zero;                        // Control when position is output
     public bool normalize = false;                             // Normalize output after the dead-zone?
     public Vector2 position;                                     // [-1, 1] in x,y
     public int tapCount;                                            // Current tap count
     
     int lastFingerId = -1;                                // Finger last used for this joystick
     float tapTimeWindow;                            // How much time there is left for a tap to occur
     Vector2 fingerDownPos;
     float fingerDownTime;
     float firstDeltaTime = 0.5f;
     
     GUITexture gui;                                // Joystick graphic
     Rect defaultRect;                                // Default position / extents of the joystick graphic        // Boundary for joystick graphic
     Vector2 guiTouchOffset;                        // Offset to apply to touch input
     Vector2 guiCenter;    
     Vector2 min = Vector2.zero;
     Vector2 max = Vector2.zero;
     // Use this for initialization
     
     void Start () {
         gui = GetComponent<GUITexture>();
         
         // Store the default rect for the gui, so we can snap back to it
         defaultRect = gui.pixelInset;    
         
         defaultRect.x += transform.position.x * Screen.width;// + gui.pixelInset.x; // -  Screen.width * 0.5;
         defaultRect.y += transform.position.y * Screen.height;// - Screen.height * 0.5;
 
         transform.position = new Vector3(0.0f, 0.0f, transform.position.z);
 
         if ( touchPad )
         {
             // If a texture has been assigned, then use the rect ferom the gui as our touchZone
             if ( gui.texture )
                 touchZone = defaultRect;
         }
         else
         {                
             // This is an offset for touch input to match with the top left
             // corner of the GUI
             guiTouchOffset.x = defaultRect.width * 0.5f;
             guiTouchOffset.y = defaultRect.height * 0.5f;
             
             // Cache the center of the GUI, since it doesn't change
             guiCenter.x = defaultRect.x + guiTouchOffset.x;
             guiCenter.y = defaultRect.y + guiTouchOffset.y;
             
             // Let's build the GUI boundary, so we can clamp joystick movement
             min.x = defaultRect.x - guiTouchOffset.x;
             max.x = defaultRect.x + guiTouchOffset.x;
             min.y = defaultRect.y - guiTouchOffset.y;
             max.y = defaultRect.y + guiTouchOffset.y;
         }
     }
     
     void Disable()
     {
         gameObject.SetActive(false);
         enumeratedJoysticks = false;
     }
     
     void ResetJoystick()
     {
         // Release the finger control and set the joystick back to the default position
         gui.pixelInset = defaultRect;
         lastFingerId = -1;
         position = Vector2.zero;
         fingerDownPos = Vector2.zero;
         
         if ( touchPad )
         {
             Color c = gui.color;
             c.a = 0.025f;
             gui.color = c;
         }
     }
     
     bool IsFingerDown()
     {
         return (lastFingerId != -1);
     }
     
     void LatchedFinger( int fingerId )
     {
         // If another joystick has latched this finger, then we must release it
         if ( lastFingerId == fingerId )
             ResetJoystick();
     }
     
     // Update is called once per frame
     void Update () {
         if ( !enumeratedJoysticks )
         {
             // Collect all joysticks in the game, so we can relay finger latching messages
             joysticks = FindObjectsOfType<Joystick>();
             enumeratedJoysticks = true;
         }    
         
         int count = Input.touchCount;
         
         // Adjust the tap time window while it still available
         if ( tapTimeWindow > 0 )
             tapTimeWindow -= Time.deltaTime;
         else
             tapCount = 0;
         
         if ( count == 0 )
             ResetJoystick();
         else
         {
             for(int i = 0;i < count; i++)
             {
                 Touch touch = Input.GetTouch(i);            
                 Vector2 guiTouchPos = touch.position - guiTouchOffset;
                 
                 var shouldLatchFinger = false;
                 if ( touchPad )
                 {                
                     if ( touchZone.Contains( touch.position ) )
                         shouldLatchFinger = true;
                 }
                 else if ( gui.HitTest( touch.position ) )
                 {
                     shouldLatchFinger = true;
                 }        
                 
                 // Latch the finger if this is a new touch
                 if ( shouldLatchFinger && ( lastFingerId == -1 || lastFingerId != touch.fingerId ) )
                 {
                     
                     if ( touchPad )
                     {
                         Color c = gui.color;
                         c.a = 0.15f;
                         gui.color = c;
                         
                         lastFingerId = touch.fingerId;
                         fingerDownPos = touch.position;
                         fingerDownTime = Time.time;
                     }
                     
                     lastFingerId = touch.fingerId;
                     
                     // Accumulate taps if it is within the time window
                     if ( tapTimeWindow > 0 )
                         tapCount++;
                     else
                     {
                         tapCount = 1;
                         tapTimeWindow = tapTimeDelta;
                     }
                     
                     // Tell other joysticks we've latched this finger
                     foreach (Joystick j in joysticks )
                     {
                         if ( j != this )
                             j.LatchedFinger( touch.fingerId );
                     }                        
                 }                
                 
                 if ( lastFingerId == touch.fingerId )
                 {    
                     // Override the tap count with what the iPhone SDK reports if it is greater
                     // This is a workaround, since the iPhone SDK does not currently track taps
                     // for multiple touches
                     if ( touch.tapCount > tapCount )
                         tapCount = touch.tapCount;
                     
                     if ( touchPad )
                     {    
                         // For a touchpad, let's just set the position directly based on distance from initial touchdown
                         position.x = Mathf.Clamp( ( touch.position.x - fingerDownPos.x ) / ( touchZone.width / 2 ), -1, 1 );
                         position.y = Mathf.Clamp( ( touch.position.y - fingerDownPos.y ) / ( touchZone.height / 2 ), -1, 1 );
                     }
                     else
                     {                    
                         // Change the location of the joystick graphic to match where the touch is
                         Rect r = gui.pixelInset;
                         r.x =  Mathf.Clamp( guiTouchPos.x, min.x, max.x );
                         r.y =  Mathf.Clamp( guiTouchPos.y, min.y, max.y ); 
                         gui.pixelInset = r;
                     }
                     
                     if ( touch.phase == TouchPhase.Ended || touch.phase == TouchPhase.Canceled ){
                         ResetJoystick();                    
                     }
                 }
             }
         }
         
         if ( !touchPad )
         {
             // Get a value between -1 and 1 based on the joystick graphic location
             position.x = ( gui.pixelInset.x + guiTouchOffset.x - guiCenter.x ) / guiTouchOffset.x;
             position.y = ( gui.pixelInset.y + guiTouchOffset.y - guiCenter.y ) / guiTouchOffset.y;
         }
         
         // Adjust for dead zone    
         var absoluteX = Mathf.Abs( position.x );
         var absoluteY = Mathf.Abs( position.y );
         
         if ( absoluteX < deadZone.x )
         {
             // Report the joystick as being at the center if it is within the dead zone
             position.x = 0;
         }
         else if ( normalize )
         {
             // Rescale the output after taking the dead zone into account
             position.x = Mathf.Sign( position.x ) * ( absoluteX - deadZone.x ) / ( 1 - deadZone.x );
         }
         
         if ( absoluteY < deadZone.y )
         {
             // Report the joystick as being at the center if it is within the dead zone
             position.y = 0;
         }
         else if ( normalize )
         {
             // Rescale the output after taking the dead zone into account
             position.y = Mathf.Sign( position.y ) * ( absoluteY - deadZone.y ) / ( 1 - deadZone.y );
         }
     }
 }

Convert js joystick script to c# but not working

1 Reply

Your answer

Follow this Question

Related Questions