view api/Util/UnitEquipmentUtil.cs @ 201:4d7ff70bb109

Re #208: equipmentslot limit issues * Fix numeric slot issues by using "amount taken excluding this item" method * Rename "without this item" to "excluding this item" to clarify purpose * Restructure percentage limits and break some tests (some of which are only broken by rounding errors)
author IBBoard <dev@ibboard.co.uk>
date Thu, 05 Nov 2009 21:09:03 +0000
parents 4bbf5624ced6
children 37ad50823531
line wrap: on
line source

// This file (UnitEquipmentUtil.cs) is a part of the IBBoard.WarFoundry.API project and is copyright 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.Text;
using IBBoard.Limits;
using IBBoard.WarFoundry.API.Objects;

namespace IBBoard.WarFoundry.API.Util
{
	public class UnitEquipmentUtil
	{
		/// <summary>
		/// Gets an array of allowed <see cref="UnitEquipmentItem"/>s based on the current selections of the unit, taking in to account Mutex groups and other limits.
		/// </summary>
		/// <param name="unit">The <see cref="Unit"/> to get equipment items for</param>
		/// <returns>The array of allowed <see cref="UnitEquipmentItem"/>s</returns>
		public static UnitEquipmentItem[] GetAllowedEquipmentItems(Unit unit)
		{
			List<UnitEquipmentItem> list = new List<UnitEquipmentItem>();
			UnitEquipmentItem[] currItems = unit.GetEquipment();

			foreach (UnitEquipmentItem item in GetAllEquipmentItems(unit))
			{
				bool allowed = IsAllowedByMutex(item, currItems);

				if (allowed)
				{
					list.Add(item);
				}
			}

			return list.ToArray();
		}

		private static bool IsAllowedByMutex(UnitEquipmentItem item, UnitEquipmentItem[] currItems)
		{
			bool allowed = true;

			foreach (UnitEquipmentItem currItem in currItems)
			{
				if (ItemsAreMutuallyExclusive(currItem, item))
				{
					allowed = false;
					break;
				}
			}

			return allowed;
		}

		/// <summary>
		/// Gets a list of all <see cref="UnitEquipmentItem"/>s that would stop the unit taking <code>item</code> because of mutex groups.
		/// </summary>
		/// <param name="unit">The unit that wants to take the equipment item</param>
		/// <param name="item">The item to check blocking items for</param>
		/// <returns>a list of all <see cref="UnitEquipmentItem"/>s that would stop the unit taking <code>item</code></returns>
		public static List<UnitEquipmentItem> GetBlockingEquipmentItems(Unit unit, UnitEquipmentItem item)
		{
			List<UnitEquipmentItem> items = new List<UnitEquipmentItem>();
			UnitEquipmentItem[] currItems = unit.GetEquipment();

			foreach (UnitEquipmentItem unitItem in currItems)
			{
				if (ItemsAreMutuallyExclusive(unitItem, item))
				{
					items.Add(unitItem);
				}
			}

			return items;
		}

		public static UnitEquipmentItem[] GetAllEquipmentItems(Unit unit)
		{
			return unit.UnitType.GetEquipmentItems();
		}

		public static bool ItemsAreMutuallyExclusive(UnitEquipmentItem item1, UnitEquipmentItem item2)
		{
			bool areMutex = false;
			string[] item1mutex = item1.MutexGroups;
			string[] item2mutex = item2.MutexGroups;

			foreach (string mutex in item1mutex)
			{
				foreach (string otherMutex in item2mutex)
				{
					if (mutex.Equals(otherMutex))
					{
						areMutex = true;
						goto postLoop;
					}
				}
			}
			postLoop:

			return areMutex;
		}

		public static int GetMaxEquipmentCount (Unit unit, UnitEquipmentItem equip)
		{			
			int unitSize = unit.Size;
			int max = Math.Max(equip.MinLimit.GetLimit(unitSize), equip.MaxLimit.GetLimit (unitSize));
			return GetEquipmentCountLimit (unit, max, equip);
		}

		private static int GetEquipmentCountLimit (Unit unit, int currLimit, UnitEquipmentItem equip)
		{
			int newLimit = currLimit;
			AbstractLimit limit = GetSlotLimitForItem(unit, equip);
			
			if (!(limit is UnlimitedLimit))
			{
				int slotMax = limit.GetLimit (unit.Size) - unit.GetEquipmentAmountInSlotExcludingItem(equip);
				newLimit = Math.Min (slotMax, newLimit);
			}
			
			return newLimit;
		}

		private static AbstractLimit GetSlotLimitForItem(Unit unit, UnitEquipmentItem equip)
		{
			return unit.UnitType.GetEquipmentSlotLimit(equip.SlotName);
		}

		
		public static int GetMinEquipmentCount (Unit unit, UnitEquipmentItem equip)
		{			
			int unitSize = unit.Size;
			int min = Math.Min (equip.MinLimit.GetLimit (unitSize), equip.MaxLimit.GetLimit (unitSize));
			return GetEquipmentCountLimit (unit, min, equip);
		}
		
		public static bool IsEquipmentRatioLimited(Unit unit, UnitEquipmentItem equip)
		{
			AbstractLimit limit = GetSlotLimitForItem(unit, equip);
			return equip.IsRatioLimit && (limit is IPercentageLimit || limit is UnlimitedLimit);
		}
		
		public static double GetMaxEquipmentPercentage(Unit unit, UnitEquipmentItem equip)
		{
			double limit = 0;
			AbstractLimit slotLimit = GetSlotLimitForItem(unit, equip);
			
			if (slotLimit is IPercentageLimit)
			{
				limit = ((IPercentageLimit)slotLimit).Percentage;
			}
			else
			{
				limit =  GetPercentageOfUnitSize(slotLimit.GetLimit(unit.Size), unit);
			}
			
			limit = limit - GetPercentageOfUnitSize(unit.GetEquipmentAmountInSlotExcludingItem(equip), unit);
			
			return GetMinOfSlotLimitAndEquipmentLimit(equip.IsRatioLimit, limit, equip.MaxLimit, unit);
		}
		
		private static double GetPercentageOfUnitSize(int number, Unit unit)
		{
			return (number / (double)unit.Size) * 100;
		}
		
		private static double GetMinOfSlotLimitAndEquipmentLimit(bool equipIsRatio, double limit, AbstractLimit equipLimit, Unit unit)
		{
			if (equipIsRatio)
			{
				limit = Math.Min(limit, ((IPercentageLimit)equipLimit).Percentage);
			}
			else
			{
				limit = Math.Min(limit, GetPercentageOfUnitSize(equipLimit.GetLimit(unit.Size), unit));
			}
			
			return limit;
		}
		
		public static double GetMinEquipmentPercentage(Unit unit, UnitEquipmentItem equip)
		{
			double limit = 0;
			AbstractLimit slotLimit = GetSlotLimitForItem(unit, equip);
			
			if (slotLimit is IPercentageLimit)
			{
				limit = ((IPercentageLimit)slotLimit).Percentage;
			}
			else
			{
				limit =  GetPercentageOfUnitSize(slotLimit.GetLimit(unit.Size), unit);
			}
			
			limit = limit - GetPercentageOfUnitSize(unit.GetEquipmentAmountInSlotExcludingItem(equip), unit);
			
			return GetMinOfSlotLimitAndEquipmentLimit(equip.IsRatioLimit, limit, equip.MinLimit, unit);
		}
	}
}