Beispiel #1
0
    public void UnitType_EqualityTest154()
    {
        UnitType expected = unitPro.UnitTypes ["Length"];
        UnitType target   = null;

        Assert.IsFalse(expected.Equals((object)target));
    }
Beispiel #2
0
    public void UnitType_EqualityTest11()
    {
        UnitType expected = unitPro.UnitTypes ["Length"];
        UnitType target   = unitPro.UnitTypes ["Mass"];

        Assert.IsFalse(expected.Equals(target));
    }
Beispiel #3
0
        private static void CheckTypes(UnitOfMeasure uom1, UnitOfMeasure uom2)
        {
            UnitType thisType   = uom1.UOMType;
            UnitType targetType = uom2.UOMType;

            if (thisType != UnitType.UNCLASSIFIED && targetType != UnitType.UNCLASSIFIED && !thisType.Equals(UnitType.UNITY) &&
                !targetType.Equals(UnitType.UNITY) && !thisType.Equals(targetType))
            {
                string msg = String.Format(MeasurementSystem.GetMessage("must.be.same.as"), uom1, uom1.UOMType,
                                           uom2, uom2.UOMType);
                throw new Exception(msg);
            }
        }
Beispiel #4
0
 private void Update()
 {
     if (currentHp <= 0 & status != UnitStatus.UNACTIVE)
     {
         if (type.Equals(UnitType.MONSTER))
         {
             Destroy(this.gameObject);
             Destroy(this);
         }
         else
         {
             currentHp   = 0;
             this.status = UnitStatus.UNACTIVE;
         }
     }
 }
Beispiel #5
0
    private Unit Select(List <Unit> units)
    {
        float minDistance = (units[0].transform.position - transform.position).sqrMagnitude;
        Unit  target      = units[0];

        foreach (var unit in units)
        {
            float unitDistanceToTower = (unit.transform.position - transform.position).sqrMagnitude;
            if (unitDistanceToTower <= minDistance && _targetType.Equals(unit.Type))
            {
                minDistance = unitDistanceToTower;
                target      = unit;
            }
        }

        return(target);
    }
Beispiel #6
0
    //
    // Equals & Hashcode
    //

    public override bool Equals(object o)
    {
        Unit unit = o as Unit;

        if (unit == null)
        {
            return(false);
        }
        if (!coordinates.Equals(unit.coordinates))
        {
            return(false);
        }
        if (!type.Equals(unit.type))
        {
            return(false);
        }
        return(true);
    }
Beispiel #7
0
        /// <summary>Get the factor to convert to the unit of measure</summary>
        ///
        /// <param name="targetUOM">Target unit of measure</param>
        ///
        /// <returns> conversion factor</returns>
        ///
        public double GetConversionFactor(UnitOfMeasure targetUOM)
        {
            if (targetUOM == null)
            {
                throw new Exception(MeasurementSystem.GetMessage("unit.cannot.be.null"));
            }

            // first check the cache
            if (ConversionRegistry.TryGetValue(targetUOM, out double cachedFactor))
            {
                return(cachedFactor);
            }

            CheckTypes(this, targetUOM);

            Reducer fromPowerMap = GetReducer();
            Reducer toPowerMap   = targetUOM.GetReducer();

            Dictionary <UnitOfMeasure, int> fromMap = fromPowerMap.Terms;
            Dictionary <UnitOfMeasure, int> toMap   = toPowerMap.Terms;

            if (fromMap.Count != toMap.Count)
            {
                string msg = String.Format(MeasurementSystem.GetMessage("incompatible.units"), this, targetUOM);
                throw new Exception(msg);
            }

            double fromFactor = fromPowerMap.MapScalingFactor;
            double toFactor   = toPowerMap.MapScalingFactor;

            double factor = 1;

            // compute map factor
            int matchCount = 0;

            foreach (KeyValuePair <UnitOfMeasure, int> fromEntry in fromMap)
            {
                UnitType      fromType  = fromEntry.Key.UOMType;
                UnitOfMeasure fromUOM   = fromEntry.Key;
                int           fromPower = fromEntry.Value;

                foreach (KeyValuePair <UnitOfMeasure, int> toEntry in toMap)
                {
                    UnitType toType = toEntry.Key.UOMType;

                    if (fromType.Equals(toType))
                    {
                        matchCount++;
                        UnitOfMeasure toUOM = toEntry.Key;
                        double        bd    = fromUOM.ConvertScalarToScalar(toUOM);
                        bd     = Math.Pow(bd, fromPower);
                        factor = factor * bd;
                        break;
                    }
                }         // to map
            }             // from map

            if (matchCount != fromMap.Count)
            {
                string msg = String.Format(MeasurementSystem.GetMessage("incompatible.units"), this, targetUOM);
                throw new Exception(msg);
            }

            cachedFactor = factor * (fromFactor / toFactor);

            // cache it
            ConversionRegistry[targetUOM] = cachedFactor;

            return(cachedFactor);
        }
