void BaseBroadcastHandler(MyIGCMessage msg)
{
// NOTE: called on ALL received messages; not just 'our' tag
if (msg.Tag != sIGCBaseAnnounceTag)
{
return; // not our message
}
if (msg.Data is string)
{
_program.Echo("Base Response");
string sMessage = (string)msg.Data;
string[] aMessage = sMessage.Trim().Split(':');
double x1, y1, z1;
int iOffset = 0;
string sName = aMessage[iOffset++];
long id = 0;
long.TryParse(aMessage[iOffset++], out id);
x1 = Convert.ToDouble(aMessage[iOffset++]);
y1 = Convert.ToDouble(aMessage[iOffset++]);
z1 = Convert.ToDouble(aMessage[iOffset++]);
Vector3D vPosition = new Vector3D(x1, y1, z1);
bool bJumpCapable = _program.stringToBool(aMessage[iOffset++]);
BaseAdd(id, sName, vPosition, bJumpCapable);
}
}
public void DoOnDirectMsg(MyIGCMessage msg)
{
if (IsFromMyMaster(msg))
{
DoOnDirectMasterMsg(msg);
}
}
public void ProcessDockingRequest()
{
Drone.LogToLcd($"\nLogging: {DateTime.Now}");
MyIGCMessage message = this.Drone.NetworkService.GetBroadcastListenerForChannel(DockingRequestChannel).AcceptMessage();
if (message.Data == null)
{
Drone.LogToLcd($"\nNo Message");
}
IMyShipConnector dockingPort = Drone.Grid().GetBlockWithName("Docking Port 1") as IMyShipConnector;
if (dockingPort == null)
{
Drone.LogToLcd("\nDocking Port 1 not found.");
}
else
{
Vector3D approachPoint = Vector3D.Add(dockingPort.GetPosition(), Vector3D.Multiply(dockingPort.WorldMatrix.Forward, 50));
List <Vector3D> dockingPath = new List <Vector3D> {
approachPoint, dockingPort.GetPosition()
};
Drone.LogToLcd($"Sending message: {dockingPort.WorldMatrix.Forward},{dockingPath[0].ToString()},{dockingPath[1].ToString()}");
this.Drone.NetworkService.BroadcastMessage(
DockingRequestChannel,
$"{dockingPort.WorldMatrix.Forward},{dockingPath[0].ToString()},{dockingPath[1].ToString()}"
);
}
}
/// <summary>
/// Tries handling an IGC message, whether sent via broadcast or unicast
/// </summary>
/// <param name="msg">Message</param>
/// <returns>Did the handling succeed?</returns>
private bool TryHandle(MyIGCMessage msg)
{
if (!CommandParsers.ContainsKey(msg.Tag))
{
logger($"Can't find parser for tag {msg.Tag}");
return(false);
}
var cmd = CommandParsers[msg.Tag](msg.Data);
if (cmd == null)
{
logger($"Failed to parse message of tag {msg.Tag}, whose data is {msg.Data}");
return(false);
}
if (!CommandHandlers.ContainsKey(msg.Tag))
{
logger($"Parsed message of tag {msg.Tag} but couldn't find handler");
return(false);
}
var handled = CommandHandlers[msg.Tag].tryHandle(cmd, msg.Source);
if (!handled)
{
logger($"Command handler couldn't handle message of tag {msg.Tag} whose inner data is {msg.Data}");
return(false);
}
return(true);
}
public void Process(string callbackString = "")
{
List<Action<MyIGCMessage>> callbacks;
foreach (var kv in this.listeners) {
string channel = kv.Key;
IMyBroadcastListener listener = kv.Value;
if (listener.HasPendingMessage && this.handlers.TryGetValue(channel, out callbacks)) {
while (listener.HasPendingMessage) {
MyIGCMessage msg = listener.AcceptMessage();
foreach (Action<MyIGCMessage> handle in callbacks) {
handle(msg);
}
}
}
}
if (this.unicastListener != null) {
if (this.unicastListener.HasPendingMessage) {
while (this.unicastListener.HasPendingMessage) {
MyIGCMessage msg = this.unicastListener.AcceptMessage();
if (this.unicastHandlers.TryGetValue(msg.Tag, out callbacks)) {
foreach (Action<MyIGCMessage> handle in callbacks) {
handle(msg);
}
}
}
}
}
}
public override void DoOnDirectMasterMsg(MyIGCMessage msg)
{
p.Echo("Getting msg from master");
if (msg.Tag == ShipFormationMaster.TAG_FORMATION)
{
GPS center = new GPS(msg.Data.ToString());
p.Echo("Getting formation msg from master : ");
IMyRemoteControl r = GetRemote();
r.ClearWaypoints();
int nbWP = 18;
double angleTmp = 0;
double angleDeg = 360 / nbWP;
for (int i = 0; i < nbWP; ++i)
{
GPS wp = center.ComputeCoordinate(ShipFormationMaster.DISTANCE, DegreeToRadian(angleTmp));
MyWaypointInfo dest = new MyWaypointInfo("WP_" + i, wp.x, wp.y, wp.z);
r.AddWaypoint(dest);
angleTmp += angleDeg;
}
GetLight().SetValue("Color", new Color(0, 255, 0));
r.FlightMode = FlightMode.Circle;
r.SetCollisionAvoidance(false);
r.SetAutoPilotEnabled(true);
}
}
void BroadcastHandler(MyIGCMessage msg)
{
// NOTE: called on ALL received messages; not just 'our' tag
if (msg.Tag == sAsteroidTag)
{
if (msg.Data is string)
{
string[] aMessage = ((string)msg.Data).Trim().Split(':');
double x1, y1, z1;
int iOffset = 0;
long id = 0;
long.TryParse(aMessage[iOffset++], out id);
long asteroidID = 0;
long.TryParse(aMessage[iOffset++], out asteroidID);
x1 = Convert.ToDouble(aMessage[iOffset++]);
y1 = Convert.ToDouble(aMessage[iOffset++]);
z1 = Convert.ToDouble(aMessage[iOffset++]);
Vector3D vMin = new Vector3D(x1, y1, z1);
x1 = Convert.ToDouble(aMessage[iOffset++]);
y1 = Convert.ToDouble(aMessage[iOffset++]);
z1 = Convert.ToDouble(aMessage[iOffset++]);
Vector3D vMax = new Vector3D(x1, y1, z1);
BoundingBoxD box = new BoundingBoxD(vMin, vMax);
AsteroidAdd(asteroidID, box, false);
}
}
}
public void Main(string argument, UpdateType updateType)
{
while (hangarBroadcastListener.HasPendingMessage)
{
MyIGCMessage igc_message = hangarBroadcastListener.AcceptMessage();
ShipIGC ship_igc;
if (shipIGCs.ContainsKey(igc_message.Source))
{
ship_igc = shipIGCs[igc_message.Source];
}
else
{
ship_igc = new ShipIGC(igc_message.Source, IGC);
shipIGCs.Add(igc_message.Source, ship_igc);
}
try
{
string igc_message_data = igc_message.As <string>();
if (igc_message_data != null)
{
shipCommands.Parse(igc_message_data, ship_igc);
}
}
catch (Exception e)
{
Echo(e.ToString());
}
}
}
/// <summary>
/// Wico Unicast Handler for Wico Main
/// </summary>
/// <param name="msg"></param>
public void WicoConfigUnicastListener(MyIGCMessage msg)
{
var tag = msg.Tag;
var src = msg.Source;
if (tag == YouAreSub)
{
bIAmMain = false;
}
else if (tag == UnicastAnnounce)
{
// another block announces themselves as one of our collective
if (_WicoMainSubscribers.Contains(src))
{
// already in the list
}
else
{
// not in the list
// _program.Echo("Adding new");
_WicoMainSubscribers.Add(src);
}
bIAmMain = true; // assume we are the main module
foreach (var other in _WicoMainSubscribers)
{
// if somebody has a lower ID, use them instead.
if (other < thisProgram.Me.EntityId)
{
bIAmMain = false;
// _program.Echo("Found somebody lower");
}
}
}
else if (tag == UnicastTagTrigger)
{
// we are being informed that we were wanted to run for some reason (misc)
thisProgram.Echo("Trigger Received" + msg.Data);
}
else if (tag == MODECHANGETAG)
{
string[] aLines = ((string)msg.Data).Split('\n');
// 0=old mode 1=old state. 2=new mode 3=new state
int theNewMode = Convert.ToInt32(aLines[2]);
int theNewState = Convert.ToInt32(aLines[3]);
if (_bDebug)
{
thisProgram.ErrorLog("IGCS M=" + theNewMode + " S=" + theNewState + " OM=" + IMode + " OS=" + _iState);
}
if (_iMode != theNewMode)
{
HandleModeChange(_iMode, _iState, theNewMode, theNewState);
}
_iMode = theNewMode;
_iState = theNewState;
}
// TODO: add more messages as needed
}
private void ProcessUniCommsMessage(MyIGCMessage message)
{
P.Echo($"Processing UNICOMMS: {message.Tag}");
if (commands.ContainsKey(message.Tag))
{
commands[message.Tag]?.Invoke(message.Data);
}
}
private void UpdateStatus(MyIGCMessage message)
{
long droneID = message.Source;
Drone drone;
if (drones.TryGetValue(droneID, out drone))
{
drone.UpdateStatus(message.Data);
}
}
public override void Perform()
{
if (!UseCallbacks)
{
if (Drone.NetworkService.GetUnicastListener().HasPendingMessage)
{
MyIGCMessage message = Drone.NetworkService.GetUnicastListener().AcceptMessage();
ParseUnicast(message);
}
}
Drone.Log("Checking for messages");
if (Drone.NetworkService.GetBroadcastListenerForChannel(channel).HasPendingMessage)
{
MyIGCMessage message = Drone.NetworkService.GetBroadcastListenerForChannel(channel).AcceptMessage();
Drone.Log(message.Data.ToString());
Drone.Log(message.Source.ToString());
}
if (Sender)
{
if (MessageType == "Vector3D")
{
MyTuple <bool, Vector3D> payload = new MyTuple <bool, Vector3D>();
payload.Item1 = true;
payload.Item2 = Drone.Remote.GetPosition();
Drone.Log($"Sending Position to miner1: {Drone.NetworkService.UnicastRecipients["miner1"]}");
long address = Drone.NetworkService.UnicastRecipients["miner1"];
Drone.Program.IGC.SendUnicastMessage <MyTuple <bool, Vector3D> >(address, "vector", payload);
//Drone.NetworkService.UnicastMessage("tester1", "vector", payload);
}
else if (MessageType == "EntityId")
{
MyTuple <bool, long> payload = new MyTuple <bool, long>();
payload.Item1 = true;
payload.Item2 = Drone.Program.Me.EntityId;
Drone.NetworkService.UnicastMessage("tester1", "entity_id", payload);
payload.Item1 = false;
Drone.NetworkService.UnicastMessage("tester2", "entity_id", payload);
}
else if (MessageType == channel)
{
Drone.NetworkService.BroadcastMessage(channel, $"My address is: {Drone.Program.Me.EntityId}");
}
else
{
throw new Exception("Message type not recognized");
}
}
//Else do nothing, wait for callbacks
}
public void ProcessClearance(MyIGCMessage clearance)
{
//=================================
//TODO: use the connectors bounding box to compute an offset?
//=================================
MyTuple <Vector3D, Vector3D, Vector3D> messageTuple = (MyTuple <Vector3D, Vector3D, Vector3D>)clearance.Data;
ApproachPath[0] = messageTuple.Item1;
ApproachPath[1] = messageTuple.Item2;
State = "Approaching Dock";
}
public void DoOnDirectMsg(MyIGCMessage msg)
{
if (msg.Tag == AbstractSlaveSystem.TAG_SLAVE_ACCEPTATION)
{
p.Echo("Adding slave " + msg.Source);
AddContact(msg.Source);
}
else if (IsFromMySlave(msg))
{
DoOnDirectSlaveMsg(msg);
}
}
void TestBroadcastHandler(MyIGCMessage msg)
{
// NOTE: called on ALL received messages; not just 'our' tag
// if (msg.Tag!=sBroadCastTag) return; // not our message
Echo("Received Test Message");
var src = msg.Source;
Echo(" Source=" + src.ToString("X"));
Echo(" Data=\"" + msg.Data + "\"");
Echo(" Tag=" + msg.Tag);
}
void Main(string argument, UpdateType updateSource)
{
if (updateSource == UpdateType.Update1 || updateSource == UpdateType.Update10 || updateSource == UpdateType.Update100)
{
// Main code
Clock.Update();
if (Clock.Runtime == startRuntime)
{
Echo("Starting.");
Start();
}
else if (startRuntime != -1)
{
Echo("Waiting to start:");
double sec = startDelay - Clock.GetSeconds(0);
Echo(sec.ToString("0.0") + 's');
return;
}
Echo("Running.");
Detect();
Echo("Has target: " + detected);
Echo("Known location: " + lastEnemy.HasValue);
double secSince = Clock.GetSeconds(contactTime);
if (secSince > 0 && secSince < timeout)
{
Echo("Time since contact: " + secSince.ToString("0.00"));
}
Move();
}
else if (updateSource == UpdateType.IGC)
{
if (helpListener != null && receiveHelpMsgs && !detected && helpListener.HasPendingMessage && !rc.IsAutoPilotEnabled)
{
MyIGCMessage msg = helpListener.AcceptMessage();
if (msg.Data is Vector3D)
{
Vector3D pos = (Vector3D)msg.Data;
double dist2 = Vector3D.DistanceSquared(rc.GetPosition(), pos);
if (dist2 < replyToHelpRange * replyToHelpRange)
{
lastEnemy = null;
GoTo(pos, "HelpCall");
}
}
}
}
else
{
Command(argument);
}
}
protected void ReadChanelMsgs(Action <MyIGCMessage, string> actionOnMessage)
{
foreach (IMyBroadcastListener l in listGroupListener)
{
while (l.HasPendingMessage)
{
MyIGCMessage msg = l.AcceptMessage();
if (p.IGC.Me != msg.Source)
{
actionOnMessage(msg, GetSubTag(msg.Tag));
}
}
}
}
public void TryRegisterMaster(MyIGCMessage msg)
{
if (msg.Tag == AbstractMasterSystem.TAG_MASTER_RESERVATION)
{
p.Echo("Getting master reservation from " + msg.Source);
// Don't change Master
if (!HasMaster())
{
p.Echo("Adding master " + msg.Source);
AddContact(msg.Source);
SendToContact(msg.Source, TAG_SLAVE_ACCEPTATION, "");
}
}
}
private void ProcessMessages()
{
while (Listener.HasPendingMessage)
{
MyIGCMessage msg = Listener.AcceptMessage();
string data = msg.Data.ToString();
if (DroneID == 0)
{
CheckForID(data);
}
Echo(data);
WriteOnScreen(data);
}
}
public void Main(string argument, UpdateType updateSource)
{
Echo(String.Format("UPDATE CALLED FROM {0}", updateSource.ToString()));
// Get message from listener
MyIGCMessage message = listener.AcceptMessage();
Dictionary <string, object> messageData = DecodeMessage((string)message.Data);
long requestSource = message.Source;
Echo(messageData["shipID"].ToString());
long shipID = (long)messageData["shipID"];
string request = messageData["request"].ToString().Trim();
Echo(string.Format("ID: {0}, request: {1}", shipID.ToString(), request));
Log(shipID, request);
Hangar dock;
bool accepted = false;
switch (request)
{
case "DOCK":
Echo(string.Format("DOCK REQUEST RECEIVED FROM SHIP: {0}", shipID.ToString("X")));
dock = GetAvailableDock();
if (dock != null)
{
dock.RunProgram("DOCK");
accepted = true;
}
TransmitMessage(requestSource, shipID, dock, "DOCK", accepted);
break;
case "UNDOCK":
Echo(string.Format("UNDOCK REQUEST RECEIVED FROM SHIP: {0}", shipID.ToString("X")));
dock = GetDockOfShip(shipID);
if (dock != null)
{
dock.RunProgram("UNDOCK");
accepted = true;
}
TransmitMessage(requestSource, shipID, dock, "UNDOCK", accepted);
break;
default:
return;
}
}
void ProcessUnicast()
{
while (IGC.UnicastListener.HasPendingMessage)
{
MyIGCMessage msg = IGC.UnicastListener.AcceptMessage();
if (msg.Tag == "command" && msg.Data is string)
{
string command = msg.Data as string;
if (command != "process_message")
{
ProcessCommand(command);
}
}
}
}
public void Main(string argument, UpdateType updateSource)
{
Echo(updateSource.ToString() + " arg:" + argument);
if ((updateSource & UpdateType.IGC) > 0)
{
if (listener.HasPendingMessage)
{
MyIGCMessage message = listener.AcceptMessage();
if (message.Data is string)
{
Echo(message.Data.ToString());
}
}
}
}
public bool Listen()
{
bool res = false;
if (listeners[0].HasPendingMessage)
{
MyIGCMessage message = listeners[0].AcceptMessage();
if (message.Data is Vector3D)
{
targetpos = (Vector3D)message.Data;
res = true;
}
}
return(res);
}
private void ReturnKeepAlive(MyIGCMessage message)
{
long droneID = (long)message.Data;
Drone drone;
if (drones.TryGetValue(droneID, out drone))
{
drone.ReturnKeepAlive(droneID, time.Time);
}
else
{
drone = new Drone(droneID, this);
drones[droneID] = drone;
}
}
void TestUnicastHandler(MyIGCMessage msg)
{
// NOTE: Called for ALL received unicast messages
if (msg.Tag != _unicastTag)
{
return; // not our message
}
if (msg.Data is string)
{
Echo("Received Acknowledge Message");
Echo(" Source=" + msg.Source.ToString("X"));
Echo(" Data=\"" + msg.Data + "\"");
Echo(" Tag=" + msg.Tag);
}
}
void HandlePing(MyIGCMessage message)
{
if (message.Source == IGC.Me)
{
return;
}
if (message.As <bool>() == true)
{
return; // Recieved Pong
}
if (respondToPing)
{
SendPong(message.Source);
}
}
void RadioInput()
{
while (ProgramInstance.IGC.UnicastListener.HasPendingMessage)
{
MyIGCMessage message = ProgramInstance.IGC.UnicastListener.AcceptMessage();
if (message.Tag == "ROUTE")
{
RouteData = message.Data.ToString();
}
if (message.Tag == "COMMAND")
{
NewInstructions(message.Data.ToString());
}
}
}
// Handler for the test broadcast messages.
void TestBroadcastHandler(MyIGCMessage msg)
{
// NOTE: called on ALL received messages; not just 'our' tag
if (msg.Tag != _broadCastTag)
{
return; // not our message
}
if (msg.Data is string)
{
Echo("Received Test Message");
Echo(" Source=" + msg.Source.ToString("X"));
Echo(" Data=\"" + msg.Data + "\"");
Echo(" Tag=" + msg.Tag);
}
}
public void Main(string argument, UpdateType updateSource)
{
// Calculate and Output for informational purposes
_runcount++;
Echo(_runcount.ToString() + ":" + updateSource.ToString());
if (
(updateSource & (UpdateType.Trigger | UpdateType.Terminal)) > 0 || // run by a terminal action
(updateSource & (UpdateType.Mod)) > 0 || // script run by a mod
(updateSource & (UpdateType.Script)) > 0 // this pb run by another script (PB)
)
{ // script was run because of an action
if (argument != "")
{
// if we are given an argument, send it out over our broadcast channel
IGC.SendBroadcastMessage(_broadCastTag, argument);
Echo("Sending message:\n" + argument);
}
}
if ((updateSource & UpdateType.IGC) > 0)
{ // script was run because of incoming IGC message
while (_myBroadcastListener.HasPendingMessage)
{
MyIGCMessage myIGCMessage = _myBroadcastListener.AcceptMessage();
if (myIGCMessage.Tag == _broadCastTag)
{ // This is our tag
if (myIGCMessage.Data is string)
{
string str = myIGCMessage.Data.ToString();
Echo("Received IGC Public Message");
Echo("Tag=" + myIGCMessage.Tag);
Echo("Data=" + myIGCMessage.Data.ToString());
Echo("Source=" + myIGCMessage.Source.ToString("X"));
}
else // if(msg.Data is XXX)
{
// handle other data types here...
}
}
else
{
// handle other tags here
}
}
}
}
public void Main(string argument, UpdateType updateSource)
{
Echo(updateSource.ToString() + " arg:" + argument);
if ((updateSource & UpdateType.IGC) > 0)
{
if (listener.HasPendingMessage)
{
MyIGCMessage message = listener.AcceptMessage();
if (message.Data is string)
{
Echo(message.Data.ToString());
// отправляем ответное сообщение
IGC.SendUnicastMessage <string>(message.Source, TAG, "result message");
}
}
}
}
