public void Init(Telemetry tel) { // Do not move N computation below, N is used by LLAtoECEF method! gpsLLA = tel.uavPosition; gpsLLA.Press_Altitude = gpsLLA.Altitude - localGeoidHeight; N = a / Math.Sqrt(1 - e2 * Math.Pow(Math.Sin(gpsLLA.Latitude), 2)); cosLat = Math.Cos(gpsLLA.Latitude); sinLat = Math.Sin(gpsLLA.Latitude); cosLon = Math.Cos(gpsLLA.Longitude); sinLon = Math.Sin(gpsLLA.Longitude); gpsECEF = LLAtoECEF(gpsLLA); uavAngles = tel.uavAngles; cosYaw = Math.Cos(uavAngles.Yaw); sinYaw = Math.Sin(uavAngles.Yaw); if (zeroUavPitchRoll) { cosPitch = cosRoll = 1; sinPitch = sinRoll = 0; } else { cosPitch = Math.Cos(uavAngles.Pitch); sinPitch = Math.Sin(uavAngles.Pitch); cosRoll = Math.Cos(uavAngles.Roll); sinRoll = Math.Sin(uavAngles.Roll); } R_ECEF_LNED = null; R_LNED_ECEF = null; R_LNED_BODY = null; R_BODY_LNED = null; }
/// <summary> /// Writes the transformation matrix to a mat file. /// </summary> /// <param name="matFile">The MAT file to write.</param> /// <param name="rotationMatrix">The rotation matrix.</param> /// <param name="translation">The translation matrix.</param> private void WriteRotationMatrixAndTranslationToMatFile(File matFile, double[,] rotationMatrix, double[] translation) { // Delete the file if a previous one exists if (System.IO.File.Exists(matFile.Path)) { System.IO.File.Delete(matFile.Path); } string xLine = null; string yLine = null; var zLine = ""; // PowerInspect writes the MAT files using Invariant culture. string transLine = " T " + Convert.ToString(translation[0], CultureInfo.InvariantCulture) + " " + Convert.ToString(translation[1], CultureInfo.InvariantCulture) + " " + Convert.ToString(translation[2], CultureInfo.InvariantCulture); var rotations = Angles.GetRotationsFromMatrixXYZ(rotationMatrix); zLine = " R Z " + Convert.ToString(rotations[0].Value, CultureInfo.InvariantCulture); yLine = " R Y " + Convert.ToString(rotations[1].Value, CultureInfo.InvariantCulture); xLine = " R X " + Convert.ToString(rotations[2].Value, CultureInfo.InvariantCulture); var lines = new List <string>(); lines.Add(xLine); lines.Add(yLine); lines.Add(zLine); lines.Add(transLine); lines.Add("*"); lines.Add(""); // create a new text document System.IO.File.WriteAllLines(matFile.Path, lines); }
public Telemetry() { uavAngles = new Angles(); uavPosition = new Position(); uavAcceleration = new Acceleration(); uavSpeed = new Speed(); }
//----------------------------------------------------------------------------- // Seed Bouncing //----------------------------------------------------------------------------- // Try to bounce off of a seed bouncer tile, returning true if the bounce was successful. private bool AttemptBounce(TileSeedBouncer seedBouncer) { // Determine the angle the we are moving in. angle = Angles.NearestFromVector(physics.Velocity); // Determine the angle to bounce off at. int newAngle = -1; int bouncerAngle = seedBouncer.Angle; int bouncerAngleReverse = Angles.Reverse(seedBouncer.Angle); int plus1 = Angles.Add(angle, 1, WindingOrder.Clockwise); int plus2 = Angles.Add(angle, 2, WindingOrder.Clockwise); int minus1 = Angles.Add(angle, 1, WindingOrder.CounterClockwise); if (plus2 == bouncerAngle || plus2 == bouncerAngleReverse) { newAngle = Angles.Reverse(angle); } else if (plus1 == bouncerAngle || plus1 == bouncerAngleReverse) { newAngle = Angles.Add(angle, 2, WindingOrder.Clockwise); } else if (minus1 == bouncerAngle || minus1 == bouncerAngleReverse) { newAngle = Angles.Add(angle, 2, WindingOrder.CounterClockwise); } // Start moving in the new angle. if (newAngle >= 0) { angle = newAngle; physics.Velocity = Angles.ToVector(angle) * physics.Velocity.Length; return(true); } return(false); }
protected override void OnGetCameraTransform(out Vec3 position, out Vec3 forward, out Vec3 up, ref Degree cameraFov) { //To use data about orientation the camera if the cut scene is switched on if (IsCutSceneEnabled()) { if (CutSceneManager.Instance.GetCamera(out position, out forward, out up, out cameraFov)) { return; } } Vec3 offset; { Quat rot = new Angles(0, 0, MathFunctions.RadToDeg(cameraDirection.Horizontal)).ToQuat(); rot *= new Angles(0, MathFunctions.RadToDeg(cameraDirection.Vertical), 0).ToQuat(); offset = rot * new Vec3(1, 0, 0); offset *= cameraDistance; } Vec3 lookAt = new Vec3(cameraPosition.X, cameraPosition.Y, 0); forward = -offset; position = lookAt + offset; up = new Vec3(0, 0, 1); cameraFov = 80f; }
void MomentaryTurnToPositionUpdate(Vec3 turnToPosition) { if (turretBody == null || baseBody == null || mainGunAttachedObject == null) { return; } Vec3 diff = turnToPosition - Position; Radian horizontalAngle = MathFunctions.ATan(diff.Y, diff.X); Radian verticalAngle = MathFunctions.ATan(diff.Z, diff.ToVec2().Length()); turretBody.Rotation = new Angles(0, 0, -horizontalAngle.InDegrees()).ToQuat(); Quat rot = baseBody.Rotation.GetInverse() * turretBody.Rotation; Quat verticalRot = new Angles(0, verticalAngle.InDegrees(), 0).ToQuat(); mainGunAttachedObject.PositionOffset = rot * mainGunOffsetPosition; mainGunAttachedObject.RotationOffset = rot * verticalRot; RecalculateMapBounds(); if (EntitySystemWorld.Instance.IsServer()) { server_shouldSendTurnToPosition = turnToPosition; } }
void ReadSpectatorMessage(PacketReader stream) { Vec3f pos = stream.ReadVec3f(); Angles ang = stream.ReadAngles(); this.ScriptObject.SetToSpectator(World.Current, pos, ang); }
static void SpawnPlayer(ArenaClient client) { var charInfo = client.CharInfo; NPCInst npc = new NPCInst(NPCDef.Get(charInfo.BodyMesh == HumBodyMeshs.HUM_BODY_NAKED0 ? "maleplayer" : "femaleplayer")) { UseCustoms = true, CustomBodyTex = charInfo.BodyTex, CustomHeadMesh = charInfo.HeadMesh, CustomHeadTex = charInfo.HeadTex, CustomVoice = charInfo.Voice, CustomFatness = charInfo.Fatness, CustomScale = new Vec3f(charInfo.BodyWidth, 1.0f, charInfo.BodyWidth), CustomName = charInfo.Name }; foreach (string e in client.HordeClass.Equipment) { ItemInst item = new ItemInst(ItemDef.Get(e)); npc.Inventory.AddItem(item); npc.EffectHandler.TryEquipItem(item); } if (client.HordeClass.NeedsBolts) { } npc.Inventory.AddItem(new ItemInst(ItemDef.Get("hptrank"))); Vec3f spawnPos = Randomizer.GetVec3fRad(activeDef.SpawnPos, activeDef.SpawnRange); Angles spawnAng = Randomizer.GetYaw(); //npc.TeamID = 0; npc.Spawn(activeWorld, spawnPos, spawnAng); client.SetControl(npc); }
protected virtual void UpdateGuidePos(long now) { if (now < guidedNextUpdate) { return; } Vec3f pos = this.Position; Angles ang = this.Angles; VobEnvironment env = this.Environment; if (now - guidedNextUpdate < TimeSpan.TicksPerSecond) { // nothing really changed, only update every second if (pos.GetDistance(guidedLastPos) < MinPositionDistance && !ang.DifferenceIsBigger(guidedLastAng, MinAnglesDifference) && env == guidedLastEnv) { return; } } guidedLastPos = pos; guidedLastAng = ang; guidedLastEnv = env; Messages.WritePosDirMessage(this, pos, ang, env); guidedNextUpdate = now + PosUpdateInterval; //this.ScriptObject.OnPosChanged(); }
static NPCInst SpawnEnemy(HordeEnemy enemy, Vec3f spawnPoint, float spawnRange = 100) { NPCInst npc = new NPCInst(NPCDef.Get(enemy.NPCDef)); if (enemy.WeaponDef != null) { ItemInst item = new ItemInst(ItemDef.Get(enemy.WeaponDef)); npc.Inventory.AddItem(item); npc.EffectHandler.TryEquipItem(item); } if (enemy.ArmorDef != null) { ItemInst item = new ItemInst(ItemDef.Get(enemy.ArmorDef)); npc.Inventory.AddItem(item); npc.EffectHandler.TryEquipItem(item); } npc.SetHealth(enemy.Health, enemy.Health); Vec3f spawnPos = Randomizer.GetVec3fRad(spawnPoint, spawnRange); Angles spawnAng = Randomizer.GetYaw(); //npc.TeamID = 1; npc.BaseInst.SetNeedsClientGuide(true); npc.Spawn(activeWorld, spawnPos, spawnAng); return(npc); }
private static int ShortestAngleDegrees(int from, int to) { var fromRadians = Angles.ToRadians(from); var toRadians = Angles.ToRadians(to); return((int)Math.Round(Angles.ToDegrees(Angles.ShortestAngleBetween(fromRadians, toRadians)))); }
public override void BuildInput(InputBuilder input) { base.BuildInput(input); var pawn = Local.Pawn; if (pawn == null) { return; } if ((Math.Abs(input.AnalogLook.pitch) + Math.Abs(input.AnalogLook.yaw)) > 0.0f) { if (!orbitEnabled) { orbitAngles = (orbitYawRot * orbitPitchRot).Angles(); orbitAngles = orbitAngles.Normal; orbitYawRot = Rotation.From(0.0f, orbitAngles.yaw, 0.0f); orbitPitchRot = Rotation.From(orbitAngles.pitch, 0.0f, 0.0f); } orbitEnabled = true; timeSinceOrbit = 0.0f; orbitAngles.yaw += input.AnalogLook.yaw; orbitAngles.pitch += input.AnalogLook.pitch; orbitAngles = orbitAngles.Normal; orbitAngles.pitch = orbitAngles.pitch.Clamp(MinOrbitPitch, MaxOrbitPitch); } input.ViewAngles = orbitEnabled ? orbitAngles : Entity.Rotation.Angles(); input.ViewAngles = input.ViewAngles.Normal; }
public override void BuildInput(InputBuilder input) { _lookAngles += input.AnalogLook; _lookAngles.roll = 0; base.BuildInput(input); }
protected void Shoot() { Projectile projectile = (Projectile)projectileType.GetConstructor(Type.EmptyTypes).Invoke(null); Vector2F vectorToPlayer = (RoomControl.Player.Center - Center).Normalized * shootSpeed; if (aimType == AimType.SeekPlayer) { ShootProjectile(projectile, vectorToPlayer.Normalized * shootSpeed); } else if (aimType == AimType.SeekPlayerByDirection) { int shootDirection = Directions.NearestFromVector(vectorToPlayer); ShootFromDirection(projectile, shootDirection, shootSpeed); } else if (aimType == AimType.SeekPlayerByAngle) { int shootAngle = Angles.NearestFromVector(vectorToPlayer); ShootFromAngle(projectile, shootAngle, shootSpeed); } else { ShootFromDirection(projectile, direction, shootSpeed); } //Pause(shootPauseDuration); }
public override void BuildInput(ClientInput input) { base.BuildInput(input); var player = Player.Local; if (player == null) { return; } if ((Math.Abs(input.AnalogLook.pitch) + Math.Abs(input.AnalogLook.yaw)) > 0.0f) { if (!orbitEnabled) { orbitAngles = Rot.Angles(); orbitAngles = orbitAngles.Normal; orbitYawRot = Rotation.From(0.0f, orbitAngles.yaw, 0.0f); orbitPitchRot = Rotation.From(orbitAngles.pitch, 0.0f, 0.0f); } orbitEnabled = true; orbitTimer = Time.Now + OrbitCooldown; orbitAngles.yaw += input.AnalogLook.yaw; orbitAngles.pitch += input.AnalogLook.pitch; orbitAngles = orbitAngles.Normal; orbitAngles.pitch = orbitAngles.pitch.Clamp(MinOrbitPitch, MaxOrbitPitch); } input.ViewAngles = orbitAngles.WithYaw(orbitAngles.yaw - player.WorldRot.Yaw()); input.ViewAngles = input.ViewAngles.Normal; }
void UpdateTaskControlKeys() { if (task_enabled) { Vec3 unit_pos = ControlledObject.Position; Vec3 unit_dir = ControlledObject.Rotation.GetForward(); Vec3 need_dir = task_position - unit_pos; Angles angle = new Angles(ControlledObject.Rotation.ToAngles().Roll, ControlledObject.Rotation.ToAngles().Pitch, Quat.FromDirectionZAxisUp(need_dir).ToAngles().Yaw); ControlledObject.Rotation = Quat.Slerp(ControlledObject.Rotation, angle.ToQuat(), 6.0f * TickDelta); ControlKeyPress(GameControlKeys.Forward, 1); if (ControlledObject.Rotation.GetUp().Z < .4f) { ControlKeyPress(GameControlKeys.Reload, 1); } else { ControlKeyRelease(GameControlKeys.Reload); } } else { ControlKeyRelease(GameControlKeys.Forward); } }
public override void UpdateCamera(Camera camera) { if (!Player.Local.IsValid()) { return; } WorldPos = camera.Pos; WorldRot = camera.Rot; camera.ViewModelFieldOfView = FieldOfView; var newPitch = WorldRot.Pitch(); var newYaw = WorldRot.Yaw(); var pitchDelta = Angles.NormalizeAngle(newPitch - lastPitch); var yawDelta = Angles.NormalizeAngle(lastYaw - newYaw); var playerVelocity = Player.Local.Velocity; var verticalDelta = playerVelocity.z * Time.Delta; var viewDown = Rotation.FromPitch(newPitch).Up * -1.0f; verticalDelta *= (1.0f - System.MathF.Abs(viewDown.Cross(Vector3.Down).y)); pitchDelta -= verticalDelta * 1; var offset = CalcSwingOffset(pitchDelta, yawDelta); offset += CalcBobbingOffset(playerVelocity); WorldPos += WorldRot * offset; lastPitch = newPitch; lastYaw = newYaw; }
public override void Update() { base.Update(); // Find the start time for the current swing angle. int swingAngleStartTime = 0; for (int i = 0; i < swingAngleIndex; i++) { swingAngleStartTime += swingAngleDurations[i]; } // Check for changing swing angles. bool changedAngles = false; int t = 0; int time = (int)playerTool.AnimationPlayer.PlaybackTime; for (int i = 0; i < swingAngleDurations.Length; i++) { if (time == t && swingAngleIndex != i) { swingAngleIndex = i; swingAngle = Angles.Add(swingAngle, 1, swingAngleDirection); changedAngles = true; break; } t += swingAngleDurations[i]; } // Check for a swing tile peak (tile peaks happen just as the angle is changed). if (changedAngles) { Vector2F hitPoint = player.Center + (Angles.ToVector(swingAngle, false) * 13); Point2I hitTileLocation = player.RoomControl.GetTileLocation(hitPoint); OnSwingTilePeak(swingAngle, hitPoint); } Rectangle2I toolBox = swingCollisionBoxes[swingDirection, Math.Min(swingCollisionBoxes.Length - 1, swingAngleIndex)]; toolBox.Point += (Point2I)player.CenterOffset; playerTool.CollisionBox = toolBox; // Invoke any occuring timed actions. if (timedActions.ContainsKey(time)) { timedActions[time].Invoke(); } // Reset the swing when the button is pressed again. if (isReswingable && weapon.IsEquipped && weapon.IsButtonPressed()) { Swing(player.UseDirection); } // End the swing. if (playerTool.AnimationPlayer.IsDone && player.Graphics.IsAnimationDone) { OnSwingEnd(); } }
public static void CreateItemCmd(string item) { var owner = ConsoleSystem.Caller.Pawn; if (owner == null) { return; } BaseItem itemClass = ItemUtils.GetItemById(item); // Check to make sure we've actually returned an item. if (itemClass == null) { Log.Info($"Error: {item} could not be found."); return; } Log.Info($"{itemClass}"); Vector3 pos = Vector3.Zero; Angles ang = new Angles(0, owner.EyeRot.Angles().yaw, 0); var tr = Trace.Ray(owner.EyePos, owner.EyePos + owner.EyeRot.Forward * 200) .UseHitboxes() .Ignore(owner) .Size(2) .Run(); pos = tr.EndPos; CreatePhysicalItem(itemClass, pos, ang); }
static void NPCInst_sOnNPCInstMove(NPCInst npc, Vec3f oldPos, Angles oldAng, NPCMovement oldMovement) { if (npc.IsDead || !npc.IsPlayer || npc.IsUnconscious) { return; } ArenaClient client = (ArenaClient)npc.Client; if (client.HordeClass == null) { return; } if (ActiveStandInst != null) { return; } foreach (var s in ActiveStands) { if (npc.GetPosition().GetDistance(s.Stand.Position) < s.Stand.Range) { StartStand(s); break; } } }
partial void pSpawn(World world, Vec3f position, Angles angles) { if (this.needsClientGuide) { SetGuide(FindNewGuide()); } }
public virtual void BuildInput(ClientInput owner) { if (Zoomed) { owner.ViewAngles = Angles.Lerp(owner.LastViewAngles, owner.ViewAngles, 0.2f); } }
private void PropertyValueChanged(object sender, string propertyname, string propertyvalue) { var val = _values.FirstOrDefault(x => x.OriginalKey == propertyname); var li = KeyValuesList.Items.OfType <ListViewItem>().FirstOrDefault(x => ((string)x.Tag) == propertyname); if (val == null) { if (li != null) { KeyValuesList.Items.Remove(li); } return; } val.IsModified = true; val.Value = propertyvalue; if (li == null) { var dt = SmartEditButton.Checked ? val.DisplayText(Document.GameData) : val.OriginalKey; var dv = SmartEditButton.Checked ? val.DisplayValue(Document.GameData) : val.Value; li = new ListViewItem(dt) { Tag = val.OriginalKey, BackColor = val.GetColour() }; KeyValuesList.Items.Add(li).SubItems.Add(dv); } else { li.BackColor = val.GetColour(); li.SubItems[1].Text = SmartEditButton.Checked ? val.DisplayValue(Document.GameData) : val.Value; } if (propertyname == "angles" && propertyvalue != Angles.GetAnglePropertyString()) { Angles.SetAnglePropertyString(propertyvalue); } }
public static bool RotateTowards(WoWPlayer PlayerUnit, Vector2 TargetUnitPos, double RotationThreshhold, bool DisableForward) { double mydiff = Angles.AngleDiff(Angles.Calculateangle(TargetUnitPos, PlayerUnit.Position), PlayerUnit.Rotation); if ((Math.Abs(mydiff) < RotationThreshhold)) { SendKey.KeyUp(ConstController.WindowsVirtualKey.VK_LEFT, PlayerUnit.MovingInfo.IsTurningLeft, ref PlayerUnit.MovingInfo.myleft, PlayerUnit.WindowTitle); SendKey.KeyUp(ConstController.WindowsVirtualKey.VK_RIGHT, PlayerUnit.MovingInfo.IsTurningRight, ref PlayerUnit.MovingInfo.myright, PlayerUnit.WindowTitle); return(true); } else if (mydiff < 0) { if (DisableForward) { SendKey.KeyUp(ConstController.WindowsVirtualKey.VK_UP, PlayerUnit.MovingInfo.IsMovingForward, ref PlayerUnit.MovingInfo.myforward, PlayerUnit.WindowTitle); } SendKey.KeyDown(ConstController.WindowsVirtualKey.VK_LEFT, !PlayerUnit.MovingInfo.IsTurningLeft, ref PlayerUnit.MovingInfo.myleft, PlayerUnit.WindowTitle); SendKey.KeyUp(ConstController.WindowsVirtualKey.VK_RIGHT, PlayerUnit.MovingInfo.IsTurningRight, ref PlayerUnit.MovingInfo.myright, PlayerUnit.WindowTitle); } else if (mydiff > 0) { if (DisableForward) { SendKey.KeyUp(ConstController.WindowsVirtualKey.VK_UP, PlayerUnit.MovingInfo.IsMovingForward, ref PlayerUnit.MovingInfo.myforward, PlayerUnit.WindowTitle); } SendKey.KeyDown(ConstController.WindowsVirtualKey.VK_RIGHT, !PlayerUnit.MovingInfo.IsTurningRight, ref PlayerUnit.MovingInfo.myright, PlayerUnit.WindowTitle); SendKey.KeyUp(ConstController.WindowsVirtualKey.VK_LEFT, PlayerUnit.MovingInfo.IsTurningLeft, ref PlayerUnit.MovingInfo.myleft, PlayerUnit.WindowTitle); } return(false); }
protected override NPCInst SpawnNPC(NPCClass classDef, Vec3f pos, Angles ang, float posOffset = 100, int teamID = 1, bool giveAI = true) { NPCInst npc = base.SpawnNPC(classDef, pos, ang, posOffset, teamID, giveAI); npc.AllowHitTarget.Add(OnAllowHit); return(npc); }
// Constructor. CameraProperties remain constant during the mission public CAMFrame(CAMProperties camera) { zeroCamDistance = RTDPSettings.geolocationSettings.zeroCamDistance; zeroCamPanRoll = RTDPSettings.geolocationSettings.zeroCamPanRoll; camPosition = camera.camPosition; scaleFactor = camera.pixelPitch; offsetX = (camera.imageHeight - 1) * scaleFactor / 2; offsetY = (camera.imageWidth - 1) * scaleFactor / 2; focalLength = camera.focalLength; camAngles = camera.camAngles; cosPitch = Math.Cos(camAngles.Pitch); sinPitch = Math.Sin(camAngles.Pitch); if (zeroCamPanRoll) { cosYaw = cosRoll = 1; sinYaw = sinRoll = 0; } else { cosYaw = Math.Cos(camAngles.Yaw); sinYaw = Math.Sin(camAngles.Yaw); cosRoll = Math.Cos(camAngles.Roll); sinRoll = Math.Sin(camAngles.Roll); } R_BODY_CAM = null; R_CAM_BODY = null; }
public override void OnReadProperties(PacketReader stream) { base.OnReadProperties(stream); this.ItemType = (ItemTypes)stream.ReadByte(); this.name = stream.ReadString(); this.visualChange = stream.ReadString(); this.Material = (ItemMaterials)stream.ReadByte(); if (stream.ReadBit()) { this.Range = stream.ReadUShort(); } if (stream.ReadBit()) { this.Damage = stream.ReadUShort(); } if (stream.ReadBit()) { this.Protection = stream.ReadUShort(); } if (stream.ReadBit()) { this.InvOffset = stream.ReadVec3f(); } if (stream.ReadBit()) { this.InvRotation = stream.ReadCompressedAngles(); } }
public override void BuildInput(InputBuilder owner) { if (Zoomed) { owner.ViewAngles = Angles.Lerp(owner.OriginalViewAngles, owner.ViewAngles, 0.2f); } }
public override void BuildInput(ClientInput input) { if (thirdperson_orbit && input.Down(InputButton.Walk)) { if (input.Down(InputButton.Attack1)) { orbitDistance += input.AnalogLook.pitch; orbitDistance = orbitDistance.Clamp(0, 1000); } else { orbitAngles.yaw += input.AnalogLook.yaw; orbitAngles.pitch += input.AnalogLook.pitch; orbitAngles = orbitAngles.Normal; orbitAngles.pitch = orbitAngles.pitch.Clamp(-89, 89); } input.AnalogLook = Angles.Zero; input.Clear(); input.StopProcessing = true; } base.BuildInput(input); }
/// <summary> /// Turns Euler angles into a rotation matrix. The angles are assumed to be in degrees. /// </summary> public static Matrix3x3 ToMatrix(this Angles eulerAngles, bool invertedPitch = false) { var x = eulerAngles.Roll.ToRadians(); var y = eulerAngles.Pitch.ToRadians(); var z = eulerAngles.Yaw.ToRadians(); if (invertedPitch) { y = -y; } return(new Matrix3x3( (float)(Math.Cos(y) * Math.Cos(z)), (float)(Math.Sin(x) * Math.Sin(y) * Math.Cos(z) - Math.Cos(x) * Math.Sin(z)), (float)(Math.Cos(x) * Math.Sin(y) * Math.Cos(z) + Math.Sin(x) * Math.Sin(z)), (float)(Math.Cos(y) * Math.Sin(z)), (float)(Math.Sin(x) * Math.Sin(y) * Math.Sin(z) + Math.Cos(x) * Math.Cos(z)), (float)(Math.Cos(x) * Math.Sin(y) * Math.Sin(z) - Math.Sin(x) * Math.Cos(z)), (float)(-Math.Sin(y)), (float)(Math.Sin(x) * Math.Cos(y)), (float)(Math.Cos(x) * Math.Cos(y)) )); }
void Fire() { if( !Visible ) return; if( fireworkBulletType == null ) return; Bullet bullet = (Bullet)Entities.Instance.Create( fireworkBulletType, Map.Instance ); bullet.Position = GetInterpolatedPosition() + new Vec3( 0, 0, .1f ); EngineRandom random = World.Instance.Random; Quat rot = new Angles( random.NextFloatCenter() * 25, 90 + random.NextFloatCenter() * 25, 0 ).ToQuat(); bullet.Rotation = rot; bullet.PostCreate(); foreach( MapObjectAttachedObject attachedObject in bullet.AttachedObjects ) { MapObjectAttachedRibbonTrail attachedRibbonTrail = attachedObject as MapObjectAttachedRibbonTrail; if( attachedRibbonTrail == null ) continue; ColorValue color; switch( random.Next( 4 ) ) { case 0: color = new ColorValue( 1, 0, 0 ); break; case 1: color = new ColorValue( 0, 1, 0 ); break; case 2: color = new ColorValue( 0, 0, 1 ); break; case 3: color = new ColorValue( 1, 1, 0 ); break; default: color = new ColorValue( 0, 0, 0 ); break; } if( attachedRibbonTrail.RibbonTrail != null ) attachedRibbonTrail.RibbonTrail.Chains[ 0 ].InitialColor = color; } }
void UpdateTowerTransform() { if( towerBody == null || chassisBody == null || mainGunAttachedObject == null ) return; Radian horizontalAngle = towerLocalDirection.Horizontal; Radian verticalAngle = towerLocalDirection.Vertical; Range gunRotationRange = Type.GunRotationAngleRange * MathFunctions.PI / 180.0f; if( verticalAngle < gunRotationRange.Minimum ) verticalAngle = gunRotationRange.Minimum; if( verticalAngle > gunRotationRange.Maximum ) verticalAngle = gunRotationRange.Maximum; //update tower body towerBody.Position = GetInterpolatedPosition() + GetInterpolatedRotation() * towerBodyLocalPosition; towerBody.Rotation = GetInterpolatedRotation() * new Angles( 0, 0, -horizontalAngle.InDegrees() ).ToQuat(); towerBody.Sleeping = true; //update gun vertical rotation Quat verticalRotation = new Angles( 0, verticalAngle.InDegrees(), 0 ).ToQuat(); mainGunAttachedObject.RotationOffset = verticalRotation; RecalculateMapBounds(); }
public double Angle(Angles angle) { return featureAngles[(int)angle]; }
private Vec2 GetMovementByControlKeys() { Vec2 localVector = Vec2.Zero; if (EntitySystemWorld.Instance.IsServer() || EntitySystemWorld.Instance.IsDedicatedServer()) { PlayerManager.ServerOrSingle_Player player = null; player = PlayerManager.Instance.ServerOrSingle_GetPlayer(Intellect); if (GameMap.Instance != null && player.Intellect == Intellect) //PlayerIntellect.Instance == Intellect) { localVector.X -= Intellect.GetControlKeyStrength(GameControlKeys.Forward);// +this.Type.SpeedForward; localVector.X += Intellect.GetControlKeyStrength(GameControlKeys.Backward);// +this.Type.SpeedBackward; localVector.Y -= Intellect.GetControlKeyStrength(GameControlKeys.Left);// +this.Type.SpeedLeft; localVector.Y += Intellect.GetControlKeyStrength(GameControlKeys.Right);// +this.Type.SpeedRight; if (localVector != Vec2.Zero) { Vec2 diff = Position.ToVec2() - TurnToPosition.ToVec2(); ;// *Rotation.GetForward().ToVec2();//RendererWorld.Instance.DefaultCamera.Position.ToVec2(); Degree angle = new Radian(MathFunctions.ATan(diff.Y, diff.X)); Degree vecAngle = new Radian(MathFunctions.ATan(-localVector.Y, localVector.X)); Quat rot = new Angles(0, 0, vecAngle - angle).ToQuat(); Vec2 vector = (rot * new Vec3(1, 0, 0)).ToVec2(); return vector; } else return Vec2.Zero; } return Vec2.Zero; } else if (EntitySystemWorld.Instance.IsSingle()) { if (GameMap.Instance != null && PlayerIntellect.Instance == Intellect) { localVector.X -= Intellect.GetControlKeyStrength(GameControlKeys.Forward);// +this.Type.SpeedForward; localVector.X += Intellect.GetControlKeyStrength(GameControlKeys.Backward);// +this.Type.SpeedBackward; localVector.Y -= Intellect.GetControlKeyStrength(GameControlKeys.Left);// +this.Type.SpeedLeft; localVector.Y += Intellect.GetControlKeyStrength(GameControlKeys.Right);// +this.Type.SpeedRight; if (localVector != Vec2.Zero) { Vec2 diff = Position.ToVec2() - TurnToPosition.ToVec2(); ;// *Rotation.GetForward().ToVec2();//RendererWorld.Instance.DefaultCamera.Position.ToVec2(); Degree angle = new Radian(MathFunctions.ATan(diff.Y, diff.X)); Degree vecAngle = new Radian(MathFunctions.ATan(-localVector.Y, localVector.X)); Quat rot = new Angles(0, 0, vecAngle - angle).ToQuat(); Vec2 vector = (rot * new Vec3(1, 0, 0)).ToVec2(); return vector; } else return Vec2.Zero; } return Vec2.Zero; } return Vec2.Zero; //// if (localVector != Vec2.Zero) //// { //// localVector.Normalize(); //// //calculate force vector with considering camera orientation //// Vec2 diff = Position.ToVec2() - RendererWorld.Instance.DefaultCamera.Position.ToVec2(); //// //new Vec3( RendererWorld.Instance.DefaultCamera.Position.X,RendererWorld.Instance.DefaultCamera.Position.Y, Damager_Ball_Player.Position.Z); //// //diff.Z += this.Type.BallRadius; //// Degree angle = new Radian(MathFunctions.ATan(diff.Y, diff.X)); //// Degree vecAngle = new Radian(MathFunctions.ATan(-vec.Y, vec.X)); //// Quat rot = new Angles(0, 0, vecAngle - angle).ToQuat(); //// Vec2 forceVector2 = (rot * new Vec3(1, 0, 0)).ToVec2(); //// Vec2 forceVector = new Vec2(forceVector2.X, forceVector2.Y); //// return forceVector; //// } //// else return vec; ////} ////else //// return vec; }
void TickUserForceToBall( float delta ) { const float forceMultiplier = 10; Vec2 vec = Vec2.Zero; if( EngineApp.Instance.IsKeyPressed( EKeys.Left ) || EngineApp.Instance.IsKeyPressed( EKeys.A ) ) vec.Y++; if( EngineApp.Instance.IsKeyPressed( EKeys.Right ) || EngineApp.Instance.IsKeyPressed( EKeys.D ) ) vec.Y--; if( EngineApp.Instance.IsKeyPressed( EKeys.Up ) || EngineApp.Instance.IsKeyPressed( EKeys.W ) ) vec.X++; if( EngineApp.Instance.IsKeyPressed( EKeys.Down ) || EngineApp.Instance.IsKeyPressed( EKeys.S ) ) vec.X--; if( vec != Vec2.Zero ) { vec.Normalize(); //calculate force vector with considering camera orientation Vec2 diff = ball.Position.ToVec2() - RendererWorld.Instance.DefaultCamera.Position.ToVec2(); Degree angle = new Radian( MathFunctions.ATan( diff.Y, diff.X ) ); Degree vecAngle = new Radian( MathFunctions.ATan( -vec.Y, vec.X ) ); Quat rot = new Angles( 0, 0, vecAngle - angle ).ToQuat(); Vec2 forceVector2 = ( rot * new Vec3( 1, 0, 0 ) ).ToVec2(); Vec3 forceVector = new Vec3( forceVector2.X, forceVector2.Y, 0 ); Body body = ball.PhysicsModel.Bodies[ 0 ]; body.AddForce( ForceType.GlobalAtLocalPos, delta, forceVector * forceMultiplier, Vec3.Zero ); } }
Vec2 GetMovementVectorByControlKeys() { //use specified force move vector if( forceMoveVectorTimer != 0 ) return forceMoveVector; //TPS arcade specific //vector is depending on camera orientation if( GameMap.Instance != null && GameMap.Instance.GameType == GameMap.GameTypes.TPSArcade && PlayerIntellect.Instance == Intellect ) { //this is not adapted for networking. //using RendererWorld.Instance.DefaultCamera is bad. Vec2 localVector = Vec2.Zero; localVector.X += Intellect.GetControlKeyStrength( GameControlKeys.Forward ); localVector.X -= Intellect.GetControlKeyStrength( GameControlKeys.Backward ); localVector.Y += Intellect.GetControlKeyStrength( GameControlKeys.Left ); localVector.Y -= Intellect.GetControlKeyStrength( GameControlKeys.Right ); if( localVector != Vec2.Zero ) { Vec2 diff = Position.ToVec2() - RendererWorld.Instance.DefaultCamera.Position.ToVec2(); Degree angle = new Radian( MathFunctions.ATan( diff.Y, diff.X ) ); Degree vecAngle = new Radian( MathFunctions.ATan( -localVector.Y, localVector.X ) ); Quat rot = new Angles( 0, 0, vecAngle - angle ).ToQuat(); Vec2 vector = ( rot * new Vec3( 1, 0, 0 ) ).ToVec2(); return vector; } else return Vec2.Zero; } //PlatformerDemo specific if( GameMap.Instance != null && GameMap.Instance.GameType == GameMap.GameTypes.PlatformerDemo && PlayerIntellect.Instance == Intellect ) { Vec2 vector = Vec2.Zero; vector.X -= Intellect.GetControlKeyStrength( GameControlKeys.Left ); vector.X += Intellect.GetControlKeyStrength( GameControlKeys.Right ); return vector; } //default behaviour { Vec2 localVector = Vec2.Zero; localVector.X += Intellect.GetControlKeyStrength( GameControlKeys.Forward ); localVector.X -= Intellect.GetControlKeyStrength( GameControlKeys.Backward ); localVector.Y += Intellect.GetControlKeyStrength( GameControlKeys.Left ); localVector.Y -= Intellect.GetControlKeyStrength( GameControlKeys.Right ); Vec2 vector = ( new Vec3( localVector.X, localVector.Y, 0 ) * Rotation ).ToVec2(); if( vector != Vec2.Zero ) { float length = vector.Length(); if( length > 1 ) vector /= length; } return vector; } }
protected override void OnRenderFrame() { base.OnRenderFrame(); //update position, rotation of attached meshes of wheels if( wheelAttachedObjects != null ) { Radian[] wheelsRotationAngle = null; Radian[] wheelsSteer = null; float[] wheelsSuspensionJounce = null; if( EntitySystemWorld.Instance.IsClientOnly() && networkingClient_wheelsRotationAngle != null ) { wheelsRotationAngle = networkingClient_wheelsRotationAngle; wheelsSteer = networkingClient_wheelsSteer; wheelsSuspensionJounce = networkingClient_wheelsSuspensionJounce; } else if( physicsVehicle != null ) { wheelsRotationAngle = physicsVehicle.GetWheelsRotationAngle(); wheelsSteer = physicsVehicle.GetWheelsSteer(); wheelsSuspensionJounce = physicsVehicle.GetWheelsSuspensionJounce(); } if( wheelsRotationAngle != null ) { for( int wheelIndex = 0; wheelIndex < 4; wheelIndex++ ) { MapObjectAttachedObject attachedObject = wheelAttachedObjects[ wheelIndex ]; if( attachedObject != null ) { attachedObject.PositionOffset = attachedObject.TypeObject.Position + new Vec3( 0, 0, wheelsSuspensionJounce[ wheelIndex ] ); Quat rotationAngle = new Angles( 0, -wheelsRotationAngle[ wheelIndex ].InDegrees(), 0 ).ToQuat(); Quat rotationSteer = new Angles( 0, 0, -wheelsSteer[ wheelIndex ].InDegrees() ).ToQuat(); attachedObject.RotationOffset = attachedObject.TypeObject.Rotation * rotationSteer * rotationAngle; } } } } }
protected override void OnGetCameraTransform( out Vec3 position, out Vec3 forward, out Vec3 up, ref Degree cameraFov) { Vec3 offset; { Quat rot = new Angles( 0, 0, MathFunctions.RadToDeg( cameraDirection.Horizontal ) ).ToQuat(); rot *= new Angles( 0, MathFunctions.RadToDeg( cameraDirection.Vertical ), 0 ).ToQuat(); offset = rot * new Vec3( 1, 0, 0 ); offset *= cameraDistance; } Vec3 lookAt = new Vec3( cameraPosition.X, cameraPosition.Y, 0 ); position = lookAt + offset; forward = -offset; up = new Vec3( 0, 0, 1 ); }
public static Matrix vm_angles_2_matrix(ref Angles a) { float sinp = Mathf.Sin(a.pitch); float cosp = Mathf.Cos(a.pitch); float sinb = Mathf.Sin(a.bank); float cosb = Mathf.Cos(a.bank); float sinh = Mathf.Sin(a.heading); float cosh = Mathf.Cos(a.heading); return sincos_2_matrix(sinp, cosp, sinb, cosb, sinh, cosh); }
void MomentaryTurnToPositionUpdate(Vec3 turnToPosition) { if ((turnToPosition - Position).Length() < 4.0f) { Vec3 dir = (turnToPosition - Position).GetNormalize(); turnToPosition += dir * 10f; } Vec3 diff = (turnToPosition - Position); Quat collisionRotation; float distance = diff.LengthFast(); Radian horizontalAngle = MathFunctions.ATan(diff.Y, diff.X); Radian verticalAngle = MathFunctions.ATan(diff.Z, diff.ToVec2().Length()); collisionRotation = new Angles(0, 0, -horizontalAngle.InDegrees()).ToQuat(); collisionRotation *= new Angles(0, verticalAngle.InDegrees(), 0).ToQuat(); Rotation = Quat.Slerp(Rotation, collisionRotation, Type.HomingCorrection); }
void TickIntellect( Intellect intellect ) { Vec2 forceVec = Vec2.Zero; if( forceMoveVectorTimer != 0 ) { forceVec = forceMoveVector; } else { Vec2 vec = Vec2.Zero; vec.X += intellect.GetControlKeyStrength( GameControlKeys.Forward ); vec.X -= intellect.GetControlKeyStrength( GameControlKeys.Backward ); vec.Y += intellect.GetControlKeyStrength( GameControlKeys.Left ); vec.Y -= intellect.GetControlKeyStrength( GameControlKeys.Right ); forceVec = ( new Vec3( vec.X, vec.Y, 0 ) * Rotation ).ToVec2(); //TPS arcade specific (camera observe) //set forceVec depending on camera orientation if( GameMap.Instance.GameType == GameMap.GameTypes.TPSArcade && forceVec != Vec2.Zero ) { if( Intellect != null && PlayerIntellect.Instance == Intellect ) { //this is not adapted for networking. //using RendererWorld.Instance.DefaultCamera is bad. Vec2 diff = Position.ToVec2() - RendererWorld.Instance.DefaultCamera. Position.ToVec2(); Degree angle = new Radian( MathFunctions.ATan( diff.Y, diff.X ) ); Degree vecAngle = new Radian( MathFunctions.ATan( -vec.Y, vec.X ) ); Quat rot = new Angles( 0, 0, vecAngle - angle ).ToQuat(); forceVec = ( rot * new Vec3( 1, 0, 0 ) ).ToVec2(); } } if( forceVec != Vec2.Zero ) { float length = forceVec.Length(); if( length > 1 ) forceVec /= length; } } if( forceVec != Vec2.Zero ) { float speedCoefficient = 1; if( FastMoveInfluence != null ) speedCoefficient = FastMoveInfluence.Type.Coefficient; float maxSpeed; float force; if( IsOnGround() ) { //calcualate maxSpeed and force on ground. Vec2 localVec = ( new Vec3( forceVec.X, forceVec.Y, 0 ) * Rotation.GetInverse() ).ToVec2(); float absSum = Math.Abs( localVec.X ) + Math.Abs( localVec.Y ); if( absSum > 1 ) localVec /= absSum; bool running = IsNeedRun(); maxSpeed = 0; force = 0; if( Math.Abs( localVec.X ) >= .001f ) { //forward and backward float speedX; if( localVec.X > 0 ) speedX = running ? Type.RunForwardMaxSpeed : Type.WalkForwardMaxSpeed; else speedX = running ? Type.RunBackwardMaxSpeed : Type.WalkBackwardMaxSpeed; maxSpeed += speedX * Math.Abs( localVec.X ); force += ( running ? Type.RunForce : Type.WalkForce ) * Math.Abs( localVec.X ); } if( Math.Abs( localVec.Y ) >= .001f ) { //left and right maxSpeed += ( running ? Type.RunSideMaxSpeed : Type.WalkSideMaxSpeed ) * Math.Abs( localVec.Y ); force += ( running ? Type.RunForce : Type.WalkForce ) * Math.Abs( localVec.Y ); } } else { //calcualate maxSpeed and force when flying. maxSpeed = Type.FlyControlMaxSpeed; force = Type.FlyControlForce; } //speedCoefficient maxSpeed *= speedCoefficient; force *= speedCoefficient; if( mainBody.LinearVelocity.LengthFast() < maxSpeed ) { mainBody.AddForce( ForceType.Global, 0, new Vec3( forceVec.X, forceVec.Y, 0 ) * force * TickDelta, Vec3.Zero ); } } lastTickForceVector = forceVec; }
// NH & KEEN - reworked the homing function for better accuracy private void MomentaryTurnToPositionUpdate(Vec3 turnToPosition) { if (targetBody != null) { turnToPosition = targetBody.Position; if (targetShape != null) { turnToPosition += (targetShape.Position * targetBody.Rotation); } if (Type.HomingPrediction > 0.0f) { float flyTime = (turnToPosition - Position).Length() / Type.Velocity; turnToPosition += targetBody.LinearVelocity * flyTime * Type.HomingPrediction; } } Vec3 diff = (turnToPosition - Position); Degree horizontalAngle = new Radian(-MathFunctions.ATan(diff.Y, diff.X)).InDegrees(); Degree verticalAngle = new Radian(MathFunctions.ATan(diff.Z, diff.ToVec2().Length())).InDegrees(); Quat collisionRotation = new Angles(0, 0, horizontalAngle).ToQuat(); collisionRotation *= new Angles(0, verticalAngle, 0).ToQuat(); Radian targetAngle = Quat.GetAngle(Rotation, collisionRotation); float PI = (float)Math.PI; if (targetAngle > PI) { targetAngle = (2 * PI) - targetAngle; } Radian maxTurnAbility = Type.HomingCorrection.InRadians() * TickDelta; if (targetAngle > maxTurnAbility) { float relativeCorrection = maxTurnAbility / targetAngle; Rotation = Quat.Slerp(Rotation, collisionRotation, relativeCorrection); } else { Rotation = collisionRotation; } }
void physics_sim_rot(float sim_time) { float shock_fraction_time_left = 0.0f; float shock_amplitude = 0.0f; float rotdamp = 0.0f; if ((p_flags & PF_IN_SHOCKWAVE) > 0) { if (timestamp_elapsed(shockwave_decay)) { p_flags &= ~PF_IN_SHOCKWAVE; rotdamp = this.rotdamp; } else { shock_fraction_time_left = timestamp_until(shockwave_decay) / (float)SW_BLAST_DURATION; rotdamp = this.rotdamp + this.rotdamp * (SW_ROT_FACTOR - 1) * shock_fraction_time_left; shock_amplitude = shockwave_shake_amp * shock_fraction_time_left; } } else { rotdamp = this.rotdamp; } Vector3 new_vel = Vector3.zero; Vector3 delta_pos = Vector3.zero; apply_physics(rotdamp, desired_rotvel.x, rotvel.x, sim_time, ref new_vel.x, ref delta_pos.x); apply_physics(rotdamp, desired_rotvel.y, rotvel.y, sim_time, ref new_vel.y, ref delta_pos.y); apply_physics(rotdamp, desired_rotvel.z, rotvel.z, sim_time, ref new_vel.z, ref delta_pos.z); rotvel = new_vel; Angles tangles = new Angles(); tangles.pitch = rotvel.x * sim_time; tangles.heading = rotvel.y * sim_time; tangles.bank = rotvel.z * sim_time; if ((p_flags & PF_IN_SHOCKWAVE) > 0) { tangles.pitch += UnityEngine.Random.Range(-0.5f, 0.5f) * shock_amplitude; tangles.heading += UnityEngine.Random.Range(-0.5f, 0.5f) * shock_amplitude; } last_rotmat = MathUtils.vm_angles_2_matrix(ref tangles); Matrix tmp = MathUtils.vm_matrix_x_matrix(ref orient, ref last_rotmat); orient.Copy(ref tmp); MathUtils.vm_orthogonalize_matrix(ref orient); }
void MomentaryTurnToPositionUpdate( Vec3 turnToPosition ) { if( turretBody == null || baseBody == null || mainGunAttachedObject == null ) return; Vec3 diff = turnToPosition - Position; Radian horizontalAngle = MathFunctions.ATan( diff.Y, diff.X ); Radian verticalAngle = MathFunctions.ATan( diff.Z, diff.ToVec2().Length() ); turretBody.Rotation = new Angles( 0, 0, -horizontalAngle.InDegrees() ).ToQuat(); Quat rot = baseBody.Rotation.GetInverse() * turretBody.Rotation; Quat verticalRot = new Angles( 0, verticalAngle.InDegrees(), 0 ).ToQuat(); mainGunAttachedObject.PositionOffset = rot * mainGunOffsetPosition; mainGunAttachedObject.RotationOffset = rot * verticalRot; if( EntitySystemWorld.Instance.IsServer() ) server_shouldSendTurnToPosition = turnToPosition; }
void sensor_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e) { using (SkeletonFrame skeletonFrame=e.OpenSkeletonFrame()) { if (skeletonFrame == null) { return; } inputmethod = W.inputmethod; skeletonFrame.CopySkeletonDataTo(allSkeletons); //get the first tracked skeleton Skeleton first = (from s in allSkeletons where s.TrackingState == SkeletonTrackingState.Tracked select s).FirstOrDefault(); // skeleton data may not be available if (first == null) { return; } // display skeleton on window displaySkeleton(first); // Selecting the input method switch (inputmethod) { case 0: // input version 1 Angles angles1 = new Angles(first); AxisAngles = angles1.getFinalAngles(); break; case 2: // input version 2 HandPosition angles2 = new HandPosition(first); AxisAngles = angles2.getFinalAngles(); break; case 1: // input version 3 HandPositionLower angles3 = new HandPositionLower(first); AxisAngles = angles3.getFinalAngles(); break; default: MessageBox.Show("Error !!!"); break; } AxisAngles = medians.getNextMedian(AxisAngles); // Displaying on GUI W.axis1.Content = AxisAngles[1].ToString(); W.axis2.Content = AxisAngles[2].ToString(); W.axis3.Content = AxisAngles[3].ToString(); W.axis4.Content = AxisAngles[4].ToString(); W.axis5.Content = AxisAngles[5].ToString(); W.axis6.Content = AxisAngles[6].ToString(); if (W.RoboticArmMovement) MoveRoboticArm(AxisAngles); } }
void UpdateRotation() { Rotation = new Angles( 0, 0, -rotationAngle.InDegrees() ).ToQuat(); }
void TickIntellect( Intellect intellect ) { Vec2 forceVec = Vec2.Zero; if( forceMoveVectorTimer != 0 ) { forceVec = forceMoveVector; } else { Vec2 vec = Vec2.Zero; vec.X += intellect.GetControlKeyStrength( GameControlKeys.Forward ); vec.X -= intellect.GetControlKeyStrength( GameControlKeys.Backward ); vec.Y += intellect.GetControlKeyStrength( GameControlKeys.Left ); vec.Y -= intellect.GetControlKeyStrength( GameControlKeys.Right ); forceVec = ( new Vec3( vec.X, vec.Y, 0 ) * Rotation ).ToVec2(); //TPS arcade specific (camera observe) //set forceVec depending on camera orientation if( GameMap.Instance.GameType == GameMap.GameTypes.TPSArcade && forceVec != Vec2.Zero ) { if( Intellect != null && PlayerIntellect.Instance == Intellect ) { //!!!!!!not adapted for networking //using RendererWorld.Instance.DefaultCamera is bad Vec2 diff = Position.ToVec2() - RendererWorld.Instance.DefaultCamera. Position.ToVec2(); Degree angle = new Radian( MathFunctions.ATan( diff.Y, diff.X ) ); Degree vecAngle = new Radian( MathFunctions.ATan( -vec.Y, vec.X ) ); Quat rot = new Angles( 0, 0, vecAngle - angle ).ToQuat(); forceVec = ( rot * new Vec3( 1, 0, 0 ) ).ToVec2(); } } if( forceVec != Vec2.Zero ) { float length = forceVec.Length(); if( length > 1 ) forceVec /= length; } } if( forceVec != Vec2.Zero ) { float velocityCoefficient = 1; if( FastMoveInfluence != null ) velocityCoefficient = FastMoveInfluence.Type.Coefficient; float maxVelocity; float force; if( IsOnGround() ) { maxVelocity = Type.WalkMaxVelocity; force = Type.WalkForce; } else { maxVelocity = Type.FlyControlMaxVelocity; force = Type.FlyControlForce; } maxVelocity *= forceVec.LengthFast(); //velocityCoefficient maxVelocity *= velocityCoefficient; force *= velocityCoefficient; if( mainBody.LinearVelocity.LengthFast() < maxVelocity ) mainBody.AddForce( ForceType.Global, 0, new Vec3( forceVec.X, forceVec.Y, 0 ) * force * TickDelta, Vec3.Zero ); } lastTickForceVector = forceVec; }