private void SignalStrengthHandler(SignalReceiver receiver, SignalEmitter emitter, SignalDataSO signalDataSo, ISignalMessage signalMessage = null)
{
SignalStrength strength = GetStrength(receiver, emitter, signalDataSo.SignalRange);
if (strength == SignalStrength.HEALTHY)
{
receiver.ReceiveSignal(strength, signalMessage);
}
if (strength == SignalStrength.TOOFAR)
{
emitter.SignalFailed();
}
if (strength == SignalStrength.DELAYED)
{
StartCoroutine(DelayedSignalRecevie(receiver.DelayTime, receiver, strength, signalMessage));
return;
}
if (strength == SignalStrength.WEAK)
{
Random chance = new Random();
if (DMMath.Prob(chance.Next(0, 100)))
{
StartCoroutine(DelayedSignalRecevie(receiver.DelayTime, receiver, strength, signalMessage));
}
emitter.SignalFailed();
}
}
IEnumerator WaitForProvider()
{
while (Provider == null)
{
yield return(WaitFor.EndOfFrame);
}
emittingDevice = Provider.GetComponent <SignalEmitter>();
frequencySlider.minValue = emittingDevice.SignalData.MinMaxFrequancy.x;
frequencySlider.maxValue = emittingDevice.SignalData.MinMaxFrequancy.y;
UpdateFrequencyFromProvider();
if (emittingDevice.RequiresPower == false)
{
radioPowerToggle.SetActive(false);
}
radioPowerToggle.isOn = emittingDevice.IsPowered;
if (Provider.TryGetComponent <StationBouncedRadio>(out var radio))
{
stationBoundRadio = radio;
broadcastModeToggle.isOn = radio.BroadcastToNearbyTiles;
broadcastModeToggle.SetActive(true);
yield break;
}
broadcastModeToggle.SetActive(false);
}
static void ExportCSV()
{
if (m_timelineAsset == null || m_jsonAsset == null)
{
if (m_jsonAsset == null)
{
DisplayJsonFileDialog();
}
else
{
DisplayTimelineAsseteDialog();
}
return;
}
// we have to merge the lua function name.
SingleSignalData json = SingleSignalData.CreateFromJSON(m_jsonAsset.text);
UpdateTrackAsset();
Dictionary <string, float> signals = new Dictionary <string, float>();
foreach (var m in m_trackAsset.GetMarkers())
{
SignalEmitter se = m as SignalEmitter;
if (string.IsNullOrEmpty(se.name) || se.name == "Signal Emitter")
{
EditorUtility.DisplayDialog("Name is empty", "You need to set up name as same as the SignalID.", "OK");
return;
}
signals.Add(se.name, (float)se.time);
}
IOrderedEnumerable <KeyValuePair <string, float> > sorted = signals.OrderBy(pair => pair.Value);
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("Signal Enum,time,function names\n");
foreach (KeyValuePair <string, float> pair in sorted)
{
string funcName = "";
if (json.signalList.ContainsKey(pair.Key))
{
funcName = json.signalList[pair.Key].functionName;
}
//Debug.LogFormat("{0} {1}", pair.Key, pair.Value);
stringBuilder.Append(pair.Key + "," + pair.Value + "," + funcName + "\n");
}
EditorUtils.WriteTextFile(CSV_FILEPATH, stringBuilder.ToString());
}
void OnEnable()
{
Undo.undoRedoPerformed += OnUndoRedo; // subscribe to the event
m_Signal = target as SignalEmitter;
m_RetroactiveProperty = serializedObject.FindProperty("m_Retroactive");
m_EmitOnceProperty = serializedObject.FindProperty("m_EmitOnce");
// In a vast majority of the cases, when this becomes enabled,
// the timeline window will be focused on the correct timeline
// in which case TimelineEditor.inspectedDirector is safe to use
m_AssociatedDirector = TimelineEditor.inspectedDirector;
UpdateState();
}
public override MarkerDrawOptions GetMarkerOptions(IMarker marker)
{
var options = base.GetMarkerOptions(marker);
SignalEmitter emitter = (SignalEmitter)marker;
if (emitter.asset != null)
{
options.tooltip = emitter.asset.name;
}
else
{
options.errorText = MissingAssetError;
}
return(options);
}
public void SendSignal(SignalEmitter emitter, SignalType type, SignalDataSO signalDataSo, ISignalMessage signalMessage = null)
{
Receivers.Remove(null);
foreach (SignalReceiver receiver in Receivers)
{
if (receiver.SignalTypeToReceive != type)
{
continue;
}
if (receiver.Frequency.IsBetween(signalDataSo.MinMaxFrequancy.x, signalDataSo.MinMaxFrequancy.y) == false)
{
continue;
}
if (receiver.ListenToEncryptedData == false && MatchingEncryption(receiver, emitter) == false)
{
continue;
}
if (receiver.SignalTypeToReceive == SignalType.PING && receiver.Emitter == emitter)
{
if (signalDataSo.UsesRange)
{
SignalStrengthHandler(receiver, emitter, signalDataSo); break;
}
receiver.ReceiveSignal(SignalStrength.HEALTHY, signalMessage);
break;
}
//TODO (Max) : Radio signals should be sent to relays and servers.
if (receiver.SignalTypeToReceive == SignalType.RADIO && AreOnTheSameFrequancy(receiver, emitter))
{
if (signalDataSo.UsesRange)
{
SignalStrengthHandler(receiver, emitter, signalDataSo, signalMessage); continue;
}
receiver.ReceiveSignal(SignalStrength.HEALTHY, signalMessage);
continue;
}
//Bounced radios always have a limited range.
if (receiver.SignalTypeToReceive == SignalType.BOUNCED && AreOnTheSameFrequancy(receiver, emitter))
{
SignalStrengthHandler(receiver, emitter, signalDataSo, signalMessage);
}
}
}
private bool MatchingEncryption(SignalReceiver receiver, SignalEmitter emitter)
{
if (receiver.EncryptionData == null)
{
return(true);
}
if (emitter.EncryptionData == null)
{
return(false);
}
if (emitter.EncryptionData.EncryptionSecret != receiver.EncryptionData.EncryptionSecret)
{
return(false);
}
return(true);
}
/// <summary>
/// gets the signal strength between a receiver and an emitter
/// the further the object is the weaker the signal.
/// </summary>
/// <returns>SignalStrength</returns>
public SignalStrength GetStrength(SignalReceiver receiver, SignalEmitter emitter, int range)
{
int distance = (int)Vector3.Distance(receiver.gameObject.AssumedWorldPosServer(), emitter.gameObject.AssumedWorldPosServer());
if (range / 4 <= distance)
{
return(SignalStrength.DELAYED);
}
if (range / 2 <= distance)
{
return(SignalStrength.WEAK);
}
if (distance > range)
{
return(SignalStrength.TOOFAR);
}
return(SignalStrength.HEALTHY);
}
public void SendSignal(SignalEmitter emitter, SignalType type, SignalDataSO signalDataSo)
{
foreach (SignalReceiver receiver in Receivers)
{
if (receiver.SignalTypeToReceive != type)
{
return;
}
if (receiver.Frequency.IsBetween(signalDataSo.MinMaxFrequancy.x, signalDataSo.MinMaxFrequancy.y) == false)
{
return;
}
if (receiver.SignalTypeToReceive == SignalType.PING && receiver.Emitter == emitter)
{
if (signalDataSo.UsesRange)
{
SignalStrengthHandler(receiver, emitter, signalDataSo); break;
}
receiver.ReceiveSignal(SignalStrength.HEALTHY);
break;
}
//TODO (Max) : Radio signals should be sent to relays and servers.
if (receiver.SignalTypeToReceive == SignalType.RADIO && AreOnTheSameFrequancy(receiver, emitter))
{
if (signalDataSo.UsesRange)
{
SignalStrengthHandler(receiver, emitter, signalDataSo); continue;
}
receiver.ReceiveSignal(SignalStrength.HEALTHY);
continue;
}
//Bounced radios always have a limited range.
if (receiver.SignalTypeToReceive == SignalType.BOUNCED && AreOnTheSameFrequancy(receiver, emitter))
{
SignalStrengthHandler(receiver, emitter, signalDataSo);
}
}
}
static void LoadSignalAssetsToTimeline()
{
if (m_timelineAsset == null)
{
return;
}
UpdateTrackAsset();
foreach (var m in m_trackAsset.GetMarkers())
{
m_trackAsset.DeleteMarker(m);
}
List <ScriptableObject> list = new List <ScriptableObject>();
string path = EditorUtils.DisplayFolderPanel("Load signals");
if (path == "")
{
return;
}
EditorUtils.GetUnityObjectsOfTypeFromPath(path, list);
Debug.Log(list.Count);
TextAsset jsonTxt = EditorUtils.GetJson(path);
SingleSignalData json = SingleSignalData.CreateFromJSON(jsonTxt.text);
Debug.Log(json.signalList.Count);
for (int i = 0; i < list.Count; i++)
{
SignalAsset signal = list[i] as SignalAsset;
SignalData data = json.signalList[signal.name];
//Debug.Log(data.time);
SignalEmitter emitter = m_trackAsset.CreateMarker <SignalEmitter>(data.time);
emitter.name = signal.name;
emitter.asset = signal;
}
}
// Use this for initialization
public override void Awake()
{
if (alreadyAwaked)
{
return;
}
base.Awake();
CircleCollider2D planetCollider = GetComponent <CircleCollider2D>();
if (planetCollider)
{
GetComponent <CircleCollider2D>().radius = GetRadius;
}
if (gravitationalField == null)
{
GetComponentInChildren <CircleCollider2D>();
}
if (gravitationalField != null)
{
gravFieldRadius = gravitationalField.radius;
}
if (signal == null)
{
signal = GetComponent <SignalEmitter>();
}
if (autoDestroyComponent == null)
{
autoDestroyComponent = GetComponent <AutoDestroy>();
}
}
private bool AreOnTheSameFrequancy(SignalReceiver receiver, SignalEmitter emitter)
{
return(Mathf.Approximately(receiver.Frequency, emitter.Frequency));
}
public override void Respond(SignalEmitter signalEmitter)
{
Chat.AddLocalMsgToChat("Signal received!", signalEmitter.gameObject);
}