private bool FlagsReady()
{
m_tmpbuf.Reset();
// Store the flags from the wire into the message structure.
m_msgFlags = 0;
int first = m_tmpbuf[0];
if ((first & V1Protocol.MoreFlag) > 0)
{
m_msgFlags |= MsgFlags.More;
}
// The payload length is either one or eight bytes,
// depending on whether the 'large' bit is set.
if ((first & V1Protocol.LargeFlag) > 0)
{
NextStep(m_tmpbuf, 8, EightByteSizeReadyState);
}
else
{
NextStep(m_tmpbuf, 1, OneByteSizeReadyState);
}
return(true);
}
static public FilteredMsgTypeList Filtered(GameObject inGameObject, MsgFlags inAll, MsgFlags inAny = MsgFlags.None)
{
if (inGameObject == null && (inAll == MsgFlags.None && inAny == MsgFlags.None))
{
return(All());
}
Initialize();
List <MsgType> types = null;
MsgUtil.GetAvailableMsgTypes(inGameObject, ref types);
List <Metadata> metadatas = new List <Metadata>(types.Count);
for (int i = 0; i < types.Count; ++i)
{
Metadata metadata = Manager.Get().Database.Find(types[i]);
if (metadata == null)
{
continue;
}
if ((inAll == MsgFlags.None || metadata.HasFlags(inAll)) &&
(inAny == MsgFlags.None || metadata.HasAnyFlags(inAny)) &&
!metadatas.Contains(metadata))
{
metadatas.Add(metadata);
}
}
metadatas.Sort();
return(new FilteredMsgTypeList(metadatas));
}
private void Clone(Msg m)
{
MsgType = m.MsgType;
m_flags = m.m_flags;
m_size = m.m_size;
m_buf = m.m_buf;
m_data = m.m_data;
}
public void InitGC([NotNull] byte[] data, int size)
{
m_type = MsgType.GC;
m_flags = MsgFlags.None;
m_data = data;
m_size = size;
m_atomicCounter = null;
}
public void InitEmpty()
{
m_type = MsgType.Empty;
m_flags = MsgFlags.None;
m_size = 0;
m_data = null;
m_atomicCounter = null;
}
/// <summary>
/// Clear this Msg to empty - ie, set MsgFlags to None, MsgType to Empty, and clear the Data.
/// </summary>
public void InitEmpty()
{
MsgType = MsgType.Empty;
Flags = MsgFlags.None;
Size = 0;
m_offset = 0;
m_data = null;
EnsureAtomicCounterNull();
}
public void InitPool(int size)
{
m_type = MsgType.Pool;
m_flags = MsgFlags.None;
m_data = BufferPool.Take(size);
m_size = size;
m_atomicCounter = new AtomicCounter();
}
/// <summary>
/// Initialise this Msg to be of MsgType.GC with the given data-buffer value.
/// </summary>
/// <param name="data">the byte-array of data to assign to the Msg's Data property</param>
/// <param name="offset">first byte in the data array</param>
/// <param name="size">the number of bytes that are in the data byte-array</param>
public void InitGC([NotNull] byte[] data, int offset, int size)
{
MsgType = MsgType.GC;
Flags = MsgFlags.None;
m_data = data;
Size = size;
m_offset = offset;
m_refCount = null;
}
/// <summary>
/// Initialise this Msg to be of MsgType.Pool, with a data-buffer of the given number of bytes.
/// </summary>
/// <param name="size">the number of bytes to allocate in the data-buffer</param>
public void InitPool(int size)
{
MsgType = MsgType.Pool;
Flags = MsgFlags.None;
m_data = BufferPool.Take(size);
Size = size;
m_offset = 0;
m_refCount = new AtomicCounter();
}
/// <summary>
/// Clear this Msg to empty - ie, set MsgFlags to None, MsgType to Empty, and clear the Data.
/// </summary>
public void InitEmpty()
{
MsgType = MsgType.Empty;
Flags = MsgFlags.None;
Size = 0;
m_offset = 0;
m_data = null;
m_refCount = null;
}
/// <summary>
/// Initialise this Msg to be of MsgType.GC with the given data-buffer value.
/// </summary>
/// <param name="data">the byte-array of data to assign to the Msg's Data property</param>
/// <param name="offset">first byte in the data array</param>
/// <param name="size">the number of bytes that are in the data byte-array</param>
public void InitGC([NotNull] byte[] data, int offset, int size)
{
MsgType = MsgType.GC;
Flags = MsgFlags.None;
m_data = data;
Size = size;
m_offset = offset;
EnsureAtomicCounterNull();
}
private void Init(MsgType type)
{
this.MsgType = type;
m_flags = MsgFlags.None;
Size = 0;
m_data = null;
m_buf = null;
m_header = null;
}
public override bool SendPackMsg <T>(T msg, MsgFlags flags, int clientId)
{
var packer = new MsgPacker((int)msg.Type, false);
if (msg.PackError(packer))
{
return(false);
}
return(SendMsg(packer, flags, clientId));
}
public void Process()
{
Flags = MakeFlags();
#if UNITY_EDITOR
StringBuilder tooltipText = new StringBuilder();
tooltipText.Append(Name).Append("\n(ID ").Append((int)Type).Append(")");
if (Description.Length > 0)
{
tooltipText.Append("\n - ").Append(Description);
}
if (ArgType == null)
{
tooltipText.Append("\n - No arguments.");
}
else
{
tooltipText.Append("\n - Arg: ").Append(ArgType.FullName);
if (HasFlags(MsgFlags.OptionalArgs))
{
tooltipText.Append(" (Optional)");
}
}
if (HasAnyFlags(MsgFlags.Local | MsgFlags.Global | MsgFlags.Input | MsgFlags.Output))
{
tooltipText.Append("\n -");
if (HasFlags(MsgFlags.Local))
{
tooltipText.Append(" Local");
}
else if (HasFlags(MsgFlags.Global))
{
tooltipText.Append(" Global");
}
if (HasFlags(MsgFlags.Input))
{
tooltipText.Append(" Input");
}
else if (HasFlags(MsgFlags.Output))
{
tooltipText.Append(" Output");
}
if (tooltipText[tooltipText.Length - 1] == ' ')
{
--tooltipText.Length;
}
}
Tooltip = tooltipText.ToString();
#endif
m_Database.Process(this);
}
public static int ZmqMsgGet(Msg msg, MsgFlags option)
{
switch (option)
{
case MsgFlags.More:
return(msg.HasMore ? 1 : 0);
default:
throw InvalidException.Create();
}
}
protected override bool SendPackMsgOne(BaseGameMessage msg,
MsgFlags flags, int clientId)
{
var packer = new MsgPacker((int)msg.MsgId);
if (msg.PackError(packer))
{
return(false);
}
return(SendMsg(packer, flags, clientId));
}
protected override bool SendPackMsgTranslate(GameMsg_SvEmoticon msg, MsgFlags flags, int clientId)
{
var copy = new GameMsg_SvEmoticon
{
ClientId = msg.ClientId,
Emoticon = msg.Emoticon
};
return(Translate(ref copy.ClientId, clientId) &&
SendPackMsgOne(copy, flags, clientId));
}
public override bool SendMsg(MsgPacker msg, MsgFlags flags, int clientId)
{
if (msg == null)
{
return(false);
}
var packet = new Chunk()
{
ClientId = clientId,
DataSize = msg.Size(),
Data = msg.Data(),
Flags = SendFlags.None,
};
if (flags.HasFlag(MsgFlags.Vital))
{
packet.Flags |= SendFlags.Vital;
}
if (flags.HasFlag(MsgFlags.Flush))
{
packet.Flags |= SendFlags.Flush;
}
if (!flags.HasFlag(MsgFlags.NoRecord))
{
// TODO demo record
}
if (flags.HasFlag(MsgFlags.NoSend))
{
return(true);
}
if (clientId == -1)
{
for (var i = 0; i < Clients.Length; i++)
{
if (Clients[i].State == ServerClientState.InGame &&
Clients[i].Quitting == false)
{
packet.ClientId = i;
NetworkServer.Send(packet);
}
}
}
else
{
NetworkServer.Send(packet);
}
return(true);
}
public override bool SendMsgEx(MsgPacker msg, MsgFlags flags, int clientId, bool system)
{
if (msg == null)
{
return(false);
}
var packet = new NetworkChunk()
{
ClientId = clientId,
DataSize = msg.Size(),
Data = msg.Data(),
};
packet.Data[0] <<= 1;
if (system)
{
packet.Data[0] |= 1;
}
if (flags.HasFlag(MsgFlags.VITAL))
{
packet.Flags |= SendFlags.VITAL;
}
if (flags.HasFlag(MsgFlags.FLUSH))
{
packet.Flags |= SendFlags.FLUSH;
}
if (!flags.HasFlag(MsgFlags.NOSEND))
{
if (clientId == -1)
{
for (var i = 0; i < Clients.Length; i++)
{
if (Clients[i].State != ServerClientState.IN_GAME)
{
continue;
}
packet.ClientId = i;
NetworkServer.Send(packet);
}
}
else
{
NetworkServer.Send(packet);
}
}
return(true);
}
private MsgFlags MakeFlags()
{
MsgFlags flags = Flags;
// Don't allow users to determine if the arguments
// are serializable
flags &= ~(MsgFlags.ArgsAreSerializable);
// Auto-populate argument flags.
if (ArgType == null)
{
// Remove optional and requires flags
flags &= ~(MsgFlags.OptionalArgs | MsgFlags.RequiresArgs);
// No argument required
flags |= MsgFlags.NoArgs;
}
else
{
flags &= ~(MsgFlags.NoArgs);
// If the argument isn't optional, set the required flag
if ((flags & MsgFlags.OptionalArgs) != 0)
{
flags |= MsgFlags.RequiresArgs;
}
// Check if the argument is serializable in the editor.
IntPtr typeHandle = ArgType.TypeHandle.Value;
if (typeHandle == TYPE_PTR_BOOL || typeHandle == TYPE_PTR_FLOAT || typeHandle == TYPE_PTR_INT || typeHandle == TYPE_PTR_STRING ||
ArgType.IsEnum || TYPE_UNITYENGINE_OBJECT.IsAssignableFrom(ArgType))
{
flags |= MsgFlags.ArgsAreSerializable;
}
}
// Should this be shown in the editor?
if (string.IsNullOrEmpty(DisplayName))
{
flags &= ~(MsgFlags.VisibleInEditor);
}
else
{
flags |= (MsgFlags.VisibleInEditor);
}
return(flags);
}
protected override bool SendPackMsgBody <T>(T msg, MsgFlags flags, int clientId)
{
if (msg is GameMsg_SvEmoticon)
{
return(SendPackMsgTranslate(msg as GameMsg_SvEmoticon, flags, clientId));
}
if (msg is GameMsg_SvChat)
{
return(SendPackMsgTranslate(msg as GameMsg_SvChat, flags, clientId));
}
if (msg is GameMsg_SvKillMsg)
{
return(SendPackMsgTranslate(msg as GameMsg_SvKillMsg, flags, clientId));
}
return(SendPackMsgTranslate(msg, flags, clientId));
}
protected override bool SendPackMsgTranslate(GameMsg_SvChat msg, MsgFlags flags, int clientId)
{
var copy = new GameMsg_SvChat
{
ClientId = msg.ClientId,
Message = msg.Message,
IsTeam = msg.IsTeam
};
if (copy.ClientId >= 0 && !Translate(ref copy.ClientId, clientId))
{
copy.Message = $"{GetClientName(copy.ClientId)}: {copy.Message}";
copy.ClientId = VANILLA_MAX_CLIENTS - 1;
}
return(SendPackMsgOne(copy, flags, clientId));
}
public void AddReferences(int amount)
{
if (amount == 0)
{
return;
}
if (m_type == MsgType.Pool)
{
if (m_flags == MsgFlags.Shared)
{
m_atomicCounter.Increase(amount);
}
else
{
m_atomicCounter.Set(amount);
m_flags |= MsgFlags.Shared;
}
}
}
public override bool SendPackMsg <T>(T msg, MsgFlags flags, int clientId)
{
var result = true;
if (clientId == -1)
{
for (var i = 0; i < Clients.Length; i++)
{
if (ClientInGame(i))
{
result &= SendPackMsgBody <T>(msg, flags, i);
}
}
}
else
{
return(SendPackMsgBody <T>(msg, flags, clientId));
}
return(result);
}
protected override bool SendPackMsgTranslate(GameMsg_SvKillMsg msg,
MsgFlags flags, int clientId)
{
var copy = new GameMsg_SvKillMsg
{
Weapon = msg.Weapon,
Killer = msg.Killer,
ModeSpecial = msg.ModeSpecial,
Victim = msg.Victim
};
if (!Translate(ref copy.Victim, clientId))
{
return(false);
}
if (!Translate(ref copy.Killer, clientId))
{
copy.Killer = copy.Victim;
}
return(SendPackMsgOne(copy, flags, clientId));
}
/// <summary>
/// Retrieves a list of all editor-visible message types that match the given flags.
/// </summary>
public void FindAll(MsgFlags inAll, ref List <Metadata> ioResults)
{
if (inAll == MsgFlags.None)
{
FindAll(ref ioResults);
return;
}
if (ioResults == null)
{
ioResults = new List <Metadata>();
}
for (int i = 0; i < m_EditorTypes.Count; ++i)
{
Metadata type = m_EditorTypes[i];
if (type.HasFlags(inAll))
{
ioResults.Add(type);
}
}
}
/// <summary>
/// If this Msg is of MsgType.Pool, then - add the given amount number to the reference-counter
/// and set the shared-data Flags bit.
/// If this is not a Pool Msg, this does nothing.
/// </summary>
/// <param name="amount">the number to add to the internal reference-counter</param>
public void AddReferences(int amount)
{
if (amount == 0)
{
return;
}
if (MsgType == MsgType.Pool)
{
if (IsShared)
{
m_refCount.Increase(amount);
}
else
{
// Because msg is not yet shared we add 1 to the amount to represent the current copy of the msg.
// We can set the amount in a none thread-safe way because the message is not yet shared and
// therefore only being used by one thread
m_refCount.Set(amount + 1);
Flags |= MsgFlags.Shared;
}
}
}
/// <summary>
/// Clear the indicated Flags bits.
/// </summary>
/// <param name="flags">which Flags bits to clear (More, Identity, or Shared)</param>
public void ResetFlags(MsgFlags flags)
{
Flags &= ~flags;
}
/// <summary>
/// Set the indicated Flags bits.
/// </summary>
/// <param name="flags">which Flags bits to set (More, Identity, or Shared)</param>
public void SetFlags(MsgFlags flags)
{
Flags |= flags;
}
private void Init(MsgType type)
{
this.MsgType = type;
m_flags = MsgFlags.None;
Size = 0;
m_data = null;
m_buf = null;
m_header = null;
}
private void Clone(Msg m)
{
MsgType = m.MsgType;
m_flags = m.m_flags;
m_size = m.m_size;
m_buf = m.m_buf;
m_data = m.m_data;
}
public void SetFlags(MsgFlags flags)
{
m_flags = m_flags | flags;
}
public void ResetFlags(MsgFlags f)
{
m_flags = m_flags & ~f;
}
public void InitDelimiter()
{
MsgType = MsgType.Delimiter;
m_flags = MsgFlags.None;
}
/// <summary>
/// Set the indicated Flags bits.
/// </summary>
/// <param name="flags">which Flags bits to set (More, Identity, or Shared)</param>
public void SetFlags(MsgFlags flags)
{
Flags |= flags;
}
public static extern int rd_kafka_produce(IntPtr rkt, int partition, MsgFlags msgflags, byte[] payload, int len,
byte[] key,
int keylen, IntPtr msg_opaque);
private bool FlagsReady()
{
// Store the flags from the wire into the message structure.
m_msgFlags = 0;
int first = m_tmpbuf[0];
if ((first & V1Protocol.MoreFlag) > 0)
m_msgFlags |= MsgFlags.More;
// The payload length is either one or eight bytes,
// depending on whether the 'large' bit is set.
if ((first & V1Protocol.LargeFlag) > 0)
NextStep (m_tmpbuf, 8, EightByteSizeReadyState);
else
NextStep (m_tmpbuf,1, OneByteSizeReadyState);
return true;
}
public static int ZmqMsgGet(Msg msg, MsgFlags option)
{
switch (option)
{
case MsgFlags.More:
return msg.HasMore ? 1 : 0;
default:
throw new ArgumentException();
}
}
/// <summary>
/// Set the indicated Flags bits.
/// </summary>
/// <param name="flags">which Flags bits to set (More, Identity, or Shared)</param>
public void SetFlags(MsgFlags flags)
{
this.Flags |= flags;
}
public static int ZmqMsgGet(Msg msg, MsgFlags option)
{
switch (option)
{
case MsgFlags.More:
return msg.HasMore ? 1 : 0;
default:
throw InvalidException.Create();
}
}
/// <summary>
/// Clear the indicated Flags bits.
/// </summary>
/// <param name="flags">which Flags bits to clear (More, Identity, or Shared)</param>
public void ResetFlags(MsgFlags flags)
{
Flags &= ~flags;
}
