/// <summary> /// Gets the number of shapes in the list for the particular shape /// </summary> /// <param name="phmo">the serialized phmo from which to get the counts</param> /// <param name="type">the shape for which to get the count</param> /// <returns></returns> private int GetNumberOfShapes(PhysicsModel phmo, HavokShapeType type) { switch (type) { case HavokShapeType.Box: return(phmo.Boxes != null ? phmo.Boxes.Count : 0); case HavokShapeType.List: return(phmo.Lists != null ? phmo.Lists.Count : 0); case HavokShapeType.Mopp: return(phmo.Mopps != null ? phmo.Mopps.Count : 0); case HavokShapeType.Pill: return(phmo.Pills != null ? phmo.Pills.Count : 0); case HavokShapeType.Polyhedron: return(phmo.Polyhedra != null ? phmo.Polyhedra.Count : 0); case HavokShapeType.Sphere: return(phmo.Spheres != null ? phmo.Spheres.Count : 0); default: return(0); } }
private void Client_ReceiveHitCall(RemoteEntityWorld sender, ReceiveDataReader reader) { Vec3 hitPosition = reader.ReadVec3(); string hitShapeBodyName = reader.ReadString(); string hitShapeName = reader.ReadString(); Vec3 hitNormal = reader.ReadVec3(); MapObject hitMapObject = Entities.Instance.GetByNetworkUIN(reader.ReadVariableUInt32()) as MapObject; if (!reader.Complete()) { return; } Position = hitPosition; Shape hitShape = null; if (PhysicsModel != null) { Body body = PhysicsModel.GetBody(hitShapeBodyName); if (body != null) { hitShape = body.GetShape(hitShapeName); } } OnHit(hitShape, hitNormal, hitMapObject); }
protected override void OnTick() { base.OnTick(); if (firstWay == true) { ActivateWayMovement(); } UpdateGeneralTask(); CalculateThings(); chassisBody = PhysicsModel.GetBody("main"); if (chassisBody == null) { Log.Error("Emrah Helli: \"main\" chassisBody dose not exists."); return; } float diff = Position.Z - flyHeight; float force = -diff - chassisBody.LinearVelocity.Z; MathFunctions.Clamp(ref force, -10, 10); chassisBody.AddForce(ForceType.GlobalAtLocalPos, TickDelta, new Vec3(0, 0, force * 3) * chassisBody.Mass, new Vec3(0, 0, 1)); chassisBody.AngularDamping = 1; this.flyHeight = TaskPosition.Z; float ZA = ZADiffAngle * 4; if (ZA < 20 && ZA > -20) { chassisBody.AngularVelocity = new Vec3 (chassisBody.AngularVelocity.X, chassisBody.AngularVelocity.Y, ZA); } else if (ZA > 20) { chassisBody.AngularVelocity = new Vec3 (chassisBody.AngularVelocity.X, chassisBody.AngularVelocity.Y, -2); } else if (ZA < -20) { chassisBody.AngularVelocity = new Vec3 (chassisBody.AngularVelocity.X, chassisBody.AngularVelocity.Y, 2); } chassisBody.AddForce(ForceType.LocalAtLocalPos, TickDelta, new Vec3(Velocity * chassisBody.Mass, 0, 0), new Vec3(-1, 0, 0)); chassisBody.LinearDamping = 1; //check outside Map position Bounds checkBounds = Map.Instance.InitialCollisionBounds; checkBounds.Expand(new Vec3(300, 300, 10000)); if (!checkBounds.IsContainsPoint(Position)) { SetDeleted(); } }
/// <summary> /// Initialise the physics model to be built /// </summary> public PhysicsModelBuilder() { _phmo = new PhysicsModel(); _phmo.RigidBodies = new List <PhysicsModel.RigidBody>(); _phmo.Nodes = new List <PhysicsModel.Node>(); var node = new PhysicsModel.Node(); node.Child = -1; node.Sibling = -1; node.Parent = -1; //the 'default' stringid node.Name = new StringId(1); _phmo.Nodes.Add(node); _phmo.Materials = new List <PhysicsModel.Material>(); var material = new PhysicsModel.Material(); //the 'default' stringid material.Name = new StringId(1); material.Flags = -256; material.PhantomType = -1; _phmo.Materials.Add(material); }
/// <summary> /// Adds planes to the physics model as described by the JSON node /// </summary> /// <param name="phmo"></param> /// <param name="n">a node that is a list of plane equations</param> /// <returns>The number of plane-equation tag-blocks added</returns> private int AddManyPlanes(PhysicsModel phmo, JSONNode n) { if (n == null) { Console.WriteLine("could not find \"Planes\" attribute."); return(0); } if (phmo.PolyhedronPlaneEquations == null) { phmo.PolyhedronPlaneEquations = new List <PhysicsModel.PolyhedronPlaneEquation>(); } foreach (JSONNode p in n.AsArray) { var p_vals = p.AsArray; var plane = new PhysicsModel.PolyhedronPlaneEquation { Unknown = p_vals[0].AsFloat, Unknown2 = p_vals[1].AsFloat, Unknown3 = p_vals[2].AsFloat, Unknown4 = p_vals[3].AsFloat }; phmo.PolyhedronPlaneEquations.Add(plane); } return(n.AsArray.Count); }
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary> protected override void OnPostCreate(bool loaded) { base.OnPostCreate(loaded); SubscribeToTickEvent(); //init doorBodyInitPosition and doorBody if (PhysicsModel != null) { for (int n = 0; n < PhysicsModel.Bodies.Length; n++) { if (PhysicsModel.Bodies[n].Name == "door" || PhysicsModel.Bodies[n].Name == "door1") { Mat4 transform = PhysicsModel.ModelDeclaration.Bodies[n].GetTransform(); doorBody1InitPosition = transform.Item3.ToVec3(); } else if (PhysicsModel.Bodies[n].Name == "door2") { Mat4 transform = PhysicsModel.ModelDeclaration.Bodies[n].GetTransform(); doorBody2InitPosition = transform.Item3.ToVec3(); } } doorBody1 = PhysicsModel.GetBody("door1"); if (doorBody1 == null) { doorBody1 = PhysicsModel.GetBody("door"); } doorBody2 = PhysicsModel.GetBody("door2"); } UpdateDoorBodies(); UpdateAttachedObjects(); }
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary> protected override void OnPostCreate(bool loaded) { base.OnPostCreate(loaded); if (EntitySystemWorld.Instance.IsServer() || EntitySystemWorld.Instance.IsSingle()) { const string regionTypeName = "ManualInfluenceRegion"; InfluenceRegionType regionType = (InfluenceRegionType)EntityTypes.Instance.GetByName( regionTypeName); if (regionType == null) { regionType = (InfluenceRegionType)EntityTypes.Instance.ManualCreateType( regionTypeName, EntityTypes.Instance.GetClassInfoByEntityClassName("InfluenceRegion")); regionType.NetworkType = EntityNetworkTypes.ServerOnly; } region = (InfluenceRegion)Entities.Instance.Create(regionType, Map.Instance); region.ShapeType = Region.ShapeTypes.Capsule; region.DistanceFunction = InfluenceRegion.DistanceFunctionType.NormalFadeAxisX; region.SetTransform(Position, Rotation, InfluenceRegionScale); region.PostCreate(); region.AllowSave = false; region.EditorSelectable = false; bladesMotor = PhysicsModel.GetMotor("bladesMotor") as GearedMotor; } SubscribeToTickEvent(); }
public override void Intersection(PhysicsModel modelB) { var delta = (MapObject.Position - modelB.MapObject.Position).Length(); var radSum = Radius; if (modelB is PhysicsSphere) { radSum += ((PhysicsSphere)modelB).Radius; } //if (modelB is PhysicsSphere sphere) // c# 7.0 //{ // radSum += sphere.Radius; //} if (delta >= radSum) { return; } CallOnIntersection(modelB); if (IsCollision && modelB.IsCollision) { var firstModel = IsSatatic ? modelB : this; var secondModel = firstModel == this ? modelB : this; var deltaVec = firstModel.MapObject.Position - secondModel.MapObject.Position; firstModel.MapObject.Position -= deltaVec / deltaVec.Length() * (delta - radSum); } }
/// <summary> /// Initialise the physics model to be built /// </summary> public PhysicsModelBuilder() { _phmo = new PhysicsModel { RigidBodies = new List <PhysicsModel.RigidBody>(), Nodes = new List <PhysicsModel.Node>() }; var node = new PhysicsModel.Node { Child = -1, Sibling = -1, Parent = -1, //the 'default' stringid Name = new StringId(1) }; _phmo.Nodes.Add(node); _phmo.Materials = new List <PhysicsModel.Material>(); var material = new PhysicsModel.Material { //the 'default' stringid Name = new StringId(1), // ??? material.Flags = -256; PhantomType = -1 }; _phmo.Materials.Add(material); }
public bool GetAdvanceAttackTargetPosition(bool alternative, MapObject obj, bool useGravity, out Vec3 pos) { Mode mode = alternative ? alternativeMode : normalMode; if (mode.typeMode.BulletType == null) { Log.Fatal("Gun: GetAdvanceAttackTargetPosition: BulletType = null"); } PhysicsModel objPhysicsModel = obj.PhysicsModel; if (objPhysicsModel == null) { pos = obj.Position; return(true); } Vec3 objPos = obj.Position; float bulletVelocity = mode.typeMode.BulletType.Velocity; if (bulletVelocity == 0) { pos = objPos; return(true); } Vec3 diff = objPos - Position; float len = diff.Length(); float flyTime; if (useGravity && mode.typeMode.BulletType.Gravity != 0) { float sh = diff.ToVec2().Length(); float angle = mode.typeMode.BulletType.CalculateDemandedVerticalAngleToHitTarget(sh, diff.Z); if (angle != -1) { float vh = bulletVelocity * MathFunctions.Cos(angle); flyTime = sh / vh; } else { pos = objPos; return(false); } } else { flyTime = len / bulletVelocity; } Vec3 objVelocity = objPhysicsModel.Bodies[0].LinearVelocity; pos = objPos + objVelocity * flyTime; return(true); }
public void LoadLevel() { if (levelJsonFile != null) { RemoveLevel(); levelObjects = new List <LevelObject>(); string data = levelJsonFile.text; LevelData levelData = JsonUtility.FromJson <LevelData>(data); audioSource.clip = Resources.Load <AudioClip>("Audio/" + levelData.songName); songIndexLength = levelData.songIndexLength; spacingBetweenSamples = levelData.spacingBetweenSamples; playerOffset = levelData.playerOffset; songTime = levelData.songTime; levelLength = levelData.levelLength; platform.localScale = new Vector3(levelData.platformScale, 1, 1); physicsModel = levelData.physicsModel; for (int i = 0; i < levelData.levelObjectData.Count; i++) { LevelObject levelObject = new LevelObject(); GameObject levelObjectPrefab = null; switch (levelData.levelObjectData[i].feature.type) { case LevelFeature.features.Spikes: levelObjectPrefab = spikePrefab; break; case LevelFeature.features.SlideBlock: levelObjectPrefab = slideBlockPrefab; break; case LevelFeature.features.DestructableWalls: break; } if (levelObject != null) { levelObject.gameObject = Instantiate(levelObjectPrefab, new Vector2(levelData.levelObjectData[i].songPositionIndex * levelData.spacingBetweenSamples + levelData.levelObjectData[i].feature.offset, levelTransform.position.y), Quaternion.identity, levelTransform); levelObject.feature = levelData.levelObjectData[i].feature; levelObject.songPositionIndex = levelData.levelObjectData[i].songPositionIndex; levelObjects.Add(levelObject); } } lightingEvents = levelData.lightingEventData; spectrumData = levelData.spectrumData; numberOfBars = levelData.spectrumData[0].spectrum.Length; loadedLevel = levelData; } }
public Simulator(Aircraft aircraft, Weather weather) { Time = 0; _aircraft = aircraft; _weather = weather; _physicsModel = new BasicPhysicsModel(_aircraft, Vector3.zero, new BasicPhysicsModelData { ControlRate = 10f, DeadZone = 0.2f, Lerp = 0.03f, MaxTurn = 15.0f, AileronTurnRate = 300f, ElevatorTurnRate = 3f, RudderTurnRate = 100f }); }
/////////////////////////////////////////// /// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary> protected override void OnPostCreate(bool loaded) { base.OnPostCreate(loaded); SubscribeToTickEvent(); CreateThreads(); magnetBody = PhysicsModel.GetBody("magnet"); if (magnetBody != null) { magnetBody.Collision += magnetBody_Collision; } }
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary> protected override void OnPostCreate(bool loaded) { base.OnPostCreate(loaded); SetTurnToPosition(Position + Rotation.GetForward() * 100); if (PhysicsModel != null) { PhysicsModel.PopFromWorld(); Damager_Ball = PhysicsModel.GetBody("Damager_Ball"); Damager_Ball_Player = PhysicsModel.GetBody("CT"); //if (Damager_Ball_Player != null) //{ // //this.Type.BallRadius = .5f;//((Damager_Ball_Player.Shapes[0].Volume * 3f) / (4f * (float)Math.PI) * .333333f); // foreach (Body body in PhysicsModel.Bodies) // body.Collision += new Body.CollisionDelegate(body_Collision); //} if (!EntitySystemWorld.Instance.IsEditor()) { Damager_Ball_Player.Shapes[0].Density = PhysicsDensity; Damager_Ball_Player.Shapes[0].DynamicFriction = PhysicsDynamicFriction; Damager_Ball_Player.Shapes[0].Restitution = PhysicsBounciness; //Bounciness Damager_Ball_Player.Shapes[0].StaticFriction = PhysicsStaticFriction; Damager_Ball_Player.Shapes[0].SpecialLiquidDensity = PhysicsLiquidDensity; Damager_Ball_Player.Shapes[0].ContactGroup = (int)ContactGroup.Dynamic; Damager_Ball_Player.EnableGravity = true; Damager_Ball_Player.LinearVelocity = linearVelocityForSerialization; } if (!EntitySystemWorld.Instance.IsEditor()) { if (Damager_Ball_Player == null) { Log.Error("Damager_Ball.type: \"Damager_Ball\" body does not exist. The Physics Body is Named incorrectly?"); } } SubscribeToTickEvent(); CheckPhysicsProperties(); PhysicsModel.PushToWorld(); } //Incin //if activeMaxTurrets turret was out from before RemoveMiniTurret it //if (turret != null) //{ // turret.SetForDeletion(false); // turretTimer = 0; //reset remove timer // activeturrets = 0; //reset turret counts //} }
protected override void OnPostCreate(bool loaded) { base.OnPostCreate(loaded); HelliBody = PhysicsModel.GetBody("Helli"); if (HelliBody == null) { Log.Error("Helli: \"Helli\" HelliBody dose not exists."); return; } SubscribeToTickEvent(); }
protected override void OnPostCreate(bool loaded) { base.OnPostCreate(loaded); AKJetBody = PhysicsModel.GetBody("Jet"); if (AKJetBody == null) { Log.Error("AKJet: \"AKJet\" AKJetBody does not exist."); return; } Stall = false; AddTimer(); }
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary> protected override void OnPostCreate(bool loaded) { base.OnPostCreate(loaded); AddTimer(); if (!EngineApp.Instance.IsResourceEditor) { if (PhysicsModel == null) { Log.Error("Forklift: Physics model not exists."); return; } forkliftBody = PhysicsModel.GetBody("forklift"); if (forkliftBody == null) { Log.Error("Forklift: \"forklift\" body not exists."); return; } leftwheelBody = PhysicsModel.GetBody("leftwheel"); rightwheelBody = PhysicsModel.GetBody("rightwheel"); forkBody = PhysicsModel.GetBody("fork"); up1Body = PhysicsModel.GetBody("up1"); up2Body = PhysicsModel.GetBody("up2"); b2Body = PhysicsModel.GetBody("b2"); b1Body = PhysicsModel.GetBody("b1"); wheelRearRightBody = PhysicsModel.GetBody("wheelRearRight"); wheelRearLeftBody = PhysicsModel.GetBody("wheelRearLeft"); foreach (MapObjectAttachedObject attachedObject in AttachedObjects) { if (attachedObject.Alias == "leftWheel") { leftWheel.wheelHelpers.Add((MapObjectAttachedHelper)attachedObject); } if (attachedObject.Alias == "rightWheel") { rightWheel.wheelHelpers.Add((MapObjectAttachedHelper)attachedObject); } } if (leftWheel.wheelHelpers.Count != 0) { wheelsPositionYOffset = Math.Abs(leftWheel.wheelHelpers[0].PositionOffset.Y); } } //initialize currentGear currentGear = Type.Gears.Find(delegate(ForkliftType.Gear gear) { return(gear.Number == 0); }); }
private PhysicsModel ConvertPhysicsModel(CachedTag instance, PhysicsModel phmo) { phmo.MoppData = HavokConverter.ConvertHkpMoppData(BlamCache.Version, CacheContext.Version, phmo.MoppData); if (BlamCache.Version == CacheVersion.HaloReach) { foreach (var rigidbody in phmo.RigidBodies) { rigidbody.MotionType = rigidbody.MotionType_Reach; rigidbody.ShapeType = rigidbody.ShapeType_Reach; rigidbody.ShapeIndex = rigidbody.ShapeIndex_Reach; rigidbody.Mass = rigidbody.Mass_Reach; } } return(phmo); }
protected override void OnPostCreate(bool loaded) { base.OnPostCreate(loaded); AKVTOLBody = PhysicsModel.GetBody("Jet"); if (AKVTOLBody == null) { Log.Error("AKVTOL: \"AKVTOL\" AKVTOLBody dose not exists."); return; } AddTimer(); EngineDir = 90f; }
private void MohiOff() { //turning off some stuff when you are getting out of helli GearedMotor main = PhysicsModel.GetMotor("hellimain") as GearedMotor; GearedMotor back = PhysicsModel.GetMotor("helliback") as GearedMotor; main.Enabled = false; back.Enabled = false; if (rotorSoundChannel != null) { rotorSoundChannel.Stop(); rotorSoundChannel = null; } }
public void GenerateLevelFromSamples(FrequencyBand[] frequencyBands, float _songTime) { levelObjects = new List <LevelObject>(); songIndexLength = frequencyBands[0].spectralFluxSamples.Count; levelLength = (songIndexLength * spacingBetweenSamples); songTime = _songTime; //Scale level to the length of the song platform.localScale = new Vector3(levelLength + 15, 1, 1); physicsModel = new PhysicsModel(); //Set physics model physicsModel.gravity = Mathf.Abs(Physics2D.gravity.y * player.rigidbody.gravityScale); physicsModel.velocity = levelLength / songTime; physicsModel.jumpAcceleration = player.GetJumpAcceleration(); physicsModel.CalculatePhysicsModel(); //Sort level based on priority Array.Sort(levelFeatures, delegate(LevelFeature feature1, LevelFeature feature2) { return(feature1.priority.CompareTo(feature2.priority)); }); for (int i = 0; i < levelFeatures.Length; i++) { switch (levelFeatures[i].type) { case LevelFeature.features.Spikes: CreateLevelObjects(spikePrefab, frequencyBands[levelFeatures[i].bandIndex], ref levelFeatures[i]); break; case LevelFeature.features.SlideBlock: CreateLevelObjects(slideBlockPrefab, frequencyBands[levelFeatures[i].bandIndex], ref levelFeatures[i]); break; case LevelFeature.features.DestructableWalls: break; case LevelFeature.features.LevelHeight: break; case LevelFeature.features.Lighting: CreateLightingEvents(frequencyBands[levelFeatures[i].bandIndex]); break; } } CleanUpLevel(); }
protected override void OnPostCreate(bool loaded) { base.OnPostCreate(loaded); SubscribeToTickEvent(); if (EntitySystemWorld.Instance.WorldSimulationType != WorldSimulationTypes.Editor) { if (PhysicsModel == null) { Log.Error("Class AKCar: Physics model not exists."); return; } chassisBody = PhysicsModel.GetBody("AKCar"); if (chassisBody == null) { Log.Error("Class AKCar: \"AKCar\" body dose not exists."); return; } //chassisBody.Collision += chassisBody_Collision; foreach (MapObjectAttachedObject attachedObject in AttachedObjects) { if (attachedObject.Alias == "leftTrack") { leftTrack.trackHelpers.Add((MapObjectAttachedHelper)attachedObject); } if (attachedObject.Alias == "rightTrack") { rightTrack.trackHelpers.Add((MapObjectAttachedHelper)attachedObject); } } if (leftTrack.trackHelpers.Count != 0) { tracksPositionYOffset = Math.Abs(leftTrack.trackHelpers[0].PositionOffset.Y); } } //initialize currentGear currentGear = Type.Gears.Find(delegate(AKCarType.Gear gear) { return(gear.Number == 0); }); }
/// <summary> /// Adds Four-vertex tag-blocks to the physics model. For lists /// of vertices that are not multiples of four, the last vertex /// is copied. /// </summary> /// <param name="phmo"></param> /// <param name="n">a node that is a list of vertex equations</param> /// <returns>the number of four-vertex tag-blocks added.</returns> private int AddManyFVS(PhysicsModel phmo, JSONNode n) { if (n == null) { Console.WriteLine("could not find \"Vertices\" attribute."); return(0); } if (phmo.PolyhedronFourVectors == null) { phmo.PolyhedronFourVectors = new List <PhysicsModel.PolyhedronFourVector>(); } int vertCount = n.AsArray.Count; int numfvs = vertCount / 4 + ((vertCount % 4) > 0 ? 1 : 0); for (int i = 0; i < numfvs; ++i) { JSONNode v0 = (i * 4) < vertCount ? n.AsArray[i * 4] : n.AsArray[vertCount - 1]; JSONNode v1 = (i * 4 + 1) < vertCount ? n.AsArray[i * 4 + 1] : n.AsArray[vertCount - 1]; JSONNode v2 = (i * 4 + 2) < vertCount ? n.AsArray[i * 4 + 2] : n.AsArray[vertCount - 1]; JSONNode v3 = (i * 4 + 3) < vertCount ? n.AsArray[i * 4 + 3] : n.AsArray[vertCount - 1]; var fourvert = new PhysicsModel.PolyhedronFourVector(); //The plugin had these named incorrectly, the four vectors are really //four vertices, with the coordinates grouped (four X's, four Y's, four Z's) //This is likely done for SIMD. If the number of vertices aren't a multiple //of four, usually the last vertex is copied several times. fourvert.FourVectorsX.I = v0.AsArray[0].AsFloat; fourvert.FourVectorsX.J = v1.AsArray[0].AsFloat; fourvert.FourVectorsX.K = v2.AsArray[0].AsFloat; fourvert.FourVectorsXRadius = v3.AsArray[0].AsFloat; fourvert.FourVectorsY.I = v0.AsArray[1].AsFloat; fourvert.FourVectorsY.J = v1.AsArray[1].AsFloat; fourvert.FourVectorsY.K = v2.AsArray[1].AsFloat; fourvert.FourVectorsYRadius = v3.AsArray[1].AsFloat; fourvert.FourVectorsZ.I = v0.AsArray[2].AsFloat; fourvert.FourVectorsZ.J = v1.AsArray[2].AsFloat; fourvert.FourVectorsZ.K = v2.AsArray[2].AsFloat; fourvert.FourVectorsZRadius = v3.AsArray[2].AsFloat; phmo.PolyhedronFourVectors.Add(fourvert); } return(numfvs); }
protected void CheckPhysicsProperties() { if (Damager_Ball_Player != null) { PhysicsModel.PopFromWorld(); Damager_Ball_Player.Shapes[0].Density = PhysicsDensity; Damager_Ball_Player.Shapes[0].DynamicFriction = PhysicsDynamicFriction; Damager_Ball_Player.Shapes[0].Restitution = PhysicsBounciness;//Bounciness Damager_Ball_Player.Shapes[0].StaticFriction = PhysicsStaticFriction; Damager_Ball_Player.Shapes[0].SpecialLiquidDensity = PhysicsLiquidDensity; Damager_Ball_Player.Shapes[0].ContactGroup = (int)ContactGroup.Dynamic; Damager_Ball_Player.EnableGravity = true; PhysicsModel.PushToWorld(); //GameEngineApp.Instance.AddScreenMessage("Physics Updated"); } }
bool DoPathFind() { Dynamic targetObj = null; { //not true because use Intellect RTSUnitAI ai = Intellect as RTSUnitAI; if (ai != null) { targetObj = ai.CurrentTask.Entity; } } GridPathFindSystem.Instance.RemoveObjectFromMotionMap(this); Bounds bounds = PhysicsModel.GetGlobalBounds(); float radius = Type.Radius; Rect targetRect = new Rect(MovePosition.ToVec2() - new Vec2(radius, radius), MovePosition.ToVec2() + new Vec2(radius, radius)); if (targetObj != null && targetObj != this) { GridPathFindSystem.Instance.RemoveObjectFromMotionMap(targetObj); } GridPathFindSystem.Instance.DoTempClearMotionMap(targetRect); const int maxFieldsDistance = 1000; const int maxFieldsToCheck = 100000; bool found = GridPathFindSystem.Instance.DoFind(Type.Radius * 2 * 1.1f, Position.ToVec2(), MovePosition.ToVec2(), maxFieldsDistance, maxFieldsToCheck, true, false, path); GridPathFindSystem.Instance.RestoreAllTempClearedMotionMap(); if (targetObj != null && targetObj != this) { GridPathFindSystem.Instance.AddObjectToMotionMap(targetObj); } GridPathFindSystem.Instance.AddObjectToMotionMap(this); return(found); }
/// <summary> /// Finds the type of the shape and adds it. Currently, only 'Polyhedron' is supported. /// </summary> /// <param name="phmo">the tag to add the shape to</param> /// <param name="n">the json node from which to parse the shape description.</param> /// <returns>shape type added, 'Unused0' is used to represent failure.</returns> private ShapeTypes AddShape(PhysicsModel phmo, JSONNode n) { if (n == null) { return(ShapeTypes.Unused0); } //an element of the top-level JSON array is a map // containing values for keys: 'Type', 'Data' switch (n["Type"]) { case "Polyhedron": return(AddPolyhedron(phmo, n["Data"]) ? ShapeTypes.Polyhedron : ShapeTypes.Unused0); default: return(ShapeTypes.Unused0); } }
/// <summary> /// Finds the type of the shape and adds it. Currently, only 'Polyhedron' is supported. /// </summary> /// <param name="phmo">the tag to add the shape to</param> /// <param name="n">the json node from which to parse the shape description.</param> /// <returns>shape type added, 'Unused0' is used to represent failure.</returns> private HavokShapeType AddShape(PhysicsModel phmo, JSONNode n) { if (n == null) { return(HavokShapeType.TriangleMesh); } //an element of the top-level JSON array is a map // containing values for keys: 'Type', 'Data' switch (n["Type"]) { case "Polyhedron": return(AddPolyhedron(phmo, n["Data"]) ? HavokShapeType.Polyhedron : HavokShapeType.TriangleMesh); default: return(HavokShapeType.TriangleMesh); } }
/// <summary>Overridden from <see cref="Engine.EntitySystem.Entity.OnPostCreate(Boolean)"/>.</summary> protected override void OnPostCreate(bool loaded) { base.OnPostCreate(loaded); pathFindWaitTime = World.Instance.Random.NextFloat(); CreatePhysicsModel(); Body body = PhysicsModel.CreateBody(); mainBody = body; body.Name = "main"; body.Static = true; body.Position = Position; body.Rotation = Rotation; float length = Type.Height - Type.Radius * 2; if (length < 0) { Log.Error("Length < 0"); return; } CapsuleShape shape = body.CreateCapsuleShape(); shape.Length = length; shape.Radius = Type.Radius; shape.ContactGroup = (int)ContactGroup.Dynamic; AddTimer(); //!!!!!need? //for update in GridPathFindSystem Vec3 p = Position; Position = p; PhysicsModel.PushToWorld(); if (mainBody != null) { oldMainBodyPosition = mainBody.Position; } }
void UpdatePhysicsModel() { DestroyPhysicsModel(); if (active) { CreatePhysicsModel(); Body body = PhysicsModel.CreateBody(); body.Static = true; body.SetTransform(Position, Rotation); BoxShape shape = body.CreateBoxShape(); shape.ContactGroup = (int)ContactGroup.Dynamic; // Static; shape.Dimensions = Scale; body.PushedToWorld = true; } }
void TickIntellect() { //horizontalMotor { float throttle = 0; throttle += Intellect.GetControlKeyStrength(GameControlKeys.Left); throttle -= Intellect.GetControlKeyStrength(GameControlKeys.Right); GearedMotor motor = PhysicsModel.GetMotor("horizontalMotor") as GearedMotor; if (motor != null) { motor.Throttle = throttle; } } //gibbetMotor { ServoMotor motor = PhysicsModel.GetMotor("gibbetMotor") as ServoMotor; if (motor != null) { Radian needAngle = motor.DesiredAngle; needAngle += Intellect.GetControlKeyStrength(GameControlKeys.Forward) * .004f; needAngle -= Intellect.GetControlKeyStrength(GameControlKeys.Backward) * .004f; MathFunctions.Clamp(ref needAngle, new Degree(-20.0f).InRadians(), new Degree(40.0f).InRadians()); motor.DesiredAngle = needAngle; } } //Change player LookDirection at rotation PlayerIntellect intellect = Intellect as PlayerIntellect; if (intellect != null) { Vec3 lookVector = intellect.LookDirection.GetVector(); lookVector *= OldRotation.GetInverse(); lookVector *= Rotation; intellect.LookDirection = SphereDir.FromVector(lookVector); } }