void Start()
{
sceneManager = FindObjectOfType<SceneManager>();
serialData = FindObjectOfType<SerialData>();
segment = GetComponentInParent<Segment>();
thisCollider = GetComponent<Collider>();
}
public void WaitForEvent(SerialData eventType, int numEvents, int timeout)
{
lock (this)
{
if (EventExists(eventType, numEvents))
{
return;
}
Stopwatch sw = new Stopwatch();
sw.Start();
do
{
System.Threading.Monitor.Wait(this, (int)(timeout - sw.ElapsedMilliseconds));
if (EventExists(eventType, numEvents))
{
return;
}
} while (sw.ElapsedMilliseconds < timeout);
sw.Stop();
}
Fail("Event wait timeout ({0})", eventType);
}
public static void Main()
{
string filePath = System.IO.Directory.GetCurrentDirectory();
//Stream stream = File.Open(filePath + "\\aa.xlsx", FileMode.Open,FileAccess.Read);
Stream stream = new FileStream("aa.xlsx", FileMode.Open);
List <string>[] list = new List <string> [4];
using (var reader = ExcelReaderFactory.CreateReader(stream))
{
var data = reader.AsDataSet();
var rowSize = data.Tables[0].Rows.Count;
var colSize = data.Tables[0].Columns.Count;
for (int r = 0; r < rowSize; r++)
{
list[r] = new List <string>();
for (int c = 0; c < colSize; c++)
{
var a = data.Tables[0].Rows;
string str = data.Tables[0].Rows[r][c].ToString();
list[r].Add(str);
Console.Write($"{str} ");
}
Console.WriteLine();
}
}
stream.Close();
// <<<<<< 직렬화
SerialData[] serialDatas = new SerialData[3];
for (int i = 0; i < 3; i++)
{
serialDatas[i].Name = list[i + 1][0];
serialDatas[i].Cost = int.Parse(list[i + 1][1]);
serialDatas[i].Option = list[i + 1][2];
Console.WriteLine($"{serialDatas[i].Name} {serialDatas[i].Cost} {serialDatas[i].Option}");
}
Stream writestream = new FileStream("a.dat", FileMode.Create);
BinaryFormatter serializer = new BinaryFormatter();
serializer.Serialize(writestream, serialDatas);
writestream.Close();
Stream readstream = new FileStream("a.dat", FileMode.Open);
BinaryFormatter deserializer = new BinaryFormatter();
SerialData[] serialDatas1;
serialDatas1 = (SerialData[])deserializer.Deserialize(readstream);
readstream.Close();
Console.WriteLine("*****직렬화된 파일 불러오기*****");
//Console.WriteLine($"{serialDatas1.Name}");
foreach (var item in serialDatas1)
{
Console.WriteLine($"{item.Name} {item.Cost} {item.Option}");
}
}
protected virtual SerialData OnSerialize(string type, hSerializedTransform serializedTransform)
{
SerialData serialData = new SerialData();
serialData.type = type;
serialData.serializedTransform = serializedTransform;
return(serialData);
}
public void Close()
{
if (DBContext.DoSync)
{
SerialData serial = new SerialData(true);
serial.Save();
}
base.Dispose();
}
void Start()
{
serialData = FindObjectOfType<SerialData>();
if (!decisionSegment) {
startSegment = transform.FindChild ("BeginSegment").GetComponent<SegmentZone> ();
middleSegment = transform.FindChild ("MiddleSegment").GetComponent<SegmentZone> ();
endSegment = transform.FindChild ("EndSegment").GetComponent<SegmentZone> ();
}
}
public void OnLoad(object generic)
{
if (generic == null)
{
return;
}
SerialData stats = (SerialData)generic;
this.RequireInit();
for (int i = 0; i < stats.stats.Length; ++i)
{
string key = stats.stats[i].statUniqueID;
float baseValue = stats.stats[i].baseValue;
this.runtimeStatsData[key].baseValue = baseValue;
if (this.onChangeStat != null)
{
this.onChangeStat.Invoke(new EventArgs(key, EventArgs.Operation.Change));
}
}
for (int i = 0; i < stats.attrs.Length; ++i)
{
string key = stats.attrs[i].statUniqueID;
float value = stats.attrs[i].value;
this.runtimeAttrsData[key].value = value;
if (this.onChangeAttr != null)
{
this.onChangeAttr.Invoke(new EventArgs(key, EventArgs.Operation.Change));
}
}
for (int i = 0; i < stats.stefs.Length; ++i)
{
string key = stats.stefs[i].stefUniqueID;
float[] timeStack = stats.stefs[i].durationStack;
for (int j = 0; j < timeStack.Length; ++j)
{
timeStack[j] = Time.time - timeStack[j];
}
RuntimeStefData stefData = new RuntimeStefData(key, timeStack);
this.runtimeStefsData.Add(key, stefData);
if (this.onChangeStef != null)
{
this.onChangeStef.Invoke(new EventArgs(key, EventArgs.Operation.Change));
}
for (int j = 0; j < timeStack.Length; ++j)
{
stefData.listStatus[j].OnStart(gameObject);
}
}
}
protected override hLevelObject.SerialData OnSerialize(string type, hSerializedTransform serializedTransform)
{
OnAwake();
SerialData serialData = new SerialData();
serialData.type = type;
serialData.serializedTransform = serializedTransform;
serialData.keyType = (int)_keyType;
return(serialData);
}
private void nextClick(object sender, RoutedEventArgs e)
{
wizIndex++;
Properties.Settings.Default.AuTe = true;
switch (wizIndex)
{
case 1:
w1.FadeIn();
break;
case 2:
w1.FadeOut();
w3.FadeIn();
//w2.FadeIn();
break;
case 3:
w3.FadeOut();
w4.FadeIn();
break;
case 4:
using (var db = new SQLiteConnection(Tables.DBPath))
{
if (db.Table <Library.TableModels.Fx>().Count() == 0)
{
var fx = SerialData.BinaryDeSerializeObject <List <Library.TableModels.Fx> >(
System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\resources\\fxSuite.bin");
foreach (var v in fx)
{
try
{
db.Insert(v);
}
catch (Exception)
{
}
}
}
}
if (!Settings.Default.AuTe)
{
Application.Current.Shutdown();
}
Close();
break;
}
txtIndex.Text = wizIndex.ToString() + "/3";
}
private void serialDataReceivedEventHandler(object sender, SerialDataReceivedEventArgs e)
{
SerialPort sData = sender as SerialPort;
string recvData = sData.ReadLine();
this.Dispatcher.Invoke(() =>
{
SerialData.AppendText(recvData);
SerialData.ScrollToEnd();
});
}
/// <summary>
/// Event raised when data is received from the <see cref="Serial"/> object.
/// </summary>
/// <param name="sender">The <see cref="Serial"/> object that raised the event</param>
/// <param name="data">A <see cref="SerialData"/> object that contains the data received.</param>
protected virtual void OnDataReceivedEvent(Serial sender, SerialData data)
{
if (this.onDataReceived == null)
{
this.onDataReceived = new DataReceivedEventHandler(this.OnDataReceivedEvent);
}
if (Program.CheckAndInvoke(this.DataReceived, this.onDataReceived, sender, data))
{
this.DataReceived(sender, data);
}
}
public SerialData Export()
{
var rs = new SerialData();
rs.IC = IC.Export();
using (var ms = new MemoryStream())
{
new BinaryFormatter().Serialize(ms, CS);
rs.CS = ms.ToArray();
}
return(rs);
}
protected override hLevelObject.SerialData OnSerialize(string type, hSerializedTransform serializedTransform)
{
SerialData serialData = new SerialData();
serialData.type = type;
serialData.serializedTransform = serializedTransform;
serialData.id = _id;
serialData.nextPortalId = (_nextPortal != null) ? _nextPortal._id : -1;
serialData.matId = System.Array.FindIndex(_materials, (mat) => _meshRenderer.sharedMaterial == mat);
return(serialData);
}
/// <summary>
/// Factory method that creates an instance of <see cref="SerialDataReceivedEventArgs" />. This
/// class has no public constructor so must be created using Reflection.
/// </summary>
/// <param name="eventType">Type of the event.</param>
/// <returns>A constructed instance of <see cref="SerialDataReceivedEventArgs" />.</returns>
public static SerialDataReceivedEventArgs CreateSerialDataReceivedEventArgs(SerialData eventType)
{
ConstructorInfo constructor =
typeof(SerialDataReceivedEventArgs).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance,
null,
new[] { typeof(SerialData) },
null);
SerialDataReceivedEventArgs eventArgs =
(SerialDataReceivedEventArgs)constructor.Invoke(new object[] { eventType });
return(eventArgs);
}
public bool EventExists(SerialData eventType, int numEvents)
{
int numOccurences = 0;
for (int i = 0; i < NumEventsHandled; i++)
{
if (eventType == _eventType[i])
{
numOccurences++;
}
}
return(numOccurences >= numEvents);
}
/// <summary>
/// Handles internal events and re-dispatches them to the publicly subscribed delegates.
/// </summary>
/// <param name="eventType">The <see cref="SerialData"/> event type.</param>
internal void OnSerialDataReceivedInternal(SerialData eventType)
{
SerialDataReceivedEventHandler callbacks = null;
lock (_syncLock)
{
if (!_disposed)
{
callbacks = _callbacksDataReceivedEvent;
}
}
callbacks?.Invoke(this, new SerialDataReceivedEventArgs(eventType));
}
protected override void Port_DataReceivedInternal(SerialData EventType, string input)
{
if (EventType == SerialData.Chars && input != null && input.StartsWith("ce"))
{
var data = input.Substring(2).Trim();
if (!string.IsNullOrEmpty(data))
{
if (!int.TryParse(data, System.Globalization.NumberStyles.Number, null, out var frequency))
{
this.AddData(frequency);
}
}
}
}
protected override void Port_DataReceivedInternal(SerialData EventType, string input)
{
if (EventType == SerialData.Chars && !string.IsNullOrEmpty(input))
{
int p = input.IndexOf(this.EndOfLineChar);
if (p > 0)
{
input = input.Substring(0, p);
}
if (double.TryParse(input.Trim(), out var data))
{
this.AddData(data);
}
}
}
protected override hLevelObject.SerialData OnSerialize(string type, hSerializedTransform serializedTransform)
{
SerialData serialData = new SerialData();
serialData.type = type;
serialData.serializedTransform = serializedTransform;
float[] rot = new float[] {
_rollComponent.center.transform.localEulerAngles.x,
_rollComponent.center.transform.localEulerAngles.y,
_rollComponent.center.transform.localEulerAngles.z
};
serialData.rot = rot;
serialData.speed = _rollComponent.moveSpeed;
return(serialData);
}
protected override hLevelObject.SerialData OnSerialize(string type, hSerializedTransform serializedTransform)
{
SerialData serialData = new SerialData();
serialData.type = type;
serialData.serializedTransform = serializedTransform;
serialData.wayPoints = new int[_wayPoints.Length];
for (int i = 0; i < _wayPoints.Length; ++i)
{
serialData.wayPoints[i] = _wayPoints[i].id;
}
serialData.isLoop = _isLoop;
serialData.speed = _speed;
return(serialData);
}
public RCS(SerialData rcs)
{
IC = new InconsistencyCoverage(rcs.IC);
if (rcs.CS == null)
{
CS = new EntityChangeSet();
}
else
{
using (var ms = new MemoryStream(rcs.CS))
{
CS = (EntityChangeSet) new BinaryFormatter().Deserialize(ms);
}
}
}
protected override void Port_DataReceivedInternal(SerialData EventType, string input)
{
if (EventType == SerialData.Chars && input != null && input.StartsWith("="))
{
//=+000.01@
var data = input.Substring(1, 7).Trim();
if (!string.IsNullOrEmpty(data))
{
if (!double.TryParse(data, System.Globalization.NumberStyles.Number, null, out var weight))
{
this.AddData(weight);
}
}
}
}
private void CommOverlappedIo_CommEvent(object sender, CommEventArgs e)
{
SerialData dataFlags = (SerialData)(e.EventType & c_DataFlags);
if (dataFlags != 0)
{
OnDataReceived(this, new SerialDataReceivedEventArgs(dataFlags));
}
SerialPinChange pinFlags = (SerialPinChange)(e.EventType & c_PinFlags);
if (pinFlags != 0)
{
OnPinChanged(this, new SerialPinChangedEventArgs(pinFlags));
}
}
private void OnSerialize(bool saving, TankPreset.BlockSpec spec)
{
if (saving)
{
var serialData = new ContainerData
{
SavedTech = _savedTech,
};
serialData.Store(spec.saveState);
}
else
{
var data = SerialData <ContainerData> .Retrieve(spec.saveState);
_savedTech = data.SavedTech;
}
}
protected override hLevelObject.SerialData OnSerialize(string type, hSerializedTransform serializedTransform)
{
SerialData serialData = new SerialData();
serialData.type = type;
serialData.serializedTransform = serializedTransform;
serialData.id = id;
if (GetComponent <Collider>() == null)
{
serialData.isCollider = false;
}
else
{
serialData.isCollider = true;
}
return(serialData);
}
/// <summary>
/// 串口接收数据处理
/// </summary>
/// <param name="sender">串口助手类对象</param>
/// <param name="arrData">接收数据数组</param>
private void SerialPortDataReceivedProcess(object sender, byte[] arrData)
{
this.Invoke(new Action(() =>
{
if (SerialData.IsBytesToString(arrData))
{
Console.WriteLine("接收数据：" + SerialData.ToHexString(arrData));
Console.WriteLine("接收数据：" + SerialData.ToString(arrData));
txtDataReceived.AppendText(SerialData.ToString(arrData) + "\r\n");
}
else
{
Console.WriteLine("接收数据：" + SerialData.ToHexString(arrData));
txtDataReceived.AppendText(SerialData.ToHexString(arrData) + "\r\n");
}
}));
}
public int NumberOfOccurrencesOfType(SerialData eventType)
{
int numOccurrences = 0;
lock (this)
{
for (int i = 0; i < EventType.Count; i++)
{
if (eventType == (SerialData)EventType[i])
{
numOccurrences++;
}
}
}
return(numOccurrences);
}
/// <summary>
/// 串口接收数据处理
/// </summary>
/// <param name="arrData">接收数据数组</param>
private void SerialPortDataReceivedProcess(byte[] arrData)
{
this.Invoke(new Action(() =>
{
if (chkShowWrite.Checked)
{
txtDataReceived.AppendText("[接收]");
}
if (chkShowTime.Checked)
{
txtDataReceived.AppendText("[" + DateTime.Now.ToString() + "] ");
}
if (!SerialData.IsBytesToString(arrData))
{
Console.WriteLine("接收数据：" + SerialData.ToHexString(arrData));
txtDataReceived.AppendText(SerialData.ToHexString(arrData) + "\r\n");
try
{
deviceTest.BytesReceviedDataProcess(arrData);
bleLinkTest.SerialData(arrData);
OutputBleLog("连接蓝牙成功");
}
catch (Exception)
{
}
}
else
{
string strData = SerialData.ToString(arrData);
if (chkLogHex.Checked)
{
txtDataReceived.AppendText(SerialData.ToHexString(arrData) + "\r\n");
}
else
{
txtDataReceived.AppendText(strData + "\r\n");
}
Console.WriteLine("接收数据：" + strData);
if (strData.IndexOf("OK") >= 0)
{
serialBle.ReceiveSerialBle(strData);
}
}
}));
}
public SerialData Serialize()
{
hWayPoint.totalNum = 0;
hPortal.totalNum = 0;
SerialData serialData = new SerialData();
serialData.levelNum = _levelNum;
serialData.difficulty = (int)_difficulty;
_levelObjects = GetComponentsInChildren <hLevelObject>();
serialData.levelObjects = new hLevelObject.SerialData[_levelObjects.Length];
for (int i = 0, j = 0; i < _levelObjects.Length; ++i, ++j)
{
serialData.levelObjects[j] = _levelObjects[i].Serialize();
}
return(serialData);
}
public SerializedFestiSpecContext()
{
Data = SerialData.Load();
Attachments = new OfflineDbSet <Attachment>(Data.Attachments.ToList());
ContactPeople = new OfflineDbSet <ContactPerson>(Data.ContactPeople.ToList());
CustomerCompanies = new OfflineDbSet <CustomerCompany>(Data.CustomerCompanies.ToList());
Employees = new OfflineDbSet <Employee>(Data.Employees.ToList());
EmployeeAccounts = new OfflineDbSet <EmployeeAccount>(Data.EmployeeAccounts.ToList());
Festivals = new OfflineDbSet <Festival>(Data.Festivals.ToList());
Inspections = new OfflineDbSet <Inspection>(Data.Inspections.ToList());
PermissionNodes = new OfflineDbSet <PermissionNode>(Data.PermissionNodes.ToList());
Questions = new OfflineDbSet <Question>(Data.Questions.ToList());
Answers = new OfflineDbSet <Answer>(Data.Answers.ToList());
QuestionTypes = new OfflineDbSet <QuestionType>(Data.QuestionTypes.ToList());
Roles = new OfflineDbSet <Role>(Data.Roles.ToList());
QuestionLists = new OfflineDbSet <QuestionList>(Data.QuestionLists.ToList());
EmployeeAbsenceDates = new OfflineDbSet <EmployeeAbsence>(Data.EmployeeAbsenceDates.ToList());
}
/// <summary>
/// 发送按钮
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnSerialWrite_Click(object sender, EventArgs e)
{
if (txtSerialWrite.Text.Length > 0)
{
if (rioHex.Checked)
{
AddSerialWrite(SerialData.ToHexByteArray(txtSerialWrite.Text));
}
else if (rioString.Checked)
{
AddSerialWrite(txtSerialWrite.Text);
}
else
{
MessageBox.Show("未知错误，无法选择发送格式！");
}
}
}
public object GetSaveData()
{
SerialData stats = new SerialData();
if (this.runtimeStatsData == null)
{
return(stats);
}
stats.stats = new SerialStat[this.runtimeStatsData.Count];
stats.attrs = new SerialAttr[this.runtimeAttrsData.Count];
stats.stefs = new SerialStef[this.runtimeStefsData.Count];
int index = 0;
foreach (KeyValuePair <string, RuntimeStatData> item in this.runtimeStatsData)
{
stats.stats[index] = new SerialStat(item.Key, item.Value.baseValue);
index++;
}
index = 0;
foreach (KeyValuePair <string, RuntimeAttrData> item in this.runtimeAttrsData)
{
stats.attrs[index] = new SerialAttr(item.Key, item.Value.value);
index++;
}
index = 0;
foreach (KeyValuePair <string, RuntimeStefData> item in this.runtimeStefsData)
{
float[] durations = new float[item.Value.listStatus.Count];
for (int i = 0; i < durations.Length; ++i)
{
durations[i] = Time.time - item.Value.listStatus[i].time;
}
stats.stefs[index] = new SerialStef(item.Key, durations);
index++;
}
return(stats);
}
/// <summary>
/// Event raised when data is received from the <see cref="Serial"/> object.
/// </summary>
/// <param name="sender">The <see cref="Serial"/> object that raised the event</param>
/// <param name="data">A <see cref="SerialData"/> object that contains the data received.</param>
protected virtual void OnDataReceivedEvent(Serial sender, SerialData data)
{
DataReceivedEventHandler handler = _dataReceivedHandler;
if (handler == null)
return;
if (SynchronousUnsafeEventInvocation)
{
try { handler(sender, data); }
catch { }
}
else
{
if (Program.CheckAndInvoke(handler, handler, sender, data))
handler(sender, data);
}
}
void Start()
{
audioSource = GetComponent<AudioSource> ();
serialData = GameObject.FindObjectOfType<SerialData> ();
}
internal SerialDataReceivedEventArgs(SerialData dataValue)
{
m_data = dataValue;
}
/// <summary>
/// Event raised when data is received from the <see cref="Serial"/> object.
/// </summary>
/// <param name="sender">The <see cref="Serial"/> object that raised the event</param>
/// <param name="data">A <see cref="SerialData"/> object that contains the data received.</param>
protected virtual void OnDataReceivedEvent(Serial sender, SerialData data)
{
if (this.onDataReceived == null)
{
this.onDataReceived = new DataReceivedEventHandler(this.OnDataReceivedEvent);
}
if (Program.CheckAndInvoke(this.DataReceived, this.onDataReceived, sender, data))
{
this.DataReceived(sender, data);
}
}
internal SerialDataReceivedEventArgs(SerialData eventType)
{
EventType = eventType;
}
void OnEnable()
{
if (GameObject.Find ("SerialManager") != null) {
serialData = GameObject.FindObjectOfType<SerialData>();
}
audioSource = GetComponent<AudioSource>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="eventType">Event that occurred</param>
public SerialDataReceivedEventArgs(SerialData eventType)
{
m_EventType = eventType;
}
internal SerialDataReceivedEventArgs(SerialData eventCode){
mReceiveType = eventCode;
}
