Exemple #1
0
        private void AddUnitToDeck(WargameUnit selectedUnit, Deck deck)
        {
            byte veterancy = (byte)selectedUnit.AvailableVeterancy[rnGesus.Next(selectedUnit.AvailableVeterancy.Count)];

            if (selectedUnit.Transports.Count > 0)
            {
                WargameUnit transport = DrawCard(selectedUnit.Transports);
                if (transport.Transports.Count > 0)
                {
                    WargameUnit superTransport = DrawCard(transport.Transports);
                    deck.AddUnit(veterancy, (int)selectedUnit.UnitId, (int)transport.UnitId, (int)superTransport.UnitId);
                }
                else
                {
                    deck.AddUnit(veterancy, (int)selectedUnit.UnitId, (int)transport.UnitId);
                }

                //AddedUnits[transport.UnitId] = AddedUnits[transport.UnitId] + 1;
            }
            else
            {
                deck.AddUnit(veterancy, (int)selectedUnit.UnitId);
            }

            //AddedUnits[selectedUnit.UnitId] = AddedUnits[selectedUnit.UnitId] + 1;
        }
Exemple #2
0
 private bool IsUnitValid(WargameUnit unit, Categories category)
 {
     return(unit.Category == category &&
            (unit.Year >= deckRestrictions[category].MinYear &&
             unit.Year <= deckRestrictions[category].MaxYear ||
             fobRegex.IsMatch(unit.Name)));
 }
Exemple #3
0
        private List <WargameUnit> GetUnits(List <CollectionItemValueHolder> references)
        {
            var units = new List <WargameUnit>();

            instanceIdToUnitId = GetInstanceIdToUnitIdMap(references);
            unitIdToUnit       = new Dictionary <uint, WargameUnit>();
            unitIdToTransports = new Dictionary <uint, List <uint> >();

            unitUpgradeTree = new Dictionary <uint, uint>(); //<unit, next unit>
            BuildUnitUpgradeTree();

            foreach (var reference in references)
            {
                NdfMap map    = (NdfMap)reference.Value;
                var    unit   = GetUnit(map);
                uint   unitId = (uint)((NdfUInt32)map.Key.Value).Value;

                unitIdToTransports[unitId] = GetTransportsIds(unit);
                var        rawCategory = GetCategory(unit);
                Categories category    = categories.ContainsKey(rawCategory) ? categories[rawCategory] : Categories.UNKNOWN;

                var modulesProperty             = unit.PropertyValues.Where(p => p.Property.Name == "Modules").First();
                var modules                     = (NdfCollection)modulesProperty.Value;
                var filteredList                = modules.Where(m => ((NdfStringReference)((NdfString)((NdfMap)m.Value).Key.Value).Value).Value == "TypeUnit").First();
                var tModuleSelector             = ((NdfObjectReference)((MapValueHolder)((NdfMap)filteredList.Value).Value).Value).Instance;
                var defaultProperty             = tModuleSelector.PropertyValues.Where(p => p.Property.Name == "Default").First();
                var typeUnitModuleDescriptor    = ((NdfObjectReference)defaultProperty.Value).Instance;
                var filtersProperty             = typeUnitModuleDescriptor.PropertyValues.Where(p => p.Property.Name == "Filters").First();
                var subCategoryLocalizationHash = "None";
                if (filtersProperty.Value.GetType() == typeof(NdfMapList))
                {
                    subCategoryLocalizationHash = ((NdfCollection)((MapValueHolder)((NdfMap)((NdfMapList)filtersProperty.Value)[0].Value).Value).Value)[0].Value.ToString();
                }

                Subcategories subcategory = subcategories.ContainsKey(subCategoryLocalizationHash) ? subcategories[subCategoryLocalizationHash] : Subcategories.NONE;

                var wUnit = new WargameUnit(unitId, GetNumberOfCards(unit), category, subcategory, GetYear(unit), GetCountry(unit), IsPrototype(unit), IsCommander(unit), GetName(unit));
                wUnit.AvailableVeterancy.AddRange(GetAvailableVeterancy(unit));

                List <Specializations> specs = GetAvailableSpecializations(unit);

                foreach (var spec in specs)
                {
                    wUnit.Specializations.Add(spec);
                }
                units.Add(wUnit);
                unitIdToUnit[unitId] = wUnit;
            }

            foreach (var unit in units)
            {
                foreach (var transportId in unitIdToTransports[unit.UnitId])
                {
                    unit.Transports.Add(unitIdToUnit[transportId]);
                }
            }

            return(units);
        }
Exemple #4
0
 private void RemoveNavalTransports(WargameUnit unit)
 {
     unit.Transports.RemoveAll(t => t.Category == Categories.NAVAL);
     foreach (var transport in unit.Transports)
     {
         RemoveNavalTransports(transport);
     }
 }
Exemple #5
0
        private void CheckCardCount(WargameUnit selectedUnit)
        {
            WargameUnit referenceUnit = unitsAndTransports.Find(unit => unit.UnitId == selectedUnit.UnitId);

            if (AddedUnits[selectedUnit.UnitId] + 1 > referenceUnit.Cards)
            {
                Console.WriteLine("Exceeded.");
            }
        }
Exemple #6
0
        private List <WargameUnit> ShuffleUnits(List <WargameUnit> units)
        {
            List <WargameUnit> shuffledUnits = new List <WargameUnit>(units);

            for (int i = 0; i < 20 * shuffledUnits.Count; i++)
            {
                int         indexA = rnGesus.Next(shuffledUnits.Count);
                int         indexB = rnGesus.Next(shuffledUnits.Count);
                WargameUnit unit   = shuffledUnits[indexA];
                shuffledUnits[indexA] = shuffledUnits[indexB];
                shuffledUnits[indexB] = unit;
            }
            return(shuffledUnits);
        }
