/// <summary>
        /// Compare outputs in text files and SQLite database for given SWAT unit
        /// </summary>
        /// <param name="source">SWAT unit type</param>
        /// <returns>Average R2</returns>
        /// <remarks>
        /// 1. R2 is calculated for each column
        /// 2. A text file would be created on desktop to record R2 for all columns
        /// </remarks>
        public double Compare(UnitType source)
        {
            using(StreamWriter file = new StreamWriter(
                Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.Desktop), source.ToString() + "_" + _extractText.OutputInterval.ToString() + "_validation.txt")))
                {
                    string[] cols = ExtractSWAT_SQLite.GetSQLiteColumns(source);
                    if (cols == null) return -99.0;

                    double mean_R2 = 0;
                    int num_R2 = 0;
                    foreach (string col in cols)
                    {
                        double R2 = Compare(source, col,file);
                        if (R2 > -99)
                        {
                            mean_R2 += R2;
                            num_R2 += 1;
                        }
                    }

                    if (num_R2 > 0)
                        return mean_R2 / num_R2;
                    return -99.0;
                }
        }

 public BirdModel(UnitType type, double maxJumpSpeed, double minJumpFactor)
     : base(type)
 {
     JumpSpeed = maxJumpSpeed;
     MinJumpFactor = minJumpFactor;
     Position = new Vector { X = 0, Y = 0 };
 }

 /// <summary>Creates a new <see cref="Unit"/> instance.
 /// </summary>
 /// <param name="type">Type.</param>
 /// <param name="power">Power.</param>
 /// <param name="location">Location.</param>
 public Unit(UnitType type, Power power, Location location)
 {
     this.type = type;
     this.power = power;
     this.location = location;
     this.retreatLocations = new LocationCollection();
 }

 public UnitType GetHallucination(UnitType t)
 {
     switch (t)
     {
         case UnitType.Probe:
             return UnitType.ProbeHallucination;
         case UnitType.Zealot:
             return UnitType.ZealotHallucination;
         case UnitType.Stalker:
             return UnitType.StalkerHallucination;
         case UnitType.HighTemplar:
             return UnitType.HighTemplarHallucination;
         case UnitType.Archon:
             return UnitType.ArchonHallucination;
         case UnitType.Immortal:
             return UnitType.ImmortalHallucination;
         case UnitType.WarpPrism:
             return UnitType.WarpPrismHallucination;
         case UnitType.WarpPrismPhasing:
             return UnitType.WarpPrismPhasingHallucination;
         case UnitType.Colossus:
             return UnitType.ColossusHallucination;
         case UnitType.Phoenix:
             return UnitType.PhoenixHallucination;
         case UnitType.VoidRay:
             return UnitType.VoidRayHallucination;
         default:
             return UnitType.Unknown; // Could throw, but it doesn't break the parser.
     }
 }

 /// <devdoc>
 /// <para> Initializes a new instance of the <see cref='System.Web.UI.WebControls.Unit'/> structure with the 
 ///    specified double-precision
 ///    floating point number as the unit value and <see langword='Pixel'/>
 ///    as the (default) unit type.</para>
 /// </devdoc>
 public Unit(double value) {
     if ((value < MinValue) || (value > MaxValue)) {
         throw new ArgumentOutOfRangeException("value");
     }
     this.value = (int)value;
     this.type = UnitType.Pixel;
 }

 /// <summary>
 /// Sets the primitive value to the given number.
 /// </summary>
 /// <param name="unitType">The unit of the number.</param>
 /// <param name="value">The value of the number.</param>
 /// <returns>The CSS primitive value instance.</returns>
 public CSSPrimitiveValue SetFloatValue(UnitType unitType, Single value)
 {
     _text = value.ToString(CultureInfo.InvariantCulture) + ConvertUnitTypeToString(unitType);
     unit = unitType;
     data = value;
     return this;
 }

 internal CSSPrimitiveValue(HtmlColor value)
 {
     _text = value.ToCss();
     _type = CssValueType.PrimitiveValue;
     unit = UnitType.Rgbcolor;
     data = value;
 }

 public void buyUnit(UnitType unitType_)
 {
     Unit newUnit = new Unit(unitType_, _players[_currentPlayerIndex]._race);
     //map.placeNewUnit(_players[currentPlayerIndex],newUnit); //beállítja a pozíciót a unitnál-is!!!!!
     _players[_currentPlayerIndex]._units.Add(newUnit);
     _players[_currentPlayerIndex]._money -= newUnit._stats._price;
 }

 public Unit(int value)
 {
     if (value < -32768 || value > 0x7fff)
         throw new ArgumentOutOfRangeException("value");
     _value = value;
     _type = UnitType.Pixel;
 }

        public void DrawUnit(HexTilePosition pos, UnitType type)
        {
            Vector3 mapPos = RenderHex.HexPositionToMapPosition(pos);
            render.PushWorldMatrix(Matrix.CreateTranslation(mapPos));

            switch (type)
            {
                case UnitType.Unknown:
                    DrawUnknown();
                    break;

                case UnitType.Infantry:
                    DrawInfantry();
                    break;

                case UnitType.Armor:
                    DrawArmor();
                    break;

                case UnitType.Artillery:
                    DrawArtillery();
                    break;

                default:
                    DrawInvalid();
                    break;
            }

            render.PopWorldMatrix();
        }

    public int GetUnitCountByType(UnitType type)
    {
        if(!mUnitsByType.ContainsKey(type))
            return 0;

        return mUnitsByType[type].Count;
    }

 public ArmyStructure(CityType requiredCityType, decimal buildCost, int capacity, UnitType unitType)
 {
     this.RequiredCityType = requiredCityType;
     this.BuildCost = buildCost;
     this.Capacity = capacity;
     this.UnitType = unitType;
 }

    //constructor
    public static Unit CreateComponent( UnitType unitType, Tile location, Village v, GameObject PeasantPrefab )
    {
        Tile toplace = null;
        foreach (Tile a in location.getNeighbours())
        {
            if(a.prefab == null && a.getOccupyingUnit() == null && a.getColor() == location.getColor())
            {
                toplace = a;
            }
        }
        if(toplace == null)
        {
            toplace = location;
        }
        GameObject o = Instantiate(PeasantPrefab, new Vector3(toplace.point.x, 0.15f, toplace.point.y), toplace.transform.rotation) as GameObject;
        Unit theUnit = o.AddComponent<Unit>();
        theUnit.locatedAt = toplace;

        theUnit.myType = unitType;
        theUnit.myVillage = v;
        theUnit.myAction = UnitActionType.ReadyForOrders;

        location.setOccupyingUnit (theUnit);
        return theUnit;
    }

 protected AbstractStructure(CityType requiredCityType, decimal buildCost, int capacity, UnitType unitType)
 {
     RequiredCityType = requiredCityType;
     BuildCost = buildCost;
     Capacity = capacity;
     UnitType = unitType;
 }

 /// <summary>
 /// Create a new FieldData object
 /// </summary>
 /// <param name="name">The name of the field</param>
 /// <param name="typeIn">The AssemblyQualifiedName of the Field's data type</param>
 /// <param name="unit">The unit type of the Field (set to UT_Undefined for non-floating point types</param>
 /// <param name="subSchema">The SchemaWrapper of the field's subSchema, if the field is of type "Entity"</param>
 public FieldData(string name, string typeIn, UnitType unit, SchemaWrapper subSchema)
 {
     m_Name = name;
      m_Type = typeIn;
      m_Unit = unit;
      m_SubSchema = subSchema;
 }

 public Unit(string unitId, String unitName, UnitType uType, List<string> components)
 {
     this.ID            = unitId;
     this.Name          = unitName;
     this.unitType      = uType;
     this.ComponentSpec = components ?? new List<string>();
 }

 public void UpdatePlayerState(UnitType playerState)
 {
     foreach (NPC npc in Units)
     {
         npc.ToggleSpotted(npc.UnitType == playerState);
     }
 }

        /// <summary>
        /// Validate SQLite results for given unit type and column. Here same column name are assumed for bother
        /// SQLite and regular text file. But some column names have been changed in SQLite results. For these 
        /// columns, a lookup table should be used.
        /// </summary>
        /// <param name="source"></param>
        /// <param name="var"></param>
        /// <returns></returns>
        public double Compare(UnitType source, string var, System.IO.StreamWriter file)
        {
            //System.Diagnostics.Debug.WriteLine("***************" + var.Trim() + "***************");

            int num = getNumberofUnit(source);
            if (source == UnitType.RSV) num = getNumberofUnit(UnitType.SUB);
            if (num == -1) return -99.0;

            double mean_R2 = 0;
            int num_R2 = 0;

            for (int i = 1; i <= num; i++)
            {
                double R2 = Compare(_startYear, _endYear, source, i, var);
                if (R2 > -99)
                {
                    mean_R2 += R2;
                    num_R2 += 1;
                    System.Diagnostics.Debug.WriteLine(string.Format("{0}-{1}-{2},{3:F4}", source, i, var.Trim(), R2));
                    file.WriteLine(string.Format("{0},{1},{2},{3:F4}", source, i, var.Trim(), R2));
                }
                else
                {
                    System.Diagnostics.Debug.WriteLine(string.Format("{0}-{1}-{2},No Record", source, i, var.Trim()));
                    file.WriteLine(string.Format("{0},{1},{2},NoRecord", source, i, var.Trim()));
                }
            }

            if (num_R2 > 0)
                return mean_R2 / num_R2;
            return -99.0;
        }

        public static IUnit Create(UnitType type, string name, int x, int y)
        {
            IUnit unit;

            switch (type)
            {
                case UnitType.IceGiant:
                    unit = new IceGiant(x, y, name, new IceGigantCombatHandler());
                    break;

                case UnitType.Mage:
                    unit = new Mage(x, y, name, new MageCombatHandler());
                    break;

                case UnitType.Warrior:
                    unit = new Warrior(x, y, name, new WarriorCombatHandler());
                    break;

                default:
                    throw new NotImplementedException();
            }

            unit.CombatHandler.Unit = unit;

            return unit;
        }

 public Unit(House owner, UnitType type, bool alive, string name)
 {
     Owner = owner;
     Type = type;
     Alive = alive;
     Name = name;
 }