private static float GetAngle(Dot dot1, Dot dot2) { float dx = dot2.X - dot1.X; float dy = dot2.Y - dot1.Y; return(MathF.Atan2(dy, dx)); }
private void FireRocket() { bool found = false; Vector3 pos = Transform.Pos; Vector3 targetPos = new Vector3(float.MaxValue, float.MaxValue, pos.Z); List <Player> players = api.Players; for (int i = 0; i < players.Count; i++) { Vector3 newPos = players[i].Transform.Pos; if ((pos - newPos).Length < (pos - targetPos).Length) { targetPos = newPos; found = true; } } if (found) { Vector3 diff = (targetPos - pos).Normalized; Rocket rocket = new Rocket(); rocket.OnActivated(new ActorActivationDetails { Api = api, Pos = new Vector3(pos.X + (IsFacingLeft ? 10f : -10f), pos.Y + 10f, pos.Z - 2f) }); rocket.Transform.Angle = MathF.Atan2(diff.Y, diff.X); api.AddActor(rocket); } }
public override void Tick() { DronePawn target = (Local.Pawn as DronePawn).Target; bool active = target != null; SetClass("active", active); if (active) { PositionAtWorld(target.Position); Vector3 start = target.Position; Vector3 lead = target.Position + (target.Velocity * TimeToTarget(target.Position)); Vector2 screen = lead.ToScreen() - start.ToScreen(); Style.Width = Length.Fraction(screen.Length); float rot = MathF.Atan2(screen.y, screen.x).RadianToDegree(); PanelTransform transform = new PanelTransform(); transform.AddRotation(0, 0, rot); Style.Transform = transform; Style.Dirty(); } }
public EntityMagicWeapon(Vector pnt, Tile[] obj, byte[,,] chips, EntityList par) { Location = pnt; Mpts = obj; Map = chips; Parent = par; Size = new Size(8, 8); SetGraphic(2); // ウェポンは同時に3つまでしか打てない if (Parent.FindEntitiesByType <EntityMagicWeapon>().Count() > 3) { Kill(); } // 対象を探す // 条件は、プレイヤーに最も近い生きているエネミー Entity?target = Parent .Where(e => e.MyGroup == EntityGroup.Enemy) .Where(e => !(e is EntityLiving l) || !l.IsDying) .OrderBy(e => MathF.Abs(e.Location.Distance(Location))) .FirstOrDefault(); // 対象がいればその方向へ、いなければランダムに射出 var r = target != null ? MathF.Atan2(Location.Y - target.Location.Y, Location.X - target.Location.X) : DFMath.ToRadian(Core.GetRand(360)); Velocity = new Vector(MathF.Cos(r), MathF.Sin(r)) * -5; }
public static Vector3 ToEuler(Quaternion q) { Vector3 angles = new Vector3(); // roll (X-axis rotation) float sr_cp = 2.0f * (q.W * q.X + q.Y * q.Z); float cr_cp = 1.0f - 2.0f * (q.X * q.X + q.Y * q.Y); angles.Z = MathF.Atan2(sr_cp, cr_cp); // pitch (Y-axis rotation) float sp = 2.0f * (q.W * q.Y - q.Z * q.X); if (MathF.Abs(sp) >= 1.0f) { angles.X = MathF.CopySign(GameSettings.PI_HALF, sp); // use 90 degrees if out of range } else { angles.X = MathF.Asin(sp); } // yaw (Z-axis rotation) float sy_cp = 2.0f * (q.W * q.Z + q.X * q.Y); float cy_cp = 1.0f - 2 * (q.Y * q.Y + q.Z * q.Z); angles.Y = MathF.Atan2(sy_cp, cy_cp); return(angles); }
private void FollowNearestPlayer() { bool found = false; Vector3 pos = Transform.Pos; Vector3 targetPos = new Vector3(float.MaxValue, float.MaxValue, pos.Z); List <Player> players = api.Players; for (int i = 0; i < players.Count; i++) { Vector3 newPos = players[i].Transform.Pos; if ((pos - newPos).Length < (pos - targetPos).Length) { targetPos = newPos; found = true; } } if (found) { Vector3 diff = (targetPos - pos).Normalized; Vector3 speed = (new Vector3(speedX, speedY, 0f) + diff * 0.8f).Normalized; speedX = speed.X * 5f; speedY = speed.Y * 5f; Transform.Angle = MathF.Atan2(speedY, speedX); } }
public Vector2 GetCurrentSample(Agent agent) { int commonSampleCount = this.layerCount * this.outerLayerSampleCount; Vector2 oldVelocity = agent.SuggestedVel / agent.Characteristics.MaxSpeed; // this can happen if the max speed changed during the last update if (oldVelocity.LengthSquared > 1f) { oldVelocity.Normalize(); } if (this.currentSampleIdx >= commonSampleCount + 1) { return(Vector2.Zero); } if (this.currentSampleIdx >= commonSampleCount) { return(oldVelocity); } int layerIdx = this.currentSampleIdx % this.layerCount; int directionIdx = (this.currentSampleIdx / this.layerCount) % this.outerLayerSampleCount; float undistortedSpeedFactor = (float)(layerIdx + 1) / this.layerCount; float undistortedAngle = MathF.Lerp(-1.0f, 1.0f, ((float)directionIdx / this.outerLayerSampleCount)); float speedFactor = undistortedSpeedFactor; float angle = MathF.Atan2(oldVelocity.Y, oldVelocity.X) + MathF.Pow(Math.Abs(undistortedAngle), 0.8f) * undistortedAngle * MathF.RadAngle180; return(new Vector2(MathF.Cos(angle) * speedFactor, MathF.Sin(angle) * speedFactor)); }
protected override Task AliveAsync() { // await base.AliveAsync(); foreach (var sensor in Sensors) { sensor.Sense(); } var contexts = ContextBehaviors.Select(b => b.Behave(Steps)).ToList(); (var finalRing, var angle, var boost) = ContextRingBlending.Blend(contexts, true); SteerAngle(angle); var willShoot = CanShoot; if (CanBoost && boost && (this.SensorFleets.MyFleet?.Ships.Count ?? 0) > BoostThreshold) { if (ShootUntil < GameTime) { Boost(); } willShoot = false; } if (CanShoot && willShoot) { var target = (AttackFleets ? FleetTargeting.ChooseTarget() : null) ?? (AttackAbandoned ? AbandonedTargeting.ChooseTarget() : null) ?? (AttackFish ? FishTargeting.ChooseTarget() : null); if (target != null) { var shootAngle = MathF.Atan2(target.Position.Y - this.Position.Y, target.Position.X - this.Position.X); bool dangerous = false; if (!AttackFleets && this.SensorFleets.MyFleet != null) { var flets = FleetTargeting.PotentialTargetFleets(); foreach (var flet in flets) { if (RoboMath.MightHit(this.HookComputer, this.SensorFleets.MyFleet, flet, shootAngle)) { dangerous = true; } } } if (!Safe || !dangerous) { ShootAt(target.Position); } } } if (ReloadConfigAfter > 0 && ReloadConfigAfter < GameTime) { LoadConfig(); ReloadConfigAfter = 0; } return(Task.FromResult(0)); }
void RotateToDirection(Vector3 dir) { dir.Y = 0; Vector3 look = new Vector3(Node.GetTransform.GlobalTransform.M31, Node.GetTransform.GlobalTransform.M32, Node.GetTransform.GlobalTransform.M33); look.Normalize(); Vector3 axis = Vector3.Cross(look, dir); float dot = Vector3.Dot(dir, look); float angle = MathF.Atan2(axis.Length, dot); if (MathF.Abs(angle) < roteteSpeed) { IsRotating = false; if (direction == targetDirection) { targetDirection = Vector3.Zero; IsTaskCompleted = true; OnComplete?.Invoke(); } } else { angle = (angle < 0) ? -roteteSpeed : roteteSpeed; } var rotation = Quaternion.FromAxisAngle(axis, angle); Node.GetTransform.RotationQuaternion *= rotation; }
public static (float, float, float) GetYawPitchRoll(this Quaternion q) { // roll (x-axis rotation) var sinr_cosp = +2f * (q.W * q.X + q.Y * q.Z); var cosr_cosp = +1f - 2f * (q.X * q.X + q.Y * q.Y); var roll = MathF.Atan2(sinr_cosp, cosr_cosp); // pitch (y-axis rotation) float pitch; var sinp = +2f * (q.W * q.Y - q.Z * q.X); if (MathF.Abs(sinp) >= 1) { pitch = MathF.Sign(sinp) * MathF.PI / 2; // use 90 degrees if out of range } else { pitch = MathF.Asin(sinp); } // yaw (z-axis rotation) var siny_cosp = +2f * (q.W * q.Z + q.X * q.Y); var cosy_cosp = +1f - 2f * (q.Y * q.Y + q.Z * q.Z); var yaw = MathF.Atan2(siny_cosp, cosy_cosp); return(yaw, pitch, roll); }
public override void ShootAt(Vector2 target) { var angle = MathF.Atan2(target.Y, target.X); var canShoot = true; if (this.firstRow != null) { var ddd = (int)MathF.Floor(((angle + 360.0f) % 360.0f) / 360.0f * (firstRow.Count - 1.0f)); if (ddd < 0) { ddd = 0; } if (ddd < firstRow.Count - 1) { (var d, var c) = firstRow[ddd].bestChildScorePath(); if (d[d.Count - 1].Fleet.Ships.Count < 1) { canShoot = false; } } } var mag = target.Length(); var r = new Random(); angle += (float)r.NextDouble() * TargetingAverageError * 2; if (canShoot) { base.ShootAt(new Vector2(MathF.Cos(angle), MathF.Sin(angle)) * mag); } }
public static void Update() { for (uint i = 0; i < MaxZombies; i++) { if (Active[i]) { int closeP = -1; float closePD = float.MaxValue; for (int j = 0; j < Players.MaxPlayers; j++) { float d = Vector2.DistanceSquared(Players.Bodies[j].Position, Bodies[i].Position); if (d < closePD) { closePD = d; closeP = j; } } if (closeP != -1 && Data.World.RayCast(Bodies[i].Position, Players.Bodies[closeP].Position).FirstOrDefault() == Players.Bodies[closeP].FixtureList.FirstOrDefault()) { float a = MathF.Atan2(Players.Bodies[closeP].Position.Y - Bodies[i].Position.Y, Players.Bodies[closeP].Position.X - Bodies[i].Position.X); Angles[i] = Functions.LerpAngle(Angles[i], a, .05f); Bodies[i].ApplyForce(new Vector2(MathF.Cos(a) * MoveSpeed, MathF.Sin(a) * MoveSpeed)); } } } }
private void assertDirections() { AddAssert("group directions are correct", () => { for (int i = 0; i < hitObjectContainer.Count; i++) { DrawableOsuHitObject expectedStart = getObject(i); DrawableOsuHitObject expectedEnd = i < hitObjectContainer.Count - 1 ? getObject(i + 1) : null; if (expectedEnd == null) { continue; } var manualClock = new ManualClock(); followPointRenderer.Clock = new FramedClock(manualClock); manualClock.CurrentTime = expectedStart.HitObject.StartTime; followPointRenderer.UpdateSubTree(); var points = getGroup(i).ChildrenOfType <FollowPoint>().ToArray(); if (points.Length == 0) { continue; } float expectedDirection = MathF.Atan2(expectedStart.Position.Y - expectedEnd.Position.Y, expectedStart.Position.X - expectedEnd.Position.X); float realDirection = MathF.Atan2(expectedStart.Position.Y - points[^ 1].Position.Y, expectedStart.Position.X - points[^ 1].Position.X);
public static float GetWorldRotation(this Vector2 directionalVector) { var angle = MathF.Atan2(directionalVector.X, directionalVector.Y) + ToRadians(135); angle = NormalizeRadians(angle); return(angle); }
private void Flock() { var oobVectorWeight = 0.2f; var ships = World.BodiesNear(Position, World.Hook.FlockCohesionMaximumDistance) .OfType <Ship>(); var flockingVector = Vector2.Zero; var oobVector = Vector2.Zero; if (ships.Count() > 1) { flockingVector = (World.Hook.FlockCohesion * Flocking.Cohesion(ships, this, World.Hook.FlockCohesionMaximumDistance)) + (World.Hook.FlockAlignment * Flocking.Alignment(ships, this)) + (World.Hook.FlockSeparation * Flocking.Separation(ships, this, World.Hook.FlockSeparationMinimumDistance)); } if (IsOOB) { if (Position != Vector2.Zero) { oobVector = Vector2.Normalize(-Position) * oobVectorWeight; } } var steeringVector = new Vector2(MathF.Cos(Angle), MathF.Sin(Angle)) + World.Hook.FlockWeight * flockingVector + oobVector; Angle = MathF.Atan2(steeringVector.Y, steeringVector.X); }
public bool PosTest3() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest3: Verify the angle of arctan(x,y) when the point in forward direction of X axis..."); try { float x = TestLibrary.Generator.GetSingle(-55); while (x <= 0) { x = TestLibrary.Generator.GetSingle(-55); } float y = 0; float angle = MathF.Atan2(y, x); if (!MathFTestLib.SingleIsWithinEpsilon(angle, 0.0f)) { TestLibrary.TestFramework.LogError("005", "The angle should be zero,actual: " + angle.ToString()); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("006", "Unexpected exception occurs: " + e); retVal = false; } return(retVal); }
public static TriggerVolume FromScenarioTriggerVolume(ScenarioTag tag, ScenarioTag.TriggerVolume tvDefinition) { var ent = new TriggerVolume(); ent.FriendlyName = tvDefinition.Description; var orient = GetOrientation(tvDefinition.Orientation, tvDefinition.OrientationAxis); var xform = new TransformComponent(ent, tvDefinition.Position, orient); var renderModel = ModelFactory.Cuboid(Vector3.Zero, tvDefinition.Size, new Vector4(1f, 1f, 0f, 0.5f)); renderModel.Flags = ModelFlags.IsTransparent; renderModel.RenderLayer = RenderLayers.Scripting; var wireframeRenderModel = ModelFactory.Cuboid(Vector3.Zero, tvDefinition.Size, new Vector4(1f, 1f, 0f, 1f)); wireframeRenderModel.Flags = ModelFlags.Wireframe; wireframeRenderModel.RenderLayer = RenderLayers.Scripting; ent.SetComponents(xform, TriggerGeometryComponent.Cuboid(ent, xform, tvDefinition.Size, tvDefinition.Description), new RenderModelComponent(ent, renderModel), new RenderModelComponent(ent, wireframeRenderModel)); return(ent); Quaternion GetOrientation(Vector3 angle, Vector3 axis) { //BUG? The Z value of the angle vector is not used here, and is present in ~5 triggers in the game var a = MathF.Atan2(angle.Y, angle.X); return(Quaternion.CreateFromAxisAngle(axis, a)); } }
public bool PosTest5() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest5: Verify the angle of arctan(x,y) when the point in negative direction of Y axis..."); try { float x = 0; float y = TestLibrary.Generator.GetSingle(-55); while (y >= 0) { y = -TestLibrary.Generator.GetSingle(-55); } float angle = MathF.Atan2(y, x); if (!MathFTestLib.SingleIsWithinEpsilon(angle, -MathF.PI / 2)) { TestLibrary.TestFramework.LogError("009", "The angle should be -pi/2, actual: " + angle.ToString()); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("010", "Unexpected exception occurs: " + e); retVal = false; } return(retVal); }
protected override void PreSweep(ContextRing ring) { base.PreSweep(ring); AverageAngle = null; if (LocalTeammates.Any()) { int count = 0; var averageMomentum = Vector2.Zero; foreach (var fleet in LocalTeammates) { var distance = Vector2.Distance(fleet.Center, this.Robot.Position); if (distance >= MinimumRange && distance <= MaximumRange) { averageMomentum += fleet.Momentum; count++; } } if (count > 0) { averageMomentum /= count; AverageAngle = MathF.Atan2(averageMomentum.Y, averageMomentum.X); } } }
public bool PosTest2() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest2: Verify the angle of arctan(x,y) when the point in quadrant four..."); try { float x = TestLibrary.Generator.GetSingle(-55); while (x <= 0) { x = TestLibrary.Generator.GetSingle(-55); } float y = TestLibrary.Generator.GetSingle(-55); while (y >= 0) { y = -TestLibrary.Generator.GetSingle(-55); } float angle = MathF.Atan2(y, x); if (angle > 0 || angle < -MathF.PI / 2) { TestLibrary.TestFramework.LogError("003", "The angle should be between 0 and -MathF.PI/2, actual: " + angle.ToString()); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("004", "Unexpected exception occurs: " + e); retVal = false; } return(retVal); }
public float GetAbsoluteAngle(float x, float y) { float dx = x - GetPositionX(); float dy = y - GetPositionY(); return(NormalizeOrientation(MathF.Atan2(dy, dx))); }
public static void Snake(Ship ship) { var hook = ship.World.Hook; var fleet = ship.Fleet; if (hook.SnakeWeight == 0) { return; } if (fleet == null || fleet.Ships.Count < 2) { return; } var shipIndex = fleet.Ships.IndexOf(ship); if (shipIndex > 0) { ship.Size = 70; var steeringVector = new Vector2(MathF.Cos(ship.Angle), MathF.Sin(ship.Angle)); steeringVector += (fleet.Ships[shipIndex - 1].Position - ship.Position) * hook.SnakeWeight; ship.Angle = MathF.Atan2(steeringVector.Y, steeringVector.X); } else { ship.Size = 100; } }
public bool IsSafeTarget(Vector2 target) { var toTarget = target - Robot.Position; var angle = MathF.Atan2(toTarget.Y, toTarget.X); return(IsSafeShot(angle)); }
private float AngleBetween(PointF junction, PointF a, PointF b) { PointF vA = a - junction; PointF vB = b - junction; return(MathF.Atan2(vB.Y, vB.X) - MathF.Atan2(vA.Y, vA.X)); }
private static Vector3 MatrixToEuler(Matrix3x3 matrix) { // from http://www.geometrictools.com/Documentation/EulerAngles.pdf // YXZ order Vector3 v = Vector3.Zero; if (matrix.Data[7] < 0.999F) // some fudge for imprecision { if (matrix.Data[7] > -0.999F) // some fudge for imprecision { v.X = MathF.Asin(-matrix.Data[7]); v.Y = MathF.Atan2(matrix.Data[6], matrix.Data[8]); v.Z = MathF.Atan2(matrix.Data[1], matrix.Data[4]); MakePositive(v); } else { // WARNING. Not unique. YA - ZA = atan2(r01,r00) v.X = MathF.PI * 0.5F; v.Y = MathF.Atan2(matrix.Data[3], matrix.Data[0]); v.Z = 0.0F; MakePositive(v); } } else { // WARNING. Not unique. YA + ZA = atan2(-r01,r00) v.X = -MathF.PI * 0.5F; v.Y = MathF.Atan2(-matrix.Data[3], matrix.Data[0]); v.Z = 0.0F; MakePositive(v); } return(v); //返回的是弧度值 }
public static float SignedAngle(Vector3 v1, Vector3 v2, Vector3 reference) { var c = Vector3.Cross(v1, v2); var angle = MathF.Atan2(c.Length(), Vector3.Dot(v1, v2)); return(Vector3.Dot(c, reference) < 0 ? -angle : angle); }
static PreyCaptureWorld() { // Calculate the size of the required lookup table. The table is a square matrix, and 'size' here is the // number of matrix rows and columns. // The matrix is used to lookup precomputed values of atan2(y, x) for some coordinate on the grid, relative to // some other coordinate on the grid. Therefore the extremes of relative coordinates are (for a grid of size 24): // // (23,23) top right. // (23,-23) bottom right. // (-23, -23) bottom left. // (-23, 23) top left. // // Hence the lookup table size is (2 * gridSize) - 1. // // Note. Given that the array indexes must begin with zero, the lookup table element at index [0,0] represents // relative XY coordinate (-23,-23). int size = (__gridSize * 2) - 1; __atan2Lookup = new float[size, size]; for (int y = 0; y < size; y++) { for (int x = 0; x < size; x++) { __atan2Lookup[y, x] = MathF.Atan2(y - __atan2LookupOffset, x - __atan2LookupOffset); } } }
private static void DrawArrow( GeometrySink sink, ReadOnlySpan <ImmutableVec2_float> bezier, float arrowSize) { var b1X = BiaNodeEditorHelper.Bezier(bezier[0].X, bezier[1].X, bezier[2].X, bezier[3].X, 0.5001f); var b1Y = BiaNodeEditorHelper.Bezier(bezier[0].Y, bezier[1].Y, bezier[2].Y, bezier[3].Y, 0.5001f); var b2X = BiaNodeEditorHelper.Bezier(bezier[0].X, bezier[1].X, bezier[2].X, bezier[3].X, 0.5f); var b2Y = BiaNodeEditorHelper.Bezier(bezier[0].Y, bezier[1].Y, bezier[2].Y, bezier[3].Y, 0.5f); var sx = b1X - b2X; var sy = b1Y - b2Y; var r = MathF.Atan2(sy, sx) + MathF.PI * 0.5f; var m = (MathF.Sin(r), MathF.Cos(r)); var l1 = new ImmutableVec2_float(arrowSize / 1.732f, arrowSize / 1.732f * 2.0f); var l2 = new ImmutableVec2_float(-arrowSize / 1.732f, arrowSize / 1.732f * 2.0f); var t1X = (bezier[0].X + bezier[3].X) * 0.5f; var t1Y = (bezier[0].Y + bezier[3].Y) * 0.5f; var t2 = Rotate(m, l1); var t3 = Rotate(m, l2); sink.BeginFigure(new RawVector2(t1X, t1Y), FigureBegin.Filled); sink.AddLine(new RawVector2(t2.X + t1X, t2.Y + t1Y)); sink.AddLine(new RawVector2(t3.X + t1X, t3.Y + t1Y)); sink.EndFigure(FigureEnd.Closed); }
public static List <ObjectPositionInfo> GeneratePositionInfos(IEnumerable <OsuHitObject> hitObjects) { var positionInfos = new List <ObjectPositionInfo>(); Vector2 previousPosition = playfield_centre; float previousAngle = 0; foreach (OsuHitObject hitObject in hitObjects) { Vector2 relativePosition = hitObject.Position - previousPosition; float absoluteAngle = MathF.Atan2(relativePosition.Y, relativePosition.X); float relativeAngle = absoluteAngle - previousAngle; ObjectPositionInfo positionInfo; positionInfos.Add(positionInfo = new ObjectPositionInfo(hitObject) { RelativeAngle = relativeAngle, DistanceFromPrevious = relativePosition.Length }); if (hitObject is Slider slider) { float absoluteRotation = getSliderRotation(slider); positionInfo.Rotation = absoluteRotation - absoluteAngle; absoluteAngle = absoluteRotation; } previousPosition = hitObject.EndPosition; previousAngle = absoluteAngle; } return(positionInfos); }
public static void Flock(Ship ship) { if (ship.World.Hook.FlockWeight == 0) { return; } var fleet = ship.Fleet; var hook = ship.World.Hook; if (fleet?.Ships == null || fleet.Ships.Count < 2) { return; } var shipFlockingVector = (hook.FlockCohesion * Flocking.Cohesion(fleet.Ships, ship, hook.FlockCohesionMaximumDistance)) + (hook.FlockSeparation * Flocking.Separation(fleet.Ships, ship, hook.FlockSeparationMinimumDistance)); var steeringVector = new Vector2(MathF.Cos(ship.Angle), MathF.Sin(ship.Angle)); steeringVector += hook.FlockWeight * shipFlockingVector; ship.Angle = MathF.Atan2(steeringVector.Y, steeringVector.X); }