public MyGasTank()
{
CreateTerminalControls();
SourceComp = new MyResourceSourceComponent();
ResourceSink = new MyResourceSinkComponent(2);
}
public MyBattery(MyCharacter owner)
{
m_owner = owner;
SyncObject = new MySyncBattery(this);
ResourceSink = new MyResourceSinkComponent();
ResourceSource = new MyResourceSourceComponent();
}
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 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 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 UpdateBeforeSimulation()
{
IMyCubeBlock cubeBlock = Entity as IMyCubeBlock;
if (!m_init)
{
m_resourceSink = (MyResourceSinkComponent)cubeBlock.ResourceSink;
for (int i = 0; i < 5; i++)
{
LastGridPositions.Enqueue(cubeBlock.CubeGrid.PositionComp.GetPosition());
}
m_init = true;
}
calculateMaximumShieldPoints();
calculateShieldPointsRecharge();
if (LastGridPositions.Count > 4)
{
LastGridPositions.Dequeue();
}
LastGridPositions.Enqueue(cubeBlock.CubeGrid.PositionComp.GetPosition());
saveFileShieldMessage.value = m_currentShieldPoints;
}
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");
}
}
private void PowerPreInit()
{
try
{
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);
}
catch (Exception ex)
{
Log.Line($"Exception in PowerPreInit: {ex}");
}
}
public override void UpdateOnceBeforeFrame()
{
resourceSink = Entity.Components.Get <MyResourceSinkComponent>();
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f);
setPowerConsumption = 0.0001f;
m_inventory = ((Sandbox.ModAPI.Ingame.IMyTerminalBlock)Entity).GetInventory(0) as IMyInventory;
}
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)
{
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)
{
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 MyAirVent()
{
ResourceSink = new MyResourceSinkComponent(2);
SourceComp = new MyResourceSourceComponent();
m_isDepressurizing.ValueChanged += (x) => SetDepressurizing();
}
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 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)
{
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_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");
}
private void SinkChanged(MyResourceSinkComponent old, MyResourceSinkComponent @new)
{
if (old != null)
{
foreach (var key in old.AcceptedResources)
{
old.SetMaxRequiredInputByType(key, 0);
old.SetRequiredInputFuncByType(key, () => 0);
}
RemoveDelegate(ref old.CurrentInputChanged, OnInputChanged);
}
if (@new == null)
{
return;
}
foreach (var kv in _sinks)
{
var info = new MyResourceSinkInfo()
{
MaxRequiredInput = kv.Value.CalculateMaxInput(),
RequiredInputFunc = kv.Value.DelCalculateRequiredInput,
ResourceTypeId = kv.Key
};
@new.AddType(ref info);
@new.SetMaxRequiredInputByType(kv.Key, kv.Value.CalculateMaxInput());
@new.SetRequiredInputFuncByType(kv.Key, kv.Value.DelCalculateRequiredInput);
}
AddDelegate(ref @new.CurrentInputChanged, OnInputChanged);
}
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_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 void initMe()
{
try
{
max = getMax();
if (fBlock.Name != "NaN" && !fBlock.Name.Contains("-"))
{
float.TryParse(fBlock.Name, out points);
}
if (points > max)
{
points = 0f;
}
if (!TeaShieldBase.shieldList.Contains(sBlock))
{
TeaShieldBase.shieldList.Add(sBlock);
}
sink = fBlock.ResourceSink as MyResourceSinkComponent;
sink.SetMaxRequiredInputByType(electricity, max / 1000);
sink.SetRequiredInputFuncByType(electricity, powerCalc);
sink.Update();
fBlock.AppendingCustomInfo += appendCustomInfo;
added = true;
for (int i = 1; i < 9; i++)
{
sbBlock.SetEmissiveParts("Emissive" + i, Color.Red, i == 6 ? 1f : 0f);
}
}
catch (Exception ex)
{
Echo("IAShields threw exception", ex.ToString());
}
}
public MyBatteryBlock()
{
#if XB1 // XB1_SYNC_NOREFLECTION
m_isFull = SyncType.CreateAndAddProp <bool>();
m_onlyRecharge = SyncType.CreateAndAddProp <bool>();
m_onlyDischarge = SyncType.CreateAndAddProp <bool>();
m_semiautoEnabled = SyncType.CreateAndAddProp <bool>();
m_producerEnabled = SyncType.CreateAndAddProp <bool>();
m_storedPower = SyncType.CreateAndAddProp <float>();
#endif // XB1
CreateTerminalControls();
SourceComp = new MyResourceSourceComponent();
ResourceSink = new MyResourceSinkComponent();
m_semiautoEnabled.ValueChanged += (x) => UpdateMaxOutputAndEmissivity();
m_onlyRecharge.ValueChanged += (x) => { if (m_onlyRecharge.Value)
{
m_onlyDischarge.Value = false;
}
UpdateMaxOutputAndEmissivity(); };
m_onlyDischarge.ValueChanged += (x) => { if (m_onlyDischarge.Value)
{
m_onlyRecharge.Value = false;
}
UpdateMaxOutputAndEmissivity(); };
m_producerEnabled.ValueChanged += (x) => ProducerEnadChanged();
m_storedPower.ValueChanged += (x) => CapacityChanged();
}
public override void UpdateOnceBeforeFrame()
{
if (!IsReal((MyCubeBlock)block) || !MyAPIGateway.Multiplayer.IsServer) // ignore projected and other non-physical grids
{
return;
}
NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME;
myNotUsedRespawn = block.Components.Get <MyEntityRespawnComponentBase>();
_respawnAllowed = myNotUsedRespawn != null;
// setup resources
sink = Entity.Components.Get <MyResourceSinkComponent>();
var fleshSink = new MyResourceSinkInfo()
{
ResourceTypeId = Gasses.Flesh, // people are flesh
MaxRequiredInput = MaxFillRate,
RequiredInputFunc = GetFleshRequired
};
sink.AddType(ref fleshSink);
sink.Update();
}
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 MyAirVent()
{
CreateTerminalControls();
ResourceSink = new MyResourceSinkComponent(2);
SourceComp = new MyResourceSourceComponent();
m_isDepressurizing.ValueChanged += (x) => SetDepressurizing();
}
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 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();
}
