C# MyCubeBlock类代码示例

 public MyUseObjectCryoChamberDoor(MyCubeBlock owner, string dummyName, MyModelDummy dummyData, int key)
 {
     CryoChamber = owner as MyCryoChamber;
     Debug.Assert(CryoChamber != null, "MyUseObjectCryoChamberDoor should only be used with MyCryoChamber blocks!");
     
     LocalMatrix = dummyData.Matrix;
 }

 void CubeBlock_IsWorkingChanged(MyCubeBlock obj)
 {
     if (IsWorking)
         OnStartWorking();
     else
         OnStopWorking();
 }

        public static IMyUseObject CreateUseObject(string detectorName, MyCubeBlock owner, string dummyName, MyModelDummy dummyData, int shapeKey)
        {
            Type type;
            if (!m_useObjectTypesByDummyName.TryGetValue(detectorName, out type) || type == null)
                return null;

            return (IMyUseObject)Activator.CreateInstance(type, owner, dummyName, dummyData, shapeKey);
        }

        public MyUseObjectPanelButton(MyCubeBlock owner, string dummyName, MyModelDummy dummyData, int key)
        {
            m_buttonPanel = owner as MyButtonPanel;
            m_localMatrix = dummyData.Matrix;

            int orderNumber = 0;
            var parts =  dummyName.Split('_');
            int.TryParse(parts[parts.Length - 1], out orderNumber);
            m_index = orderNumber - 1;
            if (m_index >= m_buttonPanel.BlockDefinition.ButtonCount)
            {
                MyLog.Default.WriteLine(string.Format("{0} Button index higher than defined count.", m_buttonPanel.BlockDefinition.Id.SubtypeName));
                Debug.Fail(string.Format("{0} Button index higher than defined count.", m_buttonPanel.BlockDefinition.Id.SubtypeName));
                m_index = m_buttonPanel.BlockDefinition.ButtonCount - 1;
            }
        }

 void MyProgrammableBlock_IsWorkingChanged(MyCubeBlock obj)
 {
     UpdateEmissivity();
 }

        public virtual void RegisterInSystems(MyCubeBlock block)
        {
            if (ResourceDistributor != null)
            {
                var powerProducer = block.Components.Get<MyResourceSourceComponent>();
                if (powerProducer != null)
                    ResourceDistributor.AddSource(powerProducer);

                var powerConsumer = block.Components.Get<MyResourceSinkComponent>();
                if (powerConsumer != null)
                    ResourceDistributor.AddSink(powerConsumer);

                var socketOwner = block as IMyRechargeSocketOwner;
                if (socketOwner != null)
                    socketOwner.RechargeSocket.ResourceDistributor = ResourceDistributor;
            }

            if (WeaponSystem != null)
            {
                var weapon = block as IMyGunObject<MyDeviceBase>;
                if (weapon != null)
                    WeaponSystem.Register(weapon);
            }

            if (TerminalSystem != null)
            {
                var functionalBlock = block as MyTerminalBlock;
                if (functionalBlock != null)
                    TerminalSystem.Add(functionalBlock);
            }

            // CH: We probably don't need to register controller blocks here. Block that's being added to a grid should not have a controller set
            var controllableBlock = block as MyShipController;
            Debug.Assert(controllableBlock == null || controllableBlock.ControllerInfo.Controller == null, "Controller of added block is not null. Call Cestmir");
            /*if (ControlSystem != null)
            {
                var controllableBlock = block as MyShipController;
                if (controllableBlock != null && controllableBlock.ControllerInfo.Controller != null)
                    ControlSystem.AddControllerBlock(controllableBlock);
            }*/

            var inventoryBlock = (block != null && block.HasInventory) ? block : null;
            if (inventoryBlock != null)
                ConveyorSystem.Add(inventoryBlock);

            var conveyorBlock = block as IMyConveyorEndpointBlock;
            if (conveyorBlock != null)
            {
                conveyorBlock.InitializeConveyorEndpoint();
                ConveyorSystem.AddConveyorBlock(conveyorBlock);
            }

            var segmentBlock = block as IMyConveyorSegmentBlock;
            if (segmentBlock != null)
            {
                segmentBlock.InitializeConveyorSegment();
                ConveyorSystem.AddSegmentBlock(segmentBlock);
            }

            var reflectorLight = block as MyReflectorLight;
            if (reflectorLight != null)
                ReflectorLightSystem.Register(reflectorLight);

            if (MyFakes.ENABLE_WHEEL_CONTROLS_IN_COCKPIT)
            {
                var wheel = block as MyMotorSuspension;
                if (wheel != null)
                    WheelSystem.Register(wheel);
            }

            var landingGear = block as IMyLandingGear;
            if (landingGear != null)
                LandingSystem.Register(landingGear);

            var gyro = block as MyGyro;
            if (gyro != null)
                GyroSystem.Register(gyro);

            var camera = block as MyCameraBlock;
            if (camera != null)
                CameraSystem.Register(camera);

            block.OnRegisteredToGridSystems();
        }

 public MyUseObjectTextPanel(MyCubeBlock owner, string dummyName, MyModelDummy dummyData, int key)
 {
     m_textPanel = (MyTextPanel)owner;
     m_localMatrix = dummyData.Matrix;
 }

 void MyWheel_IsWorkingChanged(MyCubeBlock obj)
 {
     if(Stator != null)
         Stator.UpdateIsWorking();
 }

        public void UpdateVisual()
        {
            UpdateShowParts();

            if (!ShowParts)
            {
                if (FatBlock == null)
                {
                    FatBlock = new MyCubeBlock();
                    FatBlock.SlimBlock = this;
                    FatBlock.Init();
                    CubeGrid.Hierarchy.AddChild(FatBlock);
                    m_soundEmitter.Entity = FatBlock;
                    m_soundEmitter.SetPosition(null);
                }
                else
                {
                    FatBlock.UpdateVisual();
                }
            }
            else if (FatBlock != null)
            {
                var pos = FatBlock.WorldMatrix.Translation;
                CubeGrid.Hierarchy.RemoveChild(FatBlock);
                FatBlock.Close();
                FatBlock = null;
                m_soundEmitter.Entity = null;
            }
            CubeGrid.SetBlockDirty(this);
            if (CubeGrid.Physics != null)
            {
                CubeGrid.Physics.AddDirtyArea(Min, Max);
            }
        }

        private void AddEffectToBlock(MyCubeBlock block)
        {
            foreach (var upgrade in m_upgrades)
            {
                float val;
                if (block.UpgradeValues.TryGetValue(upgrade.UpgradeType, out val))
                {
                    if (upgrade.ModifierType == MyUpgradeModifierType.Additive)
                    {
                        val += upgrade.Modifier;
                    }
                    else
                    {
                        val *= upgrade.Modifier;
                    }
                    block.UpgradeValues[upgrade.UpgradeType] = val;
                }
            }

            block.CommitUpgradeValues();
        }

        public void ChangeBlockOwnership(MyCubeBlock block, long oldOwner, long newOwner)
        {
            DecreaseValue(ref PlayerOwnedBlocks, oldOwner);
            IncreaseValue(ref PlayerOwnedBlocks, newOwner);
            if (IsValidBlock(block))
            {
                DecreaseValue(ref PlayerOwnedValidBlocks, oldOwner);
                IncreaseValue(ref PlayerOwnedValidBlocks, newOwner);
            }

            NeedRecalculateOwners = true;
        }

        private bool CanAffectBlock(MyCubeBlock block)
        {
            foreach (var upgrade in m_upgrades)
            {
                if (block.UpgradeValues.ContainsKey(upgrade.UpgradeType))
                {
                    return true;
                }
            }

            return false;
        }

        private void RemoveEffectFromBlock(MyCubeBlock block)
        {
            foreach (var upgrade in m_upgrades)
            {
                float val;
                if (block.UpgradeValues.TryGetValue(upgrade.UpgradeType, out val))
                {
                    if (upgrade.ModifierType == MyUpgradeModifierType.Additive)
                    {
                        val -= upgrade.Modifier;

                        if (val < 0f)
                        {
                            val = 0f;
                            Debug.Fail("Additive modifier cannot be negative!");
                        }
                    }
                    else
                    {
                        val /= upgrade.Modifier;
                        if (val < 1f)
                        {
                            val = 1f;
                            Debug.Fail("Multiplicative modifier cannot be < 1.0f!");
                        }
                    }
                    block.UpgradeValues[upgrade.UpgradeType] = val;
                }
            }

            block.CommitUpgradeValues();
        }

 private void CubeBlock_OnWorkingChanged(MyCubeBlock block)
 {
     m_positionDirty = true;
 }

 private void CubeBlock_IsWorkingChanged(MyCubeBlock block)
 {
     if (IsWorking)
     {
         MyCubeBlock.UpdateEmissiveParts(Render.RenderObjectIDs[0], 1.0f, Color.Green, Color.White);
         if (IsProducing)
             OnStartProducing();
     }
     else
     {
         MyCubeBlock.UpdateEmissiveParts(Render.RenderObjectIDs[0], 0.0f, Color.Red, Color.White);
     }
 }