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 override void UpdateOnceBeforeFrame()
{
if (firstrun)
{
var info = new List <MyUpgradeModuleInfo>();
hyperDriveBlock.GetUpgradeList(out info);
Maxhyper = info.FirstOrDefault(x => x.UpgradeType == "WarpFactor").Modifier;
ResourceSink.SetMaxRequiredInputByType(_electricity, HyperFunctions.MinimumPowertoActivate());
ResourceSink.SetRequiredInputByType(_electricity, HyperFunctions.PowerConsumption());
ResourceSink.SetRequiredInputFuncByType(_electricity, HyperFunctions.PowerConsumption);
ResourceSink.Update();
hyperDriveBlock.AppendingCustomInfo += HyperFunctions.hyperDriveBlock_AppendingCustomInfo;
Maxhyper = Maxhyper * 100f;
emitter = new Sandbox.Game.Entities.MyEntity3DSoundEmitter(hyperDriveBlock as MyEntity);
MyEntity3DSoundEmitter.PreloadSound(pair);
HyperFunctions.CreatehyperUI();
firstrun = false;
White = Color.White;
MyVisualScriptLogicProvider.ScreenColorFadingSetColor(White);
}
}
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);
}
static public void Init()
{
//var info = new List<MyJumpDriveInfo>();
//hyperDriveBlock.GetUpgradeList(out info);
//Maxhyper = info.FirstOrDefault(x => x.UpgradeType == "WarpFactor").Modifier;
ResourceSink.SetMaxRequiredInputByType(_electricity, MinimumPowertoActivate());
ResourceSink.SetRequiredInputByType(_electricity, PowerConsumption());
ResourceSink.SetRequiredInputFuncByType(_electricity, PowerConsumption);
ResourceSink.Update();
HyperDriveLogic.hyperDriveBlock.AppendingCustomInfo += hyperDriveBlock_AppendingCustomInfo;
HyperDriveLogic.Maxhyper = HyperDriveLogic.Maxhyper * 100f;
emitter = new Sandbox.Game.Entities.MyEntity3DSoundEmitter(HyperDriveLogic.hyperDriveBlock as MyEntity);
MyEntity3DSoundEmitter.PreloadSound(pair);
UIGen.CreatehyperUI();
//HyperFunctions.HideVanillaActions();
HyperDriveLogic.firstrun = false;
White = Color.White;
MyVisualScriptLogicProvider.ScreenColorFadingSetColor(White);
}
void InitResourceSink()
{
_sink.SetMaxRequiredInputByType(Electricity, _power);
_sink.SetRequiredInputFuncByType(Electricity, PowerConsumptionFunc);
_sink.SetRequiredInputByType(Electricity, PowerConsumptionFunc());
_sink.Update();
}
public void InitResourceSink()
{
try
{
MyRadarPowerSink.SetMaxRequiredInputByType(Electricity, 100);
MyRadarPowerSink.SetRequiredInputFuncByType(Electricity, PowerConsumptionFunc);
MyRadarPowerSink.SetRequiredInputByType(Electricity, PowerConsumptionFunc());
MyRadarPowerSink.Update();
}
catch (Exception Scrap)
{
RadarCore.LogError(RadarBlock.CustomName, Scrap);
}
}
void SetPowerSink()
{
sink = Entity.Components.Get <MyResourceSinkComponent>();
sink.SetRequiredInputFuncByType(resourceId, () => GetPowerInput());
MyResourceSinkInfo resourceInfo = new MyResourceSinkInfo()
{
ResourceTypeId = resourceId,
MaxRequiredInput = turret == null ? _idlePowerDrawBase : _idlePowerDrawMax,
RequiredInputFunc = () => GetPowerInput()
};
sink.RemoveType(ref resourceInfo.ResourceTypeId);
sink.Init(MyStringHash.GetOrCompute("Defense"), resourceInfo); //sink.Init(MyStringHash.GetOrCompute("Defense"), turret == null ? _idlePowerDrawBase : _idlePowerDrawMax, () => GetPowerInput());
sink.AddType(ref resourceInfo);
}
// Context: All
public override void UpdateOnceBeforeFrame()
{
if (me.CubeGrid?.Physics == null)
{
return;
}
_state = new SyncableProjectorState(me, ProjectorState.Idle, 0);
if (Constants.IsServer)
{
LoadStorage();
_settings.OnValueReceived += SaveStorage;
BuildState = ProjectorState.Idle;
me.IsWorkingChanged += Me_IsWorkingChanged;
}
else
{
_settings = new SyncableProjectorSettings(me, 0, true);
_state.RequestFromServer();
_settings.RequestFromServer();
_state.OnValueReceived += ReceivedNewState;
}
MyProjectorDefinition def = (MyProjectorDefinition)MyDefinitionManager.Static.GetCubeBlockDefinition(me.BlockDefinition);
minPower = def.RequiredPowerInput;
sink = me.Components.Get <MyResourceSinkComponent>();
MyDefinitionId powerDef = MyResourceDistributorComponent.ElectricityId;
sink.SetRequiredInputFuncByType(powerDef, GetCurrentPower);
sink.Update();
_settings.OnValueReceived += RefreshUI;
me.AppendingCustomInfo += CustomInfo;
me.RefreshCustomInfo();
Settings.MapSettings config = IPSession.Instance.MapSettings;
config.OnSubgridsChanged += ClearCachedComps;
config.OnComponentCostModifierChanged += ClearCachedComps;
config.OnExtraComponentChanged += ClearCachedComps;
config.OnExtraCompCostChanged += ClearCachedComps;
ProjectorControls.Create();
}
public override void UpdateOnceBeforeFrame()
{
try
{
_sink = _sink ?? Entity.Components.Get <MyResourceSinkComponent>();
if (_sink != null)
{
_sink.SetRequiredInputFuncByType(MyResourceDistributorComponent.ElectricityId, CalculateRequiredPowerInput);
_sink.Update();
}
}
catch (Exception e)
{
MyAPIGateway.Utilities.ShowNotification("[ Error in " + GetType().FullName + ": " + e.Message + " ]", 10000, MyFontEnum.Red);
MyLog.Default.WriteLine(e);
}
}
// init power usage
void InitPowerComp()
{
Entity.Components.TryGet <MyResourceSinkComponent>(out sinkComp);
if (sinkComp == null)
{
// MyLog.Default.WriteLine("set up new power sink");
sinkComp = new MyResourceSinkComponent();
sinkComp.Init(
MyStringHash.GetOrCompute("Thrust"),
MAX_POWER_USAGE_MW,
GetCurrentPowerDraw
);
Entity.Components.Add(sinkComp);
}
else
{
// MyLog.Default.WriteLine("reuse existing power sink");
sinkComp.SetRequiredInputFuncByType(MyResourceDistributorComponent.ElectricityId, GetCurrentPowerDraw);
}
(Entity as IMyTerminalBlock).AppendingCustomInfo += EngineCustomInfo;
}
// Context: All
public override void UpdateOnceBeforeFrame()
{
if (me.CubeGrid?.Physics == null)
{
return;
}
_state = new SyncableProjectorState(me, State.Idle, 0);
if (Constants.IsServer)
{
LoadStorage();
_settings.OnValueReceived += SaveStorage;
BuildState = State.Idle;
me.IsWorkingChanged += Me_IsWorkingChanged;
}
else
{
_settings = new SyncableProjectorSettings(me, 0, true);
_state.RequestFromServer();
_settings.RequestFromServer();
_state.OnValueReceived += ReceivedNewState;
}
MyProjectorDefinition def = (MyProjectorDefinition)MyDefinitionManager.Static.GetCubeBlockDefinition(me.BlockDefinition);
minPower = def.RequiredPowerInput;
sink = me.Components.Get <MyResourceSinkComponent>();
MyDefinitionId powerDef = MyResourceDistributorComponent.ElectricityId;
sink.SetRequiredInputFuncByType(powerDef, GetCurrentPower);
sink.Update();
_settings.OnValueReceived += RefreshUI;
me.AppendingCustomInfo += CustomInfo;
me.RefreshCustomInfo();
Settings.MapSettings config = IPSession.Instance.MapSettings;
config.OnSubgridsChanged += ClearCachedComps;
config.OnComponentCostModifierChanged += ClearCachedComps;
config.OnExtraComponentChanged += ClearCachedComps;
config.OnExtraCompCostChanged += ClearCachedComps;
if (!controls)
{
// Terminal controls
IMyTerminalControlSeparator sep = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlSeparator, IMyProjector>("BuildGridSep");
sep.Enabled = IsValid;
sep.Visible = IsValid;
MyAPIGateway.TerminalControls.AddControl <IMyProjector>(sep);
IMyTerminalControlButton btnBuild = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlButton, IMyProjector>("BuildGrid");
btnBuild.Enabled = IsWorking;
btnBuild.Visible = IsValid;
btnBuild.SupportsMultipleBlocks = true;
btnBuild.Title = MyStringId.GetOrCompute("Build Grid");
btnBuild.Action = BuildClient;
btnBuild.Tooltip = MyStringId.GetOrCompute("Builds the projection instantly.\nThere will be a cooldown after building.");
MyAPIGateway.TerminalControls.AddControl <IMyProjector>(btnBuild);
IMyTerminalControlButton btnCancel = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlButton, IMyProjector>("CancelBuildGrid");
btnCancel.Enabled = IsWorking;
btnCancel.Visible = IsValid;
btnCancel.SupportsMultipleBlocks = true;
btnCancel.Title = MyStringId.GetOrCompute("Cancel");
btnCancel.Action = CancelClient;
btnCancel.Tooltip = MyStringId.GetOrCompute("Cancels the build process.");
MyAPIGateway.TerminalControls.AddControl <IMyProjector>(btnCancel);
IMyTerminalControlCheckbox chkShift = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlCheckbox, IMyProjector>("MoveProjectionArea");
chkShift.Enabled = IsWorking;
chkShift.Visible = IsValid;
chkShift.SupportsMultipleBlocks = true;
chkShift.Title = MyStringId.GetOrCompute("Loose Projection Area");
chkShift.OnText = MyStringId.GetOrCompute("On");
chkShift.OffText = MyStringId.GetOrCompute("Off");
chkShift.Tooltip = MyStringId.GetOrCompute("Allow the projection to spawn in a different area if the original area is occupied.");
chkShift.Setter = SetLooseArea;
chkShift.Getter = GetLooseArea;
MyAPIGateway.TerminalControls.AddControl <IMyProjector>(chkShift);
IMyTerminalControlSlider sliderSpeed = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlSlider, IMyProjector>("BuildSpeed");
sliderSpeed.Enabled = IsWorking;
sliderSpeed.Visible = IsValid;
sliderSpeed.SupportsMultipleBlocks = true;
sliderSpeed.Title = MyStringId.GetOrCompute("Speed");
sliderSpeed.Tooltip = MyStringId.GetOrCompute("Increasing the speed will use more energy.");
sliderSpeed.SetLogLimits(Constants.minSpeed, Constants.maxSpeed);
sliderSpeed.Writer = GetSpeedText;
sliderSpeed.Getter = GetSpeed;
sliderSpeed.Setter = SetSpeed;
MyAPIGateway.TerminalControls.AddControl <IMyProjector>(sliderSpeed);
IMyTerminalControlTextbox txtTimeout = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlTextbox, IMyProjector>("GridTimer");
txtTimeout.Enabled = (b) => false;
txtTimeout.Visible = IsValid;
txtTimeout.Getter = GetTimer;
txtTimeout.Setter = (b, s) => { };
txtTimeout.SupportsMultipleBlocks = false;
txtTimeout.Title = MyStringId.GetOrCompute("Build Timer");
txtTimeout.Tooltip = MyStringId.GetOrCompute("The amount of time you must wait after building a grid to be able to build another.");
MyAPIGateway.TerminalControls.AddControl <IMyProjector>(txtTimeout);
// Terminal actions
// Button panels are special and trigger on the server instead of the client, making everything more complicated.
IMyTerminalAction aCancel = MyAPIGateway.TerminalControls.CreateAction <IMyProjector>("CancelBuildAction");
aCancel.Enabled = IsValid;
aCancel.Action = CancelClient; // For all except button panels
aCancel.ValidForGroups = true;
aCancel.Name = new StringBuilder("Cancel Spawn Grid");
aCancel.Writer = (b, s) => s.Append("Cancel");
aCancel.InvalidToolbarTypes = new[] { MyToolbarType.ButtonPanel }.ToList();
MyAPIGateway.TerminalControls.AddAction <IMyProjector>(aCancel);
IMyTerminalAction aCancel2 = MyAPIGateway.TerminalControls.CreateAction <IMyProjector>("CancelBuildGrid");
aCancel2.Enabled = IsValid;
aCancel2.Action = CancelClientUnsafe; // For only button panels
aCancel2.ValidForGroups = true;
aCancel2.Name = new StringBuilder("Cancel Spawn Grid");
aCancel2.Writer = (b, s) => s.Append("Cancel");
aCancel2.InvalidToolbarTypes = new List <MyToolbarType> {
MyToolbarType.BuildCockpit, MyToolbarType.Character, MyToolbarType.LargeCockpit,
MyToolbarType.None, MyToolbarType.Seat, MyToolbarType.Ship, MyToolbarType.SmallCockpit, MyToolbarType.Spectator
};
MyAPIGateway.TerminalControls.AddAction <IMyProjector>(aCancel2);
IMyTerminalAction aBuild = MyAPIGateway.TerminalControls.CreateAction <IMyProjector>("BuildGridAction");
aBuild.Enabled = IsValid;
aBuild.Action = BuildClient; // For all except button panels
aBuild.ValidForGroups = true;
aBuild.Name = new StringBuilder("Spawn Grid");
aBuild.Writer = (b, s) => s.Append("Spawn");
aBuild.InvalidToolbarTypes = new [] { MyToolbarType.ButtonPanel }.ToList();
MyAPIGateway.TerminalControls.AddAction <IMyProjector>(aBuild);
IMyTerminalAction aBuild2 = MyAPIGateway.TerminalControls.CreateAction <IMyProjector>("BuildGrid");
aBuild2.Enabled = IsValid;
aBuild2.Action = BuildClientUnsafe; // For only button panels
aBuild2.ValidForGroups = true;
aBuild2.Name = new StringBuilder("Spawn Grid");
aBuild2.Writer = (b, s) => s.Append("Spawn");
aBuild2.InvalidToolbarTypes = new List <MyToolbarType> {
MyToolbarType.BuildCockpit, MyToolbarType.Character, MyToolbarType.LargeCockpit,
MyToolbarType.None, MyToolbarType.Seat, MyToolbarType.Ship, MyToolbarType.SmallCockpit, MyToolbarType.Spectator
};
MyAPIGateway.TerminalControls.AddAction <IMyProjector>(aBuild2);
IMyTerminalControlListbox itemList = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlListbox, IMyProjector>("ComponentList");
itemList.Enabled = IsWorking;
itemList.Visible = IsValid;
itemList.ListContent = GetItemList;
itemList.Multiselect = false;
itemList.SupportsMultipleBlocks = false;
itemList.Title = MyStringId.GetOrCompute("Components");
itemList.VisibleRowsCount = 10;
itemList.ItemSelected = (b, l) => { };
MyAPIGateway.TerminalControls.AddControl <IMyProjector>(itemList);
// Programmable Block stuff
IMyTerminalControlProperty <Dictionary <MyItemType, int> > itemListProp
= MyAPIGateway.TerminalControls.CreateProperty <Dictionary <MyItemType, int>, IMyProjector>("RequiredComponents");
itemListProp.Enabled = IsWorking;
itemListProp.Visible = IsValid;
itemListProp.SupportsMultipleBlocks = false;
itemListProp.Setter = (b, l) => { };
itemListProp.Getter = GetItemListPB;
MyAPIGateway.TerminalControls.AddControl <IMyProjector>(itemListProp);
IMyTerminalControlProperty <int> gridTimeoutProp
= MyAPIGateway.TerminalControls.CreateProperty <int, IMyProjector>("GridTimerProjection");
gridTimeoutProp.Enabled = IsWorking;
gridTimeoutProp.Visible = IsValid;
gridTimeoutProp.SupportsMultipleBlocks = false;
gridTimeoutProp.Setter = (b, l) => { };
gridTimeoutProp.Getter = GetMaxTimerPB;
MyAPIGateway.TerminalControls.AddControl <IMyProjector>(gridTimeoutProp);
IMyTerminalControlProperty <int> gridTimeoutActive
= MyAPIGateway.TerminalControls.CreateProperty <int, IMyProjector>("GridTimerCurrent");
gridTimeoutActive.Enabled = IsWorking;
gridTimeoutActive.Visible = IsValid;
gridTimeoutActive.SupportsMultipleBlocks = false;
gridTimeoutActive.Setter = (b, l) => { };
gridTimeoutActive.Getter = GetCurrentTimerPB;
MyAPIGateway.TerminalControls.AddControl <IMyProjector>(gridTimeoutActive);
IMyTerminalControlProperty <int> buildState
= MyAPIGateway.TerminalControls.CreateProperty <int, IMyProjector>("BuildState");
buildState.Enabled = IsWorking;
buildState.Visible = IsValid;
buildState.SupportsMultipleBlocks = false;
buildState.Setter = (b, l) => { };
buildState.Getter = GetStatePB;
MyAPIGateway.TerminalControls.AddControl <IMyProjector>(gridTimeoutActive);
MyLog.Default.WriteLineAndConsole("Initialized Instant Projector.");
controls = true;
}
}