internal static Point SearchClosestResourceInRange(Point pos, ResourceType carriedResourceType, int sightRange)
{
int bestRange = sightRange;
Point nearbyResourcePos = null;
for (int i = 0; i < Map.Height; i++)
{
for (int j = 0; j < Map.Width; j++)
{
Point p = new Point(i, j);
if (pos.DistanceFrom(p) < bestRange)
{
foreach (MapObject mo in Map.GetCellAt(i, j).MapObjects)
{
if (mo.GetType().IsSubclassOf(typeof(Resource)))
{
Resource res = (Resource)mo;
if (res.Type == carriedResourceType)
{
bestRange = pos.DistanceFrom(p);
nearbyResourcePos = p;
break;
}
}
}
}
}
}
return(nearbyResourcePos);
}
/// <summary>
/// Used by the Agressive Animals.
/// To find the closest target to attack.
/// </summary>
internal static Point GetClosestUnitOrBuildingInRange(Point mapObjPos, int range, out bool foundNearbyUnit)
{
Point nearbyUnitPos = null;
foundNearbyUnit = false;
int bestRange = range;
for (int i = 0; i < Map.Height; i++)
{
for (int j = 0; j < Map.Width; j++)
{
Point p = new Point(i, j);
if (mapObjPos.DistanceFrom(p) < bestRange)
{
foreach (MapObject mo in Map.GetCellAt(i, j).MapObjects)
{
if (mo.GetType().IsSubclassOf(typeof(PlayerControlled)))
{
bestRange = mapObjPos.DistanceFrom(p);
nearbyUnitPos = p;
foundNearbyUnit = true;
break;
}
}
}
}
}
return(nearbyUnitPos);
}
internal static Point SearchClosestMainHall(Point pos)
{
int bestDistance = 10000;
Point thePlace = null;
for (int i = 0; i < Map.Height; i++)
{
for (int j = 0; j < Map.Width; j++)
{
Point p = new Point(i, j);
if (pos.DistanceFrom(p) < bestDistance)
{
foreach (MapObject mo in Map.GetCellAt(i, j).MapObjects)
{
if (mo.GetType() == typeof(MainHall))
{
bestDistance = pos.DistanceFrom(p);
thePlace = p;
break;
}
}
}
}
}
return(thePlace);
}
internal static Point SearchClosestPeacefulAnimalInRange(Point pos, int sightRange, out bool isDead)
{
int bestRange = sightRange;
Point nearbyResourcePos = null;
isDead = false;
for (int i = 0; i < Map.Height; i++)
{
for (int j = 0; j < Map.Width; j++)
{
Point p = new Point(i, j);
if (pos.DistanceFrom(p) < bestRange)
{
foreach (MapObject mo in Map.GetCellAt(i, j).MapObjects)
{
if (mo.GetType().IsSubclassOf(typeof(Animal)) && !mo.GetType().IsSubclassOf(typeof(AggressiveAnimal)))
{
Animal animal = (Animal)mo;
bestRange = pos.DistanceFrom(p);
nearbyResourcePos = p;
if (animal.Dead)
{
isDead = true;
}
break;
}
}
}
}
}
return(nearbyResourcePos);
}
/// <summary>
/// Used by the Doctor to find a nearyby needy unit.
/// </summary>
/// <param name="mapObj"></param>
/// <param name="range"></param>
/// <returns>The position of the chupacabra</returns>
internal static Point GetClosestInjuredUnitInRange(Point mapObjPos, int range)
{
Point nearbyInjuredFriendPos = null;
int bestRange = range;
for (int i = 0; i < Map.Height; i++)
{
for (int j = 0; j < Map.Width; j++)
{
Point p = new Point(i, j);
if (mapObjPos.DistanceFrom(p) < bestRange)
{
foreach (MapObject mo in Map.GetCellAt(i, j).MapObjects)
{
if (mo.GetType().IsSubclassOf(typeof(Unit)))
{
Unit unit = (Unit)mo;
if (unit.ActualHealthPoints < unit.MaximalHealthPoints)
{
bestRange = mapObjPos.DistanceFrom(p);
nearbyInjuredFriendPos = p;
break;
}
}
}
}
}
}
return(nearbyInjuredFriendPos);
}
/// <summary>
/// Used by the Soldier to find a nearyby Chupacabra.
/// </summary>
/// <param name="mapObj"></param>
/// <param name="range"></param>
/// <returns>The position of the chupacabra</returns>
internal static Point GetClosestAggressiveAnimalInRange(Point mapObjPos, int range)
{
Point nearbyEnemyPos = null;
int bestRange = range;
for (int i = 0; i < Map.Height; i++)
{
for (int j = 0; j < Map.Width; j++)
{
Point p = new Point(i, j);
if (mapObjPos.DistanceFrom(p) < bestRange)
{
foreach (MapObject mo in Map.GetCellAt(i, j).MapObjects)
{
if (mo.GetType().IsSubclassOf(typeof(AggressiveAnimal)))
{
AggressiveAnimal chu = (AggressiveAnimal)mo;
if (!chu.Dead)
{
bestRange = mapObjPos.DistanceFrom(p);
nearbyEnemyPos = p;
break;
}
}
}
}
}
}
return(nearbyEnemyPos);
}
private static void SetVisibilitiesToActiveInRange(Point point, int range)
{
for (int i = 0; i < Map.Height; i++)
{
for (int j = 0; j < Map.Width; j++)
{
Point p = new Point(i, j);
if (point.DistanceFrom(p) < range && !(point.DistanceFrom(p) == range - 1 && point.IsOnTheSameAxisParallelLine(p)))
{
Map.GetCellAt(i, j).Visibility = VisibilityType.Active;
}
}
}
}
public void 距離()
{
Point p1 = new Point(2, 2);
Point p2 = new Point(1, 2);
Assert.AreEqual(p2.DistanceFrom(p1), 1.0);
}
public void PickupItemHandler(Packet inPacket)
{
inPacket.Skip(1); // ??
inPacket.Skip(4); // ??
Point itemObjectPosition = new Point(inPacket.ReadShort(), inPacket.ReadShort());
Point itemPickerPosition = new Point(Parent.Position.X, Parent.Position.Y);
// try to check distance from char before loot, no vacuuming!
// TODO: needs proper check
if (itemPickerPosition.DistanceFrom(itemObjectPosition) < 5)
{
int itemObjectID = inPacket.ReadInt();
lock (Parent.Map.Drops)
{
// check for drop itemObject on current char Map
if (Parent.Map.Drops.Contains(itemObjectID))
{
// found so pick it up!
Pickup(Parent.Map.Drops[itemObjectID]);
}
}
}
else
{
// TODO: error your too far to loot!
}
}
public int CalculateDistance(int xOne, int yOne, int xTwo, int yTwo)
{
var pointOne = new Point(xOne, yOne);
var pointTwo = new Point(xTwo, yTwo);
return(pointTwo.DistanceFrom(pointOne));
}
public static void Main(string[] args)
{
Console.WriteLine("Point 1:\n");
Console.Write("x: ");
double x1 = Convert.ToDouble(Console.ReadLine());
Console.Write("y: ");
double y1 = Convert.ToDouble(Console.ReadLine());
Console.Write("z: ");
double z1 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Point 2:\n");
Console.Write("x: ");
double x2 = Convert.ToDouble(Console.ReadLine());
Console.Write("y: ");
double y2 = Convert.ToDouble(Console.ReadLine());
Console.Write("z: ");
double z2 = Convert.ToDouble(Console.ReadLine());
Point point1 = new Point(x1, y1, z1);
Point point2 = new Point(x2, y2, z2);
Console.WriteLine("Distance from Point 1 to Point 2 is: " + point1.DistanceFrom(point2));
}
public void DistanceFrom_Other_EucludianDistance()
{
var target = new Point(-1, 1);
var other = new Point(3, 4);
Assert.AreEqual(5, target.DistanceFrom(other));
}
private void DoZoomMap(Point rightHandCoordinate, Point leftHandCoordinate)
{
var distance = rightHandCoordinate.DistanceFrom(leftHandCoordinate);
var levelDiff = (int)((distance - _startDistance) / _PixelsDistanteToChangeZoomLevel);
_map.ZoomLevel = _startZoomLevel + levelDiff;
}
private void CreateState(Point P, int i)
{
List <RNode> Candidates = RoadNetwork.ResolvePoint(P, 0.1f, 3);
foreach (RNode n in Candidates)
{
States[i].Add(new HiddenMarkovState(P, n, P.DistanceFrom(n.Point)));
}
}
protected override void StartZoom(Vector3D rightHandPoint, Vector3D leftHandPoint)
{
IsZooming = true;
_startRightHandScreenCoord = rightHandPoint.ToScreenPoint(_map.ActualWidth, _map.ActualHeight);
_startLeftHandScreenCoord = leftHandPoint.ToScreenPoint(_map.ActualWidth, _map.ActualHeight);
_startDistance = _startRightHandScreenCoord.DistanceFrom(_startLeftHandScreenCoord);
_startZoomLevel = _map.ZoomLevel;
if (ZoomStarted != null)
{
ZoomStarted();
}
}
protected override void StartZoom(SkeletonPoint rightHandPoint, SkeletonPoint leftHandPoint)
{
IsZooming = true;
_startRightHandScreenCoord = rightHandPoint.ToScreenPoint(_map.ActualWidth, _map.ActualHeight);
_startLeftHandScreenCoord = leftHandPoint.ToScreenPoint(_map.ActualWidth, _map.ActualHeight);
_startDistance = _startRightHandScreenCoord.DistanceFrom(_startLeftHandScreenCoord);
_startZoomLevel = _map.ZoomLevel;
if (KinectZoomStarted != null)
{
KinectZoomStarted();
}
}
/// <summary>
/// Attack the target if next to it.
/// </summary>
internal void Attack(Point pos)
{
if (MoveTarget != null && pos.DistanceFrom(MoveTarget) == 1)
{
foreach (MapObject mo in Engine.Map.GetCellAt(MoveTarget).MapObjects)
{
if (mo.GetType().IsSubclassOf(typeof(Animal)))
{
Animal a = (Animal)mo;
a.TakeDamage(Damage);
}
}
}
}
/// <summary>
/// Heal the target if next to it.
/// </summary>
internal void Heal(Point pos)
{
if (MoveTarget != null && pos.DistanceFrom(MoveTarget) == 1)
{
foreach (MapObject mo in Engine.Map.GetCellAt(MoveTarget).MapObjects)
{
if (mo.GetType().IsSubclassOf(typeof(Unit)))
{
Unit a = (Unit)mo;
a.TakeHealing(Damage);
}
}
}
}
public List <TNodeCarpooling> findClosestStop(Point startPoint)
{
List <TNodeCarpooling> PTnodes = new List <TNodeCarpooling>();
foreach (KeyValuePair <long, TNodeCarpooling> node in TNodesCarpooling)
{
double distance = startPoint.DistanceFrom(node.Value.Point);
TNodeCarpooling PTnode = new TNodeCarpooling(node.Value.Id, node.Value.Point, node.Value.StopId, node.Value.StopCode, node.Value.StopName, distance, node.Key);
PTnodes.Add(PTnode);
}
PTnodes = PTnodes.OrderBy(x => x.distanceFromStartnode).ToList();
return(PTnodes);
}
public Point Filter(Point point)
{
var pt = new Point(point.X, point.Y);
if (_lastpos != null)
{
var distance = point.DistanceFrom(_lastpos);
if (distance < DistanceThreshold)
{
pt = new Point(_lastpos.X, _lastpos.Y);
}
// Log.Debug($"Distance {distance} | Threshold {DistanceThreshold}");
}
_lastpos = pt;
return(pt);
}
private Tuple <Link, Link> SplitLink(Link link, Point point)
{
return(new Tuple <Link, Link>(
new Link
{
P1 = link.P1,
P2 = point,
Distance = link.P1.DistanceFrom(point)
},
new Link
{
P1 = point,
P2 = link.P2,
Distance = point.DistanceFrom(link.P2)
}));
}
public Point Filter(Point point)
{
TimeSpan timeDelta = _lastTime - DateTime.Now;
if (timeDelta.Milliseconds >= 1 && timeDelta.Milliseconds <= 10)
{
LimitReportRate();
_reportRateAvg += ((1000f / timeDelta.Ticks) - _reportRateAvg) * (timeDelta.Ticks / 1000f) * 10;
if (_reportRateAvg > _reportRate)
{
_reportRate = _reportRateAvg;
}
}
_lastTime = DateTime.Now;
float velocity = point.DistanceFrom(_lastPoint ?? point);
float acceleration = (velocity - _oldVelocity) * _reportRate;
if (velocity < 1)
{
return(point);
}
float predictedVelocity = velocity + acceleration / _reportRate;
Point predicted;
if (velocity > 0.1 && predictedVelocity > 0.1 && velocity < 2000 && predictedVelocity < 2000)
{
predicted = new Point(_lastPoint.X, _lastPoint.Y);
double shapedVelocityFactor = Pow(predictedVelocity / velocity, Shape) * Compensation;
predicted.X += (float)(point.X + shapedVelocityFactor * Compensation * (_reportRate / 1000f));
predicted.Y += (float)(point.Y + shapedVelocityFactor * Compensation * (_reportRate / 1000f));
}
else
{
predicted = point;
}
_oldVelocity = velocity;
_lastPoint = point;
return(predicted);
}
private static void StartTranslateStoryBoard(double desiredX, double desiredY, FrameworkElement fe, int time)
{
var translatePoint = fe.GetTranslatePoint();
var destinationPoint = new Point(desiredX, desiredY);
if (destinationPoint.DistanceFrom(translatePoint) > 1)
{
var storyboard = new Storyboard {
FillBehavior = FillBehavior.HoldEnd
};
storyboard.AddTranslationAnimation(fe, translatePoint, destinationPoint,
new Duration(TimeSpan.FromMilliseconds(time)),
new CubicEase {
EasingMode = EasingMode.EaseOut
});
storyboard.Begin();
}
}
private Detour MakeDetour(Link initialLink, Point newPoint)
{
return(new Detour
{
InitialLink = initialLink,
FirstLink = new Link
{
P1 = initialLink.P1,
P2 = newPoint,
Distance = initialLink.P1.DistanceFrom(newPoint)
},
SecondLink = new Link
{
P1 = newPoint,
P2 = initialLink.P2,
Distance = newPoint.DistanceFrom(initialLink.P2)
}
});
}
/// <summary>
/// Returns the resource if it is next to the targeted Main Hall.
/// </summary>
private void ReturnResource(Point pos)
{
if (MoveTarget != null && pos.DistanceFrom(MoveTarget) == 1)
{
foreach (MapObject mo in Engine.Map.GetCellAt(MoveTarget).MapObjects)
{
if (mo.GetType() == typeof(MainHall))
{
switch (CarriedResourceType)
{
case ResourceType.Wood: Engine.ThePlayer.Resources.Wood += ReturnAmount(); break;
case ResourceType.Food: Engine.ThePlayer.Resources.Food += ReturnAmount(); break;
case ResourceType.Gold: Engine.ThePlayer.Resources.Gold += ReturnAmount(); break;
}
}
}
}
}
/// <summary>
/// Attack the target if next to it.
/// </summary>
internal void Attack(Point pos)
{
if (MoveTarget != null && pos.DistanceFrom(MoveTarget) == 1)
{
PlayerControlled playerctrl = null;
foreach (MapObject mo in Engine.Map.GetCellAt(MoveTarget).MapObjects)
{
if (mo.GetType().IsSubclassOf(typeof(PlayerControlled)))
{
playerctrl = (PlayerControlled)mo;
playerctrl.TakeDamage(Damage);
break;
}
}
if (playerctrl != null && playerctrl.ActualHealthPoints <= 0)
{
Engine.DestroyMapObject(playerctrl, MoveTarget);
}
}
}
/// <summary>
/// Builds a building if there is one under him.
/// </summary>
/// <param name="worker"></param>
private void Build(Point pos)
{
if (MoveTarget != null && pos.DistanceFrom(MoveTarget) == 1)
{
foreach (MapObject mo in Engine.Map.GetCellAt(MoveTarget).MapObjects)
{
if (mo.GetType().IsSubclassOf(typeof(Building)))
{
Building b = (Building)mo;
if (b.IsUnderConstruction)
{
b.beBuilt();
}
else
{
myNextOrder = Order.None;
}
}
}
}
}
/*
* Returns the nearest TNode stop
*/
public TNode findClosestPTStopNode(Point startPoint)
{
long TnodeId = 0;
double mindistance = double.MaxValue;
foreach (KeyValuePair <long, TNode> node in TNodes)
{
double distance = startPoint.DistanceFrom(node.Value.Point);
if (distance < mindistance)
{
TnodeId = node.Key;
mindistance = distance;
}
}
TNode tnode = null;
TNodes.TryGetValue(TnodeId, out tnode);
return(tnode);
}
public override void Update()
{
if (Alive && Chatter.Count > 0 && DateTime.UtcNow > NextChatter)
{
int index = ChatterIndex % Chatter.Count;
ChatterIndex++;
Say(Chatter[index], 0);
NextChatter = DateTime.UtcNow.AddSeconds(Program.Random(60, 90));
}
var statuses = new string[Statuses.Count];
Statuses.Keys.CopyTo(statuses, 0);
foreach (var status in statuses)
{
if (Statuses.ContainsKey(status))
{
var s = Statuses[status];
if (s.RequiresCaster && s.Caster == null)
{
RemoveStatus(status);
}
else if (DateTime.UtcNow > s.NextTick)
{
if (s.Channeled)
{
Channel(s);
}
else if (Alive || !s.OnlyTickAlive)
{
s.OnTick(this);
if (s.SpellAnimation != 0 && !s.SingleAnimation)
{
SpellAnimation(s.SpellAnimation, 100);
}
}
if (--s.TimeLeft < 1)
{
RemoveStatus(status);
}
s.NextTick = DateTime.UtcNow.AddMilliseconds(s.Speed);
}
}
}
var characters = new Character[ThreatMeter.Count];
ThreatMeter.Keys.CopyTo(characters, 0);
foreach (var c in characters)
{
if (c == null || c.Dead || !WithinRange(c, 12))
{
ThreatMeter.Remove(c);
}
}
var enemies = new Character[Enemies.Count];
Enemies.CopyTo(enemies, 0);
foreach (var e in enemies)
{
if (e == null || e.Dead || !WithinRange(e, 12))
{
Enemies.Remove(e);
}
else
{
foreach (var m in e.Group.Members)
{
this.Enemies.Add(m);
m.Enemies.Add(this);
}
}
}
if (SpawnControl != null && SpawnControl.SpecificTime && SpawnControl.SpawnTime != GameServer.Time && !Dead)
{
LifeStatus = LifeStatus.Dead;
Experience = 0;
}
if (CurrentHP <= 0 && Alive)
{
if (ShouldComa)
{
CurrentHP = 1;
AddStatus("Spell_Coma", 1, 20, this);
}
else
{
CurrentHP = 0;
LifeStatus = LifeStatus.Dead;
}
}
switch (LifeStatus)
{
case LifeStatus.Alive:
{
if (DateTime.UtcNow > NextTick)
{
if (IsHostile && Target == null)
{
var targets = from t in
from obj in Map.Objects
where obj is Character && WithinRange(obj, HostileRange)
select obj as Character
where t.Alive && AllegianceTo(t) == Allegiance.Enemy && !t.Hidden && !t.Stealth
orderby Point.DistanceFrom(t.Point) ascending
select t;
if (targets.Count() > 0)
{
var target = targets.First();
Enemies.Add(target);
target.Enemies.Add(this);
target.Threaten(this, 1);
}
}
UpdateTarget();
if (IsCasting)
{
OnTickCasting();
}
else
{
OnTick();
}
TickCount++;
NextTick = DateTime.UtcNow.AddMilliseconds(TickSpeed);
}
} break;
case LifeStatus.Coma:
{
if (DateTime.UtcNow > NextTick)
{
OnTickComa();
TickCount++;
NextTick = DateTime.UtcNow.AddMilliseconds(TickSpeed);
}
} break;
case LifeStatus.Dying:
{
if (DateTime.UtcNow > NextTick)
{
OnTickDying();
TickCount++;
NextTick = DateTime.UtcNow.AddMilliseconds(TickSpeed);
}
} break;
case LifeStatus.Dead:
{
#region Remove Statuses
statuses = new string[Statuses.Count];
Statuses.Keys.CopyTo(statuses, 0);
foreach (var s in statuses)
{
RemoveStatus(s);
}
#endregion
#region Remove Threat
characters = new Character[ThreatMeter.Count];
ThreatMeter.Keys.CopyTo(characters, 0);
foreach (var c in characters)
{
ThreatMeter.Remove(c);
}
#endregion
#region Remove Enemies
enemies = new Character[Enemies.Count];
Enemies.CopyTo(enemies, 0);
foreach (var e in enemies)
{
Enemies.Remove(e);
e.Enemies.Remove(this);
}
#endregion
#region Give EXP / Quest Kill
double highestGroupValue = 0;
double highestPlayerValue = 0;
Group highestGroup = null;
Player highestPlayer = null;
var groups = new Dictionary <Group, double>();
foreach (var attacker in Attackers)
{
if (attacker.Key is Player)
{
var player = attacker.Key as Player;
if (groups.ContainsKey(player.Group))
{
groups[player.Group] += attacker.Value;
}
else
{
groups.Add(player.Group, attacker.Value);
}
if (groups[player.Group] > highestGroupValue)
{
highestGroup = player.Group;
highestGroupValue = groups[player.Group];
}
if (attacker.Value > highestPlayerValue)
{
highestPlayer = player;
highestPlayerValue = attacker.Value;
}
}
}
foreach (var group in groups)
{
if (group.Value < MaximumHP * 0.15)
{
continue;
}
long averageLevel = 0;
var players = new List <Player>();
foreach (var p in group.Key.Members)
{
if (p.WithinRange(this, 12) && p is Player)
{
averageLevel += p.Level;
players.Add(p as Player);
}
}
if (players.Count > 0)
{
averageLevel /= players.Count;
}
foreach (var p in players)
{
var difference = Math.Abs(averageLevel - Level);
if (difference < 5)
{
var percent = 1.0 - difference * 0.125;
if (Program.Random(100) < p.ExperienceBonusChance)
{
percent *= p.ExperienceBonus;
p.SpellAnimation(341, 100);
}
p.RewardExperience((long)(Experience * percent));
}
foreach (var q in p.Quests)
{
var qs = q.Value.QuestStep;
foreach (var qo in qs.Objectives.Values)
{
if (qo.Type == QuestObjectiveType.Kill && qo.RequiredKilledTypes.Contains(GetType().Name))
{
if (qo.GroupKill || p == highestPlayer)
{
p.AddQuestCount(q.Key, qo.Name);
}
}
}
}
}
}
#endregion
#region Close Dialogs
foreach (Client c in GameServer.Clients)
{
if (c.Player != null && c.Player.DialogSession.GameObject == this && c.Player.DialogSession.IsOpen)
{
c.Player.DialogSession.IsOpen = false;
c.Player.DialogSession.Dialog = null;
c.Player.DialogSession.GameObject = null;
c.Player.DialogSession.Map = null;
c.Enqueue(Dialog.ExitPacket());
}
}
#endregion
#region Loot
if (SpawnControl != null || CanDropLootWithoutSpawn)
{
var chest = new Chest();
foreach (Loot loot in Loot)
{
if (Program.Random(loot.MaximumValue) < loot.MinimumValue)
{
int value;
int index = Program.Random(loot.Items.Count);
var item = loot.Items[index];
Item drop = null;
if (int.TryParse(item, out value))
{
drop = new Gold(value);
GameServer.InsertGameObject(drop);
}
else
{
drop = GameServer.CreateItem(item);
}
if (drop != null)
{
if (drop.LootRollLength > 0 || drop.BindType != BindType.None)
{
var chestItem = new Chest.ChestItem();
chestItem.Item = drop;
chest.Items.Add(chestItem);
}
else
{
if (highestGroup != null)
{
foreach (var member in highestGroup.Members)
{
drop.ProtectionOwners.Add(member.Name);
}
drop.ProtectionExpireTime = DateTime.UtcNow.AddSeconds(60);
}
Map.InsertCharacter(drop, Point);
}
}
}
}
if (chest.Items.Count > 0 && highestGroup != null)
{
foreach (var member in highestGroup.Members)
{
chest.GUIDs.Add(member.GUID);
}
chest.Direction = Direction.South;
GameServer.InsertGameObject(chest);
Map.InsertCharacter(chest, Point);
}
}
#endregion
this.OnDeath();
this.OnDeath(highestPlayer);
Map.RemoveCharacter(this);
GameServer.RemoveGameObject(this);
} break;
}
if (DateTime.UtcNow.Subtract(LastHpRegen).TotalSeconds > 1)
{
if (Alive && CurrentHP < MaximumHP && Target == null)
{
CurrentHP += (long)(MaximumHP * 0.10);
if (CurrentHP > MaximumHP)
{
CurrentHP = MaximumHP;
}
}
LastHpRegen = DateTime.UtcNow;
}
if (DateTime.UtcNow.Subtract(LastMpRegen).TotalSeconds > 1)
{
if (Alive && CurrentMP < MaximumMP && Target == null)
{
CurrentMP += (long)(MaximumMP * 0.10);
if (CurrentMP > MaximumMP)
{
CurrentMP = MaximumMP;
}
}
LastMpRegen = DateTime.UtcNow;
}
}
public static bool ContainsPoint(this LineSegment line, Point targetPoint)
{
return targetPoint.DistanceFrom(targetPoint.ClosestPointOn(line)) < 0.001;
}
private void DoZoomMap(Point rightHandCoordinate, Point leftHandCoordinate)
{
var distance = rightHandCoordinate.DistanceFrom(leftHandCoordinate);
var levelDiff = (int)((distance - _startDistance) / _PixelsDistanteToChangeZoomLevel);
_map.ZoomLevel = _startZoomLevel + levelDiff;
}
/// <summary>
/// Calculates the duration given a distance and a speed.
/// </summary>
/// <param name="p1">The first point.</param>
/// <param name="p2">The second point.</param>
/// <param name="speed">The speed in pixels per second.</param>
/// <returns>Time it takes to get from p1 to p2</returns>
public static Duration CalculateDuration(this Point p1, Point p2, double speed)
{
return(new Duration(TimeSpan.FromSeconds(p1.DistanceFrom(p2) / speed)));
}
/// <summary>
/// Calculates the speed in pixels per second
/// </summary>
/// <param name="p1">The first point.</param>
/// <param name="p2">The second point.</param>
/// <param name="duration">The duration</param>
/// <returns>Speed in pixels per second</returns>
public static double CalculateSpeed(this Point p1, Point p2, Duration duration)
{
return(p1.DistanceFrom(p2) / duration.TimeSpan.TotalSeconds);
}