Beispiel #8
0
        /// <summary>
        /// If the unit of measure is unclassified, from its base unit map find a matching unit type.
        /// </summary>
        /// <returns>Unit of measure</returns>
        public UnitOfMeasure Classify()
        {
            if (!UOMType.Equals(UnitType.UNCLASSIFIED))
            {
                // already classified
                return(this);
            }

            // base unit map
            Dictionary <UnitOfMeasure, int> uomBaseMap = GetReducer().Terms;

            // try to find this map in the unit types
            UnitType matchedType = UnitType.UNCLASSIFIED;

            foreach (UnitType unitType in UnitType.GetValues(typeof(UnitType)))
            {
                ConcurrentDictionary <UnitType, int> unitTypeMap = MeasurementSystem.GetSystem().GetTypeMap(unitType);

                if (unitTypeMap.Count != uomBaseMap.Count)
                {
                    // not a match
                    continue;
                }

                Boolean match = true;

                // same size, now check base unit types and exponents
                foreach (KeyValuePair <UnitOfMeasure, int> kvp in uomBaseMap)
                {
                    UnitType uomBaseType     = kvp.Key.UOMType;
                    int      uomBaseExponent = kvp.Value;

                    if (unitTypeMap.TryGetValue(uomBaseType, out int unitExponent))
                    {
                        // value is in map, check exponents
                        if (unitExponent != uomBaseExponent)
                        {
                            // not a match
                            match = false;
                            break;
                        }
                    }
                    else
                    {
                        // value not in map
                        match = false;
                        break;
                    }
                }

                if (match)
                {
                    matchedType = unitType;
                    break;
                }
            }

            if (!matchedType.Equals(UnitType.UNCLASSIFIED))
            {
                this.UOMType = matchedType;
            }

            return(this);
        }
Beispiel #9
0
    public void UpdateEveryFields()
    {
        GameObject tmpShit = (GameObject)AssetDatabase.LoadAssetAtPath(search_results[indexGO], typeof(GameObject));

        if (unitType.Equals(UnitType.AttackingUnit))
        {
            AttackingUnit unit = tmpShit.GetComponent <AttackingUnit>();

            nameUnit        = unit.NameGo;
            unitType        = unit.UnitType;
            defaultMaterial = unit.DefaultMaterial;
            //GameObject tmpSkin = new GameObject();
            //tmpSkin.AddComponent<MeshFilter>();
            //tmpSkin.GetComponent<MeshFilter>().mesh = unit.GetComponent<MeshFilter>().mesh;
            //skin = tmpSkin;
            //DestroyImmediate(tmpSkin);
            //skin
            regenManaPerSecond = unit.RegenManaPerSecond;
            healthMax          = unit.HealthMax;
            manaMax            = unit.ManaMax;
            cost    = unit.Cost;
            xpValue = unit.XpValue;

            bool inventoryEmpty = true;
            for (int i = 0; i < unit.Inventory.Length; i++)
            {
                if (unit.Inventory[i] != null)
                {
                    inventoryEmpty = false;
                }
            }

            if (!inventoryEmpty)
            {
                for (int i = 0; i < unit.Inventory.Length; i++)
                {
                    inventory[i] = unit.Inventory[i];
                }
            }

            creationTime         = unit.CreationTime;
            attackSpeed          = unit.AttackSpeed;
            damage               = unit.Damage;
            range                = unit.Range;
            defense              = unit.Defense;
            rangeAggroWhenAttack = unit.RangeAggroWhenAttack;
            moveSpeed            = unit.MoveSpeed;
        }
        else if (unitType.Equals(UnitType.Building))
        {
            CreationBuilding unit = tmpShit.GetComponent <CreationBuilding>();

            nameUnit        = unit.NameGo;
            unitType        = unit.UnitType;
            defaultMaterial = unit.DefaultMaterial;
            healthMax       = unit.HealthMax;
            manaMax         = unit.ManaMax;
            cost            = unit.Cost;
            xpValue         = unit.XpValue;
            creation        = unit.Creations[0];
            //bool creationsEmpties = true;
            //for (int i = 0; i < unit.Creations.Length; i++)
            //{
            //    if (unit.Creations[i] != null)
            //        creationsEmpties = false;
            //}
            //if (!creationsEmpties)
            //{
            //    for (int i = 0; i < unit.Creations.Length; i++)
            //    {
            //        if (unit.Creations[i] != null)
            //            creations[i] = unit.Creations[i];
            //    }
            //}
        }
    }
