public void DrawDamageModifiers(SpriteBatch spriteBatch, Camera cam, Vector2 startPos, bool isScreenSpace)
{
foreach (var modifier in damageModifiers)
{
float rotation = -body.TransformedRotation + GetArmorSectorRotationOffset(modifier.ArmorSectorInRadians) * Dir;
Vector2 forward = VectorExtensions.Forward(rotation);
float size = ConvertUnits.ToDisplayUnits(body.GetSize().Length() / 2);
if (isScreenSpace)
{
size *= cam.Zoom;
}
Color color = modifier.DamageMultiplier > 1 ? Color.Red : Color.GreenYellow;
int width = 4;
if (!isScreenSpace)
{
width = (int)Math.Round(width / cam.Zoom);
}
GUI.DrawLine(spriteBatch, startPos, startPos + Vector2.Normalize(forward) * size, color, width: width);
int thickness = 2;
if (!isScreenSpace)
{
thickness = (int)Math.Round(thickness / cam.Zoom);
}
ShapeExtensions.DrawSector(spriteBatch, startPos, size, GetArmorSectorSize(modifier.ArmorSectorInRadians) * Dir, 40, color, rotation + MathHelper.Pi, thickness);
}
}
public void LoadFromData(StrokeData sData)
{
m_TotalLength = 0;
Vector3 prevPos = Vector3.zero;
for (int i = 0; i < sData.m_RawStrokeNodeData.Length; i++)
{
TransformData sNodeData = sData.m_RawStrokeNodeData[i];
Vector3 pos = VectorExtensions.Parse(sNodeData.m_PosData);
Vector3 rot = VectorExtensions.Parse(sNodeData.m_RotData);
Vector3 scale = VectorExtensions.Parse(sNodeData.m_ScaleData);
// For each stroke node data add a new node
StrokeNode newNode = new StrokeNode(pos, Quaternion.Euler(rot), scale);
m_RawStrokeNodes.Add(newNode);
// Accumulate length
if (i > 0)
{
m_TotalLength += Vector3.Distance(pos, prevPos);
}
prevPos = pos;
}
// Update spaced stroke nodes
UpdateSpacedStrokeNodes(true);
//Vector3 colVec = VectorExtensions.Parse(sData.m_Color);
// m_StrokeRenderer.SetColour(m_StrokeRenderer.m_Color);
}
private static void SolveBuildingInNoSoilSmallVRFStochastic()
{
VectorExtensions.AssignTotalAffinityCount();
Model model = new Model();
model.SubdomainsDictionary.Add(1, new Subdomain()
{
ID = 1
});
BeamBuildingBuilder.MakeBeamBuilding(model, 20, 20, 20, 5, 4, model.NodesDictionary.Count + 1,
model.ElementsDictionary.Count + 1, 1, 4, false, false);
model.Loads.Add(new Load()
{
Amount = -100, Node = model.Nodes[21], DOF = DOFType.X
});
model.ConnectDataStructures();
PowerSpectrumTargetEvaluatorCoefficientsProvider stochasticProvider = new PowerSpectrumTargetEvaluatorCoefficientsProvider(10, 0.1, 1.2, 20, 200, DOFType.X,
0.1, 200, 1e-10);
SolverSkyline solver = new SolverSkyline(model);
ProblemStructural provider = new ProblemStructural(model, solver.SubdomainsDictionary);
LinearAnalyzer analyzer = new LinearAnalyzer(solver, solver.SubdomainsDictionary);
StaticAnalyzer childAnalyzer = new StaticAnalyzer(provider, analyzer, solver.SubdomainsDictionary);
VRFMonteCarloAnalyzerWithStochasticMaterial stochasticAnalyzer = new VRFMonteCarloAnalyzerWithStochasticMaterial(model, provider, childAnalyzer, solver.SubdomainsDictionary,
stochasticProvider, stochasticProvider, 1, 20, "monteCarlo");
analyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] { 420 });
//stochasticAnalyzer.BuildMatrices();
//childAnalyzer.Initialize();
stochasticAnalyzer.Solve();
}
/// <summary>
/// Convert Vector3 World Space location to Position taking account of zoom, scale and mapscale
/// </summary>
/// <param name="position">Vector3 World Space coordinates</param>
/// <returns>Position</returns>
static public IPosition ToPosition(this Vector3 position)
{
Vector3 mapLocal = AppState.instance.map.transform.InverseTransformPoint(position);
Mapbox.Utils.Vector2d _latlng = VectorExtensions.GetGeoPosition(mapLocal, AppState.instance.abstractMap.CenterMercator, AppState.instance.abstractMap.WorldRelativeScale);
return(new Position(_latlng.x, _latlng.y, mapLocal.y));
}
private NavigationPoint GetNearestPointInDirection(Vector3 direction, float maxDistance)
{
GameObject nearestPoint = null;
float nearestDistanceSquared = float.MaxValue;
float maxDistanceSquared = maxDistance * maxDistance;
for (int i = 0; i < navigationPointsContainer.transform.childCount; i++)
{
GameObject point = navigationPointsContainer.transform.GetChild(i).gameObject;
if (point != gameObject)
{
Vector3 directionToPoint = point.transform.position - transform.position;
if (VectorExtensions.IsSameDirection(direction, directionToPoint, anglePrecision))
{
float distanceSquared = directionToPoint.sqrMagnitude;
if (distanceSquared <= maxDistanceSquared && distanceSquared < nearestDistanceSquared)
{
nearestPoint = point;
nearestDistanceSquared = distanceSquared;
}
}
}
}
return(nearestPoint == null ? null : nearestPoint.GetComponent <NavigationPoint>());
}
private void TryAngleSingle(OnHitDetectData data)
{
if (Vector2.Angle(data.BulletShootDirection, VectorExtensions.DegreeToVector2(rotation - 90)) <= 55)
{
ShootAtDirection(rotation + 90, data);
}
}
public void LimitTest(double inputX, double inputY, double limit, double expectedX, double expectedY)
{
var input = new Vector2((float)inputX, (float)inputY);
var expected = new Vector2((float)expectedX, (float)expectedY);
Assert.AreEqual(expected, VectorExtensions.Limit(input, (float)limit));
}
[DataRow(0, -2, -1f / 2f * MathF.PI, 2)] // 270°
public void ToPolarTest(double inputX, double inputY, double expectedX, double expectedY)
{
var input = new Vector2((float)inputX, (float)inputY);
var expected = new Vector2((float)expectedX, (float)expectedY);
Assert.AreEqual(expected, VectorExtensions.ToPolar(input));
}
public void gardenDecorBuildConfirmed()
{
string longLat = VectorExtensions.GetGeoPosition(
tweakedGardenDecor.transform.position,
Map.GetComponent <BasicMap>().CenterMercator,
Map.GetComponent <BasicMap>().WorldRelativeScale
).ToString();
BaseGardenDecor newDecor = new BaseGardenDecor(gardenDecorToBuild.gardenDecorType, longLat, 0);
newDecor.yRotation = tweakedGardenDecor.transform.rotation.eulerAngles.y;
newDecor.scale = tweakedGardenDecor.transform.localScale.x;
newDecor.variation = tweakedGardenDecor.GetComponent <GardenDecorWorld>().representedDecor.variation;
newDecor.yOffset = tweakedGardenDecor.transform.localPosition.y - 0.2f;
PetKeeper.pet.Base.baseGardenDecors.Add(newDecor);
tweakedGardenDecor.GetComponent <GardenDecorWorld>().init(newDecor);
PetKeeper.pet.buildingMaterials -= gardenDecorToBuild.bmCost;
PetKeeper.pet.inventory.gardenDecorCounts[(int)gardenDecorToBuild.gardenDecorType] -= 1;
queueRewardText("Built Decor!", new Color(0.7f, 0.7f, 0.7f, 1));
isTweakingGardenDecor = false;
PetKeeper.pet.Save(false);
exitModePressed();
}
/// <summary>
/// given the relative velocity between the two objects and the MTV this method modifies the relativeVelocity to make it a collision
/// response.
/// </summary>
/// <param name="relativeVelocity">Relative velocity.</param>
/// <param name="minimumTranslationVector">Minimum translation vector.</param>
void calculateResponseVelocity(ref Vector2 relativeVelocity, ref Vector2 minimumTranslationVector, out Vector2 responseVelocity)
{
// first, we get the normalized MTV in the opposite direction: the surface normal
var inverseMTV = minimumTranslationVector * -1f;
Vector2 normal;
VectorExtensions.Normalize(ref inverseMTV, out normal);
// the velocity is decomposed along the normal of the collision and the plane of collision.
// The elasticity will affect the response along the normal (normalVelocityComponent) and the friction will affect
// the tangential component of the velocity (tangentialVelocityComponent)
float n;
VectorExtensions.Dot(ref relativeVelocity, ref normal, out n);
var normalVelocityComponent = normal * n;
var tangentialVelocityComponent = relativeVelocity - normalVelocityComponent;
if (n > 0.0f)
{
normalVelocityComponent = Vector2.zero;
}
// if the squared magnitude of the tangential component is less than glue then we bump up the friction to the max
var coefficientOfFriction = _friction;
if (tangentialVelocityComponent.LengthSquared() < _glue)
{
coefficientOfFriction = 1.01f;
}
// elasticity affects the normal component of the velocity and friction affects the tangential component
responseVelocity = -(1.0f + _elasticity) * normalVelocityComponent - coefficientOfFriction * tangentialVelocityComponent;
}
private static void SolveBuildingInNoSoilSmall()
{
VectorExtensions.AssignTotalAffinityCount();
Model model = new Model();
model.SubdomainsDictionary.Add(1, new Subdomain()
{
ID = 1
});
BeamBuildingBuilder.MakeBeamBuilding(model, 20, 20, 20, 5, 4, model.NodesDictionary.Count + 1,
model.ElementsDictionary.Count + 1, 1, 4, false, false);
model.Loads.Add(new Load()
{
Amount = -100, Node = model.Nodes[21], DOF = DOFType.X
});
model.ConnectDataStructures();
SolverSkyline solver = new SolverSkyline(model);
ProblemStructural provider = new ProblemStructural(model, solver.SubdomainsDictionary);
LinearAnalyzer analyzer = new LinearAnalyzer(solver, solver.SubdomainsDictionary);
StaticAnalyzer parentAnalyzer = new StaticAnalyzer(provider, analyzer, solver.SubdomainsDictionary);
analyzer.LogFactories[1] = new LinearAnalyzerLogFactory(new int[] { 420 });
parentAnalyzer.BuildMatrices();
parentAnalyzer.Initialize();
parentAnalyzer.Solve();
}
private void OperateRepairTool(float deltaTime)
{
character.CursorPosition = Item.WorldPosition;
if (character.Submarine != null)
{
character.CursorPosition -= character.Submarine.Position;
}
if (repairTool.Item.RequireAimToUse)
{
character.SetInput(InputType.Aim, false, true);
}
Vector2 fromToolToTarget = Item.Position - repairTool.Item.Position;
if (fromToolToTarget.LengthSquared() < MathUtils.Pow(repairTool.Range / 2, 2))
{
// Too close -> steer away
character.AIController.SteeringManager.SteeringManual(deltaTime, Vector2.Normalize(character.SimPosition - Item.SimPosition) / 2);
}
else
{
character.AIController.SteeringManager.Reset();
}
if (VectorExtensions.Angle(VectorExtensions.Forward(repairTool.Item.body.TransformedRotation), fromToolToTarget) < MathHelper.PiOver4)
{
repairTool.Use(deltaTime, character);
}
}
public virtual IEnumerator LoadRoutine()
{
yield return(new WaitForEndOfFrame());
possibleMoves = new Vector2[6];
int i = 0;
for (float angle = 0; angle < 360; angle += 360f / 6)
{
possibleMoves[i] = VectorExtensions.FromFacingAngle(angle) * WORLD_SCALE;
i++;
}
GetSingleton <SaveAndLoadManager>().Setup();
if (!HasPlayedBefore)
{
GetSingleton <SaveAndLoadManager>().DeleteAll();
HasPlayedBefore = true;
GetSingleton <SaveAndLoadManager>().OnLoaded();
}
else
{
GetSingleton <SaveAndLoadManager>().LoadMostRecent();
}
// GetSingleton<AdsManager>().ShowAd ();
Init();
yield break;
}
///
public override float ComputeObjective()
{
double user_complexity = 0;
for (int user_id = 0; user_id <= MaxUserID; user_id++)
{
if (ratings.CountByUser.Count > user_id)
{
user_complexity += Math.Pow(VectorExtensions.EuclideanNorm(user_factors.GetRow(user_id)), 2);
user_complexity += BiasReg * Math.Pow(user_bias[user_id], 2);
}
}
double item_complexity = 0;
for (int item_id = 0; item_id <= MaxItemID; item_id++)
{
if (ratings.CountByItem.Count > item_id)
{
item_complexity += Math.Pow(VectorExtensions.EuclideanNorm(item_factors.GetRow(item_id)), 2);
item_complexity += BiasReg * Math.Pow(item_bias[item_id], 2);
}
}
double complexity = RegU * user_complexity + RegI * item_complexity;
double social_regularization = 0;
for (int user_id = 0; user_id <= MaxUserID; user_id++)
{
double bias_diff = 0;
var factor_diffs = new double[NumFactors];
foreach (int v in user_connections[user_id])
{
bias_diff -= user_bias[v];
for (int f = 0; f < factor_diffs.Length; f++)
{
factor_diffs[f] -= user_factors[v, f];
}
}
if (user_connections[user_id].Count > 0)
{
bias_diff /= user_connections[user_id].Count;
}
bias_diff += user_bias[user_id];
social_regularization += Math.Pow(bias_diff, 2);
for (int f = 0; f < factor_diffs.Length; f++)
{
if (user_connections[user_id].Count > 0)
{
factor_diffs[f] /= user_connections[user_id].Count;
}
factor_diffs[f] += user_factors[user_id, f];
social_regularization += Math.Pow(factor_diffs[f], 2);
}
}
social_regularization *= this.social_regularization;
return((float)(ComputeLoss() + complexity + social_regularization));
}
/// <summary>
/// Invoked when players collider intersects with checkpoint collider
/// </summary>
/// <param name="other"></param>
protected void OnTriggerEnter(Collider other)
{
if (other.tag == "Player" && other.name == "Player")
{
Player player = other.gameObject.GetComponent <Player>();
PlayerData data = new PlayerData();
if (changeScene)
{
// if checkpoint changes scene, save values for the new scene
data.playerPosition = VectorExtensions.Vector3ToString(new Vector3(0, 0, 0));
}
else
{
data.playerPosition = VectorExtensions.Vector3ToString(other.gameObject.transform.position);
}
data.playerRotation = VectorExtensions.Vector3ToString(other.gameObject.transform.localEulerAngles);
data.playerScale = VectorExtensions.Vector3ToString(other.gameObject.transform.localScale);
data.playerEnergy = other.gameObject.GetComponent <Player>().LightEnergy.CurrentEnergy;
DataManager.SaveFile(data);
if (changeScene)
{
StartCoroutine(ChangeLevel());
}
}
}
private void StartDash()
{
if (stamina <= 0.0 || playerEntity.State == PlayerState.Dizzy)
{
return;
}
playerEntity.SwitchToState(PlayerState.Dashing);
dashTime = 0;
Entity.GetComponent <AudioSourceComponent>().PlaySound("Audio/dashSwoosh");
var physicsComponent = playerEntity.GetComponent <PhysicsComponent>();
physicsComponent.ReplaceShape(new CircleShape(0.5f, 1.0f));
physicsComponent.Fixture.IsSensor = true;
physicsComponent.Fixture.CollisionCategories = GameConstants.CollisionCategorySensor;
physicsComponent.Fixture.CollidesWith = Category.All & ~GameConstants.CollisionCategorySensor;
physicsComponent.Fixture.OnCollision += OnCollision;
stamina -= dashStaminaCost;
if (Entity.Body.LinearVelocity.LengthSquared() > 0.0000001f)
{
dashDirection = Vector2.Normalize(Entity.Body.LinearVelocity);
}
else
{
dashDirection = VectorExtensions.AngleToUnitVector(Entity.Body.Rotation);
}
}
private void PlaceLights(Scene destination)
{
for (var i = 0; i < 9; i++)
{
var position = VectorExtensions.Random(3, 12);
var color = VectorExtensions.RandomColor(200);
var item = new Light();
var model = new RenderModelComponent(item, ModelFactory.HalfTriangularThing(color));
var xform = new TransformComponent(item, position);
var light = new PointLightEmitterComponent(item)
{
Light = new PointLight()
{
Color = new Vector3(color.X, color.Y, color.Z),
Position = Vector3.Zero,
Radius = 20f
}
};
item.SetComponents(new Component[] {
model,
xform,
light
});
destination.Entities.Add(Guid.NewGuid(), item);
}
}
public void Update(float elapsedSeconds, float totalSeconds)
{
Vector2 newDirection = barnPosition - Entity.Body.Position;
newDirection.Normalize();
float desiredRotation = newDirection.UnitVectorToAngle();
float actualRotation = Entity.Body.Rotation;
float angleDistance = desiredRotation - actualRotation;
angleDistance = MathHelper.WrapAngle(angleDistance);
if (angleDistance > 0)
{
Entity.Body.AngularVelocity = Math.Min(angleDistance / elapsedSeconds, 6);
}
else if (angleDistance < 0)
{
Entity.Body.AngularVelocity = Math.Max(angleDistance / elapsedSeconds, -6);
}
else
{
Entity.Body.AngularVelocity = 0;
}
if ((barnPosition - Entity.Body.Position).LengthSquared() < 0.5 * 0.5)
{
this.Entity.Die();
}
Entity.Body.LinearVelocity = VectorExtensions.AngleToUnitVector(Entity.Body.Rotation);
}
public virtual void OnEnable()
{
if (Random.Range(0, 2) == 1)
{
trs.localScale = VectorExtensions.Multiply(trs.localScale, new Vector3(-1, 1, 1));
}
}
public override void Update(float elapsedSeconds)
{
foreach (Entity e in this.actives.Values)
{
TransformComponent transform = e.GetComponent <TransformComponent>();
MotionComponent motion = e.GetComponent <MotionComponent>();
TargetComponent target = e.GetComponent <TargetComponent>();
System.Diagnostics.Debug.Assert(transform != null, "PositionComponent not found");
System.Diagnostics.Debug.Assert(motion != null, "VelocityComponent not found");
System.Diagnostics.Debug.Assert(target != null, "TargetComponent not found");
if (EntityWorld.EntityManager.IsAlive(target.TargetId))
{
TransformComponent targetTransform = this.EntityWorld.ComponentManager.GetComponent <TransformComponent>(target.TargetId);
if (targetTransform != null)
{
Vector2 delta = targetTransform.Position - transform.Position;
float destinationDirection = VectorExtensions.Vector2ToAngle(delta);
int accelFactor = 10;
float newRotation = MathExtensions.LerpAngle(MathHelper.WrapAngle(transform.Rotation), MathHelper.WrapAngle(destinationDirection), /*0.1f*/ 2 * elapsedSeconds);
transform.Rotation = newRotation;
motion.AddAcceleration(VectorExtensions.AngleToVector2(transform.Rotation) * GameConfig.Projectile.Velocity * accelFactor);
//motion.AddAngularAcceleration((destinationDirection - transform.Rotation) * 0.5f);
}
}
//else
//{
// //target lost
// motion.AddAcceleration(VectorExtensions.AngleToVector2(transform.Rotation) * GameConfig.Projectile.Velocity * accelFactor);
//}
}
}
public override void OnUpdate(float elapsedSeconds)
{
base.OnUpdate(elapsedSeconds);
if (!this.poweringUp)
{
if (Kadro.Input.KeyboardInput.IsKeyDown(Keys.Left))
{
this.Transform.Rotation -= this.resolutionsPerSecond * elapsedSeconds;
this.Transform.Position = VectorExtensions.Rotate(this.Transform.Position, -this.resolutionsPerSecond * elapsedSeconds, focusPosition - offset);
}
if (Kadro.Input.KeyboardInput.IsKeyDown(Keys.Right))
{
this.Transform.Rotation += this.resolutionsPerSecond * elapsedSeconds;
this.Transform.Position = VectorExtensions.Rotate(this.Transform.Position, this.resolutionsPerSecond * elapsedSeconds, focusPosition - offset);
}
if (MouseInput.OnMouseMoved())
{
float targetAngle = (GameScene.ActiveScene.ViewToWorld(MouseInput.PositionVector) - focusPosition + offset).PerpRight().ToPolar();
//targetAngle = MathExtensions.LerpAngle(this.Transform.Rotation, targetAngle, 1.0f * elapsedSeconds);
this.Transform.Rotation = targetAngle;
this.Transform.Position = VectorExtensions.Rotate(focusPosition, targetAngle, focusPosition - offset);
}
if (Kadro.Input.KeyboardInput.OnKeyDown(Keys.Space))
{
this.poweringUp = true;
// add constant velocity to move back
RigidBody r = this.Components.Get <RigidBodyComponent>().RigidBody;
r.AddVelocityChange(VectorExtensions.AngleToVector2(this.Transform.Rotation).PerpLeft() * this.poweringUpVelocity * elapsedSeconds);
}
}
if (this.poweringUp && Kadro.Input.KeyboardInput.IsKeyDown(Keys.Space))
{
this.timeSinceStart += elapsedSeconds;
}
if ((this.poweringUp && Kadro.Input.KeyboardInput.OnKeyUp(Keys.Space)) || this.timeSinceStart > this.releaseTime)
{
// release
this.timeSinceStart = 0f;
this.releasing = true;
RigidBody r = this.Components.Get <RigidBodyComponent>().RigidBody;
r.Velocity = Vector2.Zero;
r.AngularVelocity = 0;
}
if (this.releasing)
{
// accelerate cue until it hits the ball
RigidBody r = this.Components.Get <RigidBodyComponent>().RigidBody;
r.AddForce(-VectorExtensions.AngleToVector2(this.Transform.Rotation).PerpLeft() * this.releaseForce * elapsedSeconds);
}
}
public virtual void AddAsteroid(Entity e, Vector2 position, float rotation, Vector2 scale)
{
e.AddComponent(new TransformComponent(position, rotation, scale));
e.AddComponent(new MotionComponent(VectorExtensions.AngleToVector2(rotation) * GameConfig.Asteroid.Velocity, ((rotation % 2 * Math.PI) - Math.PI) < 0 ? -GameConfig.Asteroid.AngularVelocity : +GameConfig.Asteroid.AngularVelocity, GameConfig.Asteroid.Velocity, GameConfig.Asteroid.AngularVelocity));
e.AddComponent(new CollidableComponent(this.LayerManager.GetBit(GameConfig.Asteroid.CollisionLayer),
this.LayerManager.GetBit(GameConfig.Spaceship.CollisionLayer) | this.LayerManager.GetBit(GameConfig.Projectile.CollisionLayer),
new CircleCollider(GameConfig.Asteroid.Large * scale.X / 2f), e.EntityId));
e.AddComponent(new TagComponent(GameConfig.Asteroid.Tag));
}
public virtual void Do()
{
points = new Vector2[pointCount];
for (int i = 0; i < pointCount; i++)
{
points[i] = circle.center + VectorExtensions.FromFacingAngle((i * 360f / pointCount) * (1f / 360f) * 360) * circle.radius;
}
polygonCollider.points = points;
}
public static Vector3 GetBlinkPosition(this Unit unit, Vector3 direction, float remainingTime)
{
var angle = (float)(Math.Max(remainingTime, 0) * unit.GetTurnRate() / 0.03);
var left = VectorExtensions.FromPolarCoordinates(1, unit.NetworkRotationRad + angle).ToVector3();
var right = VectorExtensions.FromPolarCoordinates(1, unit.NetworkRotationRad - angle).ToVector3();
return(unit.Position + (left.Distance2D(direction) < right.Distance2D(direction) ? left : right) * 100);
}
/// <summary>
/// The get stack damage.
/// </summary>
/// <param name="hero">
/// The hero.
/// </param>
/// <param name="inFrontDistance">
/// The in front distance.
/// </param>
/// <returns>
/// The <see cref="Tuple" />.
/// </returns>
public static Tuple <float, IEnumerable <RemoteMine> > GetStackDamage(this Unit hero, float inFrontDistance = 0)
{
var detonatableMines = new List <RemoteMine>();
if (Variables.Stacks == null || !Variables.Stacks.Any())
{
return(new Tuple <float, IEnumerable <RemoteMine> >(0, detonatableMines));
}
var rotSpeed = Prediction.RotSpeedDictionary.ContainsKey(hero.Handle)
? Prediction.RotSpeedDictionary[hero.Handle]
: 0;
var heroPosition = inFrontDistance > 0
? hero.Position
+ VectorExtensions.FromPolarCoordinates(
1f,
(float)(hero.NetworkRotationRad + rotSpeed)).ToVector3() * inFrontDistance
: hero.Position;
if (hero.NetworkActivity == NetworkActivity.Move)
{
heroPosition +=
VectorExtensions.FromPolarCoordinates(1f, (float)(hero.NetworkRotationRad + rotSpeed)).ToVector3()
* (float)(Variables.Techies.GetTurnTime(hero) + Game.Ping / 1000) * hero.MovementSpeed;
}
var tempDamage = 0f;
var nearestStack = Variables.Stacks.MinOrDefault(x => x.Position.Distance(heroPosition));
if (nearestStack == null || nearestStack.Position.Distance(heroPosition) > 1000)
{
return(new Tuple <float, IEnumerable <RemoteMine> >(0, detonatableMines));
}
foreach (var landMine in nearestStack.LandMines.Where(x => x.Distance(heroPosition) <= x.Radius))
{
if (tempDamage >= hero.Health)
{
return(new Tuple <float, IEnumerable <RemoteMine> >(tempDamage, detonatableMines));
}
tempDamage += Variables.Damage.GetLandMineDamage(landMine.Level, hero.ClassID);
}
foreach (var remoteMine in nearestStack.RemoteMines.Where(x => x.Distance(heroPosition) <= x.Radius))
{
if (tempDamage >= hero.Health)
{
break;
}
detonatableMines.Add(remoteMine);
tempDamage += Variables.Damage.GetRemoteMineDamage(remoteMine.Level, hero.ClassID, hero);
}
return(new Tuple <float, IEnumerable <RemoteMine> >(tempDamage, detonatableMines));
}
public override void Attached()
{
if (!entity.IsOwner)
{
return;
}
selfRotationSpeed = Random.Range(0.0f, selfRotationSpeed);
selfRotationAxis = VectorExtensions.RandomAxis();
orbitCenter = GameObjectManager.Instance.Sun.transform;
}
private void Move(float elapsedSeconds, float desiredSpeed)
{
Vector2 desiredVelocity = VectorExtensions.AngleToUnitVector(Entity.Body.Rotation);
desiredVelocity *= desiredSpeed;
float drag = 0.1f;
Entity.Body.LinearVelocity = drag * desiredVelocity + (1.0f - drag) * Entity.Body.LinearVelocity;
}
void Awake()
{
HalfDuration = Duration / 2f;
MaxScaleVector = VectorExtensions.FromValue(MaxScale);
DefaultScale = transform.localScale;
UpEaser = Ease.FromType(UpEase);
DownEaser = Ease.FromType(DownEase);
}
/// <summary>
/// The get nearest stack to kill.
/// </summary>
/// <param name="hero">
/// The hero.
/// </param>
/// <param name="predict">
/// The predict.
/// </param>
/// <returns>
/// The <see cref="Stack" />.
/// </returns>
private static Stack GetNearestStackToPush(Unit hero, Vector3 predict)
{
var detonatableMines = new List <RemoteMine>();
if (Variables.Stacks == null || !Variables.Stacks.Any())
{
return(null);
}
var heroPosition = predict;
var tempDamage = 0f;
var nearestStack =
Variables.Stacks.Where(
x =>
VectorExtensions.Distance(x.Position, heroPosition) <= PushRange + 400 &&
VectorExtensions.Distance(x.Position, heroPosition) > PushRange - 400)
.MinOrDefault(x => VectorExtensions.Distance(x.Position, heroPosition));
if (nearestStack == null)
{
return(null);
}
foreach (var landMine in
nearestStack.LandMines.Where(
x =>
x.Distance(heroPosition) <= x.Radius + PushRange &&
x.Distance(hero.Position) <= x.Radius + PushRange))
{
if (tempDamage >= hero.Health)
{
return(nearestStack);
}
tempDamage += Variables.Damage.GetLandMineDamage(landMine.Level, hero.Handle);
}
foreach (var remoteMine in
nearestStack.RemoteMines.Where(
x =>
x.Distance(heroPosition) <= x.Radius + PushRange &&
x.Distance(hero.Position) <= x.Radius + PushRange))
{
if (tempDamage >= hero.Health)
{
return(nearestStack);
}
detonatableMines.Add(remoteMine);
tempDamage += Variables.Damage.GetRemoteMineDamage(remoteMine.Level, hero.Handle, hero);
}
return(!(tempDamage >= hero.Health) ? null : nearestStack);
}
/// <summary>
/// Updates the transform and state of this object every frame, depending on
/// manipulations and docking state.
/// </summary>
public void Update()
{
if (isDragging && overlappingPositions.Count > 0)
{
var closestPosition = GetClosestPosition();
if (closestPosition.IsOccupied)
{
closestPosition.GetComponentInParent <Dock>().TryMoveToFreeSpace(closestPosition);
}
}
if (dockingState == DockingState.Docked || dockingState == DockingState.Docking)
{
Assert.IsNotNull(dockedPosition, "When a dockable is docked, its dockedPosition must be valid.");
Assert.AreEqual(dockedPosition.DockedObject, this, "When a dockable is docked, its dockedPosition reference the dockable.");
var lerpTime = dockingState == DockingState.Docked ? moveLerpTimeWhenDocked : moveLerpTime;
if (!isDragging)
{
// Don't override dragging
transform.position = Solver.SmoothTo(transform.position, dockedPosition.transform.position, Time.deltaTime, lerpTime);
transform.rotation = Solver.SmoothTo(transform.rotation, dockedPosition.transform.rotation, Time.deltaTime, lerpTime);
}
transform.localScale = Solver.SmoothTo(transform.localScale, dockedPositionScale, Time.deltaTime, lerpTime);
if (VectorExtensions.CloseEnough(dockedPosition.transform.position, transform.position, distanceTolerance) &&
QuaternionExtensions.AlignedEnough(dockedPosition.transform.rotation, transform.rotation, angleTolerance) &&
AboutTheSameSize(dockedPositionScale.x, transform.localScale.x))
{
// Finished docking
dockingState = DockingState.Docked;
// Snap to position
transform.position = dockedPosition.transform.position;
transform.rotation = dockedPosition.transform.rotation;
transform.localScale = dockedPositionScale;
}
}
else if (dockedPosition == null && dockingState == DockingState.Undocking)
{
transform.localScale = Solver.SmoothTo(transform.localScale, originalScale, Time.deltaTime, moveLerpTime);
if (AboutTheSameSize(originalScale.x, transform.localScale.x))
{
// Finished undocking
dockingState = DockingState.Undocked;
// Snap to size
transform.localScale = originalScale;
}
}
}