public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
base.Init(objectBuilder, cubeGrid);
var builder = (MyObjectBuilder_AirVent)objectBuilder;
m_isDepressurizing = builder.IsDepressurizing;
InitializeConveyorEndpoint();
NeedsUpdate = MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.EACH_100TH_FRAME;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Factory,
false,
BlockDefinition.OperationalPowerConsumption,
ComputeRequiredPower);
PowerReceiver.IsPoweredChanged += PowerReceiver_IsPoweredChanged;
PowerReceiver.Update();
UpdateEmissivity();
UdpateTexts();
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawConveyorEndpoint(m_conveyorEndpoint));
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
m_cameraDummy = Matrix.Identity;
m_characterDummy = Matrix.Identity;
base.Init(objectBuilder, cubeGrid);
var chamberOb = objectBuilder as MyObjectBuilder_CryoChamber;
if (chamberOb.SteamId != null && chamberOb.SerialId != null)
{
m_currentPlayerId = new MyPlayer.PlayerId(chamberOb.SteamId.Value, chamberOb.SerialId.Value);
}
else
{
m_currentPlayerId = null;
}
var overlayTexture = BlockDefinition.OverlayTexture;
if (!string.IsNullOrEmpty(overlayTexture))
{
m_overlayTextureName = overlayTexture;
}
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
BlockDefinition.IdlePowerConsumption,
this.CalculateRequiredPowerInput);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
NeedsUpdate |= Common.MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
BlockDefinition.RequiredPowerInput,
this.CalculateRequiredPowerInput);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.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 Engine.Physics.MyPhysicsBody(this, RigidBodyFlag.RBF_DEFAULT);
Physics.IsPhantom = false;
Physics.CreateFromCollisionObject(detectorShape, Vector3.Zero, WorldMatrix, massProperties, MyPhysics.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 void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
base.Init(objectBuilder, cubeGrid);
var ob = objectBuilder as MyObjectBuilder_TimerBlock;
Toolbar = new MyToolbar(MyToolbarType.ButtonPanel, 9, 10);
Toolbar.Init(ob.Toolbar, this);
Toolbar.ItemChanged += Toolbar_ItemChanged;
if (ob.JustTriggered)
{
NeedsUpdate |= Common.MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
}
m_countdownMsStart = ob.Delay;
m_countdownMsCurrent = ob.CurrentTime;
if (m_countdownMsCurrent > 0)
{
NeedsUpdate |= Common.MyEntityUpdateEnum.EACH_10TH_FRAME;
}
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
0.0000001f,
() => (Enabled && IsFunctional) ? PowerReceiver.MaxRequiredInput : 0f);
PowerReceiver.Update();
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawPowerReciever(PowerReceiver, this));
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
base.Init(objectBuilder, cubeGrid);
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Charging,
true,
BlockDefinition.RequiredPowerInput,
ComputeRequiredPower);
var jumpDriveBuilder = objectBuilder as MyObjectBuilder_JumpDrive;
NeedsUpdate |= VRage.ModAPI.MyEntityUpdateEnum.BEFORE_NEXT_FRAME | VRage.ModAPI.MyEntityUpdateEnum.EACH_FRAME | VRage.ModAPI.MyEntityUpdateEnum.EACH_100TH_FRAME;
m_storedPower = jumpDriveBuilder.StoredPower;
if (m_storedPower >= BlockDefinition.PowerNeededForJump)
{
m_storedPower = BlockDefinition.PowerNeededForJump;
}
m_storedJumpTarget = jumpDriveBuilder.JumpTarget;
if (jumpDriveBuilder.JumpTarget != null)
{
m_jumpTarget = MySession.Static.Gpss.GetGps(jumpDriveBuilder.JumpTarget.Value);
}
m_jumpDistanceRatio = jumpDriveBuilder.JumpRatio;
m_isRecharging = jumpDriveBuilder.Recharging;
PowerReceiver.Update();
UpdateEmissivity();
}
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;
PowerReceiver = new MyPowerReceiver(MyConsumerGroupEnum.Doors,
false,
BlockDefinition.PowerConsumptionMoving,
() => UpdatePowerInput());
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.Update();
if (!Enabled || !PowerReceiver.IsPowered)
{
UpdateDoorPosition();
}
OnStateChange();
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
PowerReceiver.Update();
}
public override void Init(Sandbox.Common.ObjectBuilders.MyObjectBuilder_CubeBlock objectBuilder, Sandbox.Game.Entities.MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
m_oxygenFarmDefinition = BlockDefinition as MyOxygenFarmDefinition;
IsWorkingChanged += OnIsWorkingChanged;
NeedsUpdate = MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.EACH_100TH_FRAME;
InitializeConveyorEndpoint();
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Factory,
false,
m_oxygenFarmDefinition.OperationalPowerConsumption,
ComputeRequiredPower);
PowerReceiver.IsPoweredChanged += PowerReceiver_IsPoweredChanged;
PowerReceiver.Update();
GameLogic = new MySolarGameLogicComponent();
m_solarComponent = GameLogic as MySolarGameLogicComponent;
m_solarComponent.Initialize(m_oxygenFarmDefinition.PanelOrientation, m_oxygenFarmDefinition.IsTwoSided, m_oxygenFarmDefinition.PanelOffset, this);
AddDebugRenderComponent(new Components.MyDebugRenderComponentSolarPanel(this));
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
m_definition = BlockDefinition as MyOreDetectorDefinition;
SyncObject = new MySyncOreDetector(this);
var ob = objectBuilder as MyObjectBuilder_OreDetector;
m_oreDetectorComponent.DetectionRadius = ob.DetectionRadius;
if (m_oreDetectorComponent.DetectionRadius == 0)
{
m_oreDetectorComponent.DetectionRadius = m_definition.MaximumRange;
}
m_oreDetectorComponent.BroadcastUsingAntennas = ob.BroadcastUsingAntennas;
m_oreDetectorComponent.OnCheckControl += OnCheckControl;
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
NeedsUpdate = MyEntityUpdateEnum.EACH_100TH_FRAME;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Factory,
false,
MyEnergyConstants.MAX_REQUIRED_POWER_ORE_DETECTOR,
() => (Enabled && IsFunctional) ? PowerReceiver.MaxRequiredInput : 0f);
PowerReceiver.Update();
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawPowerReciever(PowerReceiver, this));
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
var def = BlockDefinition as MyCargoContainerDefinition;
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();
}
PowerReceiver = new MyPowerReceiver(
group: MyConsumerGroupEnum.Conveyors,
isAdaptible: false,
maxRequiredInput: MyEnergyConstants.MAX_REQUIRED_POWER_COLLECTOR,
requiredInputFunc: () => base.CheckIsWorking() ? PowerReceiver.MaxRequiredInput : 0f);
PowerReceiver.Update();
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawPowerReciever(PowerReceiver, this));
SlimBlock.ComponentStack.IsFunctionalChanged += UpdateReceiver;
base.EnabledChanged += UpdateReceiver;
m_useConveyorSystem = ob.UseConveyorSystem;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
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;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
0.0005f,
() => (Enabled && IsFunctional) ? PowerReceiver.MaxRequiredInput : 0f);
PowerReceiver.Update();
PowerReceiver.IsPoweredChanged += PowerReceiver_IsPoweredChanged;
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 objectBuilder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
var ob = objectBuilder as MyObjectBuilder_SmallGatlingGun;
var weaponBlockDefinition = BlockDefinition as MyWeaponBlockDefinition;
if (weaponBlockDefinition != null)
{
m_ammoInventory = new MyInventory(weaponBlockDefinition.InventoryMaxVolume, new Vector3(0.4f, 0.4f, 0.4f), MyInventoryFlags.CanReceive, this);
}
else
{
m_ammoInventory = new MyInventory(64.0f / 1000, new Vector3(0.4f, 0.4f, 0.4f), MyInventoryFlags.CanReceive, this);
}
base.Init(objectBuilder, cubeGrid);
m_ammoInventory.Init(ob.Inventory);
m_gunBase.Init(ob.GunBase, BlockDefinition, this);
m_ammoInventory.ContentsChanged += AmmoInventory_ContentsChanged;
GetBarrelAndMuzzle();
//if (m_ammoPerShotConsumption == 0)
// m_ammoPerShotConsumption = (MyFixedPoint)((45.0f / (1000.0f / MyGatlingConstants.SHOT_INTERVAL_IN_MILISECONDS)) / m_gunBase.WeaponProperties.AmmoMagazineDefinition.Capacity);
m_useConveyorSystem = ob.UseConveyorSystem;
PowerReceiver = new MyPowerReceiver(MyConsumerGroupEnum.Defense, false, MyEnergyConstants.MAX_REQUIRED_POWER_SHIP_GUN, () => PowerReceiver.MaxRequiredInput);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.Update();
AddDebugRenderComponent(new MyDebugRenderComponentDrawPowerReciever(PowerReceiver, this));
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
base.Init(objectBuilder, cubeGrid);
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
PistonDefinition.RequiredPowerInput,
() => (Enabled && IsFunctional) ? PowerReceiver.MaxRequiredInput : 0.0f);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.Update();
var ob = objectBuilder as MyObjectBuilder_PistonBase;
Velocity = ob.Velocity * BlockDefinition.MaxVelocity;
MaxLimit = ob.MaxLimit.HasValue ? Math.Min(DenormalizeDistance(ob.MaxLimit.Value), BlockDefinition.Maximum) : BlockDefinition.Maximum;
MinLimit = ob.MinLimit.HasValue ? Math.Max(DenormalizeDistance(ob.MinLimit.Value), BlockDefinition.Minimum) : BlockDefinition.Minimum;
m_topBlockId = ob.TopBlockId;
m_currentPos = ob.CurrentPosition;
CubeGrid.OnPhysicsChanged += CubeGrid_OnPhysicsChanged;
NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME | MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
}
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
{
base.Init(builder, cubeGrid);
var ob = (MyObjectBuilder_AdvancedDoor)builder;
m_open = ob.Open;
PowerReceiver = new MyPowerReceiver(MyConsumerGroupEnum.Doors,
false,
BlockDefinition.PowerConsumptionMoving,
() => UpdatePowerInput());
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.Update();
if (!Enabled || !PowerReceiver.IsPowered)
{
UpdateDoorPosition();
}
OnStateChange();
if (m_open)
{
UpdateDoorPosition();
}
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
PowerReceiver.Update();
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
base.Init(objectBuilder, cubeGrid);
NeedsUpdate = MyEntityUpdateEnum.EACH_FRAME | MyEntityUpdateEnum.EACH_10TH_FRAME;
var ob = objectBuilder as MyObjectBuilder_CameraBlock;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
BlockDefinition.RequiredPowerInput,
this.CalculateRequiredPowerInput);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.RequiredInputChanged += Receiver_RequiredInputChanged;
PowerReceiver.Update();
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
IsWorkingChanged += MyCameraBlock_IsWorkingChanged;
IsInFirstPersonView = true;
if (ob.IsActive)
{
m_requestActivateAfterLoad = true;
ob.IsActive = false;
}
OnChangeFov(ob.Fov);
UpdateText();
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
var builder = (MyObjectBuilder_GravityGeneratorSphere)objectBuilder;
m_radius = builder.Radius;
m_gravityAcceleration = builder.GravityAcceleration;
base.Init(objectBuilder, cubeGrid);
SyncObject = new MySyncGravityGeneratorSphere(this);
m_defaultVolume = (float)(Math.Pow(DEFAULT_RADIUS, BlockDefinition.ConsumptionPower) * Math.PI * 0.75);
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
CalculateRequiredPowerInputForRadius(BlockDefinition.MaxRadius),
this.CalculateRequiredPowerInput);
if (CubeGrid.CreatePhysics)
{
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.RequiredInputChanged += Receiver_RequiredInputChanged;
PowerReceiver.Update();
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawPowerReciever(PowerReceiver, this));
AddDebugRenderComponent(new Components.MyDebugRenderComponentGravityGeneratorSphere(this));
}
}
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
{
base.Init(builder, cubeGrid);
m_defId = builder.GetId();
var def = MyDefinitionManager.Static.GetCubeBlockDefinition(m_defId) as MyShipDrillDefinition;
m_blockLength = def.Size.Z;
m_cubeSideLength = MyDefinitionManager.Static.GetCubeSize(def.CubeSize);
float inventoryVolume = def.Size.X * def.Size.Y * def.Size.Z * m_cubeSideLength * m_cubeSideLength * m_cubeSideLength * 0.5f;
Vector3 inventorySize = new Vector3(def.Size.X, def.Size.Y, def.Size.Z * 0.5f);
m_inventory = new MyInventory(inventoryVolume, inventorySize, MyInventoryFlags.CanSend, this);
m_inventory.Constraint = new MyInventoryConstraint(MySpaceTexts.ToolTipItemFilter_AnyOre)
.AddObjectBuilderType(typeof(MyObjectBuilder_Ore));
SlimBlock.UsesDeformation = false;
SlimBlock.DeformationRatio = def.DeformationRatio; // 3x times harder for destruction by high speed
m_drillBase = new MyDrillBase(this,
MyDrillConstants.DRILL_SHIP_DUST_EFFECT,
MyDrillConstants.DRILL_SHIP_DUST_STONES_EFFECT,
MyDrillConstants.DRILL_SHIP_SPARKS_EFFECT,
new MyDrillSensorSphere(def.SensorRadius, def.SensorOffset),
new MyDrillCutOut(def.SensorOffset, def.SensorRadius),
HEAD_SLOWDOWN_TIME_IN_SECONDS,
floatingObjectSpawnOffset: -0.4f,
floatingObjectSpawnRadius: 0.4f,
sounds: m_sounds,
inventoryCollectionRatio: 0.7f
);
m_drillBase.OutputInventory = m_inventory;
m_drillBase.IgnoredEntities.Add(this);
m_drillBase.OnWorldPositionChanged(WorldMatrix);
m_wantsToDrill = false;
m_wantsToCollect = false;
AddDebugRenderComponent(new Components.MyDebugRenderCompomentDrawDrillBase(m_drillBase));
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Defense,
false,
ComputeMaxRequiredPower(),
ComputeRequiredPower);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.Update();
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawPowerReciever(PowerReceiver, this));
var obDrill = (MyObjectBuilder_Drill)builder;
m_inventory.Init(obDrill.Inventory);
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
m_useConveyorSystem = obDrill.UseConveyorSystem;
UpdateDetailedInfo();
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
m_radioBroadcaster = new MyRadioBroadcaster(this, 10000, IsWorking);
if (((MyObjectBuilder_Beacon)objectBuilder).BroadcastRadius != 0)
{
m_radioBroadcaster.BroadcastRadius = ((MyObjectBuilder_Beacon)objectBuilder).BroadcastRadius;
}
m_radioBroadcaster.OnBroadcastRadiusChanged += OnBroadcastRadiusChanged;
m_largeLight = cubeGrid.GridSizeEnum == MyCubeSize.Large;
m_light = MyLights.AddLight();
m_light.Start(MyLight.LightTypeEnum.PointLight, 1.5f);
m_light.LightOwner = MyLight.LightOwnerEnum.SmallShip;
m_light.UseInForwardRender = true;
m_light.Range = 1;
m_light.GlareOn = true;
m_light.GlareIntensity = m_largeLight ? 2 : 1;
m_light.GlareQuerySize = m_largeLight ? 7.5f : 1.22f;
m_light.GlareType = VRageRender.Lights.MyGlareTypeEnum.Distant;
m_light.GlareMaterial = m_largeLight ? "GlareLsLight"
: "GlareSsLight";
m_light.GlareMaxDistance = GLARE_MAX_DISTANCE;
if (m_largeLight)
{
m_lightPositionOffset = new Vector3(0f, CubeGrid.GridSize * 0.5f, 0f);
}
else
{
m_lightPositionOffset = Vector3.Zero;
}
UpdateLightPosition();
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
MyEnergyConstants.MAX_REQUIRED_POWER_BEACON,
UpdatePowerInput);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.Update();
AddDebugRenderComponent(new MyDebugRenderComponentDrawPowerReciever(PowerReceiver, this));
AnimationRunning = true;
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
IsWorkingChanged += MyBeacon_IsWorkingChanged;
ShowOnHUD = false;
UpdateText();
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
if (BlockDefinition is MyMedicalRoomDefinition)
{
var def = (MyMedicalRoomDefinition)BlockDefinition;
m_idleSound = new MySoundPair(def.IdleSound);
m_progressSound = new MySoundPair(def.ProgressSound);
}
else
{
m_idleSound = new MySoundPair("BlockMedical");
m_progressSound = new MySoundPair("BlockMedicalProgress");
}
m_rechargeSocket = new MyRechargeSocket();
NeedsUpdate = MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.EACH_100TH_FRAME;
SteamUserId = (objectBuilder as MyObjectBuilder_MedicalRoom).SteamUserId;
if (SteamUserId != 0) //backward compatibility
{
MyPlayer controller = Sync.Players.TryGetPlayerById(new MyPlayer.PlayerId(SteamUserId));
if (controller != null)
{
IDModule.Owner = controller.Identity.IdentityId;
IDModule.ShareMode = MyOwnershipShareModeEnum.Faction;
}
}
SteamUserId = 0;
m_takeSpawneeOwnership = (objectBuilder as MyObjectBuilder_MedicalRoom).TakeOwnership;
m_setFactionToSpawnee = (objectBuilder as MyObjectBuilder_MedicalRoom).SetFaction;
SyncObject = new SyncClass(this);
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
InitializeConveyorEndpoint();
PowerReceiver = new MyPowerReceiver(
group: MyConsumerGroupEnum.Utility,
isAdaptible: false,
maxRequiredInput: MyEnergyConstants.MAX_REQUIRED_POWER_MEDICAL_ROOM,
requiredInputFunc: () => (Enabled && IsFunctional) ? PowerReceiver.MaxRequiredInput : 0f);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.Update();
AddDebugRenderComponent(new MyDebugRenderComponentDrawPowerReciever(PowerReceiver, this));
if (this.CubeGrid.CreatePhysics)
{
Components.Add <MyRespawnComponent>(new MyRespawnComponent());
}
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
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;
m_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();
}
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
BlockDefinition.RequiredPowerInput,
() => (Enabled && IsFunctional) ? PowerReceiver.MaxRequiredInput : 0f);
PowerReceiver.Update();
PowerReceiver.IsPoweredChanged += PowerReceiver_IsPoweredChanged;
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
}
public MyGridGyroSystem(MyCubeGrid grid)
{
m_grid = grid;
m_gyros = new HashSet <MyGyro>();
m_gyrosChanged = false;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Gyro,
true,
m_maxRequiredPowerInput,
() => m_maxRequiredPowerInput);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
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);
m_inventory = new MyInventory(inventoryVolume, inventorySize, MyInventoryFlags.CanSend, this);
m_inventory.Init(typedBuilder.Inventory);
SlimBlock.UsesDeformation = false;
SlimBlock.DeformationRatio = typedBuilder.DeformationRatio; // 3x times harder for destruction by high speed
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Defense,
false,
MyEnergyConstants.MAX_REQUIRED_POWER_SHIP_GRINDER,
ComputeRequiredPower);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
Enabled = typedBuilder.Enabled;
UseConveyorSystem = typedBuilder.UseConveyorSystem;
base.EnabledChanged += MyShipToolBase_EnabledChanged;
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
LoadDummies();
UpdateActivationState();
PowerReceiver.Update();
NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME | MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.EACH_FRAME;
}
public MyGridWheelSystem(MyCubeGrid grid)
{
m_wheels = new HashSet <MyMotorSuspension>();
m_wheelsChanged = false;
m_grid = grid;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
m_maxRequiredPowerInput,
() => m_maxRequiredPowerInput);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
grid.OnPhysicsChanged += grid_OnPhysicsChanged;
}
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
{
base.Init(builder, cubeGrid);
//m_subpartsSize = 0.5f * (0.5f * SlimBlock.CubeGrid.GridSize - 0.3f);
if (BlockDefinition is MyDoorDefinition)
{
var doorDefinition = (MyDoorDefinition)BlockDefinition;
MaxOpen = doorDefinition.MaxOpen;
m_openSound = new MySoundPair(doorDefinition.OpenSound);
m_closeSound = new MySoundPair(doorDefinition.CloseSound);
}
else
{
MaxOpen = 1.2f;
m_openSound = new MySoundPair("BlockDoorSmallOpen");
m_closeSound = new MySoundPair("BlockDoorSmallClose");
}
var ob = (MyObjectBuilder_Door)builder;
m_open = ob.State;
m_currOpening = ob.Opening;
PowerReceiver = new MyPowerReceiver(MyConsumerGroupEnum.Doors,
false,
MyEnergyConstants.MAX_REQUIRED_POWER_DOOR,
() => (Enabled && IsFunctional) ? PowerReceiver.MaxRequiredInput : 0f);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.Update();
if (!Enabled || !PowerReceiver.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;
}
//[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();
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);
}
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
}
}
base.Init(builder, cubeGrid);
m_ammoInventory.Init(ob.Inventory);
m_gunBase.Init(ob.GunBase, BlockDefinition, this);
m_ammoInventory.ContentsChanged += m_ammoInventory_ContentsChanged;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Defense,
false,
MyEnergyConstants.MAX_REQUIRED_POWER_SHIP_GUN,
() => (Enabled && IsFunctional) ? PowerReceiver.MaxRequiredInput : 0.0f);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.Update();
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawPowerReciever(PowerReceiver, this));
m_useConveyorSystem = ob.UseConveyorSystem;
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
LoadDummies();
NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
base.Init(objectBuilder, cubeGrid);
var generatorBuilder = objectBuilder as MyObjectBuilder_OxygenGenerator;
InitializeConveyorEndpoint();
m_useConveyorSystem = generatorBuilder.UseConveyorSystem;
NeedsUpdate = Common.MyEntityUpdateEnum.EACH_100TH_FRAME;
m_inventory = new MyInventory(
BlockDefinition.InventoryMaxVolume,
BlockDefinition.InventorySize,
MyInventoryFlags.CanReceive,
this);
m_inventory.Constraint = BlockDefinition.InputInventoryConstraint;
m_oreConstraint = new MyInventoryConstraint(m_inventory.Constraint.Description, m_inventory.Constraint.Icon, m_inventory.Constraint.IsWhitelist);
foreach (var id in m_inventory.Constraint.ConstrainedIds)
{
if (id.TypeId != typeof(MyObjectBuilder_OxygenContainerObject))
{
m_oreConstraint.Add(id);
}
}
m_inventory.Init(generatorBuilder.Inventory);
m_inventory.ContentsChanged += m_inventory_ContentsChanged;
m_autoRefill = generatorBuilder.AutoRefill;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Factory,
false,
BlockDefinition.OperationalPowerConsumption,
ComputeRequiredPower);
PowerReceiver.IsPoweredChanged += PowerReceiver_IsPoweredChanged;
PowerReceiver.Update();
UpdateEmissivity();
UpdateText();
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawConveyorEndpoint(m_conveyorEndpoint));
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
}
public MyGridConveyorSystem(MyCubeGrid grid)
{
m_grid = grid;
m_lineEndpoints = null;
m_linePoints = null;
m_deserializedLines = null;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Conveyors,
false,
CONVEYOR_SYSTEM_CONSUMPTION,
() => CalculateConsumption());
PowerReceiver.Update();
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
}
public override void Init(Common.ObjectBuilders.MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
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;
PowerReceiver = new MyPowerReceiver(MyConsumerGroupEnum.Utility, false, 0.0001f, () => IsFunctional ? 0.0001f : 0);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
PowerReceiver.IsPoweredChanged += ComponentStack_IsFunctionalChanged;
PowerReceiver.Update();
if (ob.CustomButtonNames != null)
{
m_customButtonNames = ob.CustomButtonNames;
}
NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME | MyEntityUpdateEnum.EACH_FRAME;
GetInteractiveObjects <MyUseObjectPanelButton>(m_buttonsUseObjects);
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
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);
}
m_conveyorSorterDefinition = (MyConveyorSorterDefinition)MyDefinitionManager.Static.GetCubeBlockDefinition(objectBuilder.GetId());
m_inventory = new MyInventory(m_conveyorSorterDefinition.InventorySize.Volume, m_conveyorSorterDefinition.InventorySize, MyInventoryFlags.CanSend, this);
m_inventory.Init(ob.Inventory);
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME | MyEntityUpdateEnum.EACH_10TH_FRAME;
if (MyPerGameSettings.InventoryMass)
{
m_inventory.ContentsChanged += Inventory_ContentsChanged;
}
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Conveyors,
false,
BlockDefinition.PowerInput,
UpdatePowerInput);
PowerReceiver.IsPoweredChanged += IsPoweredChanged;
PowerReceiver.Update();
UpdateText();
}
public override void Init(MyObjectBuilder_EntityBase builder)
{
base.Init(builder);
if (PhysicalObject != null)
{
PhysicalObject.GunEntity = builder;
}
m_sensor = new MyDrillSensorRayCast(0f, 1.8f);
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
MyEnergyConstants.REQUIRED_INPUT_ENGINEERING_TOOL,
CalculateRequiredPower);
m_soundEmitter = new MyEntity3DSoundEmitter(this);
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
base.Init(objectBuilder, cubeGrid);
var builder = (MyObjectBuilder_OxygenTank)objectBuilder;
m_isStockpiling = builder.IsStockpiling;
FilledRatio = builder.FilledRatio;
InitializeConveyorEndpoint();
NeedsUpdate = Common.MyEntityUpdateEnum.EACH_100TH_FRAME;
m_inventory = new MyInventory(
BlockDefinition.InventoryMaxVolume,
BlockDefinition.InventorySize,
MyInventoryFlags.CanReceive,
this);
m_inventory.Constraint = BlockDefinition.InputInventoryConstraint;
m_inventory.Init(builder.Inventory);
m_inventory.ContentsChanged += m_inventory_ContentsChanged;
m_autoRefill = builder.AutoRefill;
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Factory,
false,
BlockDefinition.OperationalPowerConsumption,
ComputeRequiredPower);
PowerReceiver.IsPoweredChanged += PowerReceiver_IsPoweredChanged;
PowerReceiver.Update();
UpdateEmissivity();
UdpateText();
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawConveyorEndpoint(m_conveyorEndpoint));
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
IsWorkingChanged += MyOxygenTank_IsWorkingChanged;
}
