private void ShieldChangeState()
{
if (!WarmedUp && !DsState.State.Message)
{
if (Session.Enforced.Debug == 3)
{
Log.Line($"ChangeStateSupression: WarmedUp:{WarmedUp} - Message:{DsState.State.Message} - ShieldId [{Shield.EntityId}]");
}
return;
}
if (Session.Instance.MpActive)
{
if (Session.Enforced.Debug == 4)
{
Log.Line($"ServerUpdate: Broadcast:{DsState.State.Message} - Percent:{DsState.State.ShieldPercent} - HeatLvl:{DsState.State.Heat} - ShieldCharge:{DsState.State.Charge} - EmpProt:{DsState.State.EmpProtection} - ShieldId [{Shield.EntityId}]");
}
DsState.NetworkUpdate();
}
if (!_isDedicated && DsState.State.Message)
{
BroadcastMessage();
if (Session.Enforced.Debug == 3)
{
Log.Line("ShieldChangeState");
}
Shield.RefreshCustomInfo();
}
DsState.State.Message = false;
DsState.SaveState();
}
public override bool Stop()
{
if (State == DsState.Connected)
{
var items = new Queue <int>();
lock (_pluggedInDevices)
{
foreach (var serial in _pluggedInDevices)
{
items.Enqueue(serial - _busOffset);
}
}
while (items.Count > 0)
{
Unplug(items.Dequeue());
}
// send un-plug-all to clean the bus from devices stuck in error state
XOutputWrapper.Instance.UnPlugAll();
_busState = DsState.Reserved;
}
return(State == DsState.Reserved);
}
public override bool Stop()
{
if (!IsActive)
{
return(base.Stop());
}
_state = DsState.Reserved;
// disconnect all connected devices gracefully
foreach (var device in _connected.Values)
{
device.Disconnect();
device.Stop();
}
// notify tasks to stop work
_hciCancellationTokenSource.Cancel();
_l2CapCancellationTokenSource.Cancel();
// reset tokens
_hciCancellationTokenSource = new CancellationTokenSource();
_l2CapCancellationTokenSource = new CancellationTokenSource();
_connected.Clear();
return(base.Stop());
}
public override bool Close()
{
var closed = base.Close();
_state = DsState.Disconnected;
return(closed);
}
public override bool Start()
{
if (State == DsState.Reserved)
{
_busState = DsState.Connected;
}
return(State == DsState.Connected);
}
public override bool Open(int instance = 0)
{
if (base.Open(instance))
{
_state = DsState.Reserved;
}
return(State == DsState.Reserved);
}
public override bool Open(string devicePath)
{
if (base.Open(devicePath))
{
_state = DsState.Reserved;
}
return(State == DsState.Reserved);
}
public override Boolean Start()
{
if (State == DsState.Reserved)
{
m_State = DsState.Connected;
}
return(State == DsState.Connected);
}
public ScpHidReport(DsConnection connectionType, PhysicalAddress padMacAddress, DsModel model, DsPadId padId, DsState padState, HidReport.Core.HidReport hidReport)
{
ConnectionType = connectionType;
_padMacAddress = padMacAddress.GetAddressBytes();
Model = model;
PadId = padId;
PadState = padState;
_hidReport = hidReport;
}
private void StorageSetup()
{
try
{
var isServer = MyAPIGateway.Multiplayer.IsServer;
if (DsSet == null)
{
DsSet = new ControllerSettings(Shield);
}
if (DsState == null)
{
DsState = new ControllerState(Shield);
}
if (Shield.Storage == null)
{
DsState.StorageInit();
}
if (!isServer)
{
var enforcement = Enforcements.LoadEnforcement(Shield);
if (enforcement != null)
{
Session.Enforced = enforcement;
}
}
DsSet.LoadSettings();
if (!DsState.LoadState() && !isServer)
{
_clientNotReady = true;
}
UpdateSettings(DsSet.Settings);
if (isServer)
{
if (DsSet.Settings.Fit > 22)
{
DsSet.Settings.Fit = 22;
}
DsState.State.Overload = false;
DsState.State.NoPower = false;
DsState.State.Remodulate = false;
if (DsState.State.Suspended)
{
DsState.State.Suspended = false;
DsState.State.Online = false;
}
DsState.State.Sleeping = false;
DsState.State.Waking = false;
DsState.State.FieldBlocked = false;
DsState.State.GridHalfExtents = Vector3D.Zero;
DsState.State.Heat = 0;
}
}
catch (Exception ex) { Log.Line($"Exception in StorageSetup: {ex}"); }
}
internal DsDetail(DsPadId padId, DsState state, DsModel model, byte[] mac, DsConnection mode, DsBattery level)
{
Pad = padId;
State = state;
Model = model;
Mode = mode;
Charge = level;
Buffer.BlockCopy(mac, 0, _localMac, 0, _localMac.Length);
}
internal DsDetail(DsPadId PadId, DsState State, DsModel Model, byte[] Mac, DsConnection Mode, DsBattery Level)
{
Pad = PadId;
this.State = State;
this.Model = Model;
this.Mode = Mode;
Charge = Level;
Array.Copy(Mac, m_Local, m_Local.Length);
}
internal DsDetail(DsPadId PadId, DsState State, DsModel Model, byte[] Mac, DsConnection Mode, DsBattery Level)
{
Pad = PadId;
this.State = State;
this.Model = Model;
this.Mode = Mode;
Charge = Level;
Array.Copy(Mac, m_Local, m_Local.Length);
}
internal DsDetail(DsPadId padId, DsState state, DsModel model, byte[] mac, DsConnection mode, DsBattery level)
{
Pad = padId;
State = state;
Model = model;
Mode = mode;
Charge = level;
Buffer.BlockCopy(mac, 0, _localMac, 0, _localMac.Length);
}
internal DsDetail(DsPadId PadId, DsState State, DsModel Model, Byte[] Mac, DsConnection Mode, DsBattery Level)
{
m_Serial = PadId;
m_State = State;
m_Model = Model;
m_Mode = Mode;
m_Charge = Level;
Array.Copy(Mac, m_Local, m_Local.Length);
}
public override Boolean Stop()
{
if (IsActive)
{
m_Timer.Change(Timeout.Infinite, Timeout.Infinite);
m_State = DsState.Reserved;
Publish();
}
return(base.Stop());
}
public override bool IsSerialized()
{
if (MyAPIGateway.Multiplayer.IsServer)
{
if (Shield.Storage != null)
{
DsState.SaveState();
DsSet.SaveSettings();
}
}
return(false);
}
public override Boolean Stop()
{
if (IsActive)
{
tmUpdate.Enabled = false;
m_State = DsState.Reserved;
Publish();
}
return(base.Stop());
}
private bool PostInit()
{
try
{
if (_isServer && (ShieldComp.EmitterMode < 0 || (ShieldComp.EmitterMode == 0 && ShieldComp.StationEmitter == null) || ShieldComp.EmittersSuspended || !IsFunctional))
{
if (_tick600)
{
if (Session.Enforced.Debug == 3)
{
Log.Line($"PostInit: Server Not Ready - GridComp:{MyGrid.Components.Has<ShieldGridComponent>()} - InvalidMode:{ShieldComp.EmitterMode < 0} - Functional:{IsFunctional} - EmitterSus:{ShieldComp.EmittersSuspended} - StationEmitterNull:{ShieldComp.StationEmitter == null } - EmitterNull:{ShieldComp.StationEmitter?.Emitter == null} - ShieldId [{Shield.EntityId}]");
}
GridOwnsController();
Shield.RefreshCustomInfo();
}
return(false);
}
if (RequestEnforcement() || _clientNotReady || (!_isServer && (DsState.State.Mode < 0 || (DsState.State.Mode == 0 && ShieldComp.StationEmitter == null))))
{
return(false);
}
Session.Instance.CreateControllerElements(Shield);
SetShieldType(false);
if (!Session.Instance.DsAction)
{
Session.AppendConditionToAction <IMyUpgradeModule>((a) => Session.Instance.DsActions.Contains(a.Id), (a, b) => b.GameLogic.GetAs <DefenseShields>() != null && Session.Instance.DsActions.Contains(a.Id));
Session.Instance.DsAction = true;
}
if (!IsFunctional)
{
return(false);
}
if (_mpActive && _isServer)
{
DsState.NetworkUpdate();
}
_allInited = true;
if (Session.Enforced.Debug == 3)
{
Log.Line($"AllInited: ShieldId [{Shield.EntityId}]");
}
}
catch (Exception ex) { Log.Line($"Exception in Controller PostInit: {ex}"); }
return(true);
}
public override bool Close()
{
if (IsActive)
{
base.Close();
tmUpdate.Enabled = false;
m_State = DsState.Disconnected;
OnHidReportReceived();
}
return(!IsActive);
}
public override bool Start()
{
if (!IsActive)
{
return(State == DsState.Connected);
}
_state = DsState.Connected;
Task.Factory.StartNew(HicWorker, _hciCancellationTokenSource.Token);
Task.Factory.StartNew(L2CapWorker, _l2CapCancellationTokenSource.Token);
return(State == DsState.Connected);
}
public override Boolean Close()
{
if (IsActive)
{
base.Close();
m_Timer.Change(Timeout.Infinite, Timeout.Infinite);
m_State = DsState.Disconnected;
Publish();
}
return(!IsActive);
}
public override Boolean Close()
{
if (IsActive)
{
base.Close();
tmUpdate.Enabled = false;
m_State = DsState.Disconnected;
Publish();
}
return(!IsActive);
}
public virtual Boolean Close()
{
Stop();
if (m_State == DsState.Reserved)
{
m_State = DsState.Disconnected;
m_Packet = 0;
m_Publish = false;
Publish();
}
return(m_State == DsState.Disconnected);
}
public override bool Stop()
{
if (IsActive)
{
tmUpdate.Enabled = false;
m_State = DsState.Reserved;
_hidCancellationTokenSource.Cancel();
_hidCancellationTokenSource = new CancellationTokenSource();
OnHidReportReceived();
}
return(base.Stop());
}
public virtual bool Close()
{
Stop();
if (m_State == DsState.Reserved)
{
m_State = DsState.Disconnected;
m_Packet = 0;
m_Publish = false;
OnHidReportReceived();
}
return(m_State == DsState.Disconnected);
}
public virtual Boolean Stop()
{
if (m_State == DsState.Connected)
{
m_Timer.Change(Timeout.Infinite, Timeout.Infinite);
m_State = DsState.Reserved;
m_Packet = 0;
m_Publish = false;
Publish();
}
return(m_State == DsState.Reserved);
}
public virtual Boolean Stop()
{
if (m_State == DsState.Connected)
{
tmUpdate.Enabled = false;
m_State = DsState.Reserved;
m_Packet = 0;
m_Publish = false;
Publish();
}
return(m_State == DsState.Reserved);
}
public override bool Start()
{
if (!IsActive)
{
return(State == DsState.Connected);
}
Buffer.BlockCopy(m_Local, 0, InputReport.RawBytes, (int)DsOffset.Address, m_Local.Length);
InputReport.ConnectionType = Connection;
InputReport.Model = Model;
m_State = DsState.Connected;
PacketCounter = 0;
Task.Factory.StartNew(HidWorker, _hidCancellationTokenSource.Token);
tmUpdate.Enabled = true;
Rumble(0, 0);
Log.DebugFormat("-- Started Device Instance [{0}] Local [{1}] Remote [{2}]", m_Instance, Local, Remote);
// connection sound
if (GlobalConfiguration.Instance.IsUsbConnectSoundEnabled)
{
AudioPlayer.Instance.PlayCustomFile(GlobalConfiguration.Instance.UsbConnectSoundFile);
}
#region Request HID Report Descriptor
// try to retrieve HID Report Descriptor
var buffer = new byte[512];
var transfered = 0;
if (SendTransfer(UsbHidRequestType.GetDescriptor, UsbHidRequest.GetDescriptor,
ToValue(UsbHidClassDescriptorType.Report),
buffer, ref transfered) && transfered > 0)
{
Log.DebugFormat("-- HID Report Descriptor: {0}", buffer.ToHexString(transfered));
// store report descriptor
ReportDescriptor.Parse(buffer);
}
#endregion
return(State == DsState.Connected);
}
private void SaveAndSendAll()
{
_firstSync = true;
if (!_isServer)
{
return;
}
DsSet.SaveSettings();
DsSet.NetworkUpdate();
DsState.SaveState();
DsState.NetworkUpdate();
if (Session.Enforced.Debug >= 3)
{
Log.Line($"SaveAndSendAll: ShieldId [{Shield.EntityId}]");
}
}
public override bool Close()
{
if (base.Stop())
{
m_State = DsState.Reserved;
}
if (State != DsState.Reserved)
{
if (base.Close())
{
m_State = DsState.Disconnected;
}
}
return State == DsState.Disconnected;
}
public override Boolean Close()
{
if (base.Stop())
{
m_State = DsState.Reserved;
}
if (State != DsState.Reserved)
{
if (base.Close())
{
m_State = DsState.Disconnected;
}
}
return(State == DsState.Disconnected);
}
public override Boolean Open(String DevicePath)
{
if (State == DsState.Disconnected)
{
m_Path = DevicePath;
LogDebug(String.Format("-- Bus Open : Path {0}", m_Path));
if (GetDeviceHandle(m_Path))
{
m_IsActive = true;
m_State = DsState.Reserved;
}
}
return(State == DsState.Reserved);
}
public override bool Start()
{
if (!IsActive) return State == DsState.Connected;
Buffer.BlockCopy(m_Local, 0, InputReport.RawBytes, (int) DsOffset.Address, m_Local.Length);
InputReport.ConnectionType = Connection;
InputReport.Model = Model;
m_State = DsState.Connected;
PacketCounter = 0;
Task.Factory.StartNew(HidWorker, _hidCancellationTokenSource.Token);
tmUpdate.Enabled = true;
Rumble(0, 0);
Log.DebugFormat("-- Started Device Instance [{0}] Local [{1}] Remote [{2}]", m_Instance, Local, Remote);
// connection sound
if (GlobalConfiguration.Instance.IsUsbConnectSoundEnabled)
AudioPlayer.Instance.PlayCustomFile(GlobalConfiguration.Instance.UsbConnectSoundFile);
#region Request HID Report Descriptor
// try to retrieve HID Report Descriptor
var buffer = new byte[512];
var transfered = 0;
if (SendTransfer(UsbHidRequestType.GetDescriptor, UsbHidRequest.GetDescriptor,
ToValue(UsbHidClassDescriptorType.Report),
buffer, ref transfered) && transfered > 0)
{
Log.DebugFormat("-- HID Report Descriptor: {0}", buffer.ToHexString(transfered));
// store report descriptor
ReportDescriptor.Parse(buffer);
}
#endregion
return State == DsState.Connected;
}
public virtual bool Stop()
{
if (m_State == DsState.Connected)
{
tmUpdate.Enabled = false;
m_State = DsState.Reserved;
m_Packet = 0;
m_Publish = false;
OnHidReportReceived();
// play disconnect sound
if(GlobalConfiguration.Instance.IsBluetoothDisconnectSoundEnabled)
AudioPlayer.Instance.PlayCustomFile(GlobalConfiguration.Instance.BluetoothDisconnectSoundFile);
}
return m_State == DsState.Reserved;
}
public virtual bool Close()
{
Stop();
if (State == DsState.Reserved)
{
State = DsState.Disconnected;
m_Packet = 0;
m_Publish = false;
OnHidReportReceived(NewHidReport());
}
return State == DsState.Disconnected;
}
public virtual bool Stop()
{
if (State == DsState.Connected)
{
if (_outputReportTask != null)
_outputReportTask.Dispose();
State = DsState.Reserved;
m_Packet = 0;
m_Publish = false;
OnHidReportReceived(NewHidReport());
// play disconnect sound
if (GlobalConfiguration.Instance.IsBluetoothDisconnectSoundEnabled)
AudioPlayer.Instance.PlayCustomFile(GlobalConfiguration.Instance.BluetoothDisconnectSoundFile);
}
return State == DsState.Reserved;
}
public override bool Start()
{
if (IsActive)
{
Array.Copy(m_Local, 0, m_ReportArgs.Report, (int) DsOffset.Address, m_Local.Length);
m_ReportArgs.Report[(int) DsOffset.Connection] = (byte) Connection;
m_ReportArgs.Report[(int) DsOffset.Model] = (byte) Model;
m_State = DsState.Connected;
m_Packet = 0;
HID_Worker.RunWorkerAsync();
tmUpdate.Enabled = true;
Rumble(0, 0);
Log.DebugFormat("-- Started Device Instance [{0}] Local [{1}] Remote [{2}]", m_Instance, Local, Remote);
}
return State == DsState.Connected;
}
public override bool Close()
{
if (IsActive)
{
base.Close();
tmUpdate.Enabled = false;
m_State = DsState.Disconnected;
Publish();
}
return !IsActive;
}
public override bool Stop()
{
if (State == DsState.Connected)
{
var items = new Queue<int>();
lock (_pluggedInDevices)
{
foreach (var serial in _pluggedInDevices) items.Enqueue(serial - _busOffset);
}
while (items.Count > 0) Unplug(items.Dequeue());
// send un-plug-all to clean the bus from devices stuck in error state
XOutputWrapper.Instance.UnPlugAll();
_busState = DsState.Reserved;
}
return State == DsState.Reserved;
}
public override bool Start()
{
if (!IsActive) return State == DsState.Connected;
Buffer.BlockCopy(m_Local, 0, m_ReportArgs.Report, (int) DsOffset.Address, m_Local.Length);
m_ReportArgs.Report[(int) DsOffset.Connection] = (byte) Connection;
m_ReportArgs.Report[(int) DsOffset.Model] = (byte) Model;
m_State = DsState.Connected;
m_Packet = 0;
Task.Factory.StartNew(HidWorker, _hidCancellationTokenSource.Token);
tmUpdate.Enabled = true;
Rumble(0, 0);
Log.DebugFormat("-- Started Device Instance [{0}] Local [{1}] Remote [{2}]", m_Instance, Local, Remote);
return State == DsState.Connected;
}
public override bool Start()
{
if (State == DsState.Reserved)
{
m_State = DsState.Connected;
}
return State == DsState.Connected;
}
public override bool Start()
{
if (!IsActive) return State == DsState.Connected;
State = DsState.Connected;
PacketCounter = 0;
Task.Factory.StartNew(HidWorker, _hidCancellationTokenSource.Token);
_outputReportTask = _outputReportSchedule.Subscribe(tick => Process(DateTime.Now));
Rumble(0, 0);
Log.DebugFormat("-- Started Device Instance [{0}] Local [{1}] Remote [{2}]", m_Instance,
DeviceAddress.AsFriendlyName(), HostAddress.AsFriendlyName());
// connection sound
if (GlobalConfiguration.Instance.IsUsbConnectSoundEnabled)
AudioPlayer.Instance.PlayCustomFile(GlobalConfiguration.Instance.UsbConnectSoundFile);
#region Request HID Report Descriptor
// try to retrieve HID Report Descriptor
var buffer = new byte[512];
var transfered = 0;
if (SendTransfer(UsbHidRequestType.GetDescriptor, UsbHidRequest.GetDescriptor,
ToValue(UsbHidClassDescriptorType.Report),
buffer, ref transfered) && transfered > 0)
{
Log.DebugFormat("-- HID Report Descriptor: {0}", buffer.ToHexString(transfered));
// store report descriptor
ReportDescriptor.Parse(buffer);
}
#endregion
return State == DsState.Connected;
}
public override bool Stop()
{
if (IsActive)
{
tmUpdate.Enabled = false;
m_State = DsState.Reserved;
OnHidReportReceived();
}
return base.Stop();
}
public override bool Stop()
{
if (IsActive)
{
tmUpdate.Enabled = false;
m_State = DsState.Reserved;
Publish();
}
return base.Stop();
}
public override bool Open(string devicePath)
{
if (State == DsState.Disconnected)
{
Path = devicePath;
Log.DebugFormat("-- Bus Open: Path {0}", Path);
if (GetDeviceHandle(Path))
{
IsActive = true;
m_State = DsState.Reserved;
}
}
return State == DsState.Reserved;
}
public override bool Close()
{
if (IsActive)
{
base.Close();
tmUpdate.Enabled = false;
m_State = DsState.Disconnected;
OnHidReportReceived();
}
return !IsActive;
}
public virtual bool Stop()
{
if (m_State == DsState.Connected)
{
tmUpdate.Enabled = false;
m_State = DsState.Reserved;
m_Packet = 0;
m_Publish = false;
Publish();
}
return m_State == DsState.Reserved;
}
public override bool Stop()
{
if (IsActive)
{
tmUpdate.Enabled = false;
m_State = DsState.Reserved;
_hidCancellationTokenSource.Cancel();
_hidCancellationTokenSource = new CancellationTokenSource();
OnHidReportReceived();
}
return base.Stop();
}
public override bool Close()
{
if (IsActive)
{
base.Close();
if (_outputReportTask != null)
_outputReportTask.Dispose();
State = DsState.Disconnected;
OnHidReportReceived(NewHidReport());
}
return !IsActive;
}
public virtual bool Close()
{
Stop();
if (m_State == DsState.Reserved)
{
m_State = DsState.Disconnected;
m_Packet = 0;
m_Publish = false;
Publish();
}
return m_State == DsState.Disconnected;
}
public override bool Stop()
{
if (IsActive)
{
if (_outputReportTask != null)
_outputReportTask.Dispose();
State = DsState.Reserved;
_hidCancellationTokenSource.Cancel();
_hidCancellationTokenSource = new CancellationTokenSource();
OnHidReportReceived(NewHidReport());
}
return base.Stop();
}
public override bool Stop()
{
if (State == DsState.Connected)
{
var Items = new Queue<int>();
lock (m_Plugged)
{
foreach (var serial in m_Plugged) Items.Enqueue(serial - m_Offset);
}
while (Items.Count > 0) Unplug(Items.Dequeue());
m_State = DsState.Reserved;
}
return State == DsState.Reserved;
}
public override bool Stop()
{
if (State == DsState.Connected)
{
var Items = new Queue<int>();
lock (_pluggedInDevices)
{
foreach (var serial in _pluggedInDevices) Items.Enqueue(serial - _busOffset);
}
while (Items.Count > 0) Unplug(Items.Dequeue());
_busState = DsState.Reserved;
}
return State == DsState.Reserved;
}
