public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
m_cargoDefinition = (MyCargoContainerDefinition)MyDefinitionManager.Static.GetCubeBlockDefinition(objectBuilder.GetId());
var cargoBuilder = (MyObjectBuilder_CargoContainer)objectBuilder;
m_containerType = cargoBuilder.ContainerType;
if (!Components.Has<MyInventoryBase>())
{
m_inventory = new MyInventory(m_cargoDefinition.InventorySize.Volume, m_cargoDefinition.InventorySize, MyInventoryFlags.CanSend | MyInventoryFlags.CanReceive, this);
if(MyFakes.ENABLE_MEDIEVAL_INVENTORY)
Components.Add<MyInventoryBase>(m_inventory);
if (m_containerType != null && MyFakes.RANDOM_CARGO_PLACEMENT && (cargoBuilder.Inventory == null || cargoBuilder.Inventory.Items.Count == 0))
SpawnRandomCargo();
else
m_inventory.Init(cargoBuilder.Inventory);
}
else
{
m_inventory = Components.Get<MyInventoryBase>() as MyInventory;
Debug.Assert(m_inventory != null);
//m_inventory.Owner = this;
}
if(MyPerGameSettings.InventoryMass)
m_inventory.ContentsChanged += Inventory_ContentsChanged;
m_conveyorEndpoint = new MyMultilineConveyorEndpoint(this);
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawConveyorEndpoint(m_conveyorEndpoint));
UpdateIsWorking();
}
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)
{
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;
}
var sinkComp = new MyResourceSinkComponent();
sinkComp.Init(
MyStringHash.GetOrCompute(BlockDefinition.ResourceSinkGroup),
BlockDefinition.IdlePowerConsumption,
this.CalculateRequiredPowerInput);
sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged;
ResourceSink = sinkComp;
NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
}
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);
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 Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
MyDebug.AssertDebug(BlockDefinition is MyRefineryDefinition);
m_refineryDef = BlockDefinition as MyRefineryDefinition;
InputInventory.Constraint = m_refineryDef.InputInventoryConstraint;
bool removed = InputInventory.FilterItemsUsingConstraint();
Debug.Assert(!removed, "Inventory filter removed items which were present in the object builder.");
InputInventory.ContentsChanged += inventory_OnContentsChanged;
OutputInventory.Constraint = m_refineryDef.OutputInventoryConstraint;
removed = OutputInventory.FilterItemsUsingConstraint();
Debug.Assert(!removed, "Inventory filter removed items which were present in the object builder.");
OutputInventory.ContentsChanged += inventory_OnContentsChanged;
m_queueNeedsRebuild = true;
UpgradeValues.Add("Productivity", 0f);
UpgradeValues.Add("Effectiveness", 1f);
UpgradeValues.Add("PowerEfficiency", 1f);
PowerReceiver.RequiredInputChanged += PowerReceiver_RequiredInputChanged;
OnUpgradeValuesChanged += UpdateDetailedInfo;
UpdateDetailedInfo();
}
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
{
base.Init(builder, cubeGrid);
this.NeedsUpdate = MyEntityUpdateEnum.EACH_100TH_FRAME;
m_emissivitySet = false;
AddDebugRenderComponent(new Components.MyDebugRenderComponentDrawConveyorSegment(m_segment));
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
MyDebug.AssertDebug(BlockDefinition.Id.TypeId == typeof(MyObjectBuilder_Reactor));
m_reactorDefinition = BlockDefinition as MyReactorDefinition;
MyDebug.AssertDebug(m_reactorDefinition != null);
CurrentPowerOutput = 0;
m_inventory = new MyInventory(m_reactorDefinition.InventoryMaxVolume, m_reactorDefinition.InventorySize, MyInventoryFlags.CanReceive, this);
var obGenerator = (MyObjectBuilder_Reactor)objectBuilder;
m_inventory.Init(obGenerator.Inventory);
m_inventory.ContentsChanged += inventory_ContentsChanged;
m_inventory.Constraint = m_reactorDefinition.InventoryConstraint;
RefreshRemainingCapacity();
UpdateText();
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME;
//if (MyFakes.SHOW_DAMAGE_EFFECTS && IsWorking)
// NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME;
m_baseIdleSound = BlockDefinition.PrimarySound;
m_useConveyorSystem = obGenerator.UseConveyorSystem;
if (IsWorking)
OnStartWorking();
}
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
{
var rotorOb = builder as MyObjectBuilder_MotorRotor;
base.Init(builder, cubeGrid);
LoadDummies();
}
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
{
base.Init(builder, cubeGrid);
var ob = builder as MyObjectBuilder_PistonTop;
m_pistonBlockId = ob.PistonBlockId;
NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
}
public static object CreateCubeBlock(MyObjectBuilder_CubeBlock builder)
{
var obj = m_objectFactory.CreateInstance(builder.TypeId);
MyEntity entity = obj as MyEntity;
var scriptManager = Sandbox.Game.World.MyScriptManager.Static;
if (entity != null && scriptManager != null && scriptManager.EntityScripts.ContainsKey(builder.TypeId))
entity.GameLogic = (Sandbox.Common.Components.MyGameLogicComponent)Activator.CreateInstance(scriptManager.EntityScripts[builder.TypeId]);
return obj;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
var ob = (MyObjectBuilder_FunctionalBlock)objectBuilder;
m_enabled = ob.Enabled;
IsWorkingChanged += CubeBlock_IsWorkingChanged;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
var ob = objectBuilder as MyObjectBuilder_CompoundCubeBlock;
if (ob.Blocks != null)
{
if (ob.BlockIds != null)
{
Debug.Assert(ob.Blocks.Length == ob.BlockIds.Length);
for (int i = 0; i < ob.Blocks.Length; ++i)
{
ushort id = ob.BlockIds[i];
if (m_blocks.ContainsKey(id))
{
Debug.Fail("Block with the same id found");
continue;
}
var blockBuilder = ob.Blocks[i];
object objectBlock = MyCubeBlockFactory.CreateCubeBlock(blockBuilder);
MySlimBlock cubeBlock = objectBlock as MySlimBlock;
if (cubeBlock == null)
cubeBlock = new MySlimBlock();
cubeBlock.Init(blockBuilder, cubeGrid, objectBlock as MyCubeBlock);
cubeBlock.FatBlock.Hierarchy.Parent = Hierarchy;
m_blocks.Add(id, cubeBlock);
}
RefreshNextId();
}
else
{
for (int i = 0; i < ob.Blocks.Length; ++i)
{
var blockBuilder = ob.Blocks[i];
object objectBlock = MyCubeBlockFactory.CreateCubeBlock(blockBuilder);
MySlimBlock cubeBlock = objectBlock as MySlimBlock;
if (cubeBlock == null)
cubeBlock = new MySlimBlock();
cubeBlock.Init(blockBuilder, cubeGrid, objectBlock as MyCubeBlock);
cubeBlock.FatBlock.Hierarchy.Parent = Hierarchy;
ushort id = CreateId(cubeBlock);
m_blocks.Add(id, cubeBlock);
}
}
}
RefreshTemplates();
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
if (CubeGrid.GridSizeEnum == MyCubeSize.Large)
{
IDLE_SOUND.Init("ToolLrgGrindIdle");
METAL_SOUND.Init("ToolLrgGrindMetal");
}
m_rotationSpeed = 0.0f;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
SyncFlag = true;
base.Init(objectBuilder, cubeGrid);
m_missingComponents = new Dictionary<string, int>();
var builder = (MyObjectBuilder_ShipWelder)objectBuilder;
m_helpOthers = builder.HelpOthers;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
MyObjectBuilder_UserControllableGun builder = (objectBuilder as MyObjectBuilder_UserControllableGun);
this.m_isShooting = builder.IsLargeTurret ? builder.IsShootingFromTerminal : builder.IsShooting;
if (m_isShooting)
{
NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME;
}
SyncObject = new MySyncUserControllableGun(this);
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
var ob = (MyObjectBuilder_FunctionalBlock)objectBuilder;
m_enabled = ob.Enabled;
IsWorkingChanged += CubeBlock_IsWorkingChanged;
m_baseIdleSound = BlockDefinition.PrimarySound;
m_actionSound = BlockDefinition.ActionSound;
}
public static object CreateCubeBlock(MyObjectBuilder_CubeBlock builder)
{
var obj = m_objectFactory.CreateInstance(builder.TypeId);
var entity = obj as MyEntity; // Some are SlimBlocks
if (entity != null)
{
MyEntityFactory.AddScriptGameLogic(entity, builder.TypeId, builder.SubtypeName);
MyEntities.RaiseEntityCreated(entity);
}
return obj;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
var builder = objectBuilder as MyObjectBuilder_ConveyorTurretBase;
var builder2 = objectBuilder as MyObjectBuilder_TurretBase; // Compatibility
Debug.Assert(builder != null || builder2 != null, "Turret builder was incorrect!");
if (builder != null)
m_useConveyorSystem = builder.UseConveyorSystem;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
// User settings:
m_randomStandbyChangeConst_ms = MyUtils.GetRandomInt(3500, 4500);
if (m_gunBase.HasAmmoMagazines)
m_shootingCueEnum = m_gunBase.ShootSound;
m_rotatingCueEnum.Init("WepTurretInteriorRotate");
Render.NeedsDraw = true;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
//var boxshape = new HkBoxShape((LocalAABB.Max - LocalAABB.Min) / 2);
//var boxshape = new HkBoxShape(new Vector3(0.43f, MyDefinitionManager.Static.GetCubeSize(MyCubeSize.Large) / 2.0f, 0.43f));
//Physics = new MyPhysicsBody(this, RigidBodyFlag.RBF_DISABLE_COLLISION_RESPONSE);
//Physics.CreateFromCollisionObject((HkShape)boxshape, Vector3.Zero, WorldMatrix);
//Physics.Enabled = true;
//boxshape.Base.RemoveReference();
AddDebugRenderComponent(new MyDebugRenderComponentLadder(this));
}
public bool Contains(IMySlimBlock block)
{
if (block.CubeGrid == null)
return false;
// FatBlock is null for non functional blocks such as armor
if (block.FatBlock != null)
return Contains(block.FatBlock);
// since some blocks aren't an entity we have to deal with them otherwise
// we'll create an grid that acts as substitute for the block to get an entity that has a collision
// TODO find a better suited way to get the boundings of an armor block
var worldPosition = block.CubeGrid.GetPosition() + block.Position;
// creating grid
var gridBuilder = new MyObjectBuilder_CubeGrid()
{
PersistentFlags = MyPersistentEntityFlags2.None,
PositionAndOrientation = new MyPositionAndOrientation(worldPosition, Vector3.Forward, Vector3.Up),
DisplayName = "substitute",
GridSizeEnum = block.CubeGrid.GridSizeEnum
};
// creating cube block
MyObjectBuilder_CubeBlock cube = new MyObjectBuilder_CubeBlock();
cube.Min = block.Position;
cube.SubtypeName = block.CubeGrid.GridSizeEnum == MyCubeSize.Large ? "LargeBlockArmorBlock" : "SmallBlockArmorBlock";
cube.BuildPercent = 0;
gridBuilder.CubeBlocks.Add(cube);
// add grid
MyAPIGateway.Entities.RemapObjectBuilder(gridBuilder);
var entity = MyAPIGateway.Entities.CreateFromObjectBuilder(gridBuilder);
var grid = entity as IMyCubeGrid;
var blocks = new List<IMySlimBlock>();
// get blocks
grid.GetBlocks(blocks, b => b != null);
if (blocks.Count > 0)
{
// found block
var cubeBlock = blocks[0].FatBlock;
bool isInside = Contains(cubeBlock);
grid.Close();
return isInside;
}
return false;
}
public override void Init(Sandbox.Common.ObjectBuilders.MyObjectBuilder_CubeBlock objectBuilder, Sandbox.Game.Entities.MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
m_solarPanelDefinition = BlockDefinition as MySolarPanelDefinition;
IsWorkingChanged += OnIsWorkingChanged;
NeedsUpdate = MyEntityUpdateEnum.EACH_100TH_FRAME;
GameLogic = new MySolarGameLogicComponent();
m_solarComponent = GameLogic as MySolarGameLogicComponent;
m_solarComponent.Initialize(m_solarPanelDefinition.PanelOrientation, m_solarPanelDefinition.IsTwoSided, m_solarPanelDefinition.PanelOffset, this);
AddDebugRenderComponent(new Components.MyDebugRenderComponentSolarPanel(this));
}
// This function does some modifications to the cube block's object builder before it's built, usually integrity changes, etc...
public virtual void BeforeCreateBlock(MyCubeBlockDefinition definition, MyEntity builder, MyObjectBuilder_CubeBlock ob)
{
if (definition.EntityComponents == null) return;
if (ob.ComponentContainer == null)
{
ob.ComponentContainer = new MyObjectBuilder_ComponentContainer();
}
foreach (var componentOb in definition.EntityComponents)
{
var data = new MyObjectBuilder_ComponentContainer.ComponentData();
data.TypeId = componentOb.Key.ToString();
data.Component = componentOb.Value;
ob.ComponentContainer.Components.Add(data);
}
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
if (!MyFakes.ENABLE_GATLING_TURRETS)
return;
if (MyFakes.OCTOBER_RELEASE_DISABLE_WEAPONS_AND_TOOLS)
return;
// User settings:
m_randomStandbyChangeConst_ms = MyUtils.GetRandomInt(3500,4500);
if (m_gunBase.HasAmmoMagazines)
m_shootingCueEnum = m_gunBase.ShootSound;
m_rotatingCueEnum.Init("WepTurretGatlingRotate");
Render.NeedsDraw = true;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
SyncObject = new MySyncBatteryBlock(this);
MyDebug.AssertDebug(BlockDefinition.Id.TypeId == typeof(MyObjectBuilder_BatteryBlock));
m_batteryBlockDefinition = BlockDefinition as MyBatteryBlockDefinition;
MyDebug.AssertDebug(m_batteryBlockDefinition != null);
var sourceDataList = new List<MyResourceSourceInfo>
{
new MyResourceSourceInfo { ResourceTypeId = MyResourceDistributorComponent.ElectricityId, DefinedOutput = m_batteryBlockDefinition.MaxPowerOutput, ProductionToCapacityMultiplier = 60*60}
};
SourceComp.Init(m_batteryBlockDefinition.ResourceSourceGroup, sourceDataList);
SourceComp.HasCapacityRemainingChanged += (id, source) => UpdateIsWorking();
MaxStoredPower = m_batteryBlockDefinition.MaxStoredPower;
ResourceSink.Init(
m_batteryBlockDefinition.ResourceSinkGroup,
m_batteryBlockDefinition.RequiredPowerInput,
() => (Enabled && IsFunctional && !SourceComp.ProductionEnabled && !m_isFull) ? ResourceSink.MaxRequiredInput : 0.0f);
ResourceSink.Update();
var obGenerator = (MyObjectBuilder_BatteryBlock)objectBuilder;
CurrentStoredPower = obGenerator.CurrentStoredPower;
SourceComp.SetProductionEnabledByType(MyResourceDistributorComponent.ElectricityId, obGenerator.ProducerEnabled);
SemiautoEnabled = obGenerator.SemiautoEnabled;
UpdateMaxOutputAndEmissivity();
UpdateText();
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
this.IsWorkingChanged += MyBatteryBlock_IsWorkingChanged;
NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME;
if (IsWorking)
OnStartWorking();
}
public CubeBlockEntity(CubeGridEntity parent, MyObjectBuilder_CubeBlock definition, Object backingObject)
: base(definition, backingObject)
{
m_parent = parent;
//Only enable events for non-structural blocks, for now
if (definition.EntityId != 0)
{
EntityEventManager.EntityEvent newEvent = new EntityEventManager.EntityEvent();
newEvent.type = EntityEventManager.EntityEventType.OnCubeBlockCreated;
newEvent.timestamp = DateTime.Now;
newEvent.entity = this;
if (m_parent.IsLoading)
newEvent.priority = 10;
else
newEvent.priority = 1;
EntityEventManager.Instance.AddEvent(newEvent);
}
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
IsWorkingChanged += OnIsWorkingChanged;
NeedsUpdate = MyEntityUpdateEnum.EACH_100TH_FRAME;
InitializeConveyorEndpoint();
SourceComp.Init(
BlockDefinition.ResourceSourceGroup,
new MyResourceSourceInfo
{
ResourceTypeId = BlockDefinition.ProducedGas,
DefinedOutput = BlockDefinition.MaxGasOutput,
ProductionToCapacityMultiplier = 1,
IsInfiniteCapacity = true,
});
ResourceSink.Init(
BlockDefinition.ResourceSinkGroup,
new MyResourceSinkInfo
{
ResourceTypeId = MyResourceDistributorComponent.ElectricityId,
MaxRequiredInput = BlockDefinition.OperationalPowerConsumption,
RequiredInputFunc = ComputeRequiredPower,
});
ResourceSink.IsPoweredChanged += PowerReceiver_IsPoweredChanged;
ResourceSink.Update();
GameLogic = new MySolarGameLogicComponent();
SolarComponent = GameLogic as MySolarGameLogicComponent;
SolarComponent.Initialize(BlockDefinition.PanelOrientation, BlockDefinition.IsTwoSided, BlockDefinition.PanelOffset, this);
AddDebugRenderComponent(new MyDebugRenderComponentSolarPanel(this));
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_OnIsFunctionalChanged;
UpdateVisual();
UpdateDisplay();
}
public static MyObjectBuilder_CubeBlock Upgrade(MyObjectBuilder_CubeBlock cubeBlock, MyObjectBuilderType newType, string newSubType)
{
var upgraded = MyObjectBuilderSerializer.CreateNewObject(newType, newSubType) as MyObjectBuilder_CubeBlock;
if (upgraded == null)
{
Debug.Fail("Cannot upgrade cube block, upgraded block is not derived from " + typeof(MyObjectBuilder_CubeBlock).Name);
return null;
}
upgraded.EntityId = cubeBlock.EntityId;
upgraded.Min = cubeBlock.Min;
upgraded.m_orientation = cubeBlock.m_orientation;
upgraded.IntegrityPercent = cubeBlock.IntegrityPercent;
upgraded.BuildPercent = cubeBlock.BuildPercent;
upgraded.BlockOrientation = cubeBlock.BlockOrientation;
upgraded.ConstructionInventory = cubeBlock.ConstructionInventory;
upgraded.ColorMaskHSV = cubeBlock.ColorMaskHSV;
return upgraded;
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
SolarPanelDefinition = BlockDefinition as MySolarPanelDefinition;
IsWorkingChanged += OnIsWorkingChanged;
NeedsUpdate = MyEntityUpdateEnum.EACH_100TH_FRAME;
var sourceDataList = new List<MyResourceSourceInfo>
{
new MyResourceSourceInfo {ResourceTypeId = MyResourceDistributorComponent.ElectricityId, DefinedOutput = SolarPanelDefinition.MaxPowerOutput, IsInfiniteCapacity = true, ProductionToCapacityMultiplier = 60*60}
};
SourceComp.Init(SolarPanelDefinition.ResourceSourceGroup, sourceDataList);
GameLogic = new MySolarGameLogicComponent();
SolarComponent = GameLogic as MySolarGameLogicComponent;
SolarComponent.Initialize(SolarPanelDefinition.PanelOrientation, SolarPanelDefinition.IsTwoSided, SolarPanelDefinition.PanelOffset, this);
AddDebugRenderComponent(new Components.MyDebugRenderComponentSolarPanel(this));
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
base.Init(objectBuilder, cubeGrid);
//Matrix barrelMatrix = MyMath.NormalizeMatrix(ModelLod0.Dummies["axis"].Matrix);
Matrix barrelMatrix = Matrix.Identity;
// User settings:
m_randomStandbyChangeConst_ms = 4000;
m_rotationSpeed = MathHelper.Pi / 2000.0f;
m_elevationSpeed = MathHelper.Pi / 2000.0f;
if (BlockDefinition != null)
{
m_rotationSpeed = BlockDefinition.RotationSpeed;
m_elevationSpeed = BlockDefinition.ElevationSpeed;
}
if (m_gunBase.HasAmmoMagazines)
m_shootingCueEnum = m_gunBase.ShootSound;
m_rotatingCueEnum.Init("WepTurretGatlingRotate");
}