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);
}