Mercurial > repos > IBDev-IBBoard.WarFoundry.API
view api/Objects/UnitType.cs @ 256:958ecd7b2844
Re #270: Add multiple categories to API
* Add Categories property
* Add method to add Category
* Tie up Categories with MainCategory for default behaviour
author | IBBoard <dev@ibboard.co.uk> |
---|---|
date | Mon, 17 May 2010 20:03:05 +0000 |
parents | cdda78975be1 |
children | 435eb28b4549 |
line wrap: on
line source
// This file (UnitType.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 2007, 2008, 2009 IBBoard. // // The file and the library/program it is in are licensed and distributed, without warranty, under the GNU Affero GPL license, either version 3 of the License or (at your option) any later version. Please see COPYING for more information and the full license. using System; using System.Collections.Generic; using System.Xml; using IBBoard.Limits; using IBBoard.Logging; using IBBoard.WarFoundry.API.Requirements; namespace IBBoard.WarFoundry.API.Objects { /// <summary> /// A UnitType is a type for a <see cref=" Unit"/>, normally relating to an entry in an army list. The UnitType defines the name, cost, minimum and maximum limits of a unit, and the equipment units of the type can take. /// </summary> public class UnitType : WarFoundryObject { private Category mainCat; private Race race; private int min, max, baseSize = 0; private int minSize, maxSize; private double baseUnitCost; private double costPerTrooper; private Stats stats; private List<UnitRequirement> requirements = new List<UnitRequirement>(); private Dictionary<string, UnitEquipmentItem> equipment = new Dictionary<string, UnitEquipmentItem>(); private Dictionary<string, List<UnitEquipmentItem>> equipmentExclusionGroups = new Dictionary<string, List<UnitEquipmentItem>>(); private List<string> equipmentKeyOrder = new List<string>(); private Dictionary<string, Ability> requiredAbilities = new Dictionary<string, Ability>(); private Dictionary<string, Ability> optionalAbilities = new Dictionary<string, Ability>(); private String notes = ""; private List<UnitType> containedTypes = new List<UnitType>(); private Dictionary<string, string> extraData = new Dictionary<string, string>(); private Dictionary<string, AbstractLimit> slotLimits = new Dictionary<string, AbstractLimit>(); private Dictionary<string, UnitMemberType> unitMemberTypes = new Dictionary<string, UnitMemberType>(); private List<Category> cats = new List<Category>(); public UnitType(string id, string typeName, Race parentRace) : base(id, typeName) { race = parentRace; } [Obsolete("Use three parameter constructor and setters")] public UnitType(string id, string typeName, string mainCategoryID, string[] allCategoryIDs, int minNum, int maxNum, int minimumSize, int maximumSize, double unitCost, double trooperCost, Stats unitStats, UnitRequirement[] unitRequirements, Race parentRace) : this (id, typeName, parentRace) { mainCat = race.GetCategory(mainCategoryID); MinNumber = minNum; MaxNumber = maxNum; MinSize = minimumSize; MaxSize = maximumSize; BaseUnitCost = unitCost; CostPerTrooper = trooperCost; SetUnitStats(unitStats); foreach (UnitRequirement requirement in requirements) { AddRequirement(requirement); } } public GameSystem GameSystem { get { return Race.GameSystem; } } /// <value> /// Gets the <see cref=" Race"/> that this unit belongs to. /// </value> public Race Race { get { return race; } } /// <value> /// Gets or sets the default <see cref=" Category"/> that this unit type is a member of. /// If it is not already in the collection of categories then it will be added. /// </value> public virtual Category MainCategory { get { return mainCat; } set { mainCat = value; AddCategory(value); } } /// <summary> /// Gets the collection of <see cref="Category"/> objects that this UnitType can be a member of /// </summary> public Category[] Categories { get { return cats.ToArray(); } } /// <summary> /// Adds a category to the set of categories that this unit can be taken from. The first category added will automatically become the MainCategory. /// </summary> /// <param name="cat"> /// A <see cref="Category"/> that this unit can be taken from /// </param> public void AddCategory(Category cat) { if (!cats.Contains(cat)) { cats.Add(cat); if (cats.Count == 1) { MainCategory = cat; } } } /// <value> /// Gets or sets the minimum size of each unit of this type. Note: This should be set AFTER MaxSize, otherwise an unintended default value may be set for the minimum /// </value> public int MinSize { get { return minSize; } set { minSize = (value >= 0 ? value : 0); CheckMinimumSize(); } } /// <value> /// Gets or sets the maximum size of each unit of this type. Note: This should be set BEFORE MinSize, otherwise an unintended default value may be set for the minimum /// </value> public int MaxSize { get { return maxSize; } set { maxSize = (value >= 0 ? value : WarFoundryCore.INFINITY); CheckMinimumSize(); } } /// <value> /// Gets or sets the minimum number of units of this type that must be taken in an army. Note: This should be set AFTER MaxNumber, otherwise an unintended default value may be set for the minimum /// </value> public int MinNumber { get { return min; } set { min = (value >= 0 ? value : 0); CheckMinimumNumber(); } } /// <value> /// Gets or sets the maximum number of units of this type that can be taken in an army. Note: This should be set BEFORE MinNumber, otherwise an unintended default value may be set for the minimum /// </value> public int MaxNumber { get { return max; } set { max = (value >= 0 ? value : WarFoundryCore.INFINITY); CheckMinimumNumber(); } } /// <summary> /// Makes sure that the minimum number isn't more than the maximum number, hence the warning on the properties /// </summary> private void CheckMinimumNumber() { if (MinNumber > MaxNumber && MaxNumber!=WarFoundryCore.INFINITY) { MinNumber = MaxNumber; LogNotifier.WarnFormat(GetType(), "Unit type {0} ({1}) had a minimum number greater than their maximum number.", Name, ID); } } /// <summary> /// Makes sure that the minimum unit size isn't more than the maximum unit size, hence the warning on the properties /// </summary> private void CheckMinimumSize() { if (MinSize > MaxSize && MaxSize!=WarFoundryCore.INFINITY) { MinSize = MaxSize; LogNotifier.WarnFormat(GetType(), "Unit type {0} ({1}) had a minimum size greater than their maximum size.", Name, ID); } } //// <value> /// Gets or sets the "base size" of a unit, which is the number of troopers the unit has in it for its "base cost". For a lot of units this value will be 0 as the cost is worked out based on the total number of members. /// </value> public int BaseSize { get { return baseSize; } set { baseSize = (value >= 0 ? value : 0); } } /// <value> /// The number of points that a "base unit" of <code>BaseSize</code> models costs. Additional models are charged at <code>CostPerTrooper</code> each. /// </value> public double BaseUnitCost { get { return baseUnitCost; } set { baseUnitCost = (value >= 0 ? value : 0); } } //// <value> /// The cost of an individual trooper. This value is the cost for a basic trooper without weapons, which are added on top of the cost before calculating a unit cost. /// </value> public double CostPerTrooper { get { return costPerTrooper; } set { costPerTrooper = (value >= 0 ? value : 0); } } protected override string DefaultName() { throw new InvalidOperationException("Unit type with id "+id+" did not have a name specified"); } /// <value> /// The first of the <see cref="Stat"/>s lines for the unit. /// </value> [Obsolete("Use UnitStatsArrays instead")] public Stat[] UnitStatsArray { get { return UnitStatsArrays[0]; } } //// <value> /// The first ot the <see cref="Stat"/>s lines for the unit including an additional column that contains the unit type name /// </value> [Obsolete("Use UnitStatsArrays instead")] public Stat[] UnitStatsArrayWithName { get { return UnitStatsArraysWithName[0]; } } /// <value> /// The array of <see cref="Stat"/>s for each of the unit's stat lines /// </value> public Stat[][] UnitStatsArrays { get { Stat[][] statsArray; if (stats != null) { statsArray = new Stat[][]{ stats.StatsArray }; } else if (unitMemberTypes.Count > 0) { int memTypeCount = unitMemberTypes.Count; statsArray = new Stat[memTypeCount][]; int i = 0; foreach (UnitMemberType memType in unitMemberTypes.Values) { statsArray[i] = memType.StatsArray; i++; } } else { SystemStats systemStats = GameSystem.StandardSystemStats; Stats tempStats = new Stats(systemStats); statsArray = new Stat[][]{ tempStats.StatsArray }; } return statsArray; } } public string[] UnitStatsArrayIDs { get { string[] ids; if (stats != null) { ids = new string[]{ stats.StatsID }; } else if (unitMemberTypes.Count > 0) { ids = new string[unitMemberTypes.Count]; int i = 0; foreach (UnitMemberType memType in unitMemberTypes.Values) { ids[i] = memType.StatsID; i++; } } else { ids = new string[]{ GameSystem.StandardSystemStatsID }; } return ids; } } //// <value> /// The array of <see cref="Stat"/>s for each of the unit's stat lines including an additional column that contains the unit type name /// </value> public Stat[][] UnitStatsArraysWithName { get { Stat[][] statsArray; if (stats != null) { statsArray = new Stat[][]{ ExtendStatsArrayWithName(stats.StatsArray) }; } else if (unitMemberTypes.Count > 0) { int memTypeCount = unitMemberTypes.Count; statsArray = new Stat[memTypeCount][]; int i = 0; foreach (UnitMemberType memType in unitMemberTypes.Values) { statsArray[i] = memType.StatsArrayWithName; i++; } } else { SystemStats systemStats = GameSystem.StandardSystemStats; Stats tempStats = new Stats(systemStats); statsArray = new Stat[][]{ ExtendStatsArrayWithName(tempStats.StatsArray) }; } return statsArray; } } public Stat[] ExtendStatsArrayWithName(Stat[] statsArray) { Stat[] extendedStats = new Stat[statsArray.Length+1]; extendedStats[0] = new Stat(new StatSlot("name"), Name); statsArray.CopyTo(extendedStats, 1); return extendedStats; } public void SetUnitStats(Stats newStats) { stats = newStats; } public string GetStatValue(string statName) { return stats.GetStatValue(statName.ToLower()); } internal void AddEquipmentItem(UnitEquipmentItem item) { if (!equipment.ContainsKey(item.ID)) { equipment.Add(item.ID, item); equipmentKeyOrder.Add(item.ID); AddToMutexGroups(item); } } private void AddToMutexGroups(UnitEquipmentItem item) { string[] mutexGroups = item.MutexGroups; foreach (string mutexGroup in mutexGroups) { List<UnitEquipmentItem> items = DictionaryUtils.GetValue(equipmentExclusionGroups, mutexGroup); if (items == null) { items = new List<UnitEquipmentItem>(); equipmentExclusionGroups.Add(mutexGroup, items); } items.Add(item); } } /// <summary> /// Gets a <see cref="UnitEquipmentItem"/> for the given ID string, or <code>null</code> if nothing exists for that ID /// </summary> /// <param name="id"> /// The ID of the UnitEquipmentItem to get /// </param> /// <returns> /// The <see cref="UnitEquipmentItem"/> for the given ID string, or <code>null</code> if nothing exists for that ID /// </returns> public UnitEquipmentItem GetEquipmentItem(string id) { return DictionaryUtils.GetValue(equipment, id); } /// <summary> /// Gets a <see cref=" UnitEquipmentItem"/> for the given <see cref=" EquipmentItem"/>, or <code>null</code> if the unit can't take that <code>EquipmentItem</code> /// </summary> /// <param name="item"> /// The <see cref="EquipmentItem"/> to get the <see cref=" UnitEquipmentItem"/> /// </param> /// <returns> /// The <see cref="UnitEquipmentItem"/> that definies the UnitType's restrictions for taking the <see cref=" EquipmentItem"/> /// </returns> public UnitEquipmentItem GetEquipmentItem(EquipmentItem item) { return GetEquipmentItem(item.ID); } /// <summary> /// Gets an array of all available <see cref="UnitEquipmentItem"/>s for this UnitType /// </summary> /// <returns> /// An array of all available <see cref="UnitEquipmentItem"/>s for this UnitType /// </returns> public UnitEquipmentItem[] GetEquipmentItems() { return DictionaryUtils.ToArray<string, UnitEquipmentItem>(equipment); } public UnitEquipmentItem[] GetEquipmentItemsByExclusionGroup(string group) { return GetEquipmentItemsByExclusionGroups(new string[] { group }); } public UnitEquipmentItem[] GetEquipmentItemsByExclusionGroups(string[] groups) { List<UnitEquipmentItem> list = new List<UnitEquipmentItem>(); foreach (string group in groups) { List<UnitEquipmentItem> groupList = DictionaryUtils.GetValue(equipmentExclusionGroups, group); if (groupList != null) { list.AddRange(groupList); } } return list.ToArray(); } public bool IsRatioLimitedEquipmentItem(EquipmentItem item) { UnitEquipmentItem equip = GetEquipmentItem(item); return equip != null && equip.IsRatioLimit; } public bool IsAbsoluteLimitedEquipmentItem(EquipmentItem item) { UnitEquipmentItem equip = GetEquipmentItem(item); return equip != null && !equip.IsRatioLimit; } public ICollection<Ability> GetRequiredAbilities() { return requiredAbilities.Values; } public ICollection<Ability> GetOptionalAbilities() { return optionalAbilities.Values; } public void AddAbility(Ability ability, bool isRequired) { string id = ability.ID; if (!requiredAbilities.ContainsKey(id) && !optionalAbilities.ContainsKey(id)) { if (isRequired) { requiredAbilities[id] = ability; } else { optionalAbilities[id] = ability; } } } public void AddRequirement(UnitRequirement requirement) { requirements.Add(requirement); } public UnitRequirement[] Requirements { get { return requirements.ToArray(); } } public List<FailedUnitRequirement> CanAddToArmy(Army army) { List<FailedUnitRequirement> failures = new List<FailedUnitRequirement>(); if (requirements!=null && requirements.Count > 0) { foreach (UnitRequirement requirement in requirements) { FailedUnitRequirement failure = (FailedUnitRequirement)requirement.CanAddToWarFoundryObject(army); if (failure!=null) { failures.Add(failure); } } } return failures; } public List<FailedUnitRequirement> CanRemoveFromArmy(Army army) { List<FailedUnitRequirement> failures = new List<FailedUnitRequirement>(); if (requirements!=null && requirements.Count > 0) { foreach (UnitRequirement requirement in requirements) { FailedUnitRequirement failure = (FailedUnitRequirement)requirement.CanRemoveFromWarFoundryObject(army); if (failure!=null) { failures.Add(failure); } } } return failures; } public string Notes { get { return notes; } set { notes = value; } } public bool CanContainUnit(Unit unit) { return CanContainUnitType(unit.UnitType); } public bool CanContainUnitType(UnitType unitType) { return containedTypes.Contains(unitType); } public UnitType[] ContainedUnitTypes { get { return containedTypes.ToArray(); } } public void AddContainedUnitType(UnitType containedType) { containedTypes.Add(containedType); } public void AddExtraData(string id, string data) { extraData[id] = data; } public string GetExtraData(string id) { return DictionaryUtils.GetValue(extraData, id); } public string StatsID { get { return stats.StatsID; } } public void AddEquipmentSlot(string slotName, AbstractLimit slotLimit) { slotLimits.Add(slotName, slotLimit); } public bool HasEquipmentSlot(string slotName) { return slotLimits.ContainsKey(slotName); } /// <summary> /// Gets the maximum limit on the number of items allowed in a single slot /// </summary> /// <param name="slotName">The name of the equipment slot to get the limit for</param> /// <returns>The limit of the number of items allowed in a slot, or an infinite limit if the slot is the default one or has not been specified</returns> public AbstractLimit GetEquipmentSlotLimit(string slotName) { AbstractLimit slotLimit = null; if (HasEquipmentSlot(slotName)) { slotLimit = DictionaryUtils.GetValue(slotLimits, slotName); } if (slotLimit == null) { slotLimit = new UnlimitedLimit(); } return slotLimit; } public void AddUnitMemberType(UnitMemberType unitMemberType) { unitMemberTypes.Add(unitMemberType.ID, unitMemberType); } } }