public static IPhysicsShape Unwrap(BasePhysicsShapeRemoteData data)
        {
            var collisionGroup = CollisionGroups.GetCollisionGroup(data.CollisionGroupId);

            return(data switch
            {
                CircleShapeRemoteData circleData
                => new CircleShape(circleData.Center,
                                   circleData.Radius,
                                   collisionGroup),
                RectangleShapeRemoteData rectangleData
                => new RectangleShape(rectangleData.Position,
                                      rectangleData.Size,
                                      collisionGroup),

                LineShapeRemoteData lineData
                => new LineShape(lineData.BasePosition,
                                 lineData.Direction,
                                 collisionGroup),

                LineSegmentShapeRemoteData lineSegmentData
                => new LineSegmentShape(lineSegmentData.Point1,
                                        lineSegmentData.Point2,
                                        collisionGroup),

                PointShapeRemoteData pointData
                => new PointShape(pointData.Point,
                                  collisionGroup),

                _ => throw new ArgumentOutOfRangeException("Unknown shape type: " + data.GetType().Name)
            });
        public static void SharedVisualizeTestResults(
            ITempList <TestResult> physicsTestResults,
            CollisionGroup collisionGroup)
        {
            if (IsClient)
            {
                using var testResults = Api.Shared.GetTempList <Vector2D>();
                AddTestResults(physicsTestResults.AsList(), testResults.AsList());
                ClientComponentPhysicsSpaceVisualizer.VisualizeTestResults(testResults.AsList(),
                                                                           collisionGroup,
                                                                           isClient: true);
            }
            else // if server
            {
                Api.Assert(Api.IsEditor, "This is Editor-only server code");
                var allPlayers = Server.Characters.EnumerateAllPlayerCharacters(onlyOnline: true,
                                                                                exceptSpectators: false);

                var testResults = new List <Vector2D>();
                AddTestResults(physicsTestResults.AsList(), testResults);

                var collisionGroupId = CollisionGroups.GetCollisionGroupId(collisionGroup);
                instance.CallClient(
                    allPlayers,
                    // ReSharper disable once AccessToDisposedClosure
                    _ => _.ClientRemote_ProcessServerTestResults(testResults, collisionGroupId));
            }
        }
Beispiel #3
0
        private void LoadGridEntities()
        {
            _oldEntities = new List <Entity>(_gridEntities);

            List <EntityPreset> gridPresets = EntityManager.GetGridEntities(GlobalState.CURRENT_MAP_NAME, new Vector2(GlobalState.CURRENT_GRID_X, GlobalState.CURRENT_GRID_Y));

            foreach (EntityPreset preset in gridPresets.Where(e => e.Permanence == Permanence.GRID_LOCAL))
            {
                preset.Alive = true;
            }

            GlobalState.ENEMIES_KILLED = gridPresets.Where(preset => !preset.Alive && preset.Type.IsDefined(typeof(EnemyAttribute), false)).Count();
            GlobalState.PUZZLES_SOLVED = 0;

            _groups = new CollisionGroups(GlobalState.ENEMIES_KILLED);
            _groups.Register(_player);
            _groups.Register(_player.broom);

            _gridEntities = gridPresets.Where(preset => preset.Alive)
                            .Select(preset => preset.Create(_player)).SelectMany(e => SubEntities(e)).ToList();
            foreach (Entity e in _gridEntities)
            {
                _groups.Register(e);
            }
        }
Beispiel #4
0
        /// <summary>
        /// Create a physics component.
        /// </summary>
        public PhysicsComponent(BaseEntity parent, PhysicsComponentDefinition compDef)
            : base(parent)
        {
            if ((null != compDef.PhysicsModelPath) && (compDef.PhysicsModelPath.Length > 0))
            {
                this.physMesh = this.parentEntity.Game.ModelLoader.LoadStaticModel(compDef.PhysicsModelPath);
            }

            this.shapeType          = compDef.ShapeType;
            this.mass               = compDef.Mass;
            this.collisionGroupType = compDef.CollisionGroupType;
            this.isDynamic          = compDef.IsDynamic;
            this.affectedByGravity  = compDef.AffectedByGravity;

            this.height   = compDef.Height;
            this.width    = compDef.Width;
            this.depth    = compDef.Depth;
            this.diameter = compDef.Diameter;

            InitializeActor();

            if (this.shapeType != ShapeType.TriangleMesh &&
                this.shapeType != ShapeType.Heightfield &&
                this.isDynamic)
            {
                ActivateComponent();
            }
        }
 public ColBodyAttributes()
 {
     _bodytype = ColBodyType.None;
     _dimensions = Vector2.Zero;
     _offset = Vector2.Zero;
     _collisionGroup = CollisionGroups.None;
     _collideWith = CollisionGroups.None;
 }
 public static BroadphaseProxy Create(object client, CollisionGroups group, CollisionGroups mask)
 {
     BroadphaseProxy proxy = Pool.Acquire<BroadphaseProxy>();
     proxy.ClientObject = client;
     proxy.CollisionFilterGroup = group;
     proxy.CollisionFilterMask = mask;
     CollisionGlobals.TotalProxies++;
     return proxy;
 }
        private void ClientRemote_ProcessServerTestResults(
            List <Vector2D> testResults,
            CollisionGroupId collisionGroupId)
        {
            var collisionGroup = CollisionGroups.GetCollisionGroup(collisionGroupId);

            ClientComponentPhysicsSpaceVisualizer.VisualizeTestResults(testResults,
                                                                       collisionGroup,
                                                                       isClient: false);
        }
Beispiel #8
0
        public static BroadphaseProxy Create(object client, CollisionGroups group, CollisionGroups mask)
        {
            BroadphaseProxy proxy = Pool.Acquire <BroadphaseProxy>();

            proxy.ClientObject         = client;
            proxy.CollisionFilterGroup = group;
            proxy.CollisionFilterMask  = mask;
            CollisionGlobals.TotalProxies++;
            return(proxy);
        }
 protected override void Recycle(bool isReleasing)
 {
     AABB = AABB.Zero;
     ClientObject = null;
     CollisionFilterGroup = CollisionGroups.None;
     CollisionFilterMask = CollisionGroups.None;
     if (isReleasing)
         CollisionGlobals.TotalProxies--;
     base.Recycle(isReleasing);
 }
Beispiel #10
0
 protected override void Recycle(bool isReleasing)
 {
     AABB                 = AABB.Zero;
     ClientObject         = null;
     CollisionFilterGroup = CollisionGroups.None;
     CollisionFilterMask  = CollisionGroups.None;
     if (isReleasing)
     {
         CollisionGlobals.TotalProxies--;
     }
     base.Recycle(isReleasing);
 }
Beispiel #11
0
        private CollisionGroup GetCollisionGroup(CollisionGroups groupType)
        {
            switch (groupType)
            {
            case CollisionGroups.CollideWithAll:
                return(null);

            case CollisionGroups.Phantom:
                return(this.phantomGroup);

            case CollisionGroups.RigidBody:
                return(this.rigidBodyGroup);

            case CollisionGroups.Terrain:
                return(this.terrainGroup);

            default:
                Debug.Assert(false, "Unknown CollisionGroup type, a new type was added without this switch being updated to handle it.");
                return(null);
            }
        }
 public void SetProxyFilterMask(BroadphaseProxy proxy, ref CollisionGroups mask)
 {
     proxy.CollisionFilterMask = mask;
 }
Beispiel #13
0
 public void SetProxyGroup(BroadphaseProxy proxy, ref CollisionGroups group)
 {
     proxy.CollisionFilterGroup = group;
 }
 public bool BelongsToGroup(CollisionGroups group)
 {
     return (BroadphaseProxy.CollisionFilterGroup & group) != CollisionGroups.None;
 }
Beispiel #15
0
 public void SetGroup(CollisionGroups group)
 {
     BroadphaseProxy.CollisionFilterGroup = group;
 }
 public void SetGroup(CollisionGroups group)
 {
     BroadphaseProxy.CollisionFilterGroup = group;
 }
 public void CollidesWithGroup(CollisionGroups mask)
 {
     BroadphaseProxy.CollisionFilterMask = mask;
 }
Beispiel #18
0
 public void CollidesWithGroup(CollisionGroups mask)
 {
     BroadphaseProxy.CollisionFilterMask = mask;
 }
 protected BasePhysicsShapeRemoteData(IPhysicsShape shape)
 {
     this.CollisionGroupId = CollisionGroups.GetCollisionGroupId(shape.CollisionGroup);
 }
Beispiel #20
0
 public bool BelongsToGroup(CollisionGroups group)
 {
     return((BroadphaseProxy.CollisionFilterGroup & group) != CollisionGroups.None);
 }
Beispiel #21
0
 public void SetProxyFilterMask(BroadphaseProxy proxy, ref CollisionGroups mask)
 {
     proxy.CollisionFilterMask = mask;
 }
 public void SetProxyGroup(BroadphaseProxy proxy, ref CollisionGroups group)
 {
     proxy.CollisionFilterGroup = group;
 }