private void ProcessBattle(IUnit currentUnit, IEnumerable<IUnit> targets, IList<IUnit> killedUnits)
{
foreach (var target in targets)
{
var attack = currentUnit.CombatHandler.GenerateAttack();
int healthDamage = attack.Damage - target.DefensePoints;
if (healthDamage > 0)
{
target.HealthPoints -= healthDamage;
this.Engine.OutputWriter.Write(string.Format(
"{0} cast {1} on {2} for {3} damage",
currentUnit.Name,
attack.GetType().Name,
target.Name,
healthDamage));
if (target.HealthPoints < 0)
{
target.HealthPoints = 0;
this.Engine.OutputWriter.Write(string.Format(
"{0} has killed {1}",
currentUnit.Name,
target.Name));
killedUnits.Add(target);
}
}
}
}
public override IEnumerable<IUnitConversion<double>> GetConversionsTo(IUnit to)
{
Contract.Ensures(Contract.Result<IEnumerable<IUnitConversion<double>>>() != null);
return AreUnitsMatching(_singleUnit, to)
? new[] { new UnitUnityConversion(_singleUnit, to) }
: Enumerable.Empty<IUnitConversion<double>>();
}
public override int Attack(IUnit enemy)
{
int r = 0;
if ((Unit.LifePoints > 0) && (enemy.LifePoints > 0))
{
Print("\n" + Unit.Name + " --> попадание", 0);
if (Hit(enemy) != 0)
{
Print(" --> ранение ", 0);
if (Wound(enemy) != 0)
{
Print(" --> броня ", 0);
if (NotAs(Unit) != 0)
{
if (enemy.Ward != 0)
{
Print(" --> особая защита ", 0);
}
if (not_ward(enemy) != 0)
{
Print(" --> " + enemy.Name + " РАНЕН", 2);
r = 1;
}
}
}
}
if (r == 0)
{
Print(" --> не получилось", 1);
}
}
return r;
}
public void MoveUnit(int x, int y, IUnit glad)
{
if (IsOutOfBounds(x, y))
{
Text.WriteLine("");
Text.ColorWriteLine("Cant move there!", ConsoleColor.DarkRed);
Thread.Sleep(2000);
return;
}
var unitOnTile = GetTile(x, y);
if (unitOnTile == null)
{
_map[glad.CurrentTile.x, glad.CurrentTile.y] = null;
glad.CurrentTile.y = y;
glad.CurrentTile.x = x;
_map[x, y] = (Tile)glad.CurrentTile;
return;
}
IUnit target = GetTile(x, y).OccupyingUnit;
(glad as Gladiator).Target = target;
Program.GameState = GameState.Interacting;
}
protected int Hit(IUnit enemy)
{
int r = 0;
if (Unit.Param.Contains("A"))
{
r = 1;
Print("(автопопадание)", 0);
}
else
{
if (Unit.WeaponSkill == enemy.WeaponSkill)
{
if (check_k("ws", Unit.Param, 4, 1) != 0) { r = 1; }
}
if (Unit.WeaponSkill > enemy.WeaponSkill)
{
if (check_k("ws", Unit.Param, 3, 1) != 0) { r = 1; }
}
if (Unit.WeaponSkill < enemy.WeaponSkill)
{
if ((Unit.WeaponSkill * 2) < enemy.WeaponSkill)
{
if (check_k("ws", Unit.Param, 5, 1) != 0) { r = 1; }
}
else
{
if (check_k("ws", Unit.Param, 4, 1) != 0) { r = 1; }
}
}
}
return r;
}
public void Select(IUnit unit)
{
if(SelectedUnit == unit)
return;
SelectedUnit = unit;
FireUnitEvent(unit, SelectedUnitChanged);
}
public Intracommunicator localComm(IUnit caller)
{
Intracommunicator _localComm;
//_localComm = (Intracommunicator)Communicator.world.Create(Communicator.world.Group.IncludeOnly(caller.Ranks));
_localComm = (Intracommunicator)this.WorldComm.Create(this.WorldComm.Group.IncludeOnly(caller.Ranks));
return _localComm;
}
/// <summary>
/// Получить пропись числа с согласованной единицей измерения.
/// </summary>
/// <param name="decimalDigit"> CDigit должно быть целым, неотрицательным. </param>
/// <param name="unit"></param>
/// <param name="result"> Сюда записывается результат. </param>
/// <returns> <paramref name="result"/> </returns>
/// <exception cref="ArgumentException">
/// Если decimalDigit меньше нуля или не целое.
/// </exception>
public static StringBuilder ConvertToString(decimal decimalDigit, IUnit unit, StringBuilder result)
{
string error = CheckDigit(decimalDigit);
if (error != null) throw new ArgumentException(error, "число");
// Целочисленные версии работают в разы быстрее, чем decimal.
if (decimalDigit <= uint.MaxValue)
{
ConvertToString((uint)decimalDigit, unit, result);
}
else if (decimalDigit <= ulong.MaxValue)
{
ConvertToString((ulong)decimalDigit, unit, result);
}
else
{
MyStringBuilder mySb = new MyStringBuilder(result);
decimal div1000 = Math.Floor(decimalDigit / 1000);
HightDigitClassesToString(div1000, 0, mySb);
DigitClassToString((uint)(decimalDigit - div1000 * 1000), unit, mySb);
}
return result;
}
/// <summary>
/// Loads a unit into the host
/// </summary>
/// <param name="unit">Unit to load</param>
public void LoadUnit( IUnit unit )
{
Arguments.CheckNotNull( unit, "unit" );
Log.Info( "Loading unit " + unit);
unit.Initialize( m_Environment );
m_Units.Add( unit );
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="source">The unit to copy</param>
public Unit(IUnit source)
{
Description = source.Description;
ID = source.ID;
ConversionFactorToSI = source.ConversionFactorToSI;
OffSetToSI = source.OffSetToSI;
}
/// <summary>
/// value is on line between units and on the dist form unit1
/// </summary>
/// <param name="unit1">first unit</param>
/// <param name="unit2">second unit</param>
/// <param name="Dist">distance from unit1</param>
public RelativeVector(IUnit unit1, IUnit unit2, float Dist)
{
relativeUnit1 = unit1;
relativeUnit2 = unit2;
dist = Dist;
mode = Modes.BetweenUnitsNearOne;
}
/// <summary>
/// Converts the distance into area
/// </summary>
/// <param name="d1"></param>
/// <param name="d2"></param>
/// <returns></returns>
public static IUnit<IArea> Times(this IUnit<IDistance> d1, IUnit<IDistance> d2)
{
var f1 = d1.In().Feet;
var f2 = d2.In().Feet;
return (f1.Quantity * f2.Quantity).Square().Feet;
}
private void ChangeUnitLocation(IPath pathToTheTargetPlanet, IUnit unitToTeleport, ILocation targetLocation)
{
pathToTheTargetPlanet.TargetLocation.Planet.Units.Add(unitToTeleport);
unitToTeleport.CurrentLocation.Planet.Units.Remove(unitToTeleport);
unitToTeleport.PreviousLocation = unitToTeleport.CurrentLocation;
unitToTeleport.CurrentLocation = targetLocation;
}
public SingleUnityUnitConversionMap(IUnit unit, IEqualityComparer<IUnit> unitEqualityComparer = null)
: base(unitEqualityComparer)
{
if (null == unit) throw new ArgumentNullException("unit");
Contract.EndContractBlock();
_singleUnit = unit;
}
public IUnit CreateUnit(IUnit unitType)
{
var spawnedUnit = unitType.Spawn();
this.UnitsManufactured += 1;
return spawnedUnit;
}
/// <summary>
/// Получить пропись числа с согласованной единицей измерения.
/// </summary>
/// <param name="doubleDigit">
/// CDigit должно быть целым, неотрицательным, не большим <see cref="MaxDouble"/>.
/// </param>
/// <param name="unit"></param>
/// <param name="result"> Сюда записывается результат. </param>
/// <exception cref="ArgumentException">
/// Если doubleDigit меньше нуля, не целое или больше <see cref="MaxDouble"/>.
/// </exception>
/// <returns> <paramref name="result"/> </returns>
/// <remarks>
/// float по умолчанию преобразуется к double, поэтому нет перегрузки для float.
/// В результате ошибок округления возможно расхождение цифр прописи и
/// строки, выдаваемой double.ToString ("R"), начиная с 17 значащей цифры.
/// </remarks>
public static StringBuilder ConvertToString(double doubleDigit, IUnit unit, StringBuilder result)
{
string error = CheckDigit(doubleDigit);
if (error != null) throw new ArgumentException(error, "число");
if (doubleDigit <= uint.MaxValue)
{
ConvertToString((uint)doubleDigit, unit, result);
}
else if (doubleDigit <= ulong.MaxValue)
{
// SumConvertToString с ulong выполняется в среднем в 2 раза быстрее.
ConvertToString((ulong)doubleDigit, unit, result);
}
else
{
MyStringBuilder mySb = new MyStringBuilder(result);
double div1000 = Math.Floor(doubleDigit / 1000);
HightDigitClassesToString(div1000, 0, mySb);
DigitClassToString((uint)(doubleDigit - div1000 * 1000), unit, mySb);
}
return result;
}
public Spell(IUnit unit, int energyCost, int damage)
{
this.Unit = unit;
this.Targets = targets;
this.Damage = damage;
this.EnergyCost = energyCost;
}
protected int Wound(IUnit enemy)
{
int r = 0;
int a_s = Unit.Strength;
if (Unit.Param.Contains("B")) { a_s += 2; }
if (a_s == enemy.Resistance)
{
if (check_k("s", Unit.Param, 4, 1) != 0) { r = 1; }
}
else if (a_s == (enemy.Resistance + 1))
{
if (check_k("s", Unit.Param, 3, 1) != 0) { r = 1; }
}
else if (a_s > (enemy.Resistance + 1))
{
if (check_k("s", Unit.Param, 2, 1) != 0) { r = 1; }
}
else if ((a_s + 1) == enemy.Resistance)
{
if (check_k("s", Unit.Param, 5, 1) != 0) { r = 1; }
}
else if ((a_s + 2) == enemy.Resistance)
{
if (check_k("s", Unit.Param, 6, 1) != 0) { r = 1; }
}
else if ((a_s + 2) < enemy.Resistance)
{
r = 0;
}
return r;
}
public void TestInit()
{
_unit = Unit.Create();
_unitHolder = UnitHolder.Create();
_unitChangedEventFired = false;
_unitHolder.UnitChanged += UnitHolderOnUnitChanged;
}
/// <summary>
/// Constructs a prime meridian.
/// </summary>
/// <param name="name">The name of the prime meridian.</param>
/// <param name="longitude">The longitude location of the meridian.</param>
/// <param name="angularUnit">The angular unit of the longitude value.</param>
/// <param name="authority">The authority.</param>
public OgcPrimeMeridian(string name, double longitude, IUnit angularUnit, IAuthorityTag authority = null)
: base(name, authority)
{
Contract.Requires(name != null);
Longitude = longitude;
Unit = angularUnit ?? OgcAngularUnit.DefaultDegrees;
}
public void Init()
{
motionSimulation = new ThreadSimulationProxy(new Simulation());
//var npc = new NPC() { ID = "Villain" };
//motionSimulation.Insert(npc);
//unit1 = new ThreadUnitProxy(new Unit { ID = "Unit1" }, motionSimulation);
var us = new Simulation().CreateUnit();
((Unit)us).ID = "Unit1";
unit1 = motionSimulation.CreateUnit(us);
unit1.IntersectsUnit += new EventHandler<IObjectArgs<IUnit>>(unit1_IntersectsUnit);
//unit1.IntersectsUnit -= new EventHandler<IObjectArgs<IUnit>>(unit1_IntersectsUnit);
//unit1.IntersectsUnit += (sender, unit) =>
//{
// DebugOutput("UNITS INTERSECTED");
//};
//unit1.IntersectsUnit -= (sender, unit) =>
//{
// DebugOutput("UNITS INTERSECTED");
//};
motionSimulation.Insert(unit1);
//var projectile = new Projectile();
//projectile.HitsObject += new Action<Object>((o) =>
//{
// DebugOutput("Projectile hit " + ((Unit)o).ID);
//});
//motionSimulation.Insert(projectile);
}
public override LanguageDigit ConvertToString(decimal number, IUnit unit)
{
CheckNumber(number);
if (number <= uint.MaxValue)
{
return ConvertToString((uint)number, unit);
}
if (number <= ulong.MaxValue)
{
return ConvertToString((ulong)number, unit);
}
decimal div1000 = Math.Floor(number / 1000);
HightDigitClassesToString(div1000, 0, convertedNumber);
DigitClassToString((uint)(number - div1000 * 1000), unit, convertedNumber);
return this;
}
public override void ApplyBehavior(IUnit unit)
{
if (!CanApplyBehaviorTo(unit)) return;
AppliedUnit = unit;
if (IsActivated) return;
Thread trd = new Thread(ThreadMethod);
trd.Start();
}
public void AddUnit(IUnit unit)
{
if (unit == null)
{
throw new ArgumentNullException(nameof(unit));
}
this.units.Add(unit);
}
/// <summary>
/// value is relative to unit's position
/// </summary>
/// <param name="RelativeUnit">unit to be used as a pivot</param>
/// <param name="Angle">angle between pivot.forward and direction from pivot to this vector</param>
/// <param name="Dist">dist from pivot to this vector</param>
public RelativeVector(IUnit RelativeUnit, float Angle, float Dist)
{
relativeUnit1 = RelativeUnit;
dist = Dist;
angle = Angle;
rotationOnAngle = Matrix.CreateRotation(angle);
mode = Modes.UnitsSideAndDist;
}
public void Attack(IUnit target)
{
target.TakeHit(unitAttackPower);
if (target.unitDamageSuffered >= target.unitHealth)
{
target = null;
}
}
/// <summary>
/// creates new radar instance.
/// Radar is created automatically for each UnitPilot class instance, has radius a little more than his ShootingRadius
/// </summary>
/// <param name="Radius">radar range</param>
/// <param name="HolderUnit">unit that holds this radar</param>
/// <param name="AI">AI that HolderUnit belongs to</param>
internal Radar(float Radius, IUnit HolderUnit, AI AI)
{
holderUnit = HolderUnit;
ai = AI;
this.Radius = Radius;
NearUnits = ai.Game.GetNearUnits(holderUnit.Position, Radius);
Scan();
}
public void ValidateEnergyPoints(IUnit unit, ISpell spell)
{
if (unit.EnergyPoints < spell.EnergyCost)
{
throw new NotEnoughEnergyException(
string.Format("{0} does not have enough energy to cast {1}", unit.Name, spell.GetType().Name));
}
}
public static Unit FromUnit(IUnit unit)
{
Unit u = new Unit
{
Name = unit.Name,
};
return u;
}
public void RemoveUnit(IUnit unit)
{
if (unit == null)
{
throw new ArgumentNullException("Unit cannot be null");
}
this.units.Remove(unit);
}
/// <summary>
/// Gets a new unit specific measure based on this measure but in the <paramref name="unit">specified unit</paramref>
/// </summary>
/// <param name="unit">Unit in which the new measure should be specified</param>
IMeasure <Number> IMeasure <Number> .this[IUnit <Number> unit]
{
get { return(this[unit]); }
}
/// <summary>
/// Creates a new standard unit measure.
/// </summary>
/// <param name="amount">Amount.</param>
/// <param name="unit">Unit.</param>
/// <returns>Standard unit measure.</returns>
public Number New(float amount, IUnit <Number> unit)
{
return(new Number(amount, unit));
}
/// <summary>
/// Creates a new standard unit measure.
/// </summary>
/// <param name="amount">Amount.</param>
/// <param name="unit">Unit.</param>
/// <returns>Standard unit measure.</returns>
public Number New(double amount, IUnit <Number> unit)
{
return(new Number(amount, unit));
}
/// <summary>
/// Allocates an object that associates contracts, such as preconditions and postconditions, with methods, types and loops.
/// If the object is already associated with a contract, that association will be lost as a result of this call.
/// </summary>
/// <param name="contractMethods">A collection of methods that can be called in a way that provides tools with information about contracts.</param>
/// <param name="unit">The unit that this is a contract provider for.</param>
public ContractProvider(IContractMethods contractMethods, IUnit unit)
{
this.contractMethods = contractMethods;
this.unit = unit;
}
/// <summary>
/// Creates a new measure from the specified <paramref name="amount"/> and <paramref name="unit"/>.
/// </summary>
/// <param name="amount">Amount.</param>
/// <param name="unit">Unit.</param>
/// <returns>Measure from the specified <paramref name="amount"/> and <paramref name="unit"/>.</returns>
public IMeasure <Activity> NewPreserveUnit(decimal amount, IUnit <Activity> unit)
{
return(new Measure <Activity>(amount, unit));
}
/// <summary>
/// Creates a new measure from the specified <paramref name="amount"/> and <paramref name="unit"/>.
/// </summary>
/// <param name="amount">Amount.</param>
/// <param name="unit">Unit.</param>
/// <returns>Measure from the specified <paramref name="amount"/> and <paramref name="unit"/>.</returns>
public IMeasure <Number> NewPreserveUnit(decimal amount, IUnit <Number> unit)
{
return(new Measure <Number>(amount, unit));
}
public void ShouldNotCreate()
{
IUnit createdUnit = _unitFactory.CreateUnit(UnitType.Skeleton);
Assert.Null(createdUnit);
}
/// <summary>
/// Creates a new standard unit measure.
/// </summary>
/// <param name="amount">Amount.</param>
/// <param name="unit">Unit.</param>
/// <returns>Standard unit measure.</returns>
public Activity New(double amount, IUnit <Activity> unit)
{
return(new Activity(amount, unit));
}
public Queue <IUnit> GetIntersectionsRelativeTo(IUnit firstUnit)
{
var possibleIntersections = new List <IUnit>();
var firstStartCheckPoint = firstUnit.Transform.position;
foreach (var unit in _units)
{
if (unit == firstUnit ||
unit == null ||
!BoundaryHelper.OnScreen(unit.Transform.position) ||
unit.Transform.gameObject.activeInHierarchy == false ||
unit.KillHandler.KillPoint.HasValue ||
unit.AngleDefinition.IntersectionPoint != Vector2.zero && BoundaryHelper.ContainedInObstacleCollider(unit.AngleDefinition.IntersectionPoint))
{
continue;
}
var firstRearCheckPoint = firstUnit.AngleDefinition.RearPointRelative;
var rearPoint = unit.AngleDefinition.RearPointRelative;
var forwardPoint = unit.AngleDefinition.ForwardPointRelative;
if (IntersectionMaths.IsIntersecting(firstStartCheckPoint, firstRearCheckPoint, rearPoint, forwardPoint))
{
var intersect = IntersectionMaths.FindIntersection(firstStartCheckPoint, firstRearCheckPoint,
rearPoint, forwardPoint);
if (intersect != null)
{
var directionThroughKillPoint =
(unit.KillHandler.GetFauxKillPoint() - (Vector2)unit.Transform.position).normalized;
if (possibleIntersections.Any(t => Vector2.Distance(intersect.Value, t.AngleDefinition.IntersectionPoint) < 1f))
{
continue;
}
if (!NodeGrid.Instance.NodeFromWorldPosition(intersect.Value).IsWalkable ||
!BoundaryHelper.OnScreen(intersect.Value) ||
BoundaryHelper.ContainedInObstacleCollider(intersect.Value))
{
continue;
}
if (Vector2.Distance(unit.Transform.position, intersect.Value) < 2f ||
Vector2.Distance(unit.Transform.position, firstStartCheckPoint) < 1f ||
Vector2.Distance(firstUnit.Transform.position, intersect.Value) < 1f)
{
continue;
}
unit.AngleDefinition.SetIntersectionPoint(intersect.Value);
possibleIntersections.Add(unit);
}
}
}
if (possibleIntersections.Count <= 0)
{
return(null);
}
var orderedIntersections = possibleIntersections.OrderBy(t =>
Vector2.Distance(firstStartCheckPoint, t.AngleDefinition.IntersectionPoint));
var intersectOrder = new Queue <IUnit>();
for (var i = 0; i < orderedIntersections.Count(); i++)
{
intersectOrder.Enqueue(orderedIntersections.ElementAt(i));
}
return(intersectOrder.Count > 0 ? intersectOrder : null);
}
void ISliceInit.Init(IUnit unit)
{
m_Sender = unit;
}
public void AddUnit(IUnit unit)
{
_units.Add(unit);
}
void ISliceInit.Done(IUnit unit)
{
m_Sender = null;
}
void ISliceUpdate.Update(IUnit target, float deltaTime)
{
}
/// <summary>
/// Creates a new vertex with the specified unit.
/// </summary>
/// <param name="unit">The unit will be associated with vertex.</param>
/// <returns>
/// A new instance of vertex.
/// </returns>
public Vertex NewVertex(IUnit unit)
{
return(new Vertex(unit));
}
/// <summary>
/// Gets a new unit specific measure based on this measure but in the <paramref name="unit">specified unit</paramref>
/// </summary>
/// <param name="unit">Unit in which the new measure should be specified</param>
/// <exception cref="ArgumentNullException">if specified unit is null or if specified unit is not of the Number quantity.</exception>
IMeasure IMeasure.this[IUnit unit]
{
get { return(this[unit as IUnit <Number> ]); }
}
public void ShouldCreateMonster()
{
IUnit createdUnit = _unitFactory.CreateUnit(UnitType.Monster);
Assert.True(createdUnit is Monster);
}
/// <summary>
/// Gets the amount of this measure in the requested unit
/// </summary>
/// <param name="unit">Unit to which the measured amount should be converted</param>
/// <returns>Measured amount converted into <paramref name="unit">specified unit</paramref></returns>
AmountType IMeasure.GetAmount(IUnit unit)
{
return(this.GetAmount(unit as IUnit <Number>));
}
/// <summary>
/// Gets a new unit specific measure based on this measure but in the <paramref name="unit">specified unit</paramref>
/// </summary>
/// <param name="unit">Unit in which the new measure should be specified</param>
/// <exception cref="ArgumentNullException">if specified unit is null or if specified unit is not of the Activity quantity.</exception>
IMeasure IMeasure.this[IUnit unit]
{
get { return(this[unit as IUnit <Activity> ]); }
}
/// <summary>
/// Gets a new unit specific measure based on this measure but in the <paramref name="unit">specified unit</paramref>
/// </summary>
/// <param name="unit">Unit in which the new measure should be specified</param>
IMeasure <Activity> IMeasure <Activity> .this[IUnit <Activity> unit]
{
get { return(this[unit]); }
}
/// <summary>
/// Creates a new standard unit measure.
/// </summary>
/// <param name="amount">Amount.</param>
/// <param name="unit">Unit.</param>
/// <returns>Standard unit measure.</returns>
public Mass New(float amount, IUnit <Mass> unit)
{
return(new Mass(amount, unit));
}
public void ShouldCreatePlayer()
{
IUnit createdUnit = _unitFactory.CreateUnit(UnitType.Player);
Assert.True(createdUnit is Player);
}
public Variable(string name, IUnit unit)
: this(name, unit, -1)
{
}
/// <summary>
/// Returns a unit namespace definition, nested in the given unitNamespace if possible,
/// otherwise nested in the given unit if possible, otherwise nested in the given host if possible, otherwise it returns Dummy.UnitNamespace.
/// If unitNamespaceReference is a root namespace, the result is equal to the given unitNamespace if not null,
/// otherwise the result is the root namespace of the given unit if not null,
/// otherwise the result is root namespace of unitNamespaceReference.Unit, if that can be resolved via the given host,
/// otherwise the result is Dummy.UnitNamespace.
/// </summary>
public static IUnitNamespace Resolve(IUnitNamespaceReference unitNamespaceReference, IMetadataHost host, IUnit unit = null, IUnitNamespace unitNamespace = null)
{
Contract.Requires(unitNamespaceReference != null);
Contract.Requires(host != null);
Contract.Requires(unit != null || unitNamespace == null);
Contract.Ensures(Contract.Result <IUnitNamespace>() != null);
var rootNsRef = unitNamespaceReference as IRootUnitNamespaceReference;
if (rootNsRef != null)
{
if (unitNamespace != null)
{
return(unitNamespace);
}
if (unit != null)
{
return(unit.UnitNamespaceRoot);
}
unit = UnitHelper.Resolve(unitNamespaceReference.Unit, host);
if (unit is Dummy)
{
return(Dummy.UnitNamespace);
}
return(unit.UnitNamespaceRoot);
}
var nestedNsRef = unitNamespaceReference as INestedUnitNamespaceReference;
if (nestedNsRef == null)
{
return(Dummy.UnitNamespace);
}
var containingNsDef = UnitHelper.Resolve(nestedNsRef.ContainingUnitNamespace, host, unit, unitNamespace);
if (containingNsDef is Dummy)
{
return(Dummy.UnitNamespace);
}
foreach (var nsMem in containingNsDef.GetMembersNamed(nestedNsRef.Name, ignoreCase: false))
{
var neNsDef = nsMem as INestedUnitNamespace;
if (neNsDef != null)
{
return(neNsDef);
}
}
return(Dummy.UnitNamespace);
}
/// <summary>
/// Gets the amount of this measure in the requested unit
/// </summary>
/// <param name="unit">Unit to which the measured amount should be converted</param>
/// <returns>Measured amount converted into <paramref name="unit">specified unit</paramref></returns>
AmountType IMeasure.GetAmount(IUnit unit)
{
return(this.GetAmount(unit as IUnit <Activity>));
}
public GatherCommand(IUnit unit)
{
this.unit = unit;
}
/// <summary>begins a prerecorded camera animation synchronized to unit relative to cutscene flag.</summary>
public void camera_set_animation_relative(AnimationGraphTag animationTag, string trackName, IUnit unit, ILocationFlag locationFlag)
{
this.cameraSystem.PerformCameraMove(animationTag, trackName, unit, locationFlag);
}
public void ShouldCreateRandomUnit()
{
IUnit randomUnit = _unitFactory.CreateRandomUnit();
Assert.NotNull(randomUnit);
}
/// <summary>
/// Creates a new standard unit measure.
/// </summary>
/// <param name="amount">Amount.</param>
/// <param name="unit">Unit.</param>
/// <returns>Standard unit measure.</returns>
public Number New(decimal amount, IUnit <Number> unit)
{
return(new Number(amount, unit));
}
/// <summary>
/// Creates a new standard unit measure.
/// </summary>
/// <param name="amount">Amount.</param>
/// <param name="unit">Unit.</param>
/// <returns>Standard unit measure.</returns>
public Activity New(float amount, IUnit <Activity> unit)
{
return(new Activity(amount, unit));
}
protected override bool HasUpdate(uint gameTick)
{
if (_update || ProductionInvalid)
{
_shieldsPerLine = 10;
_shieldPrice = (int)_city.CurrentProduction.Price * 10;
_totalShields = _shieldPrice;
if (_city.Shields > _totalShields)
{
_totalShields = _city.Shields;
}
_shieldWidth = 8;
if (_totalShields > 100)
{
_shieldsPerLine = (int)Math.Ceiling((double)_totalShields / 10);
_shieldWidth = ((double)80 / _shieldsPerLine);
}
int width = (int)(_shieldWidth * (_shieldsPerLine - 1)) + 11;
int height = SHIELD_HEIGHT * ((_shieldPrice - (_shieldPrice % _shieldsPerLine)) / _shieldsPerLine);
if (height < SHIELD_HEIGHT)
{
height = SHIELD_HEIGHT;
}
this.Tile(Pattern.PanelBlue)
.DrawRectangle(0, 0, width, 19 + height, 1)
.FillRectangle(1, 1, (width - 2), 16, 1);
if (width < 88)
{
this.FillRectangle(width, 0, 88 - width, 99, 5);
}
if (height < 80)
{
this.FillRectangle(0, 19 + height, width, 80 - height, 5);
}
bool blink = ProductionInvalid && (gameTick % 4 > 1);
if (!(Common.TopScreen is CityManager))
{
blink = ProductionInvalid;
}
if (!_viewCity)
{
DrawButton("Change", (byte)(blink ? 14 : 9), 1, 1, 7, 33);
DrawButton("Buy", 9, 1, 64, 7, 18);
}
DrawShields();
if (_city.CurrentProduction is IUnit)
{
IUnit unit = (_city.CurrentProduction as IUnit);
this.AddLayer(unit.ToBitmap(_city.Owner), 33, 0);
}
else
{
string name = (_city.CurrentProduction as ICivilopedia).Name;
while (Resources.GetTextSize(1, name).Width > 86)
{
name = $"{name.Substring(0, name.Length - 2)}.";
}
this.DrawText(name, 1, 15, 44, 1, TextAlign.Center);
}
_update = false;
}
return(true);
}
