Пример #1
0
        private static string GetOriginalBlockModel(MyGridDataComponent gridData, MyBlock block)
        {
            var buildableDef = block.Definition as MyBuildableBlockDefinition;

            if (buildableDef == null)
            {
                return(block.Definition.Model);
            }
            var currentState = gridData.Container?.Get <MyGridBuildingComponent>()?.GetBlockState(block.Id);

            if (currentState == null)
            {
                return(block.Definition.Model);
            }

            var buildProgress = (float)currentState.BuildIntegrity / currentState.MaxIntegrity;

            for (var i = buildableDef.BuildProgressModels.Count - 1; i >= 0; i--)
            {
                var model = buildableDef.BuildProgressModels[i];
                if (buildProgress <= model.UpperBound)
                {
                    return(model.Model);
                }
            }

            return(block.Definition.Model);
        }
Пример #2
0
 public ModifierContext(MyGridDataComponent data, MyBlock block, InterningBag <EquiModifierBaseDefinition> modifiers)
 {
     _a            = data;
     _b            = block;
     OriginalModel = GetOriginalBlockModel(data, block);
     Modifiers     = modifiers;
 }
        public static bool AnyBlocksInAABB(this MyGridDataComponent g, BoundingBoxD box)
        {
            var e = g.Entity;

            if (e.PositionComp == null)
            {
                return(false);
            }
            if (box.Contains(e.PositionComp.WorldAABB) == ContainmentType.Contains)
            {
                return(g.BlockCount > 0);
            }

            var orientedBoundingBoxD = OrientedBoundingBoxD.Create(box, e.PositionComp.WorldMatrixNormalizedInv);
            var sizeR = 1f / g.Size;

            orientedBoundingBoxD.Center     *= sizeR;
            orientedBoundingBoxD.HalfExtent *= sizeR;
            box = box.TransformFast(e.PositionComp.WorldMatrixNormalizedInv);
            var min    = box.Min;
            var max    = box.Max;
            var obbPt1 = new Vector3I((int)Math.Round(min.X * sizeR), (int)Math.Round(min.Y * sizeR), (int)Math.Round(min.Z * sizeR));
            var obbPt2 = new Vector3I((int)Math.Round(max.X * sizeR), (int)Math.Round(max.Y * sizeR), (int)Math.Round(max.Z * sizeR));
            var obbMin = Vector3I.Min(obbPt1, obbPt2);
            var obbMax = Vector3I.Max(obbPt1, obbPt2);
            var start  = Vector3I.Max(obbMin, g.Min);
            var end    = Vector3I.Min(obbMax, g.Max);

            if (start.X > end.X || start.Y > end.Y || start.Z > end.Z)
            {
                return(false);
            }
            var vector3IRangeIterator = new Vector3I_RangeIterator(ref start, ref end);
            var next = vector3IRangeIterator.Current;

            while (vector3IRangeIterator.IsValid())
            {
                if (g.GetAnyBlock(next) != null)
                {
                    return(true);
                }
                vector3IRangeIterator.GetNext(out next);
            }

            return(false);
        }
Пример #4
0
        private void BlockMoved(MyBlockComponent block, MyGridDataComponent gridData)
        {
            var nextGridPhys = gridData?.Container?.Get <MyPhysicsComponentBase>();
            var nextGridPos  = gridData?.Container?.Get <MyPositionComponentBase>();

            if (nextGridPos == _gridPositionComponent && nextGridPhys == _gridPhysicsComponent)
            {
                return;
            }
            if (_gridPositionComponent != null)
            {
                _gridPositionComponent.OnPositionChanged -= WakePhysics;
            }
            _gridPhysicsComponent  = nextGridPhys;
            _gridPositionComponent = nextGridPos;
            if (_gridPositionComponent != null)
            {
                WakePhysics(null);
            }
            else
            {
                RemoveFixedUpdate(Simulate);
            }
        }