public void OnOutgoingNetworkMessage(EMsg msgType, byte[] data)
{
LastOutgoingMessage = msgType;
Assert.NotNull(data);
Assert.NotEmpty(data);
}
Type GetMessageBodyType(uint realEMsg)
{
EMsg eMsg = MsgUtil.GetMsg(realEMsg);
if (MessageTypeOverrides.BodyMap.ContainsKey(eMsg))
{
return(MessageTypeOverrides.BodyMap[eMsg]);
}
var protomsgType = typeof(CMClient).Assembly.GetTypes().ToList().Find(type =>
{
if (type.GetInterfaces().ToList().Find(inter => inter == typeof(IExtensible)) == null)
{
return(false);
}
if (type.Name.EndsWith(eMsg.ToString(), StringComparison.OrdinalIgnoreCase))
{
return(true);
}
return(false);
});
return(protomsgType);
}
public void OnOutgoingNetworkMessage(EMsg msgType, byte[] data)
{
LastOutgoingMessage = msgType;
Assert.NotNull(data);
Assert.NotEmpty(data);
}
public void Unsubscribe(EMsg id, Action <IPacketMsg> cb)
{
if (dispatch_map.TryGetValue(id, out var arr))
{
arr.RemoveAll(x => (x == cb));
}
}
static IPacketMsg GetPacketMsg(byte[] data)
{
uint rawEMsg = BitConverter.ToUInt32(data, 0);
EMsg eMsg = MsgUtil.GetMsg(rawEMsg);
switch (eMsg)
{
// certain message types are always MsgHdr
case EMsg.ChannelEncryptRequest:
case EMsg.ChannelEncryptResponse:
case EMsg.ChannelEncryptResult:
return(new PacketMsg(eMsg, data));
}
if (MsgUtil.IsProtoBuf(rawEMsg))
{
// if the emsg is flagged, we're a proto message
return(new PacketClientMsgProtobuf(eMsg, data));
}
else
{
// otherwise we're a struct message
return(new PacketClientMsg(eMsg, data));
}
}
public void SendMsg(EMsg msg, params object[] args)
{
for (int i = 0; i < mMsgListener.Count; ++i)
{
mMsgListener[i].OnMsg(msg, args);
}
}
public void OnMsg(EMsg msg, params object[] args)
{
switch (msg)
{
case EMsg.View_Prefab_Build:
BiologyViewRoot viewRoot = (BiologyViewRoot)args[1];
m_Barrel = viewRoot.barrelController;
m_BillBoard = viewRoot.billBoard;
if (m_Target != null)
{
m_Barrel.AimTarget = m_Target;
}
break;
case EMsg.View_Model_Destroy:
if (m_TowerEffect != null && m_TowerEffect.Count > 0)
{
for (int i = 0; i < m_TowerEffect.Count; i++)
{
m_TowerEffect[i].Destroy();
}
}
break;
default:
break;
}
}
public static void On(EMsg msg, Action <Bot, IPacketMsg> callback)
{
foreach (var bot in List)
{
bot.On(msg, callback);
}
}
public void OnMsg(EMsg msg, params object[] args)
{
switch (msg)
{
#if USE_TRIGGER_FOR_SKILL
case EMsg.View_Model_AttachJoint:
GameObject injuredBuild = args[0] as GameObject;
PETrigger.AttachTriggerEvent(injuredBuild, OnColliderEnter, null, null);
break;
case EMsg.View_Model_DeatchJoint:
GameObject injuredDestroy = args[0] as GameObject;
PETrigger.DetachTriggerEvent(injuredDestroy, OnColliderEnter, null, null);
break;
case EMsg.View_Model_Build:
Profiler.BeginSample("View_Model_Build_SkAlive");
GameObject modelBuild = args[0] as GameObject;
PETrigger.AttachTriggerEvent(modelBuild, OnColliderEnter, null, null);
Profiler.EndSample();
break;
case EMsg.View_Model_Destroy:
GameObject modelDestroy = args[0] as GameObject;
PETrigger.DetachTriggerEvent(modelDestroy, OnColliderEnter, null, null);
break;
#endif
case EMsg.State_Revive:
DispatchReviveEvent();
SetAutoBuffActive(true);
isDead = false;
break;
}
}
void IPeMsg.OnMsg(EMsg msg, params object[] args)
{
if (PeGameMgr.IsMulti && null != mCommon && mCommon.Identity == EIdentity.Player)
{
switch (msg)
{
case EMsg.Net_Instantiate:
{
PeMap.LabelMgr.Instance.Add(this);
}
break;
case EMsg.Net_Destroy:
{
PeMap.LabelMgr.Instance.Remove(this);
}
break;
}
}
else
{
if (msg == EMsg.Lod_Collider_Created)
{
PeMap.LabelMgr.Instance.Add(this);
}
else if (msg == EMsg.View_Prefab_Destroy)
{
PeMap.LabelMgr.Instance.Remove(this);
}
}
}
public void OnMsg(EMsg msg, params object[] args)
{
switch (msg)
{
case EMsg.View_Prefab_Build:
if (PeGameMgr.IsSingle)
{
RelationshipDataMgr.RecoverRelationship(PeCreature.Instance.mainPlayerId);
}
else
{
if (Mount)
{
if (Mount.hasView)
{
RideMount();
}
else
{
Mount.biologyViewCmpt.Build();
StartCoroutine("RideMountIterator");
}
}
}
break;
}
}
internal static IPacketMsg GetPacketMsg(byte[] data)
{
uint rawEMsg = BitConverter.ToUInt32(data, 0);
EMsg eMsg = MsgUtil.GetMsg(rawEMsg);
switch (eMsg)
{
// certain message types are always MsgHdr
case EMsg.ChannelEncryptRequest:
case EMsg.ChannelEncryptResponse:
case EMsg.ChannelEncryptResult:
return(new PacketMsg(eMsg, data));
}
try
{
if (MsgUtil.IsProtoBuf(rawEMsg))
{
// if the emsg is flagged, we're a proto message
return(new PacketClientMsgProtobuf(eMsg, data));
}
else
{
// otherwise we're a struct message
return(new PacketClientMsg(eMsg, data));
}
}
catch (Exception ex)
{
DebugLog.WriteLine("CMClient", "Exception deserializing emsg {0} ({1}).\n{2}", eMsg, MsgUtil.IsProtoBuf(rawEMsg), ex.ToString());
return(null);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ClientMsgProtobuf<BodyType>"/> class.
/// This is a client send constructor.
/// </summary>
/// <param name="eMsg">The network message type this client message represents.</param>
/// <param name="payloadReserve">The number of bytes to initialize the payload capacity to.</param>
public ClientMsgProtobuf(EMsg eMsg, int payloadReserve = 64)
: base(payloadReserve)
{
Body = new BodyType();
// set our emsg
Header.Msg = eMsg;
}
public void SendPacket(EMsg type, byte[] payload)
{
SendPacket(new Packet()
{
type = type,
payload = payload
});
}
void IPeMsg.OnMsg(EMsg msg, params object[] args)
{
EventArg e = new EventArg();
e.msg = msg;
e.args = args;
eventor.Dispatch(e, this.Entity);
}
ClientMsgProtobuf <T> GetProtoMsgFromFile <T>(EMsg eMsg, string fileName)
where T : IExtensible, new()
{
var fileData = File.ReadAllBytes(fileName);
var msg = new SteamKit2.PacketClientMsgProtobuf(eMsg, fileData);
var proto = new ClientMsgProtobuf <T>(msg);
return(proto);
}
public void OnMsg(EMsg msg, params object[] args)
{
switch (msg)
{
case EMsg.Net_Proxy:
// RequsetProtect();
break;
}
}
/// <summary>
/// Crafts an EMsg, flagging it if required.
/// </summary>
/// <param name="msg">The EMsg to flag.</param>
/// <param name="protobuf">if set to <c>true</c>, the message is protobuf flagged.</param>
/// <returns>A crafted EMsg, flagged if requested.</returns>
public static EMsg MakeMsg(EMsg msg, bool protobuf = false)
{
if (protobuf)
{
return(( EMsg )(( uint )msg | ProtoMask));
}
return(msg);
}
public void Subscribe <T>(EMsg id, Action <ClientMsgProtobuf <T> > func)
where T : ProtoBuf.IExtensible, new()
{
Subscribe(id, new Action <IPacketMsg>(x =>
{
var msg = new ClientMsgProtobuf <T>(x);
func(msg);
}));
}
void IPeMsg.OnMsg(EMsg msg, params object[] args)
{
switch (msg)
{
case EMsg.View_Prefab_Build:
BiologyViewCmpt obj = args[0] as BiologyViewCmpt;
m_Sleep.m_PhyCtrl = obj.monoPhyCtrl;
break;
}
}
string GetFileName(string direction, EMsg msgType)
{
return(string.Format(
"{0:D3}_{1}_{2:D}_k_EMsg{3}.bin",
Interlocked.Increment(ref MessageNumber),
direction,
msgType,
msgType
));
}
bool IsExpectedEMsg(EMsg msg)
{
return(state switch
{
EncryptionState.Disconnected => false,
EncryptionState.Connected => msg == EMsg.ChannelEncryptRequest,
EncryptionState.Challenged => msg == EMsg.ChannelEncryptResult,
EncryptionState.Encrypted => true,
_ => throw new InvalidOperationException("Unreachable - landed up in undefined state."),
});
static bool FilterNonProtobufMessageBodyTypes(Type type, EMsg eMsg)
{
if (type.GetInterfaces().ToList().Find(@interface => @interface == typeof(ISteamSerializableMessage)) == null)
{
return(false);
}
var gcMsg = Activator.CreateInstance(type) as ISteamSerializableMessage;
return(gcMsg.GetEMsg() == eMsg);
}
void IPeMsg.OnMsg(EMsg msg, params object[] args)
{
if (EMsg.View_Prefab_Build == msg)
{
mousePickable.CollectColliders();
}
else if (EMsg.View_Prefab_Destroy == msg)
{
mousePickable.ClearCollider();
}
}
public void Subscribe(EMsg id, Action <IPacketMsg> cb)
{
dispatch_map.FindOrCreate(id).Add(cb);
if (dispatch_map.TryGetValue(id, out var arr))
{
arr.Add(cb);
return;
}
dispatch_map[id] = new List <Action <IPacketMsg> >();
dispatch_map[id].Add(cb);
}
void IPeMsg.OnMsg(EMsg msg, params object[] args)
{
switch (msg)
{
case EMsg.View_Prefab_Build:
BiologyViewRoot viewRoot = args[1] as BiologyViewRoot;
m_AnimEffectCtrl = viewRoot.ikAnimEffectCtrl;
m_IKAimCtrl = viewRoot.ikAimCtrl;
m_IKFlashLight = viewRoot.ikFlashLight;
m_FBBIK = viewRoot.fbbik;
m_GroundFBBIK = viewRoot.grounderFBBIK;
m_IKArray = viewRoot.ikArray;
if (null != m_IKAimCtrl)
{
m_IKAimCtrl.SetSmoothMoveState(m_SmoothAim);
}
m_AutoCloseFBBIK = (null == m_GroundFBBIK);
if (null != m_FBBIK)
{
m_FBBIK.Disable();
m_FBBIK.solver.iterations = 1;
m_DefaultMappingValue = m_FBBIK.solver.leftArmMapping.weight;
}
if (null != m_GroundFBBIK)
{
m_DefaultSpineBend = m_GroundFBBIK.spineBend;
}
ikEnable = m_IKEnable;
flashLightActive = m_FlashLightActive;
enableArmMap = m_SpineMask.Count == 0;
enableGrounderSpineEffect = m_SpineMask.Count == 0;
break;
// case EMsg.Battle_EnterShootMode:
// enableGrounderSpineEffect = false;
// enableArmMap = false;
// break;
// case EMsg.Battle_ExitShootMode:
// enableGrounderSpineEffect = true;
// enableArmMap = true;
// break;
// case EMsg.Battle_PauseShootMode:
// if(null != m_IKAimCtrl)
// m_IKAimCtrl.SetActive(false);
// break;
// case EMsg.Battle_ContinueShootMode:
// if(null != m_IKAimCtrl)
// m_IKAimCtrl.SetActive(true);
// break;
}
}
public void OnMsg(EMsg msg, params object[] args)
{
switch (msg)
{
case EMsg.Net_Controller:
ActivateImpactDamage(true);
break;
case EMsg.Net_Proxy:
ActivateImpactDamage(false);
break;
}
}
public void OnMsg(EMsg msg, params object[] args)
{
switch (msg)
{
case EMsg.View_Prefab_Build:
//BiologyViewRoot viewRoot = (BiologyViewRoot)args[1];
//m_Barrel = viewRoot.barrelController;
break;
default:
break;
}
}
public void OnMsg(EMsg msg, params object[] args)
{
switch (msg)
{
case EMsg.View_Prefab_Build:
DispatchViewData();
break;
case EMsg.View_Prefab_Destroy:
CollectViewData();
break;
}
}
public static Type GetProtobufMessageBodyType(uint realEMsg)
{
EMsg eMsg = MsgUtil.GetMsg(realEMsg);
if (MessageTypeOverrides.BodyMap.ContainsKey(eMsg))
{
return(MessageTypeOverrides.BodyMap[eMsg]);
}
var protomsgType = SteamKit2Assembly.GetTypes().ToList().Find(t => FilterProtobufMessageBodyType(t, eMsg));
return(protomsgType);
}
public static Type GetProtobufMessageBodyType(uint realEMsg)
{
EMsg eMsg = MsgUtil.GetMsg(realEMsg);
if (MessageTypeOverrides.BodyMap.TryGetValue(eMsg, out var wellKnownType))
{
return(wellKnownType);
}
var protomsgType = SteamKit2Assembly.GetTypes().ToList().Find(t => FilterProtobufMessageBodyType(t, eMsg));
return(protomsgType);
}
public static Type GetNonProtobufMessageBodyType(EMsg eMsg)
{
// lets first find the type by checking all EMsgs we have
var msgType = SteamKit2Assembly.GetTypes().ToList().Find(type =>
{
if (type.GetInterfaces().ToList().Find(@interface => @interface == typeof(ISteamSerializableMessage)) == null)
return false;
var gcMsg = Activator.CreateInstance(type) as ISteamSerializableMessage;
return gcMsg.GetEMsg() == eMsg;
});
return msgType;
}
/// <summary>
/// Initializes a new instance of the <see cref="PacketMsg"/> class.
/// </summary>
/// <param name="eMsg">The network message type for this packet message.</param>
/// <param name="data">The data.</param>
public PacketMsg( EMsg eMsg, byte[] data )
{
MsgType = eMsg;
payload = data;
MsgHdr msgHdr = new MsgHdr();
// deserialize the header to get our hands on the job ids
using ( MemoryStream ms = new MemoryStream( data ) )
{
msgHdr.Deserialize( ms );
}
TargetJobID = msgHdr.TargetJobID;
SourceJobID = msgHdr.SourceJobID;
}
/// <summary>
/// Called when a packet is about to be sent to the Steam server.
/// </summary>
/// <param name="msgType">Network message type of this packet message.</param>
/// <param name="data">Raw packet data that will be sent.</param>
public void OnOutgoingNetworkMessage( EMsg msgType, byte[] data )
{
LogNetMessage( "out", msgType, data );
}
/// <summary>
/// Called when a packet is received from the Steam server.
/// </summary>
/// <param name="msgType">Network message type of this packet message.</param>
/// <param name="data">Raw packet data that was received.</param>
public void OnIncomingNetworkMessage( EMsg msgType, byte[] data )
{
LogNetMessage( "in", msgType, data );
}
string GetFileName( string direction, EMsg msgType )
{
return string.Format(
"{0:D3}_{1}_{2:D}_k_EMsg{3}.bin",
Interlocked.Increment( ref MessageNumber ),
direction,
msgType,
msgType
);
}
public void SetEMsg( EMsg msg ) { this.Msg = msg; }
static bool FilterNonProtobufMessageBodyTypes(Type type, EMsg eMsg)
{
if (type.GetInterfaces().ToList().Find(@interface => @interface == typeof(ISteamSerializableMessage)) == null)
return false;
var gcMsg = Activator.CreateInstance(type) as ISteamSerializableMessage;
return gcMsg.GetEMsg() == eMsg;
}
/// <summary>
/// Initializes a new instance of the <see cref="PacketClientMsg"/> class.
/// </summary>
/// <param name="eMsg">The network message type for this packet message.</param>
/// <param name="data">The data.</param>
public PacketClientMsg( EMsg eMsg, byte[] data )
{
MsgType = eMsg;
payload = data;
ExtendedClientMsgHdr extendedHdr = new ExtendedClientMsgHdr();
// deserialize the extended header to get our hands on the job ids
using ( MemoryStream ms = new MemoryStream( data ) )
{
extendedHdr.Deserialize( ms );
}
TargetJobID = extendedHdr.TargetJobID;
SourceJobID = extendedHdr.SourceJobID;
}
/// <summary>
/// Initializes a new instance of the <see cref="PacketClientMsgProtobuf"/> class.
/// </summary>
/// <param name="eMsg">The network message type for this packet message.</param>
/// <param name="data">The data.</param>
public PacketClientMsgProtobuf( EMsg eMsg, byte[] data )
{
MsgType = eMsg;
payload = data;
MsgHdrProtoBuf protobufHeader = new MsgHdrProtoBuf();
// we need to pull out the job ids, so we deserialize the protobuf header
using ( MemoryStream ms = new MemoryStream( data ) )
{
protobufHeader.Deserialize( ms );
}
TargetJobID = protobufHeader.Proto.jobid_target;
SourceJobID = protobufHeader.Proto.jobid_source;
}
void LogNetMessage( string direction, EMsg msgType, byte[] data )
{
var path = Path.Combine( LogDirectory, GetFileName( direction, msgType ) );
File.WriteAllBytes( path, data );
}
public void OnIncomingNetworkMessage(EMsg msgType, byte[] data)
{
//
}
static bool FilterProtobufMessageBodyType(Type type, EMsg eMsg)
{
if (type.GetInterfaces().ToList().Find(inter => inter == typeof(IExtensible)) == null)
{
return false;
}
if (type.Namespace != "SteamKit2.Internal")
{
return false;
}
if (!type.Name.EndsWith(eMsg.ToString(), StringComparison.OrdinalIgnoreCase))
{
return false;
}
return true;
}
