Finding the length of an enum in a different class

I've started the Bergzerg Arcade tutorial, and just like the 3D Buzz tutorial I am converting it to UnityScript (because like a turtle hiding in his shell I am more comfortable with uJS ). He did his best to bamboozle me with a Delegate-Sort (which I got around with a bubble-sort), and all these classes that extend classes nearly did my head in, I also rewrote the getters and setters the only way I could understand. But finally I have been caught out trying to get the lengths of different enums on these classes.

Here is the C# version :

 _primaryAttribute = new Attribute( Enum.GetValues( typeof(AttributeName) ).Length ); 

and here's what I did after a search ( Eric is there with master smarts as always : http://answers.unity3d.com/questions/149520/javascript-checking-enum-length.html ) and the conversion :

 _primaryAttribute = new Attribute( System.Enum.GetValues( AttributeName ).Length );

Note : I have import System; at the top of the script (apparently this is to access the enum class, but I havn't a clue....)

This is the script I am working on (BaseCharacter):

 #pragma strict
 import System; // added to access the enum class
 
 public class BaseCharacter extends MonoBehaviour
 {
     private var _name : String;
     private var _level : int;
     private var _freeExp : uint;
     
     private var _primaryAttribute : Attribute[];
     private var _vital : Vital[];
     private var _skill : Skill[];
     
     function Awake() 
     {
         _name = "";
         _level = 0;
         _freeExp = 0;
         
         //_primaryAttribute = new Attribute( Enum.GetValues( typeof( AttributeName ) ).Length );
         _primaryAttribute = new Attribute( System.Enum.GetValues( AttributeName ).Length );
         
         //_vital = new Vital( Enum.GetValues( typeof( VitalName ) ).Length );
         _vital = new Vital( System.Enum.GetValues( VitalName ).Length );
         
         //_skill = new Skill( Enum.GetValues( typeof( SkillName ) ).Length );
         _skill = new Skill( System.Enum.GetValues( SkillName ).Length );
     }
 }

Now these are the errors :

Assets/_Scripts/CharacterClasses/BaseCharacter.js(23,41): BCE0085: Cannot create instance of abstract class 'System.Attribute'.

Assets/_Scripts/CharacterClasses/BaseCharacter.js(27,30): BCE0024: The type 'Vital' does not have a visible constructor that matches the argument list '(int)'.

Assets/_Scripts/CharacterClasses/BaseCharacter.js(30,30): BCE0024: The type 'Skill' does not have a visible constructor that matches the argument list '(int)'.

What I find odd is that the errors are the same for both the C# and the uJS versions. I am totally lost, please consider helping, simplify the thought (dumb it down), then explain if you would like. As ever I am in awe of the talented minds here and am always grateful for advice and guidance.

Fix My Script ! No, sorry, that's just the brain melting, please educate me (in laymans terms), many thanks =]

---

Here is the Attribute Class :

 #pragma strict
 
 public class Attribute extends BaseStat
 {
     public function Attribute() 
     {
         SetExpToLevel( 50 );
         SetLevelModifier( 1.05 );
     }
 }
 
 public enum AttributeName
 {
     Might, 
     Constitution, 
     Nimbleness, 
     Speed, 
     Concentration, 
     Willpower, 
     Charisma
 }

Here is the Vital Class :

 #pragma strict 
 
 public class Vital extends ModifiedStat
 {
     private var _currValue : int;
     
     public function Vital() 
     {
         _currValue = 0;
         SetExpToLevel( 50 );
         SetLevelModifier( 1.1 );
     }
     
     public function GetCurrValue() : int
     {
         if ( _currValue > GetAdjustedBaseValue() )
         {
             _currValue = GetAdjustedBaseValue();
         }
         
         return _currValue;
     }
     
     public function SetCurrValue( theValue : int ) 
     {
         _currValue = theValue;
     }
 }
 
 public enum VitalName
 {
     Health,
     Energy,
     Mana
 }

Here is the Skill Class :

 #pragma strict
 
 public class Skill extends ModifiedStat
 {
     private var _known : boolean;
     
     public function Skill() 
     {
         _known = false;
         SetExpToLevel( 25 );
         SetLevelModifier( 1.1 );
     }
     
     public function GetKnown() : boolean
     {
         return _known;
     }
     
     public function SetKnown( theBool : boolean )
     {
         _known = theBool;
     }
 }
 
 public enum SkillName
 {
     Melee_Offense,
     Melee_Defense,
     Ranged_Offense,
     Ranged_Defense,
     Magic_Offense,
     Magic_Defense
 }

I can also supply my BaseStat and ModifiedStat classes if required. Thanks for reading this far !

---

Edit : and the BaseStat class :

 #pragma strict
 
 public class BaseStat extends MonoBehaviour
 {
 
     private var _baseValue : int; // base value of this stat
     private var _buffValue : int; // buff to add to stat
     private var _expToLevel : int; // exp needed for next level
     private var _levelModifier : float; // modifier applied to exp needed for next level
     
     
     public function BaseStat() 
     {
         _baseValue = 0;
         _buffValue = 0;
         _levelModifier = 1.1;
         _expToLevel = 100;
     }
     
     
     // #region Basic Getters and Setters
     
     public function GetBaseValue() : int
     {
         return _baseValue;
     }
     
     public function SetBaseValue( theValue : int ) 
     {
         _baseValue = theValue;
     }
     
     
     public function GetBuffValue() : int
     {
         return _buffValue;
     }
     
     public function SetBuffValue( theValue : int ) 
     {
         _buffValue = theValue;
     }
     
     
     public function GetExpToLevel() : int
     {
         return _expToLevel;
     }
     
     public function SetExpToLevel( theValue : int ) 
     {
         _expToLevel = theValue;
     }
     
     
     public function GetLevelModifier() : float
     {
         return _levelModifier;
     }
     
     public function SetLevelModifier( theValue : float ) 
     {
         _levelModifier = theValue;
     }
     
     // #endregion
     
     
     private function CalculateExpToLevel() : int
     {
         return parseInt( _expToLevel * _levelModifier );
     }
     
     
     public function LevelUp()
     {
         _expToLevel = CalculateExpToLevel();
         _baseValue ++;
     }
     
     // --
     
     public function GetAdjustedBaseValue() : int
     {
         return _baseValue + _buffValue;
     }
     
     public function SetAdjustedBaseValue()
     {
         
     }
 
 }

 _primaryAttribute = new Attribute[ System.Enum.GetValues( AttributeName ).Length ];