void OutGoingMessage(ref List <RadioMessage> mlist, List <IMyRadioAntenna> radios, string to, string from, string options, string message,
MyTransmitTarget transmitTarget = MyTransmitTarget.Default, bool append = false, char seperator = ';')
{
if (append)
{
bool added = false;
for (int i = 0; i < mlist.Count; ++i)
{
for (int j = 0; j < radios.Count; ++j)
{
if (mlist[i].Radio == radios[j] && mlist[i].To == to &&
mlist[i].From == from && mlist[i].Options == options &&
mlist[i].TransmitTarget == transmitTarget && mlist[i].Seperator == seperator)
{
mlist[i].Message += "\n" + message;
added = true;
}
}
}
if (!added)
{
for (int i = 0; i < radios.Count; ++i)
{
mlist.Add(new RadioMessage(radios[i], to, from, options, message, transmitTarget, seperator));
}
}
}
else
{
for (int i = 0; i < radios.Count; ++i)
{
mlist.Add(new RadioMessage(radios[i], to, from, options, message, transmitTarget, seperator));
}
}
}
private void CommonInit(Program p)
{
this.P = p;
msgQueue = new List <string>();
TRANSMITTARGET = MyTransmitTarget.Default;
}
public void SendResponce(string target, int ID, MyTransmitTarget group = MyTransmitTarget.Ally)
{
if (ComWorking)
{
Message mes = new Message(Tag.RES, target, "", ID, "", group);
buffer.Add(mes);
}
}
//SCRIPTINPUT (FS)
void SendResponce(string target, int ID, MyTransmitTarget group = MyTransmitTarget.Ally | MyTransmitTarget.Owned)
{
if (ComWorking)
{
Message mes = new Message(Tag.RES, target, "", ID, group);
prioList.Add(mes);
}
}
public void LowPriority(IMyRadioAntenna radio, string to, string from, string options, string message,
MyTransmitTarget transmitTarget = MyTransmitTarget.Default, bool append = false, char seperator = ';')
{
List <IMyRadioAntenna> radios = new List <IMyRadioAntenna> {
radio
};
OutGoingMessage(ref lowPriority, radios, to, from, options, message, transmitTarget, append, seperator);
}
public RadioMessage(IMyRadioAntenna radio, string to, string from, string options, string message, MyTransmitTarget transmitTarget = MyTransmitTarget.Default, char seperator = ';')
{
Radio = radio;
To = to;
From = from;
Options = options;
Message = message;
TransmitTarget = transmitTarget;
Seperator = seperator;
}
public Message(Tag kind, string tar, string load, int id, string key, MyTransmitTarget group)
{
tick = 0;
tag = kind;
targetName = tar;
payload = load;
ID = id;
Skey = key;
targetGroup = group;
}
/// <summary>
/// Attempts to initialize the protocol
/// </summary>
/// <param name="runtime">runtime object</param>
/// <param name="antennas">antennas array</param>
/// <param name="transmissionMode">transmission mode</param>
/// <param name="localName">local id, must be between 1 and 99 characters long</param>
/// <param name="sendLimit">send limit per packet, if a packet is attempted to be sent more than this value, the associated connection is terminated [default=5]</param>
/// <param name="sendTimeoutMs">time to wait between attempting packet retransmission [default=400]</param>
/// <param name="connectionAcceptor">connection acceptor delegate, decides whether to accept an incoming connection request, null causes any such connections to be rejected</param>
/// <param name="connectionListener">connection listener delegate, invoked when a new connection has been accepted, can be null</param>
public static void Initialize(IMyGridProgramRuntimeInfo runtime, IMyRadioAntenna[] antennas, MyTransmitTarget transmissionMode, string localName, int sendLimit = 5, int sendTimeoutMs = 400, Func <string, byte, bool> connectionAcceptor = null, Action <IConnection> connectionListener = null)
{
if (m_connections == null)
{
if (runtime == null)
{
throw new Exception("runtime can not be null");
}
if (antennas == null || antennas.Length == 0)
{
throw new Exception("antennas can not be null or have length of 0");
}
if (localName == null || localName.Length <= 0 || localName.Length > 99)
{
throw new Exception("localName length must be between 1 and 9 inclusive");
}
m_runtime = runtime;
m_antennas = (IMyRadioAntenna[])antennas.Clone();
m_localID = localName;
m_sendLimit = sendLimit <= 0 ? 1 : sendLimit;
m_sendTimeoutMs = sendTimeoutMs < 0 ? 0 : sendTimeoutMs;
m_connectionAcceptor = connectionAcceptor;
m_connectionListener = connectionListener;
m_connections = new List <StaticConnection>();
m_connections.Add(new StaticConnection());
m_transmissionMode = transmissionMode;
m_localIDLength = m_localID.Length.ToString("00");
CurrentTime = sendTimeoutMs * 3;// just an arbitrary value above 0
for (int i = 0, l = m_antennas.Length; i < l; i++)
{
IMyRadioAntenna a = m_antennas[i];
if (transmissionMode == MyTransmitTarget.Owned)
{
a.IgnoreAlliedBroadcast = true;
a.IgnoreOtherBroadcast = true;
}
else if (transmissionMode == MyTransmitTarget.Ally)
{
a.IgnoreAlliedBroadcast = false;
a.IgnoreOtherBroadcast = true;
}
else if (transmissionMode == MyTransmitTarget.Enemy || transmissionMode == MyTransmitTarget.Everyone)
{
a.IgnoreAlliedBroadcast = false;
a.IgnoreOtherBroadcast = false;
}
}
}
}
public bool SendStringMessage(string message, MyTransmitTarget target = MyTransmitTarget.Default)
{
if (type == antennaType.radioAntenna)
{
return(radioAntenna.TransmitMessage(message, target));
}
else
{
if (laserAntenna.Status == MyLaserAntennaStatus.Connected)
{
return(laserAntenna.TransmitMessage(message));
}
}
return(false);
}
private void OnMessageRecieved(MyRadioAntenna requester, string arg, MyTransmitTarget target)
{
if (!ReferenceEquals(requester.CubeGrid, base.CubeGrid))
{
MyProgrammableBlock block2;
switch (MyIDModule.GetRelation(base.OwnerId, requester.OwnerId, MyOwnershipShareModeEnum.Faction, MyRelationsBetweenPlayerAndBlock.Enemies, MyRelationsBetweenFactions.Enemies, MyRelationsBetweenPlayerAndBlock.FactionShare))
{
case MyRelationsBetweenPlayerAndBlock.NoOwnership:
case MyRelationsBetweenPlayerAndBlock.Neutral:
if (target.HasFlag(MyTransmitTarget.Neutral))
{
break;
}
return;
case MyRelationsBetweenPlayerAndBlock.Owner:
if (target.HasFlag(MyTransmitTarget.Owned))
{
break;
}
return;
case MyRelationsBetweenPlayerAndBlock.FactionShare:
if (!this.m_ignoreAlliedBroadcast.Value && target.HasFlag(MyTransmitTarget.Ally))
{
break;
}
return;
case MyRelationsBetweenPlayerAndBlock.Enemies:
if (!this.m_ignoreOtherBroadcast.Value && target.HasFlag(MyTransmitTarget.Enemy))
{
break;
}
return;
default:
return;
}
Sandbox.Game.Entities.MyEntities.TryGetEntityById <MyProgrammableBlock>(this.m_attachedPB.Value, out block2, false);
if (((this.RadioReceiver != null) && ((block2 != null) && MyCubeGridGroups.Static.Logical.GetGroup(block2.CubeGrid).Nodes.Any <MyGroups <MyCubeGrid, MyGridLogicalGroupData> .Node>(n => (n.NodeData == base.CubeGrid)))) && MyAntennaSystem.Static.GetAllRelayedBroadcasters(this.RadioReceiver, base.OwnerId, false, null).Contains(requester.RadioBroadcaster))
{
block2.Run(arg, UpdateType.Antenna);
}
}
}
bool Sandbox.ModAPI.Ingame.IMyRadioAntenna.TransmitMessage(string message, MyTransmitTarget target)
{
if (((this.m_nextBroadcast != null) || ((this.EnableBroadcasting == null) || !base.Enabled)) || !base.IsFunctional)
{
return(false);
}
if (target == MyTransmitTarget.None)
{
return(false);
}
if (message.Length > 0x186a0)
{
return(false);
}
this.m_nextBroadcast = new MyTuple <string, MyTransmitTarget>(message, target);
base.NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
return(true);
}
//USERINPUT (FS)
public int SendMessage(string target, string message, bool chat, MyTransmitTarget group = MyTransmitTarget.Default)
{
if (ComWorking)
{
if (responceList.Count == 0 || !responceList.Keys.Contains(target))
{
responceList.Add(target, new Target(target));
}
Message mes = new Message(Tag.MES, target, message, 0, group);
if (chat)
{
mes.tag = Tag.CHAT;
}
parent.printOut("INFO: Message added");
return(responceList[target].addMessage(mes));
}
parent.printOut("WARNING: Message not added");
return(-1);
}
public void EnqueueMessage(string message, long targetId, MyTransmitTarget target, antennaType type)
{
messageBuilder.Clear();
messageBuilder.Append(GTS.Me.EntityId);
messageBuilder.Append('|');
messageBuilder.Append(targetId);
messageBuilder.Append('|');
messageBuilder.Append(message);
var msg = new Message
{
message = messageBuilder.ToString(),
target = target,
antennaType = type,
isEmpty = false
};
messageQueue.Enqueue(msg);
}
public void Transmit(string text, string targetString)
{
MyTransmitTarget target = ParseTarget(targetString);
bool allTransmitted = true;
foreach (var antenna in Antennas)
{
if (antenna is IMyRadioAntenna)
{
allTransmitted = ((IMyRadioAntenna)antenna).TransmitMessage(text, target);
}
else if (antenna is IMyLaserAntenna)
{
var laserAntenna = (IMyLaserAntenna)antenna;
if (laserAntenna.Status == MyLaserAntennaStatus.Connected)
{
allTransmitted = ((IMyLaserAntenna)antenna).TransmitMessage(text);
}
}
}
}
/// <summary>
/// Gets a transmit target object, by looking at individual tokens
/// in the argument and OR-gating them.
/// </summary>
/// <param name="targetName">The string to be examined. </param>
/// <returns>A valid target from MyTransmitTarget if the target string contained only valid elements, else MyTransmitTarget.None.</returns>
private MyTransmitTarget ParseTarget(string targetName)
{
MyTransmitTarget targetGroup = MyTransmitTarget.None;
string[] tokens = targetName.Split(new char[] { ',', '|' }, StringSplitOptions.RemoveEmptyEntries);
targetGroup = tokens.Aggregate(MyTransmitTarget.None, (r, t) =>
{
MyTransmitTarget e;
if (Enum.TryParse(t, true, out e))
{
r |= e;
}
else
{
Log.WriteFormat(ImplLogger.LOG_CAT, LogLevel.Warning, "{0} is not a valid target.", t);
}
return(r);
});
return(targetGroup);
}
Initialize(IMyGridProgramRuntimeInfo m, IMyRadioAntenna[] n, MyTransmitTarget o, string p, int q = 5, int r = 400, Func <string, byte, bool
> s = null, Action <IConnection> t = null)
{
if (b == null)
{
if (m == null)
{
throw new Exception("runtime can not be null");
}
if (n == null || n.
Length == 0)
{
throw new Exception("antennas can not be null or have length of 0");
}
if (p == null || p.Length <= 0 || p.Length > 99)
{
throw
new Exception("localName length must be between 1 and 9 inclusive");
}
a = m; c = (IMyRadioAntenna[])n.Clone(); i = p; e = q <= 0?1:q; f = r < 0?
0:r; g = s; h = t; b = new List <X>(); b.Add(new X()); d = o; j = i.Length.ToString("00"); k = r * 3; for (int i = 0, l = c.Length; i < l; i++)
{
IMyRadioAntenna a = c[i]; if (o == MyTransmitTarget.Owned)
{
a.IgnoreAlliedBroadcast = true; a.IgnoreOtherBroadcast = true;
}
else if (o ==
MyTransmitTarget.Ally)
{
a.IgnoreAlliedBroadcast = false; a.IgnoreOtherBroadcast = true;
}
else if (o == MyTransmitTarget.Enemy || o ==
MyTransmitTarget.Everyone)
{
a.IgnoreAlliedBroadcast = false; a.IgnoreOtherBroadcast = false;
}
}
}
}
public void SendMessage(Tag tag, string target, string message, string key = "", MyTransmitTarget group = MyTransmitTarget.Ally)
{
if (ComWorking)
{
Message mes = new Message(tag, target, message, currentID, key, group);
buffer.Add(mes);
currentID++;
}
}
