public void OnRead(TransportConnection connection, ref DataBufferReader reader)
{
var ev = reader.ReadValue <SControllerEvent>();
var entity = playerManager.Get(connection, ev.Player);
switch (ev.State)
{
case SControllerEvent.EState.Paused:
break;
case SControllerEvent.EState.Stop:
entity.Set(new StopAudioRequest());
break;
case SControllerEvent.EState.Play:
var resource = resourceManager.GetWav(connection, ev.ResourceId);
entity.Set(resource);
entity.Set(new PlayAudioRequest());
break;
default:
throw new ArgumentOutOfRangeException();
}
entity.Set <StandardAudioPlayerComponent>();
if (ev.Delay > TimeSpan.Zero)
{
entity.Set(new AudioDelayComponent(worldTime.Total + ev.Delay - worldTime.Delta));
}
}
public bool Parse(PacketEvent packet)
{
DataBuffer rawInput = new DataBuffer(packet.GetData(), packet.GetLength());
DataBufferReader reader = new DataBufferReader();
int firstByte = reader.Read8(rawInput);
this.version = firstByte >> 6;
this.padding = ((firstByte >> 5 & 1) != 0);
this.hasExtension = ((firstByte >> 4 & 1) != 0);
this.csrcCount = firstByte & 0xF;
int secondByte = reader.Read8(rawInput);
this.marker = (secondByte & 0x80) == 0x80;
this.payloadType = secondByte & 0x7f;
this.SequenceNumber = reader.Read16(rawInput);
this.timestamp = reader.ReadInteger(rawInput);
this.ssrc = reader.ReadInteger(rawInput);
int block3 = reader.Read8(rawInput);
bool bflag = (block3 >> 7 & 1) != 0;
bool jflag = ((block3 >> 6 & 1) & 0x1) != 0;
bool zflag = ((block3 >> 5 & 1) & 0x1) != 0;
bool pflag = ((block3 >> 4 & 1) & 0x1) != 0;
int command_length = block3 & 0x7;
this.payload = rawInput.Slice(rawInput.GetStreamPosition());
this.payload_length = rawInput.GetBytesLength() - rawInput.GetStreamPosition();
return(true);
}
private void OnReceiveResource(TransportConnection connection, ref DataBufferReader reader)
{
var count = reader.ReadValue <int>();
for (var i = 0; i != count; i++)
{
var id = reader.ReadValue <int>();
var type = (EAudioRegisterResourceType)reader.ReadValue <int>();
switch (type)
{
case EAudioRegisterResourceType.Bytes:
{
var data = new byte[reader.ReadValue <int>()];
reader.ReadDataSafe(data.AsSpan());
resourceManager.Register(connection, id, data);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
}
protected override void OnUpdate()
{
// Update first...
foreach (var(featureEntity, feature) in Features)
{
feature.Driver.Update();
while (feature.Driver.Accept().IsCreated)
{
}
// todo: check events for errors and all
TransportEvent ev;
while ((ev = feature.Driver.PopEvent()).Type != TransportEvent.EType.None)
{
switch (ev.Type)
{
case TransportEvent.EType.None:
break;
case TransportEvent.EType.RequestConnection:
break;
case TransportEvent.EType.Connect:
break;
case TransportEvent.EType.Disconnect:
break;
case TransportEvent.EType.Data:
var reader = new DataBufferReader(ev.Data);
var type = (EAudioSendType)reader.ReadValue <int>();
switch (type)
{
case EAudioSendType.Unknown:
throw new InvalidOperationException();
case EAudioSendType.RegisterResource:
throw new InvalidOperationException("shouldn't be called");
case EAudioSendType.SendReplyResourceData:
{
clientReceiveAudioResourceDataSystem.OnMessage(ref reader);
break;
}
case EAudioSendType.SendAudioPlayerData:
throw new InvalidOperationException("shouldn't be called");
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
}
public bool Parse(PacketEvent packet)
{
this.valid = false;
DataBuffer rawInput = new DataBuffer(packet.GetData(), packet.GetLength());
DataBufferReader reader = new DataBufferReader();
int protocol = reader.Read16(rawInput);
if (protocol == 0xffff)
{
command = commandMap.GetValueOrDefault <int, AppleMIDICommand>(reader.Read16(rawInput));
switch (command)
{
case AppleMIDICommand.INVITATION:
case AppleMIDICommand.INVITATION_ACCEPTED:
case AppleMIDICommand.INVITATION_REJECTED:
case AppleMIDICommand.END:
this.valid = true;
protocol_version = reader.ReadInteger(rawInput);
initiator_token = reader.ReadInteger(rawInput);
ssrc = reader.ReadInteger(rawInput);
name = reader.ReadString(rawInput);
// this.version = buffer.readUInt32BE(4);
// this.token = buffer.readUInt32BE(8);
// this.ssrc = buffer.readUInt32BE(12);
// this.name = buffer.toString('utf-8', 16);
break;
case AppleMIDICommand.SYNCHRONIZATION:
this.valid = true;
ssrc = reader.ReadInteger(rawInput);
count = reader.Read8(rawInput);
padding = reader.Read24(rawInput);
timestamp1 = reader.ReadUnsignedInteger64(rawInput);
timestamp2 = reader.ReadUnsignedInteger64(rawInput);
timestamp3 = reader.ReadUnsignedInteger64(rawInput);
// this.ssrc = buffer.readUInt32BE(4, 8);
// this.count = buffer.readUInt8(8);
// this.padding = (buffer.readUInt8(9) << 0xF0) + buffer.readUInt16BE(10);
// this.timestamp1 = buffer.slice(12, 20); //[buffer.readUInt32BE(12), buffer.readUInt32BE(16)];
// this.timestamp2 = buffer.slice(20, 28); //[buffer.readUInt32BE(20), buffer.readUInt32BE(24)];
// this.timestamp3 = buffer.slice(28, 36); //[buffer.readUInt32BE(28), buffer.readUInt32BE(32)];
break;
case AppleMIDICommand.RECEIVER_FEEDBACK:
this.valid = true;
ssrc = reader.ReadInteger(rawInput);
sequenceNumber = reader.Read16(rawInput);
// this.ssrc = buffer.readUInt32BE(4, 8);
// this.sequenceNumber = buffer.readUInt16BE(8);
break;
case AppleMIDICommand.BITRATE_RECEIVE_LIMIT:
this.valid = true;
break;
}
}
return(valid);
}
private void addComponent <T>(Entity entity, ref DataBufferReader reader)
where T : ITransportableData, new()
{
var data = new T();
data.Deserialize(ref reader);
entity.Set(data);
}
public Entity Deserialize(ref DataBufferReader data)
{
var entity = World.Mgr.CreateEntity();
var str = data.ReadString();
var type = Type.GetType(str);
CreateComponent(type, entity, ref data);
return(entity);
}
private void OnReceivePlayer(TransportConnection connection, ref DataBufferReader reader)
{
var count = reader.ReadValue <int>();
for (var i = 0; i != count; i++)
{
var id = reader.ReadValue <int>();
var type = reader.ReadString();
playerManager.Register(connection, id, type);
}
}
private void CreateComponent(Type type, Entity entity, ref DataBufferReader reader)
{
if (!createComponentMap.TryGetValue(type, out var method))
{
method = (CreateComponentDel)GetType().GetMethod(nameof(addComponent), BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(type)
.CreateDelegate(typeof(CreateComponentDel), this);
createComponentMap[type] = method;
}
method(entity, ref reader);
}
public void OnMessage(ref DataBufferReader reader)
{
var resourceId = reader.ReadValue <int>();
var wavLength = reader.ReadValue <double>();
foreach (var entity in resourceSet.GetEntities())
{
if (!entity.TryGet(out AudioResource audioResource))
{
continue;
}
audioResource.Length = TimeSpan.FromSeconds(wavLength);
}
}
public bool ParseMessage(PacketEvent packet)
{
this.valid = false;
Parse(packet);
DataBufferReader reader = new DataBufferReader();
DataBuffer rawPayload = new DataBuffer(payload, payload_length);
if (payload_length > 0)
{
message = rawPayload.GetBytes();
this.valid = true;
// Log.Debug("MIDIMessage", "byte array:" + BitConverter.ToString(message).Replace("-", ""));
return(true);
}
else
{
return(false);
}
}
public boolean parseMessage(PacketEvent packet)
{
this.valid = false;
parse(packet);
DataBufferReader reader = new DataBufferReader();
DataBuffer rawPayload = new DataBuffer(payload, payload_length);
// payload should contain command + journal
int block4 = reader.read8(rawPayload);
channel_status = block4 >> 4;
channel = block4 & 0xf;
int block5 = reader.read8(rawPayload);
note = block5 & 0x7f;
int block6 = reader.read8(rawPayload);
velocity = block6 & 0x7f;
this.valid = true;
Log.d("MIDIMessage", "cs:" + channel_status + " c:" + channel + " n:" + note + " v" + velocity);
return(true);
}
public JobHandle Deserialize(EntityManager entityManager, ICustomComponentArchetypeAttach attach, NativeArray <GhGameEntitySafe> gameEntities, NativeArray <Entity> output, DataBufferReader reader)
{
return(default);
protected override void OnUpdate()
{
base.OnUpdate();
foreach (var(_, feature) in Features)
{
feature.Driver.Update();
while (feature.Driver.Accept().IsCreated)
{
}
TransportEvent ev;
while ((ev = feature.Driver.PopEvent()).Type != TransportEvent.EType.None)
{
switch (ev.Type)
{
case TransportEvent.EType.None:
break;
case TransportEvent.EType.RequestConnection:
break;
case TransportEvent.EType.Connect:
break;
case TransportEvent.EType.Disconnect:
break;
case TransportEvent.EType.Data:
var reader = new DataBufferReader(ev.Data);
var type = (EAudioSendType)reader.ReadValue <int>();
switch (type)
{
case EAudioSendType.Unknown:
break;
case EAudioSendType.RegisterResource:
OnReceiveResource(ev.Connection, ref reader);
break;
case EAudioSendType.RegisterPlayer:
OnReceivePlayer(ev.Connection, ref reader);
break;
case EAudioSendType.SendAudioPlayerData:
var player = reader.ReadBuffer <CharBuffer128>();
var @delegate = playerManager.GetDelegate(player);
@delegate?.Invoke(ev.Connection, ref reader);
break;
default:
throw new ArgumentOutOfRangeException($"EAudioSendType: " + type);
}
break;
default:
throw new ArgumentOutOfRangeException($"MessageType" + ev.Type);
}
}
}
}
public void Deserialize(EntityManager em, NativeHashMap <GhGameEntitySafe, Entity> ghEntityToUEntity, ref T component, ref DataBufferReader reader)
{
reader.ReadValue <GhComponentType>(); // skip StatusEffectSettingsBase.Type
component.Resistance = reader.ReadValue <float>();
component.RegenPerSecond = reader.ReadValue <float>();
component.Power = reader.ReadValue <float>();
component.Immunity = reader.ReadValue <float>();
}
public void Deserialize(EntityManager em, NativeHashMap <GhGameEntitySafe, Entity> ghEntityToUEntity, ref PlayerCurrentCityLocation component, ref DataBufferReader reader)
{
ghEntityToUEntity.TryGetValue(reader.ReadValue <GhGameEntitySafe>(), out component.Entity);
}
public void Deserialize(EntityManager em, NativeHashMap <GhGameEntitySafe, Entity> ghEntityToUEntity, ref OwnerActiveAbility component, ref DataBufferReader reader)
{
var replica = reader.ReadValue <Replica>();
LastActivationTime = replica.LastActivationTime;
LastCommandActiveTime = replica.LastCommandActiveTime;
ghEntityToUEntity.TryGetValue(replica.Previous, out PreviousActive);
ghEntityToUEntity.TryGetValue(replica.Active, out Active);
ghEntityToUEntity.TryGetValue(replica.Incoming, out Incoming);
CurrentCombo = replica.CurrentCombo;
component = this;
}
public void Deserialize(EntityManager em, NativeHashMap <GhGameEntitySafe, Entity> ghEntityToUEntity, ref UnitEnemySeekingState component, ref DataBufferReader reader)
{
var replica = reader.ReadValue <Replica>();
RelativeDistance = replica.RelativeDistance;
SelfDistance = replica.SelfDistance;
ghEntityToUEntity.TryGetValue(replica.Enemy, out Enemy);
component = this;
}
public void Deserialize(EntityManager em, NativeHashMap <GhGameEntitySafe, Entity> ghEntityToUEntity, ref HideoutLeaderSquad component, ref DataBufferReader reader)
{
ghEntityToUEntity.TryGetValue(reader.ReadValue <GhGameEntitySafe>(), out component.Leader);
}
