319 lines
14 KiB
Text
319 lines
14 KiB
Text
#
|
|
# bridge message rules;
|
|
# - if distinct must be absolute and self contained as a later message will supercede any earlier ones in the outgoing queue.
|
|
# - use the message type and ident to identify distinct messages
|
|
# The outgoing 'port' is a multiplay/generic/string index.
|
|
# - ! is used as a seperator between the elements that are used to send the notification (typeid, sequence, notification)
|
|
# - ; is used to seperate serialzied elemnts of the notification
|
|
#
|
|
# Outgoing messages are sent in a scheduled manner, usually once per second, and each message has a lifetime (to allow for propogation to
|
|
# all clients over UDP). Clients will ignore messages that they have already received (based on the sequence id).
|
|
#
|
|
# The incoming bridge will usually be created part of the aircraft model file; it is important to understand that each AI/MP model will have an incoming bridge
|
|
# as each element in /ai/models needs its own bridge to keep up with the incoming sequence id. This scheme may not work properly as it relies on the model being
|
|
# loaded which may only happen when visible so it may be necessary to track AI models in a seperate instantiatable incoming bridge manager.
|
|
#
|
|
# The outgoing bridge would usually be created within the aircraft loading Nasal.
|
|
var OutgoingMPBridge =
|
|
{
|
|
new: func(_ident, _notifications_to_bridge=nil, _mpidx=19, _root="", _transmitter=nil)
|
|
{
|
|
if (_transmitter == nil)
|
|
_transmitter = emesary.GlobalTransmitter;
|
|
|
|
print("OutgoingMPBridge created for "~_ident);
|
|
|
|
var new_class = emesary.Recipient.new("OutgoingMPBridge "~_ident);
|
|
|
|
new_class.MessageIndex = 100;
|
|
# foreach (var notification; _notifications_to_bridge)
|
|
# new_class.NotificationsToBridge = notification.new(;
|
|
if(_notifications_to_bridge == nil)
|
|
new_class.NotificationsToBridge = [];
|
|
else
|
|
new_class.NotificationsToBridge = _notifications_to_bridge;
|
|
|
|
new_class.MPout = "";
|
|
new_class.MPidx = _mpidx;
|
|
new_class.MessageLifeTime = 10; # seconds
|
|
new_class.OutgoingList = [];
|
|
new_class.Transmitter = _transmitter;
|
|
new_class.TransmitRequired=0;
|
|
new_class.Transmitter.Register(new_class);
|
|
new_class.MpVariable = _root~"sim/multiplay/generic/string["~new_class.MPidx~"]";
|
|
new_class.TransmitterActive = 0;
|
|
|
|
new_class.TransmitTimer =
|
|
maketimer(6, func
|
|
{
|
|
if(new_class.TransmitterActive)
|
|
new_class.Transmit();
|
|
|
|
new_class.TransmitTimer.restart(1);
|
|
});
|
|
new_class.TransmitTimer.restart(1);
|
|
|
|
new_class.Delete = func
|
|
{
|
|
if (me.Transmitter != nil) {
|
|
me.Transmitter.DeRegister(me);
|
|
me.Transmitter = nil;
|
|
}
|
|
};
|
|
new_class.AddMessage = func(m)
|
|
{
|
|
append(me.NotificationsToBridge, m);
|
|
};
|
|
|
|
#-------------------------------------------
|
|
# Receive override:
|
|
new_class.Receive = func(notification)
|
|
{
|
|
if (notification.FromIncomingBridge)
|
|
return emesary.Transmitter.ReceiptStatus_NotProcessed;
|
|
|
|
#print("Receive ",notification.Type," (",notification.Ident);
|
|
for (var idx = 0; idx < size(me.NotificationsToBridge); idx += 1)
|
|
{
|
|
if(me.NotificationsToBridge[idx].Type == notification.Type)
|
|
{
|
|
me.MessageIndex += 1;
|
|
notification.MessageExpiryTime = systime()+me.MessageLifeTime;
|
|
notification.BridgeMessageId = me.MessageIndex;
|
|
notification.BridgeMessageTypeId = idx;
|
|
#
|
|
# The message key is a composite of the type and ident to allow for multiple senders
|
|
# of the same message type.
|
|
notification.BridgeMessageTypeKey = notification.Type~"."~notification.Ident;
|
|
#print("Received ",notification.BridgeMessageTypeKey," expire=",notification.MessageExpiryTime);
|
|
me.AddToOutgoing(notification);
|
|
return emesary.Transmitter.ReceiptStatus_Pending;
|
|
}
|
|
}
|
|
return emesary.Transmitter.ReceiptStatus_NotProcessed;
|
|
};
|
|
new_class.AddToOutgoing = func(notification)
|
|
{
|
|
if (notification.IsDistinct)
|
|
{
|
|
for (var idx = 0; idx < size(me.OutgoingList); idx += 1)
|
|
{
|
|
if(me.OutgoingList[idx].BridgeMessageTypeKey == notification.BridgeMessageTypeKey)
|
|
{
|
|
#print("Update ",me.OutgoingList[idx].BridgeMessageTypeKey);
|
|
me.OutgoingList[idx]= notification;
|
|
me.TransmitterActive = size(me.OutgoingList);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
#print("Added ",notification.BridgeMessageTypeKey);
|
|
append(me.OutgoingList, notification);
|
|
me.TransmitterActive = size(me.OutgoingList);
|
|
};
|
|
new_class.Transmit = func
|
|
{
|
|
var outgoing = "";
|
|
var cur_time=systime();
|
|
var out_idx = 0;
|
|
for (var idx = 0; idx < size(me.OutgoingList); idx += 1)
|
|
{
|
|
var sect = "";
|
|
var notification = me.OutgoingList[idx];
|
|
if (notification.MessageExpiryTime > cur_time)
|
|
{
|
|
var encval="";
|
|
var first_time = 1;
|
|
var eidx = 0;
|
|
foreach(var p ; notification.bridgeProperties())
|
|
{
|
|
if (encval != "")
|
|
encval = encval ~ ";";
|
|
encval = encval ~ p.getValue();
|
|
#print("Encode ",eidx,"=",encval);
|
|
eidx += 1;
|
|
}
|
|
sect = sprintf("%d!%d!%s",notification.BridgeMessageId, notification.BridgeMessageTypeId, encval);
|
|
outgoing = outgoing~sect;
|
|
me.OutgoingList[out_idx] = me.OutgoingList[idx];
|
|
# print("xmit ",idx," out=",out_idx);
|
|
out_idx += 1;
|
|
}
|
|
# else
|
|
# printf("expired ",idx,out_idx);
|
|
}
|
|
me.TransmitterActive = size(me.OutgoingList);
|
|
var del_count = size(me.OutgoingList)-out_idx;
|
|
setprop(me.MpVariable,outgoing);
|
|
# print("Set ",me.MpVariable," to ",outgoing);
|
|
# print("outgoingList : ",out_idx, " ", size(me.OutgoingList), " del count=",del_count);
|
|
for(var del_i=0; del_i < del_count; del_i += 1)
|
|
pop(me.OutgoingList);
|
|
};
|
|
return new_class;
|
|
},
|
|
};
|
|
|
|
#
|
|
#
|
|
# one of these for each model instantiated in the model XML - it will
|
|
# route messages to
|
|
var IncomingMPBridge =
|
|
{
|
|
new: func(_ident, _notifications_to_bridge=nil, _mpidx=19, _transmitter=nil)
|
|
{
|
|
if (_transmitter == nil)
|
|
_transmitter = emesary.GlobalTransmitter;
|
|
|
|
print("IncominggMPBridge created for "~_ident);
|
|
|
|
var new_class = emesary.Transmitter.new("IncominggMPBridge "~_ident);
|
|
|
|
new_class.IncomingMessageIndex = 100;
|
|
if(_notifications_to_bridge == nil)
|
|
new_class.NotificationsToBridge = [];
|
|
else
|
|
new_class.NotificationsToBridge = _notifications_to_bridge;
|
|
|
|
new_class.MPout = "";
|
|
new_class.MPidx = _mpidx;
|
|
new_class.MessageLifeTime = 10; # seconds
|
|
new_class.OutgoingList = [];
|
|
new_class.Transmitter = _transmitter;
|
|
new_class.MpVariable = "";
|
|
|
|
new_class.Connect = func(_root)
|
|
{
|
|
me.MpVariable = _root~"sim/multiplay/generic/string["~new_class.MPidx~"]";
|
|
me.Callsign = getprop(_root~"callsign");
|
|
print("bridge ",me.MpVariable, " callsign ",me.Callsign);
|
|
setlistener(me.MpVariable, func(v)
|
|
{
|
|
me.ProcessIncoming(v.getValue());
|
|
});
|
|
};
|
|
|
|
new_class.AddMessage = func(m)
|
|
{
|
|
append(me.NotificationsToBridge, m);
|
|
};
|
|
|
|
new_class.Remove = func
|
|
{
|
|
print("Emesary IncomingMPBridge Remove() ",me.Ident);
|
|
me.Transmitter.DeRegister(me);
|
|
};
|
|
|
|
#-------------------------------------------
|
|
# Receive override:
|
|
new_class.ProcessIncoming = func(encoded_val)
|
|
{
|
|
if (encoded_val == "")
|
|
return;
|
|
# print("ProcessIncoming ", encoded_val);
|
|
var encoded_notifications = split(";", encoded_val);
|
|
for (var idx = 0; idx < size(encoded_notifications); idx += 1)
|
|
{
|
|
# get the message parts
|
|
var encoded_notification = split("!", encoded_val);
|
|
if (size(encoded_notification) < 3)
|
|
print("Error: emesary.IncomingBridge.ProcessIncoming bad msg ",encoded_val);
|
|
else
|
|
{
|
|
var msg_idx = encoded_notification[0];
|
|
var msg_type_id = encoded_notification[1];
|
|
if (msg_type_id >= size(me.NotificationsToBridge))
|
|
{
|
|
print("Error: emesary.IncomingBridge.ProcessIncoming invalid type_id ",msg_type_id);
|
|
}
|
|
else
|
|
{
|
|
var msg = me.NotificationsToBridge[msg_type_id];
|
|
var msg_notify = encoded_notification[2];
|
|
print("received idx=",msg_idx," ",msg_type_id,":",msg.Type);
|
|
if(msg_idx <= me.IncomingMessageIndex)
|
|
print(" **Already processed");
|
|
else
|
|
{
|
|
# raise notification
|
|
var bridged_notification = msg; #emesary.Notification.new(msg.Type,"BridgedMessage");
|
|
# populate fields
|
|
var bridgedProperties = msg.bridgeProperties();
|
|
var encvals=split(";", msg_notify);
|
|
|
|
for (var bpi = 0; bpi < size(encvals); bpi += 1) {
|
|
if (bpi < size(bridgedProperties)) {
|
|
var bp = bridgedProperties[bpi];
|
|
print("encval ",bpi,"=",encvals[bpi]);
|
|
if (encvals[bpi] != ";" and encvals[bpi] != "") {
|
|
var bp = bridgedProperties[bpi];
|
|
bp.setValue(encvals[bpi]);
|
|
}
|
|
#else
|
|
#print("EMPTY encoded ",bpi," empty");
|
|
} else
|
|
print("Error: emesary.IncomingBridge.ProcessIncoming: supplementary encoded value at",bpi);
|
|
}
|
|
if (bridged_notification.Ident == "none")
|
|
bridged_notification.Ident = "mp-bridge";
|
|
bridged_notification.FromIncomingBridge = 1;
|
|
bridged_notification.Callsign = me.Callsign;
|
|
me.Transmitter.NotifyAll(bridged_notification);
|
|
me.IncomingMessageIndex = msg_idx;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
foreach(var n; new_class.NotificationsToBridge)
|
|
{
|
|
print("IncomingBridge: ",n.Type);
|
|
}
|
|
return new_class;
|
|
},
|
|
startMPBridge : func(notification_list)
|
|
{
|
|
var incomingBridgeList = {};
|
|
setlistener("/ai/models/model-added", func(v)
|
|
{
|
|
#Model added /ai[0]/models[0]/multiplayer[0]
|
|
var path = v.getValue();
|
|
print("Model added ",path);
|
|
if (find("/multiplayer",path) > 0)
|
|
{
|
|
var callsign = getprop(path~"/callsign");
|
|
print("Creating Emesary MPBridge for ",callsign);
|
|
if (callsign == "" or callsign == nil)
|
|
callsign = path;
|
|
var incomingBridge = emesary_mp_bridge.IncomingMPBridge.new(callsign~"mp", notification_list, 19);
|
|
incomingBridge.Connect(path~"/");
|
|
incomingBridgeList[path] = incomingBridge;
|
|
}
|
|
});
|
|
|
|
setlistener("/ai/models/model-removed", func(v){
|
|
print("Model removed ",v.getValue());
|
|
var path = v.getValue();
|
|
var bridge = incomingBridgeList[path];
|
|
if (bridge != nil)
|
|
{
|
|
bridge.Remove();
|
|
incomingBridgeList[path]=nil;
|
|
}
|
|
});
|
|
},
|
|
};
|
|
#to setup bridges;
|
|
#io.load_nasal(getprop("/sim/fg-root") ~ "/Nasal/emesary_mp_bridge.nas");
|
|
#var outgoingBridge = emesary_mp_bridge.OutgoingMPBridge.new("F-15mp");
|
|
#outgoingBridge.AddMessage(an_spn_46.ANSPN46ActiveNotification.new("template"));
|
|
#incomingBridge = emesary_mp_bridge.IncomingMPBridge.new("F-15mp");
|
|
#incomingBridge.AddMessage(an_spn_46.ANSPN46ActiveNotification.new("template"));
|
|
#var outgoingBridge = emesary_mp_bridge.OutgoingMPBridge.new("F-15mp");
|
|
#outgoingBridge.AddMessage(an_spn_46.ANSPN46ActiveNotification.new("template"));
|
|
# var m = emesary.notifications.TacticalNotification("rr",2);
|
|
# emesary.GlobalTransmitter.NotifyAll(m);
|
|
#var outgoingBridge = emesary_mp_bridge.OutgoingMPBridge.new("F-15mp");
|
|
#outgoingBridge.AddMessage(notifications.TacticalNotification.new(nil));
|
|
# var m = emesary.notifications.TacticalNotification("rr",2);
|
|
# emesary.GlobalTransmitter.NotifyAll(m);
|