public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { SyncFlag = true; var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( BlockDefinition.ResourceSinkGroup, BlockDefinition.RequiredPowerInput, ComputeRequiredPower); ResourceSink = sinkComp; base.Init(objectBuilder, cubeGrid); var ob = objectBuilder as MyObjectBuilder_JumpDrive; NeedsUpdate |= VRage.ModAPI.MyEntityUpdateEnum.BEFORE_NEXT_FRAME | VRage.ModAPI.MyEntityUpdateEnum.EACH_FRAME | VRage.ModAPI.MyEntityUpdateEnum.EACH_100TH_FRAME; m_storedPower.Value = Math.Min(ob.StoredPower, BlockDefinition.PowerNeededForJump); m_storedJumpTarget = ob.JumpTarget; if (ob.JumpTarget != null) { m_jumpTarget = MySession.Static.Gpss.GetGps(ob.JumpTarget.Value); } m_jumpDistanceRatio.Value = ob.JumpRatio; m_isRecharging.Value = ob.Recharging; SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; IsWorkingChanged += MyJumpDrive_IsWorkingChanged; ResourceSink.Update(); UpdateEmissivity(); }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { ResourceSink = new MyResourceSinkComponent(); ResourceSink.Init( BlockDefinition.ResourceSinkGroup, BlockDefinition.RequiredPowerInput, this.CalculateRequiredPowerInput); base.Init(objectBuilder, cubeGrid); ResourceSink.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink.Update(); if (Physics != null) { Physics.Close(); } var detectorShape = new HkBoxShape(new Vector3(cubeGrid.GridSize / 3.0f)); var massProperties = HkInertiaTensorComputer.ComputeBoxVolumeMassProperties(detectorShape.HalfExtents, BlockDefinition.VirtualMass); Physics = new Sandbox.Engine.Physics.MyPhysicsBody(this, RigidBodyFlag.RBF_DEFAULT); Physics.IsPhantom = false; Physics.CreateFromCollisionObject(detectorShape, Vector3.Zero, WorldMatrix, massProperties, MyPhysics.CollisionLayers.VirtualMassLayer); Physics.Enabled = IsWorking && cubeGrid.Physics != null && cubeGrid.Physics.Enabled; Physics.RigidBody.Activate(); detectorShape.Base.RemoveReference(); UpdateText(); NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME; SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; }
public override unsafe void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { base.SyncFlag = true; MyResourceSinkComponent component = new MyResourceSinkComponent(1); component.Init(this.MotorDefinition.ResourceSinkGroup, this.MotorDefinition.RequiredPowerInput, new Func <float>(this.ComputeRequiredPowerInput)); component.IsPoweredChanged += new Action(this.Receiver_IsPoweredChanged); base.ResourceSink = component; base.Init(objectBuilder, cubeGrid); base.SlimBlock.ComponentStack.IsFunctionalChanged += new Action(this.ComponentStack_IsFunctionalChanged); base.ResourceSink.Update(); this.m_dummyDisplacement.SetLocalValue(0f); this.m_dummyDisplacement.ValueChanged += new Action <SyncBase>(this.m_dummyDisplacement_ValueChanged); this.LoadDummyPosition(); MyObjectBuilder_MotorBase base2 = objectBuilder as MyObjectBuilder_MotorBase; if ((Sync.IsServer && (base2.RotorEntityId != null)) && (base2.RotorEntityId.Value != 0)) { MyMechanicalConnectionBlockBase.State *statePtr1; MyMechanicalConnectionBlockBase.State state = new MyMechanicalConnectionBlockBase.State { TopBlockId = base2.RotorEntityId }; statePtr1->Welded = (base2.WeldedEntityId != null) || base2.ForceWeld; statePtr1 = (MyMechanicalConnectionBlockBase.State *) ref state; base.m_connectionState.Value = state; } base.AddDebugRenderComponent(new MyDebugRenderComponentMotorBase(this)); base.NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME; }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { SyncFlag = true; base.Init(objectBuilder, cubeGrid); SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( MotorDefinition.ResourceSinkGroup, MotorDefinition.RequiredPowerInput, () => (Enabled && IsFunctional) ? sinkComp.MaxRequiredInput : 0.0f); sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink = sinkComp; ResourceSink.Update(); m_dummyDisplacement.Value = 0.0f; LoadDummyPosition(); var ob = objectBuilder as MyObjectBuilder_MotorBase; m_rotorBlockId = ob.RotorEntityId; AddDebugRenderComponent(new Components.MyDebugRenderComponentMotorBase(this)); cubeGrid.OnPhysicsChanged += cubeGrid_OnPhysicsChanged; }
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid) { var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( BlockDefinition.ResourceSinkGroup, BlockDefinition.PowerConsumptionMoving, UpdatePowerInput); ResourceSink = sinkComp; base.Init(builder, cubeGrid); var ob = (MyObjectBuilder_AdvancedDoor)builder; m_open.Value = ob.Open; sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; sinkComp.Update(); if (!Enabled || !ResourceSink.IsPowered) { UpdateDoorPosition(); } OnStateChange(); if (m_open) { UpdateDoorPosition(); } SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; ResourceSink.Update(); }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { base.Init(objectBuilder, cubeGrid); var def = BlockDefinition as MyPoweredCargoContainerDefinition; var ob = objectBuilder as MyObjectBuilder_Collector; m_inventory = new MyInventory(def.InventorySize.Volume, def.InventorySize, MyInventoryFlags.CanSend, this); m_inventory.Init(ob.Inventory); m_inventory.ContentsChanged += Inventory_ContentChangedCallback; if (Sync.IsServer && CubeGrid.CreatePhysics) { LoadDummies(); } var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( MyStringHash.GetOrCompute(def.ResourceSinkGroup), MyEnergyConstants.MAX_REQUIRED_POWER_COLLECTOR, () => base.CheckIsWorking() ? ResourceSink.MaxRequiredInput : 0f); ResourceSink = sinkComp; ResourceSink.Update(); ResourceSink.IsPoweredChanged += Receiver_IsPoweredChanged; AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawPowerReciever(ResourceSink, this)); SlimBlock.ComponentStack.IsFunctionalChanged += UpdateReceiver; base.EnabledChanged += UpdateReceiver; m_useConveyorSystem = ob.UseConveyorSystem; }
public override void UpdateOnceBeforeFrame() { if (!U.IsReal((MyCubeBlock)Block) || !MyAPIGateway.Multiplayer.IsServer) // ignore projected and other non-physical grids { return; } NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME; // setup resources Sink = Entity.Components.Get <MyResourceSinkComponent>(); if (Sink == null) { Sink = new MyResourceSinkComponent(); Entity.Components.Add(Sink); } Source = Entity.Components.Get <MyResourceSourceComponent>(); if (Source == null) { Source = new MyResourceSourceComponent(); Entity.Components.Add(Source); } var subTanks = tankDefs.Select(def => new SubTankImpl(this, def)).ToList(); Sink.Init(MyStringHash.GetOrCompute("Factory"), subTanks.Select(x => x.sinkInfo).ToList()); Source.Init(MyStringHash.GetOrCompute("Reactors"), subTanks.Select(x => x.sourceInfo).ToList()); }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { MyObjectBuilder_Collector collector = objectBuilder as MyObjectBuilder_Collector; MyResourceSinkComponent component = new MyResourceSinkComponent(1); component.Init(MyStringHash.GetOrCompute(this.BlockDefinition.ResourceSinkGroup), this.BlockDefinition.RequiredPowerInput, new Func <float>(this.ComputeRequiredPower)); base.ResourceSink = component; base.Init(objectBuilder, cubeGrid); if (MyFakes.ENABLE_INVENTORY_FIX) { base.FixSingleInventory(); } if (this.GetInventory(0) == null) { MyInventory inventory = new MyInventory(this.BlockDefinition.InventorySize.Volume, this.BlockDefinition.InventorySize, MyInventoryFlags.CanSend); base.Components.Add <MyInventoryBase>(inventory); inventory.Init(collector.Inventory); } if (Sync.IsServer && base.CubeGrid.CreatePhysics) { this.LoadDummies(); } base.ResourceSink.IsPoweredChanged += new Action(this.Receiver_IsPoweredChanged); base.SlimBlock.ComponentStack.IsFunctionalChanged += new Action(this.UpdateReceiver); base.EnabledChanged += new Action <MyTerminalBlock>(this.UpdateReceiver); this.m_useConveyorSystem.SetLocalValue(collector.UseConveyorSystem); base.ResourceSink.Update(); base.NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME; }
public override void Init(MyObjectBuilder_EntityBase objectBuilder) { try { npcCrewBlock = Entity as IMyUpgradeModule; //MyAPIGateway.Utilities.ShowMessage("DEBUG", "Init Ran"); NeedsUpdate = MyEntityUpdateEnum.EACH_FRAME; npcCrewBlock.CubeGrid.ColorBlocks(npcCrewBlock.SlimBlock.Position, npcCrewBlock.SlimBlock.Position, Color.Red.ColorToHSV()); NPCCrewConfig loadconfig = NPCCrewConfig.LoadConfigFile(); forceColor = loadconfig.forceColor; if (Sink == null) { Sink = new MyResourceSinkComponent(); } ResourceInfo = new MyResourceSinkInfo() { ResourceTypeId = GId, MaxRequiredInput = 0.02f, RequiredInputFunc = () => Power }; Sink.Init(MyStringHash.GetOrCompute("Utility"), ResourceInfo); Sink.AddType(ref ResourceInfo); Entity.Components.Add(Sink); Sink.Update(); } catch (Exception e) { MyVisualScriptLogicProvider.ShowNotificationToAll("Init Error" + e, 10000, "Red"); } }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { SyncFlag = true; var soundBlockDefinition = BlockDefinition as MySoundBlockDefinition; Debug.Assert(soundBlockDefinition != null); var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( soundBlockDefinition.ResourceSinkGroup, MyEnergyConstants.MAX_REQUIRED_POWER_SOUNDBLOCK, UpdateRequiredPowerInput); sinkComp.IsPoweredChanged += PowerReceiver_IsPoweredChanged; ResourceSink = sinkComp; base.Init(objectBuilder, cubeGrid); var builder = (MyObjectBuilder_SoundBlock)objectBuilder; Volume = builder.Volume; Range = builder.Range; LoopPeriod = builder.LoopPeriod; if (builder.IsPlaying) { m_willStartSound = true; } InitCue(builder.CueName); ResourceSink.Update(); SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; }
public override void Init(MyObjectBuilder_EntityBase objectBuilder) { Entity.NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME; Entity.NeedsUpdate |= MyEntityUpdateEnum.EACH_10TH_FRAME; if (!(Entity is IMyFunctionalBlock)) { LogManager.WriteLine("WARNING: Hacking Computer Is Not An IMyFunctionalBlock!"); } m_hackingblock = Entity as IMyFunctionalBlock; m_sink = new MyResourceSinkComponent(1); m_sink.Init(MyStringHash.GetOrCompute("Utility"), 0.05f, delegate { if (!UsePower()) { return(0f); } return(m_sink.MaxRequiredInput); }); if (m_hackingblock.Components.Contains(typeof(MyResourceSinkComponent))) { LogManager.WriteLine("WARNING: HackingComputer Already Has A Resource Sink"); m_hackingblock.Components.Remove <MyResourceSinkComponent>(); } m_hackingblock.Components.Add(m_sink); m_hackingblock.AppendingCustomInfo += updateInfo; // Setup Audio m_soundEmitter = new MyEntity3DSoundEmitter((MyEntity)Entity); m_soundPair = new MySoundPair("ArcBlockTimerSignalB"); }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { var blockDefinition = BlockDefinition as MyProgrammableBlockDefinition; var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( blockDefinition.ResourceSinkGroup, 0.0005f, () => (Enabled && IsFunctional) ? ResourceSink.MaxRequiredInput : 0f); sinkComp.IsPoweredChanged += PowerReceiver_IsPoweredChanged; ResourceSink = sinkComp; base.Init(objectBuilder, cubeGrid); var programmableBlockBuilder = (MyObjectBuilder_MyProgrammableBlock)objectBuilder; m_editorData = m_programData = programmableBlockBuilder.Program; m_storageData = programmableBlockBuilder.Storage; this.m_terminalRunArgument = programmableBlockBuilder.DefaultRunArgument; this.SyncObject = new MySyncProgrammableBlock(this); NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; ResourceSink.Update(); SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; IsWorkingChanged += MyProgrammableBlock_IsWorkingChanged; if (Sync.IsServer && Sync.Clients != null) { Sync.Clients.ClientRemoved += ProgrammableBlock_ClientRemoved; } }
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid) { base.Init(builder, cubeGrid); var ob = (MyObjectBuilder_AirtightDoorGeneric)builder; m_open = ob.Open; m_currOpening = ob.CurrOpening; m_openingSpeed = BlockDefinition.OpeningSpeed; m_sound = new MySoundPair(BlockDefinition.Sound); m_subpartMovementDistance = BlockDefinition.SubpartMovementDistance; ResourceSink = new MyResourceSinkComponent(); ResourceSink.Init( MyStringHash.GetOrCompute(BlockDefinition.ResourceSinkGroup), BlockDefinition.PowerConsumptionMoving, UpdatePowerInput); ResourceSink.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink.Update(); if (!Enabled || !ResourceSink.IsPowered) { UpdateDoorPosition(); } OnStateChange(); SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; ResourceSink.Update(); }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { SyncFlag = true; var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( BlockDefinition.ResourceSinkGroup, BlockDefinition.RequiredPowerInput, () => (Enabled && IsFunctional) ? ResourceSink.MaxRequiredInput : 0.0f); ResourceSink = sinkComp; base.Init(objectBuilder, cubeGrid); SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; ResourceSink.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink.Update(); var ob = objectBuilder as MyObjectBuilder_PistonBase; Velocity.Value = ob.Velocity * BlockDefinition.MaxVelocity; MaxLimit.Value = ob.MaxLimit.HasValue ? Math.Min(DenormalizeDistance(ob.MaxLimit.Value), BlockDefinition.Maximum) : BlockDefinition.Maximum; MinLimit.Value = ob.MinLimit.HasValue ? Math.Max(DenormalizeDistance(ob.MinLimit.Value), BlockDefinition.Minimum) : BlockDefinition.Minimum; m_currentPos.Value = ob.CurrentPosition; NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME | MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.BEFORE_NEXT_FRAME; }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { this.m_definition = base.BlockDefinition as MyOreDetectorDefinition; MyResourceSinkComponent component = new MyResourceSinkComponent(1); component.Init(this.m_definition.ResourceSinkGroup, 0.002f, delegate { if (!base.Enabled || !base.IsFunctional) { return(0f); } return(base.ResourceSink.MaxRequiredInputByType(MyResourceDistributorComponent.ElectricityId)); }); base.ResourceSink = component; base.ResourceSink.IsPoweredChanged += new Action(this.Receiver_IsPoweredChanged); base.Init(objectBuilder, cubeGrid); MyObjectBuilder_OreDetector detector = objectBuilder as MyObjectBuilder_OreDetector; this.m_oreDetectorComponent.DetectionRadius = (detector.DetectionRadius == 0f) ? MathHelper.Clamp(0.5f * this.m_definition.MaximumRange, 1f, this.m_definition.MaximumRange) : MathHelper.Clamp(detector.DetectionRadius, 1f, this.m_definition.MaximumRange); this.m_oreDetectorComponent.BroadcastUsingAntennas = detector.BroadcastUsingAntennas; this.m_broadcastUsingAntennas.SetLocalValue(this.m_oreDetectorComponent.BroadcastUsingAntennas); this.m_oreDetectorComponent.OnCheckControl = (MyOreDetectorComponent.CheckControlDelegate)Delegate.Combine(this.m_oreDetectorComponent.OnCheckControl, new MyOreDetectorComponent.CheckControlDelegate(this.OnCheckControl)); base.ResourceSink.Update(); base.SlimBlock.ComponentStack.IsFunctionalChanged += new Action(this.ComponentStack_IsFunctionalChanged); base.NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME; base.OnClose += new Action <VRage.Game.Entity.MyEntity>(this.MyOreDetector_OnClose); }
public NaniteOreDetector(IMyFunctionalBlock entity) { m_block = entity as IMyOreDetector; m_lastUpdate = DateTime.MinValue; m_scanStart = DateTime.MinValue; m_scanEnd = DateTime.MinValue; m_lock = new FastResourceLock(); m_oreListCache = new StringBuilder(); m_detectorState = DetectorStates.Disabled; m_lastDetectorState = DetectorStates.Disabled; m_block.Components.TryGet(out Sink); ResourceInfo = new MyResourceSinkInfo() { ResourceTypeId = MyResourceDistributorComponent.ElectricityId, MaxRequiredInput = 0f, RequiredInputFunc = () => (m_block.Enabled && m_block.IsFunctional) ? _power : 0f }; Sink.RemoveType(ref ResourceInfo.ResourceTypeId); Sink.Init(MyStringHash.GetOrCompute("Utility"), ResourceInfo); Sink.AddType(ref ResourceInfo); m_effects.Add(new OreDetectorEffect((MyCubeBlock)m_block)); if (!NaniteConstructionManager.OreDetectors.ContainsKey(entity.EntityId)) { NaniteConstructionManager.OreDetectors.Add(entity.EntityId, this); } }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( MyStringHash.GetOrCompute("Defense"), MyEnergyConstants.MAX_REQUIRED_POWER_SHIP_GRINDER, ComputeRequiredPower); sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink = sinkComp; base.Init(objectBuilder, cubeGrid); m_entitiesInContact = new Dictionary <MyEntity, int>(); m_blocksToActivateOn = new HashSet <MySlimBlock>(); m_tempBlocksBuffer = new HashSet <MySlimBlock>(); m_isActivated = false; m_isActivatedOnSomething = false; m_wantsToActivate = false; m_effectsSet = false; m_shootHeatup = 0; m_activateCounter = 0; m_defId = objectBuilder.GetId(); var def = MyDefinitionManager.Static.GetCubeBlockDefinition(m_defId); var typedBuilder = objectBuilder as MyObjectBuilder_ShipToolBase; //each dimension of size needs to be scaled by grid size not only one float inventoryVolume = def.Size.X * cubeGrid.GridSize * def.Size.Y * cubeGrid.GridSize * def.Size.Z * cubeGrid.GridSize * 0.5f; Vector3 inventorySize = new Vector3(def.Size.X, def.Size.Y, def.Size.Z * 0.5f); if (this.GetInventory() == null) // could be already initialized as component { MyInventory inventory = new MyInventory(inventoryVolume, inventorySize, MyInventoryFlags.CanSend); Components.Add <MyInventoryBase>(inventory); inventory.Init(typedBuilder.Inventory); } Debug.Assert(this.GetInventory().Owner == this, "Ownership was not set!"); SlimBlock.UsesDeformation = false; SlimBlock.DeformationRatio = typedBuilder.DeformationRatio; // 3x times harder for destruction by high speed Enabled = typedBuilder.Enabled; UseConveyorSystem = typedBuilder.UseConveyorSystem; SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; LoadDummies(); UpdateActivationState(); IsWorkingChanged += MyShipToolBase_IsWorkingChanged; ResourceSink.Update(); NeedsUpdate |= MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.EACH_FRAME; }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { SyncFlag = true; var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( BlockDefinition.ResourceSinkGroup, BlockDefinition.RequiredPowerInput, () => (Enabled && IsFunctional) ? ResourceSink.MaxRequiredInput : 0f); ResourceSink = sinkComp; base.Init(objectBuilder, cubeGrid); MyObjectBuilder_TextPanel ob = (MyObjectBuilder_TextPanel)objectBuilder; PrivateTitle.Append(ob.Title); PrivateDescription.Append(ob.Description); PublicDescription.Append(ob.PublicDescription); PublicTitle.Append(ob.PublicTitle); m_currentPos = ob.CurrentShownTexture; AccessFlag = ob.AccessFlag; if (Sync.IsServer && Sync.Clients != null) { Sync.Clients.ClientRemoved += TextPanel_ClientRemoved; } FontColor = ob.FontColor; BackgroundColor = ob.BackgroundColor; NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME; Render.NeedsDrawFromParent = true; this.ChangeInterval = ob.ChangeInterval; FontSize = ob.FontSize; ShowTextFlag = ob.ShowText; if (ob.SelectedImages != null) { foreach (var savedTextureName in ob.SelectedImages) { foreach (var textureDefinition in m_definitions) { if (textureDefinition.Id.SubtypeName == savedTextureName) { m_selectedTexturesToDraw.Add(textureDefinition); break; } } } m_currentPos = Math.Min(m_currentPos, m_selectedTexturesToDraw.Count); RaisePropertiesChanged(); } ResourceSink.Update(); ResourceSink.IsPoweredChanged += PowerReceiver_IsPoweredChanged; SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { MyBeaconDefinition blockDefinition = base.BlockDefinition as MyBeaconDefinition; if (blockDefinition.EmissiveColorPreset == MyStringHash.NullOrEmpty) { blockDefinition.EmissiveColorPreset = MyStringHash.GetOrCompute("Beacon"); } MyResourceSinkComponent component = new MyResourceSinkComponent(1); component.Init(MyStringHash.GetOrCompute(blockDefinition.ResourceSinkGroup), 0.02f, new Func <float>(this.UpdatePowerInput)); base.ResourceSink = component; this.RadioBroadcaster = new MyRadioBroadcaster(blockDefinition.MaxBroadcastRadius / 10f); MyObjectBuilder_Beacon beacon = (MyObjectBuilder_Beacon)objectBuilder; if (beacon.BroadcastRadius > 0f) { this.RadioBroadcaster.BroadcastRadius = beacon.BroadcastRadius; } this.RadioBroadcaster.BroadcastRadius = MathHelper.Clamp(this.RadioBroadcaster.BroadcastRadius, 1f, blockDefinition.MaxBroadcastRadius); this.HudText.Clear(); if (beacon.HudText != null) { this.HudText.Append(beacon.HudText); } base.Init(objectBuilder, cubeGrid); component.IsPoweredChanged += new Action(this.Receiver_IsPoweredChanged); component.Update(); MyRadioBroadcaster radioBroadcaster = this.RadioBroadcaster; radioBroadcaster.OnBroadcastRadiusChanged = (Action)Delegate.Combine(radioBroadcaster.OnBroadcastRadiusChanged, new Action(this.OnBroadcastRadiusChanged)); this.m_largeLight = cubeGrid.GridSizeEnum == MyCubeSize.Large; this.m_light = MyLights.AddLight(); if (this.m_light != null) { this.m_light.Start(this.DisplayNameText); this.m_light.Range = this.m_largeLight ? 2f : 0.3f; this.m_light.GlareOn = false; this.m_light.GlareQuerySize = this.m_largeLight ? 1.5f : 0.3f; this.m_light.GlareQueryShift = this.m_largeLight ? 1f : 0.2f; this.m_light.GlareType = MyGlareTypeEnum.Normal; this.m_light.GlareMaxDistance = GLARE_MAX_DISTANCE; MyDefinitionId id = new MyDefinitionId(typeof(MyObjectBuilder_FlareDefinition), blockDefinition.Flare); MyFlareDefinition definition = MyDefinitionManager.Static.GetDefinition(id) as MyFlareDefinition; this.m_flare = definition ?? new MyFlareDefinition(); this.m_light.GlareIntensity = this.m_flare.Intensity; this.m_light.GlareSize = this.m_flare.Size; this.m_light.SubGlares = this.m_flare.SubGlares; } this.m_lightPositionOffset = this.m_largeLight ? new Vector3(0f, base.CubeGrid.GridSize * 0.3f, 0f) : Vector3.Zero; this.UpdateLightPosition(); this.m_restartTimeMeasure = false; this.AnimationRunning = true; base.SlimBlock.ComponentStack.IsFunctionalChanged += new Action(this.ComponentStack_IsFunctionalChanged); base.IsWorkingChanged += new Action <MyCubeBlock>(this.MyBeacon_IsWorkingChanged); base.ShowOnHUD = false; this.UpdateText(); }
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid) { base.Init(builder, cubeGrid); //m_subpartsSize = 0.5f * (0.5f * SlimBlock.CubeGrid.GridSize - 0.3f); var doorDefinition = BlockDefinition as MyDoorDefinition; MyStringHash resourceSinkGroup; if (doorDefinition != null) { MaxOpen = doorDefinition.MaxOpen; m_openSound = new MySoundPair(doorDefinition.OpenSound); m_closeSound = new MySoundPair(doorDefinition.CloseSound); resourceSinkGroup = MyStringHash.GetOrCompute(doorDefinition.ResourceSinkGroup); } else { MaxOpen = 1.2f; m_openSound = new MySoundPair("BlockDoorSmallOpen"); m_closeSound = new MySoundPair("BlockDoorSmallClose"); resourceSinkGroup = MyStringHash.GetOrCompute("Doors"); } var ob = (MyObjectBuilder_Door)builder; m_open = ob.State; m_currOpening = ob.Opening; var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( resourceSinkGroup, MyEnergyConstants.MAX_REQUIRED_POWER_DOOR, () => (Enabled && IsFunctional) ? sinkComp.MaxRequiredInput : 0f); sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; sinkComp.Update(); ResourceSink = sinkComp; if (!Enabled || !ResourceSink.IsPowered) { UpdateSlidingDoorsPosition(true); } OnStateChange(); if (m_open) { // required when reinitializing a door after the armor beneath it is destroyed if (Open && (m_currOpening == MaxOpen)) { UpdateSlidingDoorsPosition(true); } } SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; }
private void InitPowerSystem() { MyResourceSinkComponent powerSystem = new MyResourceSinkComponent(); powerSystem.Init(MyStringHash.GetOrCompute("Utility"), WarpConstants.baseRequiredPower * WarpConstants.powerRequirementMultiplier, ComputeRequiredPower); Entity.Components.Add(powerSystem); sink = powerSystem; }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { m_conveyorSorterDefinition = (MyConveyorSorterDefinition)MyDefinitionManager.Static.GetCubeBlockDefinition(objectBuilder.GetId()); var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( m_conveyorSorterDefinition.ResourceSinkGroup, BlockDefinition.PowerInput, UpdatePowerInput); sinkComp.IsPoweredChanged += IsPoweredChanged; ResourceSink = sinkComp; base.Init(objectBuilder, cubeGrid); MyObjectBuilder_ConveyorSorter ob = (MyObjectBuilder_ConveyorSorter)objectBuilder; DrainAll = ob.DrainAll; IsWhitelist = ob.IsWhiteList; foreach (var id in ob.DefinitionIds) { m_inventoryConstraint.Add(id); } foreach (byte b in ob.DefinitionTypes) { Tuple <MyObjectBuilderType, StringBuilder> tuple; if (!CandidateTypes.TryGetValue(b, out tuple)) { Debug.Assert(false, "type not in dictionary"); continue; } m_inventoryConstraint.AddObjectBuilderType(tuple.Item1); } if (MyFakes.ENABLE_INVENTORY_FIX) { FixSingleInventory(); } if (this.GetInventory() == null) { MyInventory inventory = new MyInventory(m_conveyorSorterDefinition.InventorySize.Volume, m_conveyorSorterDefinition.InventorySize, MyInventoryFlags.CanSend); Components.Add <MyInventoryBase>(inventory); inventory.Init(ob.Inventory); } Debug.Assert(this.GetInventory().Owner == this, "Ownership was not set!"); SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME | MyEntityUpdateEnum.EACH_10TH_FRAME; ResourceSink.Update(); UpdateText(); }
private int InitializeType(MyDefinitionId fuelType) { m_dataByFuelType.Add(new FuelTypeData { ThrustsByDirection = new Dictionary <Vector3I, HashSet <MyEntity> >(6, m_directionComparer), MaxRequirementsByDirection = new Dictionary <Vector3I, float>(6, m_directionComparer), FuelConversionDirty = true, CurrentPowerFromFuel = 0f, CurrentRequiredFuelInput = 0f, Efficiency = 0f, EnergyDensity = 0f, }); int typeIndex = m_dataByFuelType.Count - 1; m_fuelTypeToIndex.Add(fuelType, typeIndex); m_fuelTypes.Add(fuelType); foreach (var direction in Base6Directions.IntDirections) { m_dataByFuelType[typeIndex].ThrustsByDirection[direction] = new HashSet <MyEntity>(); } var sinkData = new MyResourceSinkInfo { ResourceTypeId = fuelType, MaxRequiredInput = 0, RequiredInputFunc = () => RequiredFuelInput(ref fuelType) }; if (m_fuelTypes.Count == 1) { ResourceSink.Init(MyStringHash.GetOrCompute("Thrust"), sinkData); ResourceSink.IsPoweredChanged += Sink_IsPoweredChanged; ResourceSink.CurrentInputChanged += Sink_CurrentInputChanged; var cubeGrid = Container.Entity as MyCubeGrid; if (cubeGrid != null) { var gridSystems = cubeGrid.GridSystems; if (gridSystems != null) { if (gridSystems.ResourceDistributor != null) { gridSystems.ResourceDistributor.AddSink(ResourceSink); } } } } else { ResourceSink.AddType(ref sinkData); } return(typeIndex); }
private void CheckEntityComponents(IMyEntity e, string arg2, string arg3) { if (e is IMyCubeGrid) { if (!e.Components.Has <BeamController>()) { e.Components.Add(new BeamController(this)); } } var def = Definitions.BeamOf(e); if (def != null) { if (def.RequiresResourceSink) { if (!e.Components.Has <MyResourceSinkComponent>()) { var sink = new MyResourceSinkComponent(); sink.Init(MyStringHash.GetOrCompute("Defense"), new List <MyResourceSinkInfo>()); e.Components.Add(sink); } if (!e.Components.Has <AdvancedResourceSink>()) { var advSink = new AdvancedResourceSink(this); e.Components.Add(advSink); } } if (def.Components.OfType <Lossy>().Any()) { e.Components.Add(new ThermalPhysicsComponent()); } if (def.Components.OfType <Weapon>().Any() && e is IMyUserControllableGun && !e.Components.Has <AmmoGeneratorComponent>()) { var wepDep = WeaponShortcuts.GetWeaponDefinition(e); if (wepDep != null) { foreach (var k in wepDep.AmmoMagazinesId) { _generatedAmmos.Add(k); } } e.Components.Add(new AmmoGeneratorComponent()); } if (!e.Components.Has <NetworkComponent>()) { e.Components.Add(new NetworkComponent(this)); } } }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { SyncFlag = true; var ob = objectBuilder as MyObjectBuilder_SmallGatlingGun; var weaponBlockDefinition = BlockDefinition as MyWeaponBlockDefinition; if (MyFakes.ENABLE_INVENTORY_FIX) { FixSingleInventory(); } //m_soundEmitterRotor = new MyEntity3DSoundEmitter(this); if (this.GetInventory() == null) { MyInventory inventory = null; if (weaponBlockDefinition != null) { inventory = new MyInventory(weaponBlockDefinition.InventoryMaxVolume, new Vector3(0.4f, 0.4f, 0.4f), MyInventoryFlags.CanReceive); } else { inventory = new MyInventory(64.0f / 1000, new Vector3(0.4f, 0.4f, 0.4f), MyInventoryFlags.CanReceive); } Components.Add <MyInventoryBase>(inventory); this.GetInventory().Init(ob.Inventory); } Debug.Assert(this.GetInventory().Owner == this, "Ownership was not set!"); var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( weaponBlockDefinition.ResourceSinkGroup, MyEnergyConstants.MAX_REQUIRED_POWER_SHIP_GUN, () => ResourceSink.MaxRequiredInput); sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink = sinkComp; base.Init(objectBuilder, cubeGrid); m_gunBase.Init(ob.GunBase, BlockDefinition, this); GetBarrelAndMuzzle(); //if (m_ammoPerShotConsumption == 0) // m_ammoPerShotConsumption = (MyFixedPoint)((45.0f / (1000.0f / MyGatlingConstants.SHOT_INTERVAL_IN_MILISECONDS)) / m_gunBase.WeaponProperties.AmmoMagazineDefinition.Capacity); ResourceSink.Update(); AddDebugRenderComponent(new MyDebugRenderComponentDrawPowerReciever(ResourceSink, this)); m_useConveyorSystem.Value = ob.UseConveyorSystem; }
//[TerminalValues(MySpaceTexts.SwitchText_On, MySpaceTexts.SwitchText_Off)] //[Terminal(2, MyPropertyDisplayEnum.Switch, MySpaceTexts.Terminal_UseConveyorSystem, MySpaceTexts.Blank)] //[Obfuscation(Feature = Obfuscator.NoRename, Exclude = true)] //public MyStringId UseConveyorSystemGui //{ // get { return m_useConveyorSystem ? MySpaceTexts.SwitchText_On : MySpaceTexts.SwitchText_Off; } // set // { // if (m_useConveyorSystem != (value == MySpaceTexts.SwitchText_On)) // { // m_useConveyorSystem = (value == MySpaceTexts.SwitchText_On); // OnPropertiesChanged(); // } // } //} //[TerminalValueSetter(2)] //public void RequestUseConveyorSystemChange(MyStringId newVal) //{ // MySyncConveyors.SendChangeUseConveyorSystemRequest(EntityId, newVal == MySpaceTexts.SwitchText_On); //} public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid) { SyncFlag = true; var ob = builder as MyObjectBuilder_SmallMissileLauncher; m_gunBase = new MyGunBase(); MyStringHash resourceSinkGroup; var weaponBlockDefinition = BlockDefinition as MyWeaponBlockDefinition; if (weaponBlockDefinition != null) { m_ammoInventory = new MyInventory(weaponBlockDefinition.InventoryMaxVolume, new Vector3(1.2f, 0.98f, 0.98f), MyInventoryFlags.CanReceive, this); resourceSinkGroup = weaponBlockDefinition.ResourceSinkGroup; } else { if (cubeGrid.GridSizeEnum == MyCubeSize.Small) { m_ammoInventory = new MyInventory(240.0f / 1000, new Vector3(1.2f, 0.45f, 0.45f), MyInventoryFlags.CanReceive, this); // 4 missiles } else { m_ammoInventory = new MyInventory(1140.0f / 1000, new Vector3(1.2f, 0.98f, 0.98f), MyInventoryFlags.CanReceive, this); // 19 missiles } resourceSinkGroup = MyStringHash.GetOrCompute("Defense"); } base.Init(builder, cubeGrid); m_ammoInventory.Init(ob.Inventory); m_gunBase.Init(ob.GunBase, BlockDefinition, this); m_ammoInventory.ContentsChanged += m_ammoInventory_ContentsChanged; var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( resourceSinkGroup, MyEnergyConstants.MAX_REQUIRED_POWER_SHIP_GUN, () => (Enabled && IsFunctional) ? ResourceSink.MaxRequiredInput : 0.0f); ResourceSink = sinkComp; ResourceSink.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink.Update(); AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawPowerReciever(ResourceSink, this)); m_useConveyorSystem = ob.UseConveyorSystem; SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; LoadDummies(); NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME; }
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid) { SyncFlag = true; var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( BlockDefinition.ResourceSinkGroup, 0.0001f, () => IsFunctional ? 0.0001f : 0); sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; sinkComp.IsPoweredChanged += ComponentStack_IsFunctionalChanged; ResourceSink = sinkComp; base.Init(builder, cubeGrid); m_emissiveNames = new List <string>(BlockDefinition.ButtonCount); for (int i = 1; i <= BlockDefinition.ButtonCount; i++) //button dummies have 1-based index { m_emissiveNames.Add(string.Format("Emissive{0}", i)); // because of modding } var ob = builder as MyObjectBuilder_ButtonPanel; Toolbar = new MyToolbar(MyToolbarType.ButtonPanel, Math.Min(BlockDefinition.ButtonCount, MyToolbar.DEF_SLOT_COUNT), (BlockDefinition.ButtonCount / MyToolbar.DEF_SLOT_COUNT) + 1); Toolbar.DrawNumbers = false; Toolbar.GetSymbol = (slot) => { var ret = new Sandbox.Graphics.GUI.MyGuiControlGrid.ColoredIcon(); if (Toolbar.SlotToIndex(slot) < BlockDefinition.ButtonCount) { ret.Icon = BlockDefinition.ButtonSymbols[Toolbar.SlotToIndex(slot) % BlockDefinition.ButtonSymbols.Length]; var color = BlockDefinition.ButtonColors[Toolbar.SlotToIndex(slot) % BlockDefinition.ButtonColors.Length]; color.W = 1; ret.Color = color; } return(ret); }; Toolbar.Init(ob.Toolbar, this); Toolbar.ItemChanged += Toolbar_ItemChanged; AnyoneCanUse = ob.AnyoneCanUse; SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; ResourceSink.Update(); if (ob.CustomButtonNames != null) { m_customButtonNames = ob.CustomButtonNames; } NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; UseObjectsComponent.GetInteractiveObjects <MyUseObjectPanelButton>(m_buttonsUseObjects); }
public MyGridGyroSystem(MyCubeGrid grid) { m_grid = grid; m_gyros = new HashSet <MyGyro>(); m_gyrosChanged = false; ResourceSink = new MyResourceSinkComponent(); ResourceSink.Init( MyStringHash.GetOrCompute("Gyro"), m_maxRequiredPowerInput, () => m_maxRequiredPowerInput); ResourceSink.IsPoweredChanged += Receiver_IsPoweredChanged; }
public MyGridWheelSystem(MyCubeGrid grid) { m_wheels = new HashSet <MyMotorSuspension>(); m_wheelsChanged = false; m_grid = grid; SinkComp = new MyResourceSinkComponent(); SinkComp.Init(MyStringHash.GetOrCompute("Utility"), m_maxRequiredPowerInput, () => m_maxRequiredPowerInput); SinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; grid.OnPhysicsChanged += grid_OnPhysicsChanged; }
protected void doSetup(string powerPriority, float smallGridMW, float largeGridMW, params MyEntityUpdateEnum[] updateCycles) { NeedsUpdate |= MyEntityUpdateEnum.EACH_10TH_FRAME; Entity.NeedsUpdate |= MyEntityUpdateEnum.EACH_10TH_FRAME; NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; Entity.NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; if (updateCycles.Length == 0) { IO.log("WARNING: " + this + " has no update cycles set!"); } foreach (MyEntityUpdateEnum e in updateCycles) { NeedsUpdate |= e; Entity.NeedsUpdate |= e; } thisBlock = Container.Entity as IMyFunctionalBlock; thisGrid = thisBlock.CubeGrid as IMyCubeGrid; //thisBlock.Enabled = false; //causes it to turn off every time you load the game //Sandbox.ModAPI.Ingame.TerminalBlockExtentions.ApplyAction(thisBlock, "OnOff_Off"); energySink = new MyResourceSinkComponent(1); energySink.Init(MyStringHash.GetOrCompute(powerPriority), thisGrid.GridSizeEnum == MyCubeSize.Small ? smallGridMW : largeGridMW, calcRequiredPower, (MyCubeBlock)thisBlock); if (thisBlock.Components.Contains(typeof(MyResourceSinkComponent))) { IO.log("Power sinks already present in " + this + " #" + Entity.EntityId + ":"); List <MyResourceSinkComponent> li = new List <MyResourceSinkComponent>(); Dictionary <Type, MyComponentBase> .ValueCollection.Enumerator e = thisBlock.Components.GetEnumerator(); while (e.MoveNext()) { if (e.Current is MyResourceSinkComponent) { MyResourceSinkComponent req = e.Current as MyResourceSinkComponent; IO.log(">> " + req.GetType() + " needing " + req.MaxRequiredInput + ", of " + req.AcceptedResources.ToString()); } } thisBlock.Components.Remove <MyResourceSinkComponent>(); } thisBlock.Components.Add(energySink); energySink.Update(); thisBlock.IsWorkingChanged += onWorkingChanged; thisBlock.AppendingCustomInfo += updateInfo; MyAPIGateway.TerminalControls.CustomControlGetter += filterControls; soundSource = new MultiSoundSource(thisBlock); IO.log("Loaded logic script " + this + " for block '" + thisBlock.CustomName + "' / '" + Entity.DisplayName + "' #" + Entity.EntityId + "; update rate = " + NeedsUpdate); }