Beispiel #10
0
        public bool Equals(DestinyHistoricalStatsDefinition input)
        {
            if (input == null)
            {
                return(false);
            }

            return
                ((
                     StatId == input.StatId ||
                     (StatId != null && StatId.Equals(input.StatId))
                     ) &&
                 (
                     Group == input.Group ||
                     (Group != null && Group.Equals(input.Group))
                 ) &&
                 (
                     PeriodTypes == input.PeriodTypes ||
                     (PeriodTypes != null && PeriodTypes.SequenceEqual(input.PeriodTypes))
                 ) &&
                 (
                     Modes == input.Modes ||
                     (Modes != null && Modes.SequenceEqual(input.Modes))
                 ) &&
                 (
                     Category == input.Category ||
                     (Category != null && Category.Equals(input.Category))
                 ) &&
                 (
                     StatName == input.StatName ||
                     (StatName != null && StatName.Equals(input.StatName))
                 ) &&
                 (
                     StatNameAbbr == input.StatNameAbbr ||
                     (StatNameAbbr != null && StatNameAbbr.Equals(input.StatNameAbbr))
                 ) &&
                 (
                     StatDescription == input.StatDescription ||
                     (StatDescription != null && StatDescription.Equals(input.StatDescription))
                 ) &&
                 (
                     UnitType == input.UnitType ||
                     (UnitType != null && UnitType.Equals(input.UnitType))
                 ) &&
                 (
                     IconImage == input.IconImage ||
                     (IconImage != null && IconImage.Equals(input.IconImage))
                 ) &&
                 (
                     MergeMethod == input.MergeMethod ||
                     (MergeMethod.Equals(input.MergeMethod))
                 ) &&
                 (
                     UnitLabel == input.UnitLabel ||
                     (UnitLabel != null && UnitLabel.Equals(input.UnitLabel))
                 ) &&
                 (
                     Weight == input.Weight ||
                     (Weight.Equals(input.Weight))
                 ) &&
                 (
                     MedalTierHash == input.MedalTierHash ||
                     (MedalTierHash.Equals(input.MedalTierHash))
                 ));
        }
        /// <summary>
        /// Unit Conversion Method.
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public double Conversion(UnitType type)
        {
            if (type.Equals(UnitType.FEET))
            {
                return(1.0 * 12.0);
            }

            if (type.Equals(UnitType.YARD))
            {
                return(1.0 * 36.0);
            }

            if (type.Equals(UnitType.CENTIMETER))
            {
                return(1.0 / 2.5);
            }

            if (type.Equals(UnitType.GALLON))
            {
                return(1.0 * 3.785);
            }

            if (type.Equals(UnitType.LITRE))
            {
                return(1.0);
            }

            if (type.Equals(UnitType.MILLILITRE))
            {
                return(1.0 / 1000.0);
            }

            if (type.Equals(UnitType.KILOGRAM))
            {
                return(1.0);
            }

            if (type.Equals(UnitType.GRAM))
            {
                return(1.0 / 1000.0);
            }

            if (type.Equals(UnitType.TONNE))
            {
                return(1.0 * 1000.0);
            }

            if (type.Equals(UnitType.CELSIUS))
            {
                return(1.8);
            }

            if (type.Equals(UnitType.FAHRENHEIT))
            {
                return(1.0);
            }
            else
            {
                return(1.0);
            }
        }