public static ReusableList <IUserCmd> FromProtoBuf(UserCmdMessage message)
{
ReusableList <IUserCmd> list = ReusableList <IUserCmd> .Allocate();
var count = message.UserCmdList.Count;
for (int i = 0; i < count; i++)
{
var item = message.UserCmdList[i];
UserCmd cmd = UserCmd.Allocate();
cmd.RenderTime = item.RenderTime;
cmd.FrameInterval = item.FrameInterval;
cmd.MoveHorizontal = item.MoveHorizontal;
cmd.MoveVertical = item.MoveVertical;
cmd.MoveUpDown = item.MoveUpDown;
cmd.Seq = item.Seq;
cmd.DeltaPitch = item.DeltaPitch;
cmd.DeltaYaw = item.DeltaYaw;
cmd.Buttons = item.Buttons;
cmd.BeState = item.BeState;
cmd.SwitchNumber = item.SwitchNumber;
cmd.ChangedSeat = item.ChangedSeat;
cmd.ChangeChannel = item.ChangeChannel;
cmd.SnapshotId = item.SnapshotId;
cmd.CurWeapon = item.CurWeapon;
cmd.PickUpEquip = item.PickUpEquip;
cmd.UseEntityId = item.UseVehicleId;
cmd.UseVehicleSeat = item.UseVehicleSeat;
cmd.UseType = item.UseType;
cmd.BagIndex = item.BagIndex;
list.Value.Add(cmd);
}
return(list);
}
private string MakeNode(DataType item, StringBuilder classText)
{
StringBuilder outputText = new StringBuilder();
foreach (var property in item.Properties)
{
classText.Append(property.Name + " : " + property.DataTypeName);
if (!string.IsNullOrWhiteSpace(property.MinCardinality) && !string.IsNullOrWhiteSpace(property.MaxCardinality))
{
classText.Append("[" + property.MinCardinality + "..." + property.MaxCardinality + "] ");
}
classText.Append("\\l");
if (ClassList.Contains(property.DataType))
{
outputText.Append("edge[ arrowhead = \"none\" headlabel = \"0...*\" taillabel = \"0...*\"] ");
outputText.Append(item.Name + " -> " + property.DataTypeName + "[ label = \"" + property.Name + "\"] ");
}
if (ReusableList.Contains(property.DataType) && ShowReusables)
{
return(MakeCluster(item));
}
}
if (!string.IsNullOrWhiteSpace(item.ExtendsTypeName) && Inheritance)
{
outputText.Append("edge [arrowhead = \"empty\" headlabel = \"\" taillabel = \"\"] ");
outputText.Append(item.Name + "->" + item.ExtendsTypeName + " ");
}
outputText.Append(classText.ToString() + "}\"] ");
return(outputText.ToString());
}
public static void ToProtoBuf(UserCmdMessage rc, ReusableList <IUserCmd> list)
{
foreach (var item in list.Value)
{
UserCmdItem cmd = UserCmdItem.Allocate();
{
cmd.RenderTime = item.RenderTime;
cmd.FrameInterval = item.FrameInterval;
cmd.Buttons = item.Buttons;
cmd.MoveHorizontal = item.MoveHorizontal;
cmd.MoveVertical = item.MoveVertical;
cmd.MoveUpDown = item.MoveUpDown;
cmd.Seq = item.Seq;
cmd.DeltaPitch = item.DeltaPitch;
cmd.DeltaYaw = item.DeltaYaw;
cmd.SwitchNumber = item.SwitchNumber;
cmd.ChangedSeat = item.ChangedSeat;
cmd.ChangeChannel = item.ChangeChannel;
cmd.SnapshotId = item.SnapshotId;
cmd.CurWeapon = item.CurWeapon;
cmd.PickUpEquip = item.PickUpEquip;
cmd.UseVehicleId = item.UseEntityId;
cmd.UseVehicleSeat = item.UseVehicleSeat;
cmd.UseType = item.UseType;
cmd.BagIndex = item.BagIndex;
};
rc.UserCmdList.Add(cmd);
}
}
public ReusableList <T> GetRange(int index, int count)
{
if (index < 0)
{
throw new ArgumentException();
}
if (count < 0)
{
throw new ArgumentException();
}
if (_size - index < count)
{
throw new ArgumentException();
}
Contract.Ensures(Contract.Result <ReusableList <T> >() != null);
Contract.EndContractBlock();
ReusableList <T> list = new ReusableList <T>(count);
Array.Copy(_items, index, list._items, 0, count);
list._size = count;
return(list);
}
internal Enumerator(ReusableList <T> list)
{
this.list = list;
index = 0;
version = list._version;
current = default(T);
}
public void List()
{
ReusableList <int> integers = new ReusableList <int>();
List <int> list = integers.CleanList;
Assert.AreEqual(0, list.Count);
}
public object Deserialize(Stream inStream)
{
ReusableList <UpdateLatestPacakge> list = ReusableList <UpdateLatestPacakge> .Allocate();
BinaryReader binaryReader = new BinaryReader(inStream);
int count = binaryReader.ReadByte();
for (int i = 0; i < count; i++)
{
UpdateLatestPacakge pacakge = UpdateLatestPacakge.Allocate();
pacakge.Head.Deserialize(binaryReader);
var seq = pacakge.Head.UserCmdSeq;
var bodyLenght = pacakge.Head.BodyLength;
if (MessagePool.GetPackageBySeq(seq) == null)
{
var baseSeq = pacakge.Head.BaseUserCmdSeq;
var old = MessagePool.GetPackageBySeq(baseSeq);
if (old != null)
{
pacakge.CopyUpdateComponentsFrom(old.UpdateComponents);
}
for (int c = 0; c < pacakge.Head.ComponentCount; c++)
{
var opType = (ComponentReplicateOperationType)binaryReader.ReadByte();
var patch = CreateEmptyComponentPatch(opType);
patch.DeSerialize(binaryReader, _componentSerializerManager);
ApplyPatchTo(patch, pacakge.UpdateComponents);
patch.ReleaseReference();
}
if (pacakge.Head.ComponentCount == pacakge.UpdateComponents.Count)
{
MessagePool.AddMessage(pacakge);
pacakge.AcquireReference();
list.Value.Add(pacakge);
}
else
{
_logger.WarnFormat("Skip package {0} with length {1} baseSeq;{2}", pacakge.Head.UserCmdSeq, pacakge.Head.BodyLength, pacakge.Head.BaseUserCmdSeq);
}
}
else
{
_logger.DebugFormat("Skip package {0} with length {1}", pacakge.Head.UserCmdSeq, pacakge.Head.BodyLength);
binaryReader.BaseStream.Seek(bodyLenght, SeekOrigin.Current);
}
pacakge.ReleaseReference();
}
return(list);
}
public static void ToProtoBuf(VehicleCmdMessage msg, ReusableList <IVehicleCmd> list)
{
foreach (var cmd in list.Value)
{
var item = VehicleCmdItem.Allocate();
item.Seq = cmd.Seq;
item.PlayerId = cmd.PlayerId;
item.VehicleId = cmd.VehicleId;
item.MoveHorizontal = cmd.MoveHorizontal;
item.MoveVertical = cmd.MoveVertical;
item.IsSpeedup = cmd.IsSpeedup;
item.IsHandbrake = cmd.IsHandbrake;
item.ExecuteTime = cmd.ExecuteTime;
item.CmdSeq = cmd.CmdSeq;
item.IsHornOn = cmd.IsHornOn;
item.IsStunt = cmd.IsStunt;
item.IsLeftShift = cmd.IsLeftShift;
item.IsRightShift = cmd.IsRightShift;
var vehicleCmd = (VehicleCmd)cmd;
item.Body = VehicleBodyItem.Allocate();
item.Body.Position = Vector3Converter.UnityToProtobufVector3(vehicleCmd.Body.Position.WorldVector3());
item.Body.Rotation = Vector3Converter.UnityToProtobufQuaternion(vehicleCmd.Body.Rotation);
item.Body.LinearVelocity = Vector3Converter.UnityToProtobufVector3(vehicleCmd.Body.LinearVelocity);
item.Body.AngularVelocity = Vector3Converter.UnityToProtobufVector3(vehicleCmd.Body.AngularVelocity);
item.Body.Crashed = vehicleCmd.Body.Crashed;
item.Body.IsSleeping = vehicleCmd.Body.IsSleeping;
if (vehicleCmd.VehicleType == (int)EVehicleType.Car)
{
for (int i = 0; i < vehicleCmd.SteerableCount; ++i)
{
var steerableItem = CarSteerableItem.Allocate();
var steerable = vehicleCmd.Steerables[i].Car;
steerableItem.Position = Vector3Converter.UnityToProtobufVector3(steerable.Position);
steerableItem.Rotation = Vector3Converter.UnityToProtobufQuaternion(steerable.Rotation);
steerableItem.Angle = steerable.Angle;
item.CarSteerables.Add(steerableItem);
}
}
else
{
for (int i = 0; i < vehicleCmd.SteerableCount; ++i)
{
var steerableItem = ShipSteerableItem.Allocate();
var steerable = vehicleCmd.Steerables[i].Ship;
steerableItem.Angle = steerable.Angle;
item.ShipSteerables.Add(steerableItem);
}
}
msg.VehicleCmdList.Add(item);
}
}
public void Serialize(Stream outStream, object message)
{
ReusableList <IUserCmd> list = (ReusableList <IUserCmd>)message;
UserCmdMessage msg = UserCmdMessage.Allocate();
UserCmdMessageConverter.ToProtoBuf(msg, list);
_serialize.Serialize(outStream, msg);
msg.ReleaseReference();
}
public void MakeGraphSingle(CogsModel model, string header)
{
int previousOutput = 0;
foreach (var item in model.ItemTypes.Concat(model.ReusableDataTypes))
{
if (previousOutput > item.Name.Length)
{
Console.Write("\rCreating Graph for " + item.Name + string.Join("", Enumerable.Repeat(" ", previousOutput - item.Name.Length)));
}
else
{
Console.Write("\rCreating Graph for " + item.Name);
}
previousOutput = item.Name.Length;
StringBuilder arrows = new StringBuilder();
bool isCluster = false;
if (ShowReusables && item.Properties.Where(x => ReusableList.Contains(x.DataType)).ToList().Count > 0)
{
isCluster = true;
}
foreach (var clss in model.ItemTypes.Concat(model.ReusableDataTypes))
{
if (Inheritance && clss.ExtendsTypeName.Equals(item.Name))
{
if (isCluster)
{
arrows.Append($"{clss.Name} -> {item.Name}Properties [arrowhead=\"empty\" lhead = cluster{item.Name}] ");
}
else
{
arrows.Append($"{clss.Name} -> {item.Name} [ arrowhead=\"empty\"] ");
}
}
foreach (var property in clss.Properties)
{
if (property.DataTypeName.Equals(item.Name))
{
if (isCluster && clss.Name.Equals(item.Name))
{
arrows.Append($"{clss.Name}Properties -> {item.Name}Properties [ arrowhead=\"none\" label = {property.Name}] ");
}
else if (isCluster)
{
arrows.Append($"{clss.Name} -> {item.Name}Properties [ arrowhead=\"none\" label= {property.Name} lhead = cluster{item.Name}] ");
}
else
{
arrows.Append($"{clss.Name} -> {item.Name}[ arrowhead=\"none\" label={property.Name}] ");
}
}
}
}
GenerateOutput(item.Name, header + " " + MakeItem(item) + arrows + " }");
}
}
public override void DoHandle(INetworkChannel channel, PlayerEntity entity,
EClient2ServerMessage eClient2ServerMessage, ReusableList <UpdateLatestPacakge> messageBody)
{
var messageAck = UpdateMessageAck.Allocate();
messageAck.AckSeq = channel.Serializer.MessageTypeInfo.LatestUpdateMessageSeq;
_logger.DebugFormat("UserUpdateAckMsgHandler:{0}", messageAck.AckSeq);
channel.SendRealTime((int)EServer2ClientMessage.UpdateAck, messageAck);
messageAck.ReleaseReference();
}
public int Serialize(Stream outStream, object message)
{
ReusableList <IVehicleCmd> list = (ReusableList <IVehicleCmd>)message;
VehicleCmdMessage msg = VehicleCmdMessage.Allocate();
VehicleCmdMessageConverter.ToProtoBuf(msg, list);
var ret = _serialize.Serialize(outStream, msg);
msg.ReleaseReference();
return(ret);
}
public bool MoveNext()
{
ReusableList <T> localList = list;
if (version == localList._version && ((uint)index < (uint)localList._size))
{
current = localList._items[index];
index++;
return(true);
}
return(MoveNextRare());
}
public override void DoHandle(INetworkChannel channel, PlayerEntity entity,
EClient2ServerMessage eClient2ServerMessage, ReusableList <UpdateLatestPacakge> messageBody)
{
var pool = entity.updateMessagePool.UpdateMessagePool;
foreach (var updateLatestPacakge in messageBody.Value)
{
pool.AddMessage(updateLatestPacakge);
updateLatestPacakge.ReleaseReference();
_logger.DebugFormat("DoHandle:{0}", updateLatestPacakge.Head.UserCmdSeq);
entity.network.NetworkChannel.Serializer.MessageTypeInfo.SetReplicationAckId(updateLatestPacakge.Head.LastSnapshotId);
}
}
public override void DoHandle(INetworkChannel channel, PlayerEntity entity,
EClient2ServerMessage eClient2ServerMessage, ReusableList <IVehicleCmd> messageBody)
{
//_logger.DebugFormat("Server VehicleCmd seq is {0}", messageBody.Seq);
var vehicle = PlayerVehicleUtility.GetControlledVehicle(entity, _contexts.vehicle);
var cmdList = messageBody.Value;
if (vehicle != null)
{
vehicle.vehicleCmd.AddLatestList(cmdList);
}
CheckVehicleCmdList(cmdList);
}
// a list of latest 'SendCount' item, from newest to oldest
public ReusableList <TCmd> CreateLatestList()
{
var rc = ReusableList <TCmd> .Allocate();
int count = 0;
foreach (var cmd in _userCmdList)
{
rc.Value.Add(cmd);
count++;
if (count >= SendCount)
{
break;
}
}
return(rc);
}
//Author : Benjamin Lemelin, John Smith, Mary Smith
public Region(Vector2 topLeft, Vector2 bottomRight)
{
if (topLeft.x > bottomRight.x || topLeft.y < bottomRight.y)
{
throw new ArgumentException("Unable to create region : top left limit is below or to the right of the bottom right limit.");
}
nodeCount = 0;
nodes = new Node[MAX_NODE_COUNT];
subregions = new Region[NB_SUB_REGIONS];
this.topLeft = topLeft;
this.bottomRight = bottomRight;
size = new Vector2(bottomRight.x - topLeft.x, topLeft.y - bottomRight.y);
center = new Vector2(bottomRight.x - size.x / 2, topLeft.y - size.y / 2);
reusableNodeList = new ReusableList <Node>();
}
public ReusableList <T> FindAll(Predicate <T> match)
{
if (match == null)
{
throw new ArgumentException();
}
Contract.EndContractBlock();
ReusableList <T> list = new ReusableList <T>();
for (int i = 0; i < _size; i++)
{
if (match(_items[i]))
{
list.Add(_items[i]);
}
}
return(list);
}
public ReusableList <TOutput> ConvertAll <TOutput>(Converter <T, TOutput> converter)
{
if (converter == null)
{
throw new ArgumentException();
}
// @
Contract.EndContractBlock();
ReusableList <TOutput> list = new ReusableList <TOutput>(_size);
for (int i = 0; i < _size; i++)
{
list._items[i] = converter(_items[i]);
}
list._size = _size;
return(list);
}
public AttributeModifierList(Action onChanged, int capacity = 10)
{
Modifiers = new List <T>(capacity);
reusableModifiers = new ReusableList <T>(4);
this.onChanged = onChanged;
}
protected override void InternalExecute()
{
while (true)
{
var item = _contexts.session.clientSessionObjects.Replay.GetItem(EReplayMessageType.OUT, MyGameTime.stage,
MyGameTime.seq,
_contexts.session.clientSessionObjects.NetworkChannel.Id);
if (item == null)
{
return;
}
if (item.MessageBody is ReusableList <UpdateLatestPacakge> && item.ProcessSeq == MyGameTime.seq)
{
var last = _contexts.player.flagSelfEntity.userCmd.Latest as UserCmd;
ReusableList <UpdateLatestPacakge> reusableList =
item.MessageBody as ReusableList <UpdateLatestPacakge>;
var current = reusableList.Value.Last();
foreach (var updateComponent in current.UpdateComponents)
{
if (updateComponent is SendUserCmdComponent)
{
var right = updateComponent as SendUserCmdComponent;
_logger.DebugFormat("replay usercmd: last:{0}, timeseq:{1}, msgSeq:{2} {3}", last.Seq, MyGameTime.seq, current.Head.LastUserCmdSeq, item);
//last.Seq = current.Head.UserCmdSeq;
//last.SnapshotId = current.Head.LastSnapshotId;
_contexts.session.clientSessionObjects.TimeManager.RenderTime = right.RenderTime;
last.FrameInterval = right.FrameInterval;
last.MoveHorizontal = right.MoveHorizontal;
last.MoveUpDown = right.MoveUpDown;
last.MoveVertical = right.MoveVertical;
last.DeltaYaw = right.DeltaYaw;
last.DeltaPitch = right.DeltaPitch;
last.RenderTime = right.RenderTime;
last.ClientTime = right.ClientTime;
last.ChangedSeat = right.ChangedSeat;
last.BeState = right.BeState;
last.Buttons = right.Buttons;
last.SwitchNumber = right.SwitchNumber;
last.CurWeapon = right.CurWeapon;
last.UseEntityId = right.UseEntityId;
last.ManualPickUpEquip = right.ManualPickUpEquip;
last.AutoPickUpEquip = UserCmd.CopyList(last.AutoPickUpEquip, right.AutoPickUpEquip);
last.UseVehicleSeat = right.UseVehicleSeat;
last.UseType = right.UseType;
last.ChangeChannel = right.ChangeChannel;
last.BagIndex = right.BagIndex;
}
}
}
if (item.MessageBody is ReusableList <IVehicleCmd> && item.ProcessSeq == MyGameTime.seq)
{
var cmd = (item.MessageBody as ReusableList <IVehicleCmd>).Value.Last();
var controlledVehicle = PlayerVehicleUtility.GetControlledVehicle(_contexts.player.flagSelfEntity, _contexts.vehicle);
if (controlledVehicle != null)
{
controlledVehicle.vehicleCmd.AddLatest(cmd);
}
}
if (item.MessageBody is ReusableList <IRefCounter> )
{
foreach (var updateLatestPacakge in (item.MessageBody as ReusableList <UpdateLatestPacakge>).Value)
{
updateLatestPacakge.ReleaseReference();
}
}
item.ReleaseReference();
}
}
private void OverlappedIoThreadMainLoop()
{
// WaitCommEvent
bool serialCommPending = false;
bool serialCommError = false;
m_SerialCommEvent.Reset();
NativeOverlapped serialCommOverlapped = new NativeOverlapped();
#if NETSTANDARD15
serialCommOverlapped.EventHandle = m_SerialCommEvent.GetSafeWaitHandle().DangerousGetHandle();
#else
serialCommOverlapped.EventHandle = m_SerialCommEvent.SafeWaitHandle.DangerousGetHandle();
#endif
// ReadFile
bool readPending = false;
m_ReadEvent.Reset();
NativeOverlapped readOverlapped = new NativeOverlapped();
#if NETSTANDARD15
readOverlapped.EventHandle = m_ReadEvent.GetSafeWaitHandle().DangerousGetHandle();
#else
readOverlapped.EventHandle = m_ReadEvent.SafeWaitHandle.DangerousGetHandle();
#endif
// WriteFile
bool writePending = false;
m_WriteEvent.Reset();
NativeOverlapped writeOverlapped = new NativeOverlapped();
m_ReadByteAvailable = false;
#if NETSTANDARD15
writeOverlapped.EventHandle = m_WriteEvent.GetSafeWaitHandle().DangerousGetHandle();
#else
writeOverlapped.EventHandle = m_WriteEvent.SafeWaitHandle.DangerousGetHandle();
#endif
// SEt up the types of serial events we want to see.
UnsafeNativeMethods.SetCommMask(m_ComPortHandle, maskRead);
bool result;
NativeMethods.SerialEventMask commEventMask = 0;
bool running = true;
uint bytes;
ReusableList <WaitHandle> handles = new ReusableList <WaitHandle>(2, 7);
while (running)
{
handles.Clear();
handles.Add(m_StopRunning);
handles.Add(m_WriteClearEvent);
#if PL2303_WORKAROUNDS
// - - - - - - - - - - - - - - - - - - - - - - - - -
// PROLIFIC PL23030 WORKAROUND
// - - - - - - - - - - - - - - - - - - - - - - - - -
// If we have a read pending, we don't request events
// for reading data. To do so will result in errors.
// Have no idea why.
if (readPending)
{
UnsafeNativeMethods.SetCommMask(m_ComPortHandle, maskReadPending);
}
else
{
UnsafeNativeMethods.SetCommMask(m_ComPortHandle, maskRead);
// While the comm event mask was set to ignore read events, data could have been written
// to the input queue. Check for that and if there are bytes waiting or EOF was received,
// set the appropriate flags.
uint bytesInQueue;
bool eofReceived;
if (GetReceiveStats(out bytesInQueue, out eofReceived) && (bytesInQueue > 0 || eofReceived))
{
// Tell DoReadEvent that there is data pending
m_ReadByteAvailable = true;
m_ReadByteEof |= eofReceived;
}
}
#else
UnsafeNativeMethods.SetCommMask(m_ComPortHandle, maskRead);
#endif
// commEventMask is on the stack, and is therefore fixed
if (!serialCommError)
{
try {
if (!serialCommPending)
{
serialCommPending = DoWaitCommEvent(out commEventMask, ref serialCommOverlapped);
}
if (serialCommPending)
{
handles.Add(m_SerialCommEvent);
}
} catch (IOException) {
// Some devices, such as the Arduino Uno with a CH340 on board don't support an overlapped
// WaitCommEvent. So if that occurs, we remember it and don't use it again. The Windows error
// returned was 87 (ERROR_INVALID_PARAMETER) was returned in that case. GetReceiveStats() did
// work, so we can still know of data pending by polling. But we won't get any other events,
// such as TX_EMPTY.
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Warning))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Warning, 0,
"{0}: SerialThread: Not processing WaitCommEvent events", m_Name);
}
serialCommError = true;
}
}
if (!readPending)
{
if (!m_Buffer.Serial.ReadBufferNotFull.WaitOne(0))
{
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Verbose))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: Read Buffer Full", m_Name);
}
handles.Add(m_Buffer.Serial.ReadBufferNotFull);
}
else
{
readPending = DoReadEvent(ref readOverlapped);
}
}
if (readPending)
{
handles.Add(m_ReadEvent);
}
if (!writePending)
{
if (!m_Buffer.Serial.WriteBufferNotEmpty.WaitOne(0))
{
handles.Add(m_Buffer.Serial.WriteBufferNotEmpty);
}
else
{
writePending = DoWriteEvent(ref writeOverlapped);
}
}
if (writePending)
{
handles.Add(m_WriteEvent);
}
// We wait up to 100ms, in case we're not actually pending on anything. Normally, we should always be
// pending on a Comm event. Just in case this is not so (and is a theoretical possibility), we will
// slip out of this WaitAny() after 100ms and then restart the loop, effectively polling every 100ms in
// worst case.
WaitHandle[] whandles = handles.ToArray();
int ev = WaitHandle.WaitAny(whandles, 100);
if (ev != WaitHandle.WaitTimeout)
{
if (whandles[ev] == m_StopRunning)
{
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Verbose))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: Thread closing", m_Name);
}
result = UnsafeNativeMethods.CancelIo(m_ComPortHandle);
if (!result)
{
int win32Error = Marshal.GetLastWin32Error();
//int hr = Marshal.GetHRForLastWin32Error();
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Warning))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Warning, 0,
"{0}: SerialThread: CancelIo error {1}", m_Name, win32Error);
}
Marshal.ThrowExceptionForHR(win32Error);
}
running = false;
}
else if (whandles[ev] == m_SerialCommEvent)
{
result = UnsafeNativeMethods.GetOverlappedResult(m_ComPortHandle, ref serialCommOverlapped, out bytes, true);
if (!result)
{
int win32Error = Marshal.GetLastWin32Error();
//int hr = Marshal.GetHRForLastWin32Error();
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Error))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Error, 0,
"{0}: SerialThread: Overlapped WaitCommEvent() error {1}", m_Name, win32Error);
}
Marshal.ThrowExceptionForHR(win32Error);
}
ProcessWaitCommEvent(commEventMask);
serialCommPending = false;
}
else if (whandles[ev] == m_ReadEvent)
{
result = UnsafeNativeMethods.GetOverlappedResult(m_ComPortHandle, ref readOverlapped, out bytes, true);
if (!result)
{
int win32Error = Marshal.GetLastWin32Error();
//int hr = Marshal.GetHRForLastWin32Error();
// Should never get ERROR_IO_PENDING, as this method is only called when the event is triggered.
if (win32Error != WinError.ERROR_OPERATION_ABORTED || bytes > 0)
{
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Error))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Error, 0,
"{0}: SerialThread: Overlapped ReadFile() error {1} bytes {2}", m_Name, win32Error, bytes);
}
Marshal.ThrowExceptionForHR(win32Error);
}
else
{
// ERROR_OPERATION_ABORTED may be caused by CancelIo or PurgeComm
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Verbose))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0,
"{0}: SerialThread: Overlapped ReadFile() error {1} bytes {2}", m_Name, win32Error, bytes);
}
}
}
else
{
ProcessReadEvent(bytes);
}
readPending = false;
}
else if (whandles[ev] == m_Buffer.Serial.ReadBufferNotFull)
{
// The read buffer is no longer full. We just loop back to the beginning to test if we
// should read or not.
}
else if (whandles[ev] == m_WriteEvent)
{
result = UnsafeNativeMethods.GetOverlappedResult(m_ComPortHandle, ref writeOverlapped, out bytes, true);
if (!result)
{
int win32Error = Marshal.GetLastWin32Error();
//int hr = Marshal.GetHRForLastWin32Error();
// Should never get ERROR_IO_PENDING, as this method is only called when the event is triggered.
if (win32Error != WinError.ERROR_OPERATION_ABORTED || bytes > 0)
{
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Error))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Error, 0,
"{0}: SerialThread: Overlapped WriteFile() error {1} bytes {2}", m_Name, win32Error, bytes);
}
Marshal.ThrowExceptionForHR(win32Error);
}
else
{
// ERROR_OPERATION_ABORTED may be caused by CancelIo or PurgeComm
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Verbose))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0,
"{0}: SerialThread: Overlapped WriteFile() error {1} bytes {2}", m_Name, win32Error, bytes);
}
}
}
else
{
ProcessWriteEvent(bytes);
}
writePending = false;
}
else if (whandles[ev] == m_Buffer.Serial.WriteBufferNotEmpty)
{
// The write buffer is no longer empty. We just loop back to the beginning to test if we
// should write or not.
}
else if (whandles[ev] == m_WriteClearEvent)
{
if (writePending)
{
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Verbose))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: PurgeComm() write pending", m_Name);
}
m_PurgePending = true;
result = UnsafeNativeMethods.PurgeComm(m_ComPortHandle,
NativeMethods.PurgeFlags.PURGE_TXABORT | NativeMethods.PurgeFlags.PURGE_TXCLEAR);
if (!result)
{
int win32Error = Marshal.GetLastWin32Error();
//int hr = Marshal.GetHRForLastWin32Error();
if (win32Error != WinError.ERROR_OPERATION_ABORTED)
{
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Error))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Error, 0,
"{0}: SerialThread: PurgeComm() error {1}", m_Name, win32Error);
}
Marshal.ThrowExceptionForHR(win32Error);
}
else
{
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Verbose))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0,
"{0}: SerialThread: PurgeComm() error {1}", m_Name, win32Error);
}
}
}
}
else
{
lock (m_Buffer.WriteLock) {
if (Log.SerialTrace(System.Diagnostics.TraceEventType.Verbose))
{
Log.Serial.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: Purged", m_Name);
}
m_Buffer.Serial.Purge();
m_WriteClearDoneEvent.Set();
}
}
}
}
#if STRESSTEST
SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: STRESSTEST SerialThread: Stress Test Delay of 1000ms", m_Name);
System.Threading.Thread.Sleep(1000);
NativeMethods.ComStatErrors commStateErrors = new NativeMethods.ComStatErrors();
NativeMethods.COMSTAT commStat = new NativeMethods.COMSTAT();
result = UnsafeNativeMethods.ClearCommError(m_ComPortHandle, out commStateErrors, out commStat);
if (result)
{
SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Information, 0,
"{0}: STRESSTEST SerialThread: ClearCommError errors={1}", m_Name, commStateErrors);
SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Information, 0,
"{0}: STRESSTEST SerialThread: ClearCommError stats flags={1}, InQueue={2}, OutQueue={3}", m_Name, commStat.Flags, commStat.cbInQue, commStat.cbOutQue);
}
else
{
SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Warning, 0,
"{0}: STRESSTEST SerialThread: ClearCommError error: {1}", m_Name, Marshal.GetLastWin32Error());
}
#endif
}
}
private bool ExecuteGuarded(IList <string> tokens, string commandLine = null)
{
ResetOptions();
Iterator <string> iter = new Iterator <string>(tokens);
iter.Next(); // first token is a command name
if (this.IsManualMode)
{
PrintPrompt(commandLine);
}
if (this.IsPlayModeOnly && !Runtime.IsPlaying)
{
PrintError("Command is available in the play mode only");
return(false);
}
ReusableList <string> argsList = ReusableLists.NextAutoRecycleList <string>();
while (iter.HasNext())
{
string token = StringUtils.UnArg(iter.Next());
// first, try to parse options
if (!TryParseOption(iter, token))
{
// consume the rest of the args
argsList.Add(token);
while (iter.HasNext())
{
token = StringUtils.UnArg(iter.Next());
argsList.Add(token);
}
break;
}
}
if (m_values != null)
{
if (argsList.Count != 1)
{
PrintError("Unexpected arguments count {0}", argsList.Count);
PrintUsage();
return(false);
}
string arg = argsList[0];
if (Array.IndexOf(m_values, arg) == -1)
{
PrintError("Unexpected argument '{0}'", arg);
PrintUsage();
return(false);
}
}
if (m_options != null)
{
for (int i = 0; i < m_options.Count; ++i)
{
Option opt = m_options[i];
if (opt.IsRequired && !opt.IsHandled)
{
PrintError("Missing required option --{0}{1}", opt.Name, opt.ShortName != null ? "(-" + opt.ShortName + ")" : "");
PrintUsage();
return(false);
}
}
}
string[] args = argsList.Count > 0 ? argsList.ToArray() : EMPTY_COMMAND_ARGS;
MethodInfo executeMethod = resolveExecuteMethod(args);
if (executeMethod == null)
{
PrintError("Wrong arguments");
PrintUsage();
return(false);
}
return(CCommandUtils.Invoke(this, executeMethod, args));
}
public static StackTraceLine[] ParseStackTrace(string stackTrace)
{
if (stackTrace != null)
{
ReusableList <StackTraceLine> list = ReusableLists.NextList <StackTraceLine>();
int lineStart = 0;
int lineEnd;
while (lineStart < stackTrace.Length)
{
// extract next line
lineEnd = StringUtils.EndOfLineIndex(stackTrace, lineStart);
string line = stackTrace.Substring(lineStart, lineEnd - lineStart);
lineStart = lineEnd + 1;
// extract data
Match m;
if ((m = PatternUnityStackTrace.Match(line)).Success)
{
GroupCollection groups = m.Groups;
string sourcePath = groups[2].Value;
string lineNumberStr = groups[3].Value;
int lineNumber = StringUtils.ParseInt(lineNumberStr, -1);
list.Add(new StackTraceLine(line, string.IsNullOrEmpty(sourcePath) ? null : sourcePath, lineNumber, lineNumberStr.Length));
}
else if ((m = PatternSystemStackTrace.Match(line)).Success)
{
GroupCollection groups = m.Groups;
string method = groups[1].Value;
string args = OptimizeArgs(groups[2].Value);
string path = OptimizePath(groups[4].Value);
string lineNumberStr = groups[5].Value;
int lineNumber = StringUtils.ParseInt(lineNumberStr, -1);
if (!string.IsNullOrEmpty(path) && lineNumber != -1)
{
line = StringUtils.TryFormat("{0}({1}) (at {2}:{3})", method, args, path, lineNumberStr);
}
else
{
line = StringUtils.TryFormat("{0}({1})", method, args);
}
list.Add(new StackTraceLine(line, path, lineNumber, lineNumberStr.Length));
}
else
{
list.Add(new StackTraceLine(line));
}
}
StackTraceLine[] lines = list.ToArray();
list.Recycle();
return(lines);
}
return(StackTraceLine.kEmptyLinesArray);
}
public override void DoHandle(INetworkChannel channel, PlayerEntity entity, EClient2ServerMessage eClient2ServerMessage, ReusableList <IUserCmd> messageBody)
{
var cmdList = messageBody.Value;
entity.userCmd.AddLatestList(cmdList);
entity.network.NetworkChannel.Serializer.MessageTypeInfo.SetReplicationAckId(entity.userCmd.Latest.SnapshotId);
var lastCmd = cmdList[cmdList.Count - 1];
var firstCmd = cmdList[0];
#pragma warning disable RefCounter002 // possible reference counter error
var cmd = firstCmd.Seq > lastCmd.Seq ? firstCmd : lastCmd;
#pragma warning restore RefCounter002 // possible reference counter error
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("received usercmd message, seq {0}, ack snapshot {1}", cmd.Seq, cmd.SnapshotId);
}
CheckVehicleCmdList(cmdList);
}
public static ReusableList <IVehicleCmd> FromProtoBuf(VehicleCmdMessage message)
{
ReusableList <IVehicleCmd> list = ReusableList <IVehicleCmd> .Allocate();
var count = message.VehicleCmdList.Count;
for (int i = 0; i < count; ++i)
{
var item = message.VehicleCmdList[i];
var cmd = VehicleCmd.Allocate();
{
cmd.Seq = item.Seq;
cmd.PlayerId = item.PlayerId;
cmd.VehicleId = item.VehicleId;
cmd.MoveHorizontal = item.MoveHorizontal;
cmd.MoveVertical = item.MoveVertical;
cmd.IsSpeedup = item.IsSpeedup;
cmd.IsHandbrake = item.IsHandbrake;
cmd.IsHornOn = item.IsHornOn;
cmd.IsStunt = item.IsStunt;
cmd.IsLeftShift = item.IsLeftShift;
cmd.IsRightShift = item.IsRightShift;
cmd.ExecuteTime = item.ExecuteTime;
cmd.CmdSeq = item.CmdSeq;
cmd.Body.Position = Vector3Converter.ProtobufToUnityVector3(item.Body.Position).ShiftedToFixedVector3();
cmd.Body.Rotation = Vector3Converter.ProtobufToUnityQuaternion(item.Body.Rotation);
// cmd.Body.Body2WorldPosition = Vector3Converter.ProtobufToUnityVector3(item.Body.Body2WorldPosition);
// cmd.Body.Body2WorldRotation = Vector3Converter.ProtobufToUnityQuaternion(item.Body.Body2WorldRotation);
cmd.Body.LinearVelocity = Vector3Converter.ProtobufToUnityVector3(item.Body.LinearVelocity);
cmd.Body.AngularVelocity = Vector3Converter.ProtobufToUnityVector3(item.Body.AngularVelocity);
// cmd.Body.ContactCount = item.Body.ContactCount;
cmd.Body.Crashed = item.Body.Crashed;
cmd.Body.IsSleeping = item.Body.IsSleeping;
var carSteerableCount = item.CarSteerables.Count;
for (int j = 0; j < carSteerableCount; ++j)
{
var steerable = cmd.Steerables[j].Car;
var steerableItem = item.CarSteerables[j];
steerable.Position = Vector3Converter.ProtobufToUnityVector3(steerableItem.Position);
steerable.Rotation = Vector3Converter.ProtobufToUnityQuaternion(steerableItem.Rotation);
steerable.Angle = steerableItem.Angle;
// steerable.Grounded = steerableItem.Grounded;
// steerable.GroundedOnTerrain = steerableItem.GroundedOnTerrain;
// steerable.ColliderSteerAngle = steerableItem.ColliderSteerAngle;
// steerable.SteerAngle = steerableItem.SteerAngle;
// steerable.MotorTorque = steerableItem.MotorTorque;
//
// steerable.SuspensionDistance = steerableItem.SuspensionDistance;
// steerable.SuspensionSpring = steerableItem.SuspensionSpring;
// steerable.SuspensionTargetPosition = steerableItem.SuspensionTargetPosition;
//
// steerable.SprungMass = steerableItem.SprungMass;
// steerable.ForceDistance = steerableItem.ForceDistance;
//
// steerable.AngularVelocity = steerableItem.AngularVelocity;
// steerable.AngularPosition = steerableItem.AngularPosition;
// steerable.RotationAngle = steerableItem.RotationAngle;
//
// steerable.RotationSpeed = steerableItem.RotationSpeed;
// steerable.CorrectedRotationSpeed = steerableItem.CorrectedRotationSpeed;
// steerable.Jounce = steerableItem.Jounce;
//
// steerable.TireLowSideSpeedTimers = steerableItem.TireLowSideSpeedTimers;
// steerable.TireLowforwardSpeedTimers = steerableItem.TireLowforwardSpeedTimers;
//
// steerable.Grounded = steerableItem.Grounded;
// steerable.Point = Vector3Converter.ProtobufToUnityVector3(steerableItem.Point);
// steerable.Normal = Vector3Converter.ProtobufToUnityVector3(steerableItem.Normal);
// steerable.ForwardDir = Vector3Converter.ProtobufToUnityVector3(steerableItem.ForwardDir);
// steerable.SidewaysDir = Vector3Converter.ProtobufToUnityVector3(steerableItem.SidewaysDir);
// steerable.Force = steerableItem.Force;
//
// steerable.ForwardSlip = steerableItem.ForwardSlip;
// steerable.SidewaysSlip = steerableItem.SidewaysSlip;
cmd.Steerables[j].Car = steerable;
}
var shipSteerableCount = item.ShipSteerables.Count;
for (int j = 0; j < shipSteerableCount; ++j)
{
var steerable = cmd.Steerables[j].Ship;
var steerableItem = item.ShipSteerables[j];
steerable.Angle = steerableItem.Angle;
// steerableItem.Rpm = steerableItem.Rpm;
// steerableItem.SpinVelocity = steerableItem.SpinVelocity;
// steerableItem.Submerged = steerableItem.Submerged;
cmd.Steerables[j].Ship = steerable;
}
if (carSteerableCount > shipSteerableCount)
{
cmd.VehicleType = (int)EVehicleType.Car;
cmd.SteerableCount = carSteerableCount;
}
else
{
cmd.VehicleType = (int)EVehicleType.Ship;
cmd.SteerableCount = shipSteerableCount;
}
};
list.Value.Add(cmd);
}
return(list);
}
internal SynchronizedList(ReusableList <T> list)
{
_list = list;
_root = ((System.Collections.ICollection)list).SyncRoot;
}
private string MakeCluster(DataType item)
{
StringBuilder output = new StringBuilder();
StringBuilder outerClass = new StringBuilder($"subgraph cluster{item.Name} {{ style = \"filled\" " +
$"fillcolor = \"#4abdac\" label = \"{item.Name}\" ");
List <DataType> reusablesPresent = new List <DataType>();
outerClass.Append(item.Name + "Properties [ shape = \"record\" label=\"{Properties |");
foreach (var property in item.Properties)
{
outerClass.Append(property.Name + " : " + property.DataTypeName);
if (!string.IsNullOrWhiteSpace(property.MinCardinality) && !string.IsNullOrWhiteSpace(property.MaxCardinality))
{
outerClass.Append("[" + property.MinCardinality + "..." + property.MaxCardinality + "] ");
}
outerClass.Append("\\l");
if (ClassList.Contains(property.DataType))
{
output.Append("edge[ arrowhead = \"none\" headlabel = \"0...*\" taillabel = \"0...*\"] ");
output.Append(item.Name + "Properties -> " + property.DataTypeName + "[ arrowhead = \"none\" label = \"" + property.Name + "\"] ");
}
else if (ReusableList.Contains(property.DataType))
{
// add reusableTypes within that type to reusable list as well
Stack <DataType> stack = new Stack <DataType>();
if (!property.DataTypeName.Equals(item.Name) && !reusablesPresent.Contains(property.DataType))
{
stack.Push(property.DataType);
reusablesPresent.Add(property.DataType);
while (stack.Count > 0)
{
var type = stack.Pop();
foreach (var prop in type.Properties)
{
// checks: item is a reusable type, item is not already seen, item isn't current item, item isn't primitive
if (ReusableList.Contains(prop.DataType) && !reusablesPresent.Contains(type) &&
!type.Name.Equals(prop.DataTypeName) && !prop.DataTypeName.Equals(item.Name))
{
stack.Push(prop.DataType);
reusablesPresent.Add(prop.DataType);
}
}
}
output.Append(item.Name + "Properties -> " + item.Name + property.DataTypeName + "[ arrowhead = \"none\" label = \"" + property.Name + "\"] ");
}
}
}
if (Inheritance && !string.IsNullOrWhiteSpace(item.ExtendsTypeName))
{
output.Append("edge [arrowhead = \"empty\"] ");
output.Append(item.Name + "Properties ->" + item.ExtendsTypeName + "[ltail=cluster" + item.Name + "] ");
}
outerClass.Append("}\"] ");
foreach (var reused in reusablesPresent)
{
outerClass.Append(item.Name + reused.Name + " [ shape = \"record\" fillcolor = \"#fc4a1a\" label=\"{ " + reused.Name + " | ");
foreach (var property in reused.Properties)
{
outerClass.Append(property.Name + " : " + property.DataTypeName);
if (!string.IsNullOrWhiteSpace(property.MinCardinality) && !string.IsNullOrWhiteSpace(property.MaxCardinality))
{
outerClass.Append("[" + property.MinCardinality + "..." + property.MaxCardinality + "] ");
}
outerClass.Append("\\l");
if (ClassList.Contains(property.DataType) && !property.IsPrimitive)
{
output.Append("edge[ arrowhead = \"none\" headlabel = \"0...*\" taillabel = \"0...*\"] ");
output.Append(item.Name + reused.Name + " -> " + property.DataTypeName + "[ label = \"" + property.Name + "\"] ");
}
else if (reusablesPresent.Contains(property.DataType))
{
output.Append(item.Name + reused.Name + " -> " + item.Name + property.DataTypeName + "[ arrowhead = \"none\" label = \"" + property.Name + "\"] ");
}
}
if (Inheritance && !string.IsNullOrWhiteSpace(reused.ExtendsTypeName))
{
output.Append("edge [arrowhead = \"empty\"] ");
output.Append(item.Name + reused.Name + "->" + reused.ExtendsTypeName + " ");
}
outerClass.Append("}\"] ");
}
outerClass.Append("}");
output.Append(outerClass);
return(output.ToString());
}
internal static IList <T> Synchronized(ReusableList <T> list)
{
return(new SynchronizedList(list));
}
