public void AstroQueueUpdateExposure(String jSon)
{
jSon = StringCompression.DecompressString(jSon);
JObject obj = JObject.Parse(jSon);
STATIONNAME stationName = TTCSHelper.StationStrConveter(obj["StationName"].ToString());
String Id = obj["Id"].ToString();
String AstroQueueId = obj["AstroQueueId"].ToString();
ExposedHistory exposedHistoryRecv = (ExposedHistory)JsonConvert.DeserializeObject(obj["ExposedHistory"].ToString(), typeof(ExposedHistory));
Console.WriteLine("[AstroQueueUpdateExposure] " + obj["StationName"] + " : " + exposedHistoryRecv.filterName + " --> " + Id);
AstroQueueImpl astroQueue = DBQueueEngine.FindById(stationName, AstroQueueId);
ExposedHistory exposedHistory = astroQueue.Target.exposedHistory.Find(Item => Item.filterName == exposedHistoryRecv.filterName && Item.executedStatus == EXECUTESTATUS.WAIT);
if (exposedHistory != null)
{
exposedHistory.executedStatus = exposedHistoryRecv.executedStatus;
exposedHistory.executedDate = exposedHistoryRecv.executedDate;
astroQueue.Save();
Task task = Task.Run(async() =>
{
await Task.Delay(100);
StationHandler StationCommunication = AstroData.GetStationObject(stationName);
StationCommunication.AckExposure(Id, SENDING_STATUS.COMPLETED);
});
}
}
//--------------------------------------------------------------------------------------Queue----------------------------------------------------------------------------------
public void AstroQueueUpdate(String jSon)
{
jSon = StringCompression.DecompressString(jSon);
JObject obj = JObject.Parse(jSon);
STATIONNAME stationName = TTCSHelper.StationStrConveter(obj["StationName"].ToString());
String Id = obj["Id"].ToString();
String Event = obj["Event"].ToString();
DateTime TimeStamp = DateTime.Parse(obj["TimeStamp"].ToString());
Console.WriteLine("[AstroQueueUpdate] " + obj["StationName"] + " : " + obj["Event"] + " --> " + Id);
AstroQueueImpl astroQueue = DBQueueEngine.FindById(stationName, Id);
if (Event == "RECEIVED")
{
QueueStatus queueStatus = new QueueStatus(QUEUE_STATUS.WAITINGSTATION, SENDING_STATUS.COMPLETED, TimeStamp);
astroQueue.QueueStatus.Add(queueStatus);
astroQueue.Save();
}
Task task = Task.Run(async() =>
{
await Task.Delay(100);
StationHandler StationCommunication = AstroData.GetStationObject(stationName);
StationCommunication.AckTarget(astroQueue, QUEUE_STATUS.WAITINGSTATION, SENDING_STATUS.COMPLETED);
});
}
public void ClearAsteroids()
{
if (PrefabUtility.GetPrefabInstanceStatus(this.gameObject) == PrefabInstanceStatus.NotAPrefab)
{
var tempList = transform.Cast <Transform>().ToList();
foreach (var child in tempList)
{
AstroData astroData = child.GetComponent <AstroData>();
if (astroData != null)
{
if (astroData.DoNotDelete == false)
{
DestroyImmediate(child.gameObject);
}
}
else
{
DestroyImmediate(child.gameObject);
}
}
tempList.Clear();
passCount = 0;
}
else
{
ShowDebugMessage("Unable to delete. Instance is part of a prefab. Unpack the prefab to edit.", true);
}
}
public void AddASTROSERVER(STATIONNAME StationName, DEVICENAME DeviceName, ASTROSERVER[] FieldName, Object[] Value, DateTime[] DateTime)
{
for (int i = 0; i < FieldName.Count(); i++)
{
AstroData.NewASTROSERVERInformation(StationName, DeviceName, FieldName[i], Value[i], DateTime[i]);
}
}
public ReturnKnowType AstroCreateStation(STATIONNAME StationName, Double Version = 0)
{
try
{
if (Version != RequirePackageVersion)
{
return(ReturnKnowType.DefineReturn(ReturnStatus.FAILED, "(#Co003) Failed to create " + StationName + ". Your client version is " + Version + " (Require version " + RequirePackageVersion + ")."));
}
else
{
OperationContext context = OperationContext.Current;
ServerCallBack SiteCallBack = OperationContext.Current.GetCallbackChannel <ServerCallBack>();
CallBackHandler.AddSiteConnection(StationName, context.SessionId, SiteCallBack);
OperationContext.Current.Channel.Closed += StationChannel_Closed;
OperationContext.Current.Channel.Faulted += StationChannel_Closed;
ReturnKnowType CreateSiteResult = AstroData.CreateStation(StationName, context.SessionId, SiteCallBack);
return(CreateSiteResult);
}
}
catch (Exception e)
{
return(ReturnKnowType.DefineReturn(ReturnStatus.FAILED, "(#Co001) Failed to create site at TTCSCreateSite see. (" + e.Message + ")"));
}
}
public void AddLANOUTLET(STATIONNAME StationName, DEVICENAME DeviceName, LANOUTLET[] FieldName, Object[] Value, DateTime[] DateTime)
{
for (int i = 0; i < FieldName.Count(); i++)
{
AstroData.NewLANOUTLETInformation(StationName, DeviceName, FieldName[i], Value[i], DateTime[i]);
}
}
private void GetOnlineStation()
{
ReturnKnowType ThisResult = AstroData.GetAllOnlineStation();
if (ThisResult.ReturnValue != null)
{
List <StationHandler> AllStation = (List <StationHandler>)ThisResult.ReturnValue;
List <String> OnlineStation = new List <string>();
foreach (StationHandler ThisStation in AllStation)
{
if (ThisStation.IsStationConnected)
{
OnlineStation.Add(ThisStation.StationName.ToString());
}
}
if (OnlineStation.Count > 0)
{
AstroData.NewASTROSERVERInformation(STATIONNAME.ASTROSERVER, DEVICENAME.ASTROPARK_SERVER, ASTROSERVER.ASTROSERVER_ALLONLINESTATION, String.Join(", ", OnlineStation), DateTime.UtcNow);
}
}
else
{
AstroData.NewASTROSERVERInformation(STATIONNAME.ASTROSERVER, DEVICENAME.ASTROPARK_SERVER, ASTROSERVER.ASTROSERVER_ONLINEDEVICES, "", DateTime.UtcNow);
}
}
public void AddWEATHERSTATION(STATIONNAME StationName, DEVICENAME DeviceName, WEATHERSTATION[] FieldName, Object[] Value, DateTime[] DateTime)
{
for (int i = 0; i < FieldName.Count(); i++)
{
AstroData.NewWEATHERSTATIONInformation(StationName, DeviceName, FieldName[i], Value[i], DateTime[i]);
}
}
//public Boolean DelayScheduleEvented(ScriptStructureNew[] Scripts)
//{
// foreach (ScriptStructureNew Script in Scripts)
// {
// DBScheduleEngine.UpdateSchedule(Script);
// }
// return true;
//}
public void GetNextScriptPart(STATIONNAME StationName)
{
String Output = "";
StationHandler ThisStation = AstroData.GetStationObject(StationName);
ThisStation.NextScriptInformation(out Output);
}
private void UpdateMeshesAndColliders(bool overrideColliders)
{
if ((currentShowMeshes != enableMeshes || currentShowColliders != enableColliders) || overrideColliders == true)
{
var tempList = transform.Cast <Transform>().ToList();
foreach (var child in tempList)
{
AstroData astroData = child.GetComponent <AstroData>();
if (astroData != null)
{
astroData.ShowMesh = enableMeshes;
if (overrideColliders == false)
{
astroData.ShowColliders = enableColliders;
}
else
{
astroData.ShowColliders = true;
}
}
}
tempList.Clear();
currentShowMeshes = enableMeshes;
if (overrideColliders == false)
{
currentShowColliders = enableColliders;
}
else
{
currentShowColliders = true;
}
}
}
public void EnforceMyBufferZone()
{
Collider[] hitColliders = Physics.OverlapSphere(transform.position, GetBufferZoneRadius());
if (hitColliders.Length > 0f)
{
for (int i = 0; i < hitColliders.Length; i++)
{
if (hitColliders[i].gameObject != gameObject)
{
AstroData otherAstroData = hitColliders[i].gameObject.GetComponent <AstroData>();
if (otherAstroData != null)
{
if (otherAstroData.DoNotDelete == false)
{
DestroyImmediate(hitColliders[i].gameObject);
}
}
else
{
DestroyImmediate(hitColliders[i].gameObject);
}
}
}
}
}
public static void SendScriptToStation(ScriptTB CompletedScript)
{
STATIONNAME DestinationStation = STATIONNAME.NULL;
List <ScriptTB> ScriptArr = ScriptDBBuffer.Values.Where(Item => Item.BlockID == CompletedScript.BlockID).ToList();
ScriptStructure[] StructureArr = ConvertScriptTBToScriptStructure(ScriptArr);
foreach (ScriptTB ThisScript in ScriptArr)
{
DestinationStation = TTCSHelper.StationStrConveter(ThisScript.StationName);
ThisScript.ScriptState = SCRIPTSTATE.WAITINGSERVER.ToString();
UpdateScriptToMonitoring(ThisScript);
}
StationHandler ThisStation = AstroData.GetStationObject(DestinationStation);
if (ThisStation.IsStationConnected)
{
StructureArr.OrderBy(Item => Item.ExecutionNumber);
AstroData.ScriptHandler(DestinationStation, StructureArr);
foreach (ScriptTB ThisScript in ScriptArr)
{
ThisScript.ScriptState = SCRIPTSTATE.SENDINGTOSTATION.ToString();
UpdateScriptToMonitoring(ThisScript);
}
}
}
public void SubscribeInformation(STATIONNAME StationName, DEVICENAME DeviceName, dynamic FieldName)
{
ServerCallBack ClientCallBack = OperationContext.Current.GetCallbackChannel <ServerCallBack>();
OperationContext Context = OperationContext.Current;
AstroData.SubscribeInformation(StationName, DeviceName, FieldName, Context.SessionId, ClientCallBack);
}
//------------------------------------------------------------------------------------Event Handler--------------------------------------------------------------------------------
private void InterfaceChannel_Closed(object sender, EventArgs e)
{
IContextChannel ThisContext = (IContextChannel)sender;
CallBackHandler.RemoveInterfaceConnection(ThisContext.SessionId);
AstroData.UnsubscribeBySessionID(ThisContext.SessionId);
}
public void AddGPS(String DataGroupID, STATIONNAME StationName, DEVICENAME DeviceName, GPS[] FieldName, Object[] Value, DateTime[] DateTime, Boolean IsHistory)
{
for (int i = 0; i < FieldName.Count(); i++)
{
AstroData.NewGPSInformation(DataGroupID, StationName, DeviceName, FieldName[i], Value[i], DateTime[i], IsHistory);
}
AstroData.ReturnAckState(DataGroupID, StationName, DeviceName);
}
private void CreateAstroStation()
{
ReturnKnowType ReturnResult = AstroData.CreateStation(STATIONNAME.ASTROSERVER, "ASTROSERVER", this);
if (ReturnResult.ReturnType == ReturnStatus.FAILED)
{
IsStopTTCSLoop = true;
}
}
public Boolean AddASTROCLIENT(STATIONNAME StationName, DEVICENAME DeviceName, ASTROCLIENT[] FieldName, Object[] Value, DateTime[] DateTime)
{
for (int i = 0; i < FieldName.Count(); i++)
{
AstroData.NewASTROCLIENTInformation(StationName, DeviceName, FieldName[i], Value[i], DateTime[i]);
}
return(true);
}
private void GetServerUpTime()
{
if (TTCSStartTime == null)
{
return;
}
TimeSpan Span = DateTime.UtcNow - TTCSStartTime.Value;
AstroData.NewASTROSERVERInformation(STATIONNAME.ASTROSERVER, DEVICENAME.ASTROPARK_SERVER, ASTROSERVER.ASTROSERVER_UPTIME_DATA, Span.ToString(@"dd\.hh\:mm\:ss"), DateTime.UtcNow);
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
AstroData ScriptHandler = (AstroData)target;
if (GUILayout.Button("Update This Buffer Zones"))
{
ScriptHandler.EnforceMyBufferZone();
}
}
public static void UserCheckerLoop()
{
Task UserTask = Task.Run(() =>
{
while (true)
{
TransectionBuffer ThisUser;
if (BufferList.TryPeek(out ThisUser))
{
List <String> StationArr = ThisUser.UserInformation.UserStationPermission.Split(new char[] { ',' }).ToList();
foreach (String StationNameStr in StationArr)
{
if (StationNameStr == "All Station")
{
StationArr.Add("AIRFORCE");
StationArr.Add("CHACHOENGSAO");
StationArr.Add("NAKHONRATCHASIMA");
StationArr.Add("CHINA");
StationArr.Add("USA");
//StationArr.Add("ASTROPARK");
break;
}
}
StationArr.Remove("All Station");
StationArr.Remove("NULL");
Boolean IsSend = true;
foreach (String StationName in StationArr)
{
ReturnKnowType ReturnResult = AstroData.UpdateStationUser(ThisUser.UserInformation.UserID, ThisUser.UserInformation.UserName, ThisUser.UserInformation.UserLoginName, ThisUser.UserInformation.UserLoginPassword,
ThisUser.UserInformation.UserPermissionType, ThisUser.UserInformation.UserStationPermission, StationName, ThisUser.UserAction);
if (ReturnResult.ReturnType != ReturnStatus.SUCESSFUL)
{
IsSend = false;
}
}
if (IsSend)
{
BufferList.TryDequeue(out ThisUser);
}
}
Thread.Sleep(1000);
}
});
}
private HttpResponseMessage GetByDeviceName(String StationName, String DeviceCategory, String SessionID)
{
XmlDocument myXml = new XmlDocument();
XPathNavigator xNav = myXml.CreateNavigator();
if (UserSessionHandler.VerifyTimeout(SessionID))
{
STATIONNAME ThisStation = HostingHelper.ConvertStationNameStrToSTATIONNAME(StationName);
DeviceCategory.Replace("WEATHER", "WEATHERSTATION");
var TempDeviceName = DeviceCategory.Split('_');
DEVICECATEGORY ThisDeviceCategory = HostingHelper.ConvertDevicecCategoryStrToDEVICECATEGORY(DeviceCategory);
if (TempDeviceName.Length > 1)
{
ThisDeviceCategory = HostingHelper.ConvertDevicecCategoryStrToDEVICECATEGORY(TempDeviceName[1]);
}
if (ThisStation == STATIONNAME.NULL)
{
return(HostingHelper.ReturnError("Invalid station name. Please check.", myXml, xNav));
}
if (ThisDeviceCategory == DEVICECATEGORY.NULL)
{
return(HostingHelper.ReturnError("Invalid device name. Please check.", myXml, xNav));
}
List <OUTPUTSTRUCT> InformationResult = AstroData.GetInformation(ThisStation, ThisDeviceCategory);
if (InformationResult != null)
{
JavaScriptSerializer Serializer = new JavaScriptSerializer();
Serializer.MaxJsonLength = Int32.MaxValue;
var json = Serializer.Serialize(InformationResult);
return(new HttpResponseMessage()
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
});
}
else
{
return(HostingHelper.ReturnError("An error occur while getting information", myXml, xNav));
}
}
else
{
return(HostingHelper.ReturnError("Session is timeout. Please login to the system.", myXml, xNav));
}
}
public void ReciveAcknowledge(STATIONNAME StationName, DEVICENAME DeviceName, String FieldName, Object[] Value, DateTime TimeRecive)
{
ACKNOWLEDGE ThisAcknowledge = new ACKNOWLEDGE();
ThisAcknowledge.StationName = StationName.ToString();
ThisAcknowledge.DeviceName = DeviceName.ToString();
ThisAcknowledge.FieldName = FieldName;
ThisAcknowledge.Value = String.Join(",", Value);
ThisAcknowledge.ReviceDateTime = TimeRecive.ToString();
var ReturningJson = new JavaScriptSerializer().Serialize(ThisAcknowledge);
AstroData.NewASTROCLIENTInformation(StationName, DeviceName, ASTROCLIENT.ASTROCLIENT_LASTESTEXECTIONCOMMAND, ReturningJson.ToString(), TimeRecive);
}
private void StationChannel_Closed(object sender, EventArgs e)
{
IContextChannel ThisContext = (IContextChannel)sender;
CallBackHandler.RemoveSiteConnection(ThisContext.SessionId);
if (AstroData.IsStationConnected(ThisContext.SessionId))
{
STATIONNAME ThisStation = AstroData.GetStationName(ThisContext.SessionId);
TTCSLog.NewLogInformation(ThisStation, DateTime.UtcNow, "Station name : " + ThisStation.ToString() + " is now disconnceted.", LogType.COMMUNICATION, null);
AstroData.SetStationDisconnected(ThisContext.SessionId);
AstroData.StationDisconnected(ThisStation);
}
}
private HttpResponseMessage GetByCommandName(String StationName, String DeviceName, String FieldName, String SessionID)
{
XmlDocument myXml = new XmlDocument();
XPathNavigator xNav = myXml.CreateNavigator();
if (UserSessionHandler.VerifyTimeout(SessionID))
{
STATIONNAME ThisStation = HostingHelper.ConvertStationNameStrToSTATIONNAME(StationName);
DEVICENAME ThisDevice = HostingHelper.ConvertDevicecNameStrToDEVICENAME(DeviceName);
dynamic ThisFieldName = HostingHelper.ConvertFieldNameStrToFIELDNAME(FieldName);
if (ThisStation == STATIONNAME.NULL)
{
return(HostingHelper.ReturnError("Invalid station name. Please check.", myXml, xNav));
}
if (ThisDevice == DEVICENAME.NULL)
{
return(HostingHelper.ReturnError("Invalid device name. Please check.", myXml, xNav));
}
if (ThisFieldName == null)
{
return(HostingHelper.ReturnError("Invalid field name. Please check.", myXml, xNav));
}
OUTPUTSTRUCT InformationResult = AstroData.GetInformation(ThisStation, ThisDevice, FieldName);
if (InformationResult != null)
{
JavaScriptSerializer Serializer = new JavaScriptSerializer();
Serializer.MaxJsonLength = Int32.MaxValue;
var json = Serializer.Serialize(InformationResult);
return(new HttpResponseMessage()
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
});
}
else
{
return(HostingHelper.ReturnError("An error occur while getting information", myXml, xNav));
}
}
else
{
return(HostingHelper.ReturnError("Session is timeout. Please login to the system.", myXml, xNav));
}
}
public static void SendScriptToStation(STATIONNAME ScriptStationName)
{
if (ScriptStationName != STATIONNAME.NULL)
{
String Message = null;
StationHandler StationCommunication = AstroData.GetStationObject(ScriptStationName);
StationScript StationScript = GetStationScript(ScriptStationName);
DBScheduleEngine.UpdateFailSchedule(ScriptStationName);
//DBScheduleEngine.DropSchedule(ScriptStationName);
Console.WriteLine("Preparing Station Script before sending.");
foreach (ScriptStructureNew Script in StationScript.ScriptCollection)
{
//if (Script.ScriptState != SCRIPTSTATE.CANCELED.ToString())
//{
// Script.ScriptState = SCRIPTSTATE.SENDINGTOSTATION.ToString();
// DBScheduleEngine.UpdateSchedule(Script);
//}
//else
//{
// Console.WriteLine("CANCEL");
//}
Script.ScriptState = SCRIPTSTATE.SENDINGTOSTATION.ToString();
DBScheduleEngine.UpdateSchedule(Script);
}
Console.WriteLine("Sending Script to " + ScriptStationName + " ...");
if (StationCommunication.NewScriptInformation(StationScript.GetScript(), out Message))
{
//DBScheduleEngine.DropSchedule(ScriptStationName);
/*
* foreach (ScriptStructureNew Script in StationScript.ScriptCollection)
* {
* Script.ScriptState = SCRIPTSTATE.WAITINGSTATION.ToString();
* DBScheduleEngine.UpdateSchedule(Script);
* }
*/
}
DisplayScriptMessage(Message);
}
}
private HttpResponseMessage Operation(String StationName, String DeviceName, String CommandName, String Value, String SessionID)
{
XmlDocument myXml = new XmlDocument();
XPathNavigator xNav = myXml.CreateNavigator();
if (UserSessionHandler.VerifyTimeout(SessionID))
{
STATIONNAME ThisStation = HostingHelper.ConvertStationNameStrToSTATIONNAME(StationName);
DEVICENAME ThisDeviceName = HostingHelper.ConvertDevicecNameStrToDEVICENAME(DeviceName);
DEVICECATEGORY ThisDeviceCategory = HostingHelper.ConvertDeviceNameToDeviceCategory(ThisStation, ThisDeviceName);
if (ThisStation == STATIONNAME.NULL)
{
return(HostingHelper.ReturnError("Invalid station name. Please check.", myXml, xNav));
}
if (ThisDeviceName == DEVICENAME.NULL)
{
return(HostingHelper.ReturnError("Invalid device name. Please check.", myXml, xNav));
}
ReturnKnowType VerificationResult = CommandDefinition.VerifyCommand(ThisStation, ThisDeviceCategory, CommandName, HostingHelper.SplitValue(Value));
if (VerificationResult.ReturnType == ReturnStatus.SUCESSFUL)
{
dynamic ThisCommandName = CommandDefinition.GetCommandNameENUM(CommandName);
XmlSerializer xmlSerializer2 = new XmlSerializer(typeof(ReturnMessage));
ReturnKnowType CommandResult = AstroData.SetCommandHandler(ThisStation, ThisDeviceCategory, ThisDeviceName, ThisCommandName.Value, CommandDefinition.ValueConvertion(HostingHelper.SplitValue(Value)), DateTime.UtcNow);
XmlSerializer xmlSerializer3 = new XmlSerializer(typeof(ReturnKnowType));
using (var xs = xNav.AppendChild()) { xmlSerializer3.Serialize(xs, CommandResult); }
return(new HttpResponseMessage()
{
Content = new StringContent(myXml.OuterXml, Encoding.UTF8, "text/xml")
});
}
return(HostingHelper.ReturnError(VerificationResult.ReturnMessage, myXml, xNav));
}
else
{
return(HostingHelper.ReturnError("Session is timeout. Please login to the system.", myXml, xNav));
}
}
private void InitializeServer()
{
AstroData.CreateTTCSData(this);
TCPService = new ServiceHost(typeof(TTCSConnection.Connection));
TCPService.Open();
InitializeStation();
AstroServerHandler AstroHandler = new AstroServerHandler();
AstroHandler.StartAstroServer();
DatabaseSynchronization.SetDBConnection(Properties.Settings.Default.DatabaseName, Properties.Settings.Default.DatabaseUserName, Properties.Settings.Default.DatabasePassword, Properties.Settings.Default.DatabaseServerName);
FITSHandler.CreateMaximObject();
ScriptManager.CreateScriptPool();
ScriptEngine.NewScriptChecker("192.168.2.110", "astronet", "P@ssw0rd");
}
private void GetMissingData()
{
ReturnKnowType ThisResult = AstroData.GetAllOnlineStation();
if (ThisResult.ReturnValue != null)
{
List <StationHandler> AllStation = (List <StationHandler>)ThisResult.ReturnValue;
foreach (StationHandler ThisStation in AllStation)
{
if (ThisStation.IsStationConnected && ThisStation.StationName != STATIONNAME.ASTROSERVER)
{
StationHandler StationCommunication = AstroData.GetStationObject(ThisStation.StationName);
StationCommunication.CheckLastesInformation(DateTime.UtcNow.Ticks);
}
}
}
}
public void AddRemoveAstroDataScripts(bool removeScripts)
{
var tempList = transform.Cast <Transform>().ToList();
if (PrefabUtility.GetPrefabInstanceStatus(this.gameObject) == PrefabInstanceStatus.Connected)
{
PrefabUtility.UnpackPrefabInstance(this.gameObject, PrefabUnpackMode.Completely, InteractionMode.AutomatedAction);
}
foreach (var child in tempList)
{
AstroData astroData = child.GetComponent <AstroData>();
if (removeScripts == true)
{
if (astroData != null)
{
GameObject targetObject = astroData.gameObject;
if (PrefabUtility.GetPrefabInstanceStatus(targetObject) == PrefabInstanceStatus.Connected)
{
PrefabUtility.UnpackPrefabInstance(targetObject, PrefabUnpackMode.Completely, InteractionMode.AutomatedAction);
}
if (PrefabUtility.IsPartOfAnyPrefab(targetObject) == false)
{
DestroyImmediate(astroData);
}
}
}
else
{
if (astroData == null)
{
GameObject targetObject = child.gameObject;
if (PrefabUtility.GetPrefabInstanceStatus(targetObject) == PrefabInstanceStatus.Connected)
{
PrefabUtility.UnpackPrefabInstance(targetObject, PrefabUnpackMode.Completely, InteractionMode.AutomatedAction);
}
if (PrefabUtility.IsPartOfAnyPrefab(targetObject) == false)
{
targetObject.AddComponent <AstroData>();
}
}
}
}
tempList.Clear();
}
public void EnforceBufferZones()
{
UpdateMeshesAndColliders(true);
var tempList = transform.Cast <Transform>().ToList();
foreach (var child in tempList)
{
if (child != null)
{
AstroData astroData = child.GetComponent <AstroData>();
if (astroData != null)
{
astroData.EnforceMyBufferZone();
}
}
}
tempList.Clear();
}