Exemple #7
0
 static private void PrintUnits(List <WargameUnit> units, List <uint> unitsInDeck)
 {
     foreach (uint unitId in unitsInDeck)
     {
         WargameUnit wUnit = units.Find(unit => unit.UnitId == unitId);
         if (wUnit != null)
         {
             Console.WriteLine(wUnit.Name + ", " + wUnit.Category.ToString());
         }
         else
         {
             Console.WriteLine(unitId + ": Not found in units...");
         }
     }
 }
Exemple #8
0
 private bool HasNavalTransport(WargameUnit unit)
 {
     foreach (var transport in unit.Transports)
     {
         if (transport.Category == Categories.NAVAL)
         {
             return(true);
         }
         if (HasNavalTransport(transport))
         {
             return(true);
         }
     }
     return(false);
 }
Exemple #9
0
        public WargameUnit DrawCard(List <WargameUnit> availableUnits)
        {
            double totalWeight = availableUnits.Sum(unit => unit.Weight);
            double chosen      = rnGesus.NextDouble() * totalWeight;
            var    enumerator  = availableUnits.GetEnumerator();

            while (chosen > 0 && enumerator.MoveNext())
            {
                chosen -= enumerator.Current.Weight;
            }
            WargameUnit selectedUnit = enumerator.Current;

            //CheckCardCount(selectedUnit);
            selectedUnit.Cards--;
            CleanUpUnitPool();
            return(selectedUnit);
        }
Exemple #10
0
        private void AddFob()
        {
            List <WargameUnit> fobs = unitPool[Categories.LOGISTICS].AvailableUnits.Where(unit => fobRegex.IsMatch(unit.Name)).ToList();

            if (fobs.Count <= 0)
            {
                return;
            }
            WargameUnit fob = DrawCard(fobs);

            if (fob.Cards <= 0)
            {
                unitPool[Categories.LOGISTICS].AvailableUnits.RemoveAll(unit => unit.UnitId == fob.UnitId);
            }
            AddUnitToDeck(fob, deck);
            UpdateDeckCost(Categories.LOGISTICS, costMatrix);
        }
Exemple #11
0
        private void AddCommander()
        {
            List <WargameUnit> commanders = unitPool[Categories.LOGISTICS].AvailableUnits.Where(unit => unit.IsCommander).ToList();

            if (commanders.Count == 0)
            {
                throw new Exception("No command unit available.");
            }
            WargameUnit commander = DrawCard(commanders);

            if (commander.Cards <= 0)
            {
                unitPool[Categories.LOGISTICS].AvailableUnits.RemoveAll(unit => unit.UnitId == commander.UnitId);
            }
            AddUnitToDeck(commander, deck);
            UpdateDeckCost(Categories.LOGISTICS, costMatrix);
        }
Exemple #12
0
 private bool IsTransportValid(WargameUnit transport, Categories category)
 {
     return(transport.Year >= deckRestrictions[category].MinTransportYear &&
            transport.Year <= deckRestrictions[category].MaxTransportYear);
 }
Exemple #13
0
        public Deck GenerateDeck(Deck.DeckType type)
        {
            deck = new Deck(type);
            List <WargameUnit> units = LoadUnits(type);

            units = FilterInvalidUnits(units);
            units = FilterByDeckType(units, type);
            foreach (var unit in units)
            {
                RemoveNavalTransports(unit);
            }
            CategorizeUnitsAndApplyRestrictions(units);

            InitAddedUnits(units);
            InitCardCountChecker(type);

            foreach (var unitPoolCategory in unitPool)
            {
                InitUnitWeights(unitPoolCategory.Value.AvailableUnits);
            }

            int activationPoints = GetActivationPoints(type);

            costMatrix = database.GetCostMatrix();

            UsedActivationPoints = 0;

            AddCommander();
            AddCommander();
            unitPool[Categories.LOGISTICS].AvailableUnits.RemoveAll(unit => unit.IsCommander);

            AddFob();

            while (CanDrawAnotherCard())
            {
                Categories category = ChooseCategory();
                if (unitPool[category].AvailableUnits.Count == 0 || costMatrix[category].Count == 0 || costMatrix[category].First() + UsedActivationPoints > activationPoints)
                {
                    unitPool.Remove(category);
                }
                else
                {
                    WargameUnit selectedUnit = DrawCard(unitPool[category].AvailableUnits);
                    AddUnitToDeck(selectedUnit, deck);
                    UpdateDeckCost(category, costMatrix);
                }
            }

            List <WargameUnit> navalUnits = LoadUnits(type);

            navalUnits = FilterByDeckType(navalUnits, type);
            navalUnits = navalUnits.Where(unit => unit.Cards > 0 &&
                                          unit.AvailableVeterancy.Count > 0 &&
                                          unit.Specializations.Count > 0 &&
                                          unit.Year > 1900 &&
                                          (unit.Category == Categories.NAVAL ||
                                           HasNavalTransport(unit))).ToList();

            InitUnitWeights(navalUnits);

            foreach (var unit in navalUnits)
            {
                unit.Transports.RemoveAll(t => t.Category != Categories.NAVAL && !HasNavalTransport(t));
            }

            while (navalUnits.Count > 0 && costMatrix[Categories.NAVAL].Count > 0)
            {
                WargameUnit navalUnit = DrawCard(navalUnits);
                AddUnitToDeck(navalUnit, deck);
                UpdateDeckCost(Categories.NAVAL, costMatrix);
            }

            return(deck);
        }