public void Dispose()
{
Logger.Info("AbstractNetowrkChannel.Dispose");
try
{
ProcessSerializeQueue();
ProcessSendQueue();
ProcessDeserializeQueue();
//_serializer 有可能是公共的，这里不调Dispose
// if (_serializer != null)
// {
// _serializer.Dispose();
// }
ObjectAllocatorHolder <MemoryStream> .Free(_receiveMemoryStream);
_receiveMemoryStream = null;
if (_serializer != null)
{
_serializer.Dispose();
}
}
catch (Exception e)
{
Logger.ErrorFormat("{0}", e);
}
}
private void RemoveHistoryFirst()
{
_sendHistorySeqs.RemoveFirst();
var old = _sendHistoryStreams.RemoveFirst();
ObjectAllocatorHolder <MemoryStream> .Free(old);
}
internal void Invalidate()
{
list = null;
next = null;
prev = null;
ObjectAllocatorHolder <LinkedListNode <T> > .Free(this);
}
public int ProcessSendQueue(bool isMultiThread = false)
{
int count = 0;
while (_sendQueue.Count > 0 && count < MaxLoopCount)
{
if (isMultiThread)
{
count++;
}
try
{
NetworkMessageItem item = (NetworkMessageItem)_sendQueue.Dequeue();
if (IsConnected)
{
DoSend(item);
}
ObjectAllocatorHolder <MemoryStream> .Free(item.MemoryStream);
}
catch (Exception e)
{
_logger.ErrorFormat("error while do send {0} {1}", IdInfo(), e);
}
}
return(count);
}
protected override void OnCleanUp()
{
_seq = -1;
_snapshot = null;
_filter.Init(EntityKey.Default, Vector3.zero);
_preEntitys.Clear();
ObjectAllocatorHolder <PartialSnapshotFactory> .Free(this);
}
public void Free()
{
foreach (var value in EmitterDict.Values)
{
ObjectAllocatorHolder <AudioEmitter> .Free(value);
}
EmitterDict.Clear();
}
protected override void OnCleanUp()
{
foreach (var entityPath in _entityPatchList)
{
entityPath.ReleaseReference();
}
_entityPatchList.Clear();
ObjectAllocatorHolder <SnapshotPatch> .Free(this);
}
public void Serialize(Stream outStream, object message)
{
var stream = ObjectAllocatorHolder <CodedOutputStream> .Allocate();
stream.Initizlize(outStream, _outputBuffer);
(message as IMessage).WriteTo(stream);
stream.Flush();
ObjectAllocatorHolder <CodedOutputStream> .Free(stream);
}
protected override void Free(ClientEffectEmitter emitter)
{
if (Parent)
{
emitter.nodeObject.transform.SetParent(emitter.PoolFolder);
}
ObjectAllocatorHolder <ChunkEffectBehavior> .Free(this);
ChunkEffectBehaviors.Remove(this);
}
protected override void OnCleanUp()
{
foreach (var component in _components.Values)
{
GameCompoentInfo.Free(component.GetComponentId(), component);
}
_components.Clear();
ObjectAllocatorHolder <CompensatioSnapshotGameEntity> .Free(this);
}
protected override void OnCleanUp()
{
Head.ReInit();
foreach (var component in UpdateComponents)
{
GameComponentInfo.Instance.Free(component.GetComponentId(), component);
}
UpdateComponents.Clear();
ObjectAllocatorHolder <UpdateLatestPacakge> .Free(this);
}
public void MergeFrom(IMessage message, Stream input)
{
CodedInputStream codedInputStream = ObjectAllocatorHolder <CodedInputStream> .Allocate();
MemoryStream stream = (MemoryStream)input;
codedInputStream.Initialize(null, stream.GetBuffer(), (int)stream.Position, (int)stream.Length);
message.MergeFrom(codedInputStream);
ObjectAllocatorHolder <CodedInputStream> .Free(codedInputStream);
}
protected override void OnCleanUp()
{
base.OnCleanUp();
if (_lastComponent != null)
{
GameComponentInfo.Instance.Free(_lastComponent);
}
_lastComponent = null;
ObjectAllocatorHolder <ModifyComponentPatch> .Free(this);
}
public static void Free(AssetLoadRequestBatch <T> batch)
{
if (!batch._isDisposed)
{
batch._isDisposed = true;
batch._source = default(T);
batch.OnLoaded = null;
batch._loadedUnityObjects.Clear();
ObjectAllocatorHolder <AssetLoadRequestBatch <T> > .Free(batch);
}
}
protected override void OnCleanUp()
{
active = true;
foreach (var entity in _gameEntities)
{
entity.ReleaseReference();
}
_gameEntities.Clear();
ObjectAllocatorHolder <ListBasedSnapshot> .Free(this);
}
public void Free()
{
if (ShootS != null)
{
ObjectAllocatorHolder <StatisticsHitPlayerEvent> .Free(ShootS);
}
if (ShootC != null)
{
ObjectAllocatorHolder <StatisticsHitPlayerEvent> .Free(ShootC);
}
}
private void OnSend(SocketAsyncEventArgs args)
{
args.Completed -= OnSendComplete;
ObjectAllocatorHolder <SendSocketAsyncEventArgsExt> .Free(args as SendSocketAsyncEventArgsExt);
if (args.SocketError != SocketError.Success)
{
Logger.ErrorFormat("tcp send failed error {0} {1}", args.SocketError, _connectid);
OnDisconnect();
}
}
protected override void OnCleanUp()
{
Player = null;
Bin2DConfig = null;
Bin = null;
ServerTime = 0;
SnapshotSeq = 0;
VehicleSimulationTime = 0;
Channel = null;
PreEntitas.Clear();
_contexts = null;
ObjectAllocatorHolder <CreateSnapshotTask> .Free(this);
}
protected override void OnCleanUp()
{
int count = _list.Count;
for (var i = 0; i < count; i++)
{
//var component = _list[i];
//GameCompoentInfo.Free(component.GetComponentId(), component);
_wrapperLists[i].ReleaseReference();
}
_list.Clear();
_wrapperLists.Clear();
ObjectAllocatorHolder <ListBasedGameEntity> .Free(this);
}
public override IGameComponent GetComponent(int componentId)
{
var fake = ObjectAllocatorHolder <FakeGameComponent> .Allocate();
fake.ComponentId = componentId;
int idx = SortedComponentList.BinarySearch(fake, GameComponentIComparer.Instance);
ObjectAllocatorHolder <FakeGameComponent> .Free(fake);
if (idx >= 0)
{
return(SortedComponentList[idx]);
}
return(null);
}
protected override void OnCleanUp()
{
Snapshot = null;
SnapshotFactory = null;
Player = null;
Bin2DConfig = null;
Bin = null;
ServerTime = 0;
SnapshotSeq = 0;
VehicleSimulationTime = 0;
Channel = null;
PreEnitys.Clear();
ObjectAllocatorHolder <CreateSnapshotParams> .Free(this);
}
public void Send(byte[] bytes, int length, int offset = 0)
{
if (!IsConnected)
{
return;
}
MemoryStream sendBuffer = ObjectAllocatorHolder <MemoryStream> .Allocate();
sendBuffer.Seek(0, SeekOrigin.Begin);
sendBuffer.SetLength(0);
//var lenArray = BitConverter.GetBytes(length);
if (!_littleEndian)
{
sendBuffer.WriteByte((byte)(length >> 24));
sendBuffer.WriteByte((byte)(length >> 16));
sendBuffer.WriteByte((byte)(length >> 8));
sendBuffer.WriteByte((byte)length);
}
else
{
sendBuffer.WriteByte((byte)length);
sendBuffer.WriteByte((byte)(length >> 8));
sendBuffer.WriteByte((byte)(length >> 16));
sendBuffer.WriteByte((byte)(length >> 24));
}
sendBuffer.Write(bytes, offset, length);
//Logger.Debug("RealSendMsg");
try
{
var async = ConnSocket.Send(sendBuffer.GetBuffer(), 0, (int)sendBuffer.Length, SocketFlags.None);
}
catch (Exception e)
{
Logger.ErrorFormat("tcp send failed error {0} {1}", e, _connectid);
OnDisconnect();
}
finally
{
ObjectAllocatorHolder <MemoryStream> .Free(sendBuffer);
}
}
public static Transform GetVehicleSeatTransform(this VehicleEntity vehicle, PlayerEntity player)
{
if (vehicle.hasGameObject)
{
var config = GetSeatConfig(vehicle);
Transform seatTransform;
var seat = GetVehicleSeat(player);
switch (seat)
{
case (int)VehicleSeatIndex.Driver:
seatTransform = config.DriverSeat;
break;
case (int)VehicleSeatIndex.Codriver:
seatTransform = config.CodriverSeat;
break;
case (int)VehicleSeatIndex.BackDriver:
seatTransform = config.BackDriverSeat;
break;
case (int)VehicleSeatIndex.BackCodriver:
seatTransform = config.BackCodriverSeat;
break;
case (int)VehicleSeatIndex.BackDriver_1:
seatTransform = config.BackDriverSeat_1;
break;
case (int)VehicleSeatIndex.BackCodriver_1:
seatTransform = config.BackCodriverSeat_1;
break;
default:
throw new Exception("Undefined Vehicle Seat!");
}
ObjectAllocatorHolder <VehicleSeatConfigInfo> .Free(config);
return(seatTransform);
}
return(null);
}
private static void ConfigureVehicleSeat(this VehicleEntity vehicle)
{
AssertUtility.Assert(vehicle.hasGameObject && vehicle.hasVehicleSeat);
var config = GetSeatConfig(vehicle);
var seats = vehicle.vehicleSeat;
if (config.DriverSeat != null)
{
seats.AddSeat((int)VehicleSeatIndex.Driver);
}
if (config.CodriverSeat != null)
{
seats.AddSeat((int)VehicleSeatIndex.Codriver);
}
if (config.BackDriverSeat != null)
{
seats.AddSeat((int)VehicleSeatIndex.BackDriver);
}
if (config.BackCodriverSeat != null)
{
seats.AddSeat((int)VehicleSeatIndex.BackCodriver);
}
if (config.BackDriverSeat_1)
{
seats.AddSeat((int)VehicleSeatIndex.BackDriver_1);
}
if (config.BackCodriverSeat_1)
{
seats.AddSeat((int)VehicleSeatIndex.BackCodriver_1);
}
ObjectAllocatorHolder <VehicleSeatConfigInfo> .Free(config);
}
public void TestReuseable()
{
List <ReusableApple> list = new List <ReusableApple>();
for (int count = 0; count < 100; count++)
{
for (int i = 0; i < 100; i++)
{
ReusableApple apple = ObjectAllocatorHolder <ReusableApple> .Allocate();
apple.eaten = true;
list.Add(apple);
}
foreach (var s in list)
{
ObjectAllocatorHolder <ReusableApple> .Free(s);
}
}
var o = ObjectAllocatorHolder <ReusableApple> .Allocate();
Assert.IsFalse(o.eaten);
}
protected override void OnCleanUp()
{
base.OnCleanUp();
ObjectAllocatorHolder <DeleteEntityPatch> .Free(this);
}
protected override void OnCleanUp()
{
EType = TriggerObjectSyncEventType.Undefined;
ObjectAllocatorHolder <ChunkSyncEvent> .Free(this);
}
} //cmd count
protected override void OnCleanUp()
{
ObjectAllocatorHolder <VehicleCmd> .Free(this);
}
protected override void OnCleanUp()
{
ResetObject(_value);
ObjectAllocatorHolder <TChild> .Free(this as TChild);
}
protected override void OnCleanUp()
{
OutStream = Stream.Null;
ObjectAllocatorHolder <MyBinaryWriter> .Free(this);
}
