void CreateLocalObject(ushort _usPrefabId, CNetworkViewId _cNetworkViewId)
{
//((APrefabInfo)typeof(EPrefab).GetField(_ePrefab.ToString()).GetCustomAttributes(typeof(APrefabInfo), true)[0]).GetResourceName()
// Extract prefab resource name
string sPrefabName = m_mPrefabs[_usPrefabId];
// Create the game object
GameObject cNewgameObject = Resources.Load(ksPrefabDir + sPrefabName, typeof(GameObject)) as GameObject;
if (cNewgameObject == null)
{
Debug.LogError(string.Format("Prefab could not be found. PrefabId({0}) PrefabName({1})", _usPrefabId, sPrefabName));
}
cNewgameObject = GameObject.Instantiate(cNewgameObject) as GameObject;
// Extract network view component from created object
CNetworkView cNetworkView = cNewgameObject.GetComponent <CNetworkView>();
// Ensure the created object has a network view component
Logger.WriteErrorOn(cNetworkView == null, "The created prefab ({0}), name ({1}) does not have a network view!!!", _cNetworkViewId, cNewgameObject.name);
cNetworkView.ViewId = _cNetworkViewId;
m_mCreatedObjects.Add(_cNetworkViewId, new TObjectInfo(_usPrefabId, cNewgameObject));
// Notice
Logger.Write("Created new game object with prefab ({0}), name ({1}) and network view id ({2})", _usPrefabId, cNewgameObject.name, _cNetworkViewId);
}
public static CNetworkView FindUsingViewId(CNetworkViewId _cViewId)
{
CNetworkView cNetworkView = null;
if (_cViewId != null)
{
if (!s_cNetworkViews.ContainsKey(_cViewId.Id))
{
Logger.WriteError("Cannot find network view with id ({0})", _cViewId.Id);
}
else
{
cNetworkView = s_cNetworkViews[_cViewId.Id];
}
if (_cViewId != null &&
_cViewId.IsChildViewId)
{
/*
foreach (KeyValuePair<byte, CNetworkView> Entry in cNetworkView.m_SubNetworkViews)
{
Debug.LogError(string.Format("MyViewId({0}) ChildId({1}) ChildViewId({2}) ChildSubViewId({3}) ",
cNetworkView.ViewId.Id, Entry.Key, Entry.Value.ViewId.Id, Entry.Value.ViewId.SubId));
}
*/
cNetworkView = cNetworkView.FindChildNetworkView(_cViewId.ChildId);
Logger.WriteErrorOn(cNetworkView == null, "Could not find child network view. ViewId({0}) SubViewId({1})", _cViewId.Id, _cViewId.ChildId);
}
}
return (cNetworkView);
}
public GameObject CreateObject(object _cPrefabId)
{
// Ensure only servers call this function
Logger.WriteErrorOn(!CNetwork.IsServer, "Only the server can create objects");
// Generate dynamic network view id for object
CNetworkViewId cObjectViewId = CNetworkView.GenerateDynamicViewId();
// Invoke create local object call on all connected players
InvokeRpcAll("CreateLocalObject", (ushort)_cPrefabId, cObjectViewId);
return(CNetworkView.FindUsingViewId(cObjectViewId).gameObject);
}
public void SwitchToPanel(CDUIPanel _Panel)
{
CNetworkView nv = _Panel.GetComponent <CNetworkView>();
if (nv == null)
{
Debug.LogError("CNetworkView was not found in panel");
}
else
{
m_ActivePanelId.Set(nv.ViewId);
}
}
public GameObject FindObject(CNetworkViewId _cNetworkViewId)
{
CNetworkView cObjectNetworkView = CNetworkView.FindUsingViewId(_cNetworkViewId);
GameObject cGameObject = null;
if (cObjectNetworkView != null)
{
cGameObject = cObjectNetworkView.gameObject;
}
else
{
Logger.WriteErrorOn(cGameObject == null, "Could not find network object with ViewId({0}) SubViewId({1})", _cNetworkViewId.Id, _cNetworkViewId.ChildId);
}
return(cGameObject);
}
void RegisterChildNetworkView(CNetworkView _cChildView)
{
Logger.WriteErrorOn(_cChildView.ViewId != null, "Child network view has already been registered a network view id");
for (byte i = 1; i < byte.MaxValue; ++ i)
{
if (!m_mChildrenNetworkViews.ContainsKey(i))
{
m_mChildrenNetworkViews.Add(i, _cChildView);
_cChildView.ViewId = new CNetworkViewId(0, i);
//Debug.LogError(string.Format("Registered ({0}) sub newwork view with ViewId({1}) SubViewId({2})", _cSubView.gameObject.name, _cSubView.ViewId.Id, _cSubView.ViewId.ChildId));
break;
}
}
}
void DecodingUpdate()
{
if (s_decodedFrames.Count > 0)
{
//Take data from the queue to add to the audioclip.
DecodeInformation decodedFrame = s_decodedFrames.Dequeue();
short[] saDecodedFrames = decodedFrame.saDecodedData;
int numSamples = decodedFrame.iNumSamples;
int frequency = decodedFrame.iFrequency;
CNetworkViewId senderViewID = decodedFrame.cSenderViewID;
float[] faDecodedAudioData = new float[numSamples];
for (int i = 0; i < faDecodedAudioData.Length; ++i)
{
faDecodedAudioData[i] = (float)((float)saDecodedFrames[i] / 32767.0f);
}
// Play audio at location of sender
GameObject senderNetworkView = CNetworkView.FindUsingViewId(senderViewID).gameObject;
AudioSource senderAudioSource = senderNetworkView.gameObject.GetComponent <AudioSource>();
AudioClip newClip = AudioClip.Create("Test", faDecodedAudioData.Length, 1, frequency, true, false);
newClip.SetData(faDecodedAudioData, 0);
senderAudioSource.clip = newClip;
senderAudioSource.volume = 1.0f;
//AudioSystem.GetInstance.Play(newClip, senderNetworkView.gameObject.transform.position, 1.0f, 1.0f, false, 0.0f, AudioSystem.SoundType.SOUND_EFFECTS, true);
CAudioSystem.Play(senderAudioSource, 1.0f, 1.0f, false, 0.0f, CAudioSystem.SoundType.SOUND_EFFECTS, true);
}
if (s_framesToDecode.Count > 0)
{
for (int i = 0; i < m_kiNumDecodeThreads; i++)
{
if (m_DecodeThreads[i].IsAlive == false)
{
m_DecodeThreads[i] = new Thread(new ParameterizedThreadStart(DecodeAudio));
m_DecodeThreads[i].Start((object)s_framesToDecode.Dequeue());
break;
}
}
}
}
void HandleNetworkViewPacket(byte[] _baData)
{
if (IsConnected)
{
// Create stream with data
CNetworkStream cStream = new CNetworkStream(_baData);
// Ignore ID_TIME
cStream.IgnoreBytes(1);
// Retrieve latency
ulong ulLatency = RakNet.RakNet.GetTime() - cStream.ReadULong();
// Ignore EPacketId.NetworkView identifier
cStream.IgnoreBytes(1);
// Process packet data
CNetworkView.ProcessInboundStream(ulLatency, cStream);
// Logger.WriteError("Processed Inbound Data of size ({0})", cStream.GetSize());
}
}
public void PickupTool(GameObject _cInteractableObject)
{
// Check object exists
if (_cInteractableObject != null)
{
// Find free slot
for (uint i = 0; i < ToolCapacity; ++i)
{
if (GetToolViewId(i) == null)
{
// Retrieve tool interface script
CToolInterface cToolInterface = _cInteractableObject.GetComponent <CToolInterface>();
CNetworkView cToolNetworkView = _cInteractableObject.GetComponent <CNetworkView>();
// Check script found
if (cToolInterface == null)
{
Debug.LogError(string.Format("Target tool does not have the CToolInterface component attached! ObjectName({0})", _cInteractableObject.name));
}
else if (cToolInterface.IsHeld)
{
break;
}
else
{
m_acToolsViewId[i].Set(cToolNetworkView.ViewId);
cToolInterface.NotifyPickedUp(m_ulOwnerPlayerId);
ChangeTool((byte)i);
// Commented out by Nathan to avoid extraneous debug information.
// Feel free to uncomment for debugging purposes when required.
//Debug.Log(string.Format("Picked up tool. PlayerId({0}) ToolObjectName({1}) SlotId({2})", _ulPlayerId, _cInteractableObject.name, i));
}
break;
}
}
}
}
public void SyncPlayer(CNetworkPlayer _cNetworkPlayer)
{
// Ensure only servers call this function
Logger.WriteErrorOn(!CNetwork.IsServer, "Only the server can sync players");
// Sync new player with all the current game objects are their network var values
if (!_cNetworkPlayer.IsHost)
{
Logger.Write("A Player joined. Sending them the objects and states");
foreach (KeyValuePair <CNetworkViewId, TObjectInfo> tEntry in m_mCreatedObjects)
{
// Tell player to instantiate already created object
InvokeRpc(_cNetworkPlayer.PlayerId, "CreateLocalObject", tEntry.Value.usPrefab, tEntry.Key);
}
// Sync parents for each transform
foreach (KeyValuePair <CNetworkViewId, TObjectInfo> tEntry in m_mCreatedObjects)
{
if (tEntry.Value.cGameObject == null)
{
Debug.LogError(string.Format("Gameobject({0}) is null. PrefabId({1})", tEntry.Value.cGameObject, tEntry.Value.usPrefab));
}
if (tEntry.Value.cGameObject.GetComponent <CNetworkView>() == null)
{
Debug.LogError(string.Format("Gameobject({0}) does not have a networkview. PrefabId({1})", tEntry.Value.cGameObject, tEntry.Value.usPrefab));
}
// Extract the network view from this object
CNetworkView cSelfView = tEntry.Value.cGameObject.GetComponent <CNetworkView>();
// Only sync if position is not default
if (tEntry.Value.cGameObject.transform.position != Vector3.zero)
{
cSelfView.SyncTransformPosition();
}
// Sync if rotation is not default
if (tEntry.Value.cGameObject.transform.eulerAngles != Vector3.zero)
{
cSelfView.SyncTransformRotation();
}
// Sync if scale is not default
if (tEntry.Value.cGameObject.transform.localScale != Vector3.zero)
{
// Sync object's scale
cSelfView.SyncTransformScale();
}
}
// Sync network vars last
foreach (KeyValuePair <CNetworkViewId, TObjectInfo> tEntry in m_mCreatedObjects)
{
// Extract the network view from this object
CNetworkView cNetworkView = tEntry.Value.cGameObject.GetComponent <CNetworkView>();
// Tell object to sync all their network vars with the player
cNetworkView.SyncNetworkVarsWithPlayer(_cNetworkPlayer.PlayerId);
// Have children network views to sync their values
foreach (KeyValuePair <byte, CNetworkView> tEntity in cNetworkView.ChildrenNetworkViews)
{
tEntity.Value.SyncNetworkVarsWithPlayer(_cNetworkPlayer.PlayerId);
}
}
}
}
public static void ProcessInboundStream(ulong _uiLatency, CNetworkStream _cStream)
{
List<INetworkVar> cSyncedNetworkVars = new List<INetworkVar>();
float fSyncedTick = 0.0f;
if (CNetwork.IsServer)
{
fSyncedTick = ((float)RakNet.RakNet.GetTimeMS()) / 1000.0f;
fSyncedTick -= Mathf.Floor(fSyncedTick);
fSyncedTick *= CNetworkServer.k_fSendRate;
}
else
{
fSyncedTick = CNetwork.Connection.Tick - ((float)_uiLatency / 1000.0f);
if (fSyncedTick < 0.0f)
{
fSyncedTick = CNetworkServer.k_fSendRate - fSyncedTick;
//Debug.Log(fSyncedTick);
}
}
while (_cStream.HasUnreadData)
{
// Extract owner network view id
CNetworkViewId cNetworkViewId = _cStream.ReadNetworkViewId();
// Extract procedure type
EProdecure eProcedure = (EProdecure)_cStream.ReadByte();
// Retrieve network view instance
CNetworkView cNetworkView = CNetworkView.FindUsingViewId(cNetworkViewId);
// Process network var sync procedure
if (eProcedure == EProdecure.SyncNetworkVar)
{
// Extract network var identifier
byte bNetworkVarIdentifier = _cStream.ReadByte();
// Retrieve network var instance
INetworkVar cNetworkVar = cNetworkView.m_mNetworkVars[bNetworkVarIdentifier];
// Retrieve network var type
Type cVarType = cNetworkVar.GetValueType();
// Extract value serialized
object cNewVarValue = _cStream.ReadType(cVarType);
// Sync with new value
cNetworkVar.SyncValue(cNewVarValue, fSyncedTick);
// Add to callback list
cSyncedNetworkVars.Add(cNetworkVar);
}
// Process network rpc procedure
else if (eProcedure == EProdecure.InvokeNetworkRpc)
{
// Extract rpc method identifier
byte bMethodIdentifier = _cStream.ReadByte();
// Retrieve method owner instance
Component cParentComponent = cNetworkView.m_mNetworkRpcs[bMethodIdentifier].cUnityComponent;
// Retrieve method info
MethodInfo cMethodInfo = cNetworkView.m_mNetworkRpcs[bMethodIdentifier].cMethodInfo;
// Extract method parameters
object[] caParameterValues = _cStream.ReadMethodParameters(cMethodInfo);
// Invoke the rpc method
cMethodInfo.Invoke(cParentComponent, caParameterValues);
}
}
// Invoke callbacks for synced network vars
foreach (INetworkVar cSyncedNetworkVar in cSyncedNetworkVars)
{
cSyncedNetworkVar.InvokeSyncCallback();
}
}
public void SyncNetworkVar(ulong _ulPlayerId, byte _bNetworkVarId)
{
// Ensure only servers can sync network vars
Logger.WriteErrorOn(!CNetwork.IsServer, "Clients cannot sync network vars fool!");
// Instance new packet stream
CNetworkStream cVarStream = new CNetworkStream();
// View id
cVarStream.Write(this.ViewId);
// Prodecure type
cVarStream.Write((byte)EProdecure.SyncNetworkVar);
// Network var identifier
cVarStream.Write(_bNetworkVarId);
// Network var value
cVarStream.Write(m_mNetworkVars[_bNetworkVarId].GetValueObject(), m_mNetworkVars[_bNetworkVarId].GetValueType());
// Send to all players
if (_ulPlayerId == 0)
{
// Process on server straight away
CNetworkView.ProcessInboundStream(0, cVarStream);
cVarStream.SetReadOffset(0);
// Append network var sync stream to connected non-host players
foreach (KeyValuePair<ulong, CNetworkPlayer> tEntry in CNetwork.Server.FindNetworkPlayers())
{
// Make host execute sync straight away
if (!tEntry.Value.IsHost)
{
// Append packet data
tEntry.Value.NetworkViewStream.Write(cVarStream);
}
}
// Notice
//Logger.Write("Sent network var sync (id {0}) to all players", _bNetworkVarId);
}
// Send to individual player
else
{
// Retieve player instance
CNetworkPlayer cNetworkPlayer = CNetwork.Server.FindNetworkPlayer(_ulPlayerId);
// Make host execute sync straight away
if (cNetworkPlayer.IsHost)
{
CNetworkView.ProcessInboundStream(0, cVarStream);
cVarStream.SetReadOffset(0);
}
else
{
// Append packet data
cNetworkPlayer.NetworkViewStream.Write(cVarStream);
}
// Notice
//Logger.Write("Sent network var sync id ({0}) to player id ({1})", _bNetworkVarId, _ulPlayerId);
}
}
public void InvokeRpc(ulong _ulPlayerId, Component _cComponent, string _sFunction, params object[] _caParameterValues)
{
// Ensure sure only servers can invoke rpcs
Logger.WriteErrorOn(!CNetwork.IsServer, "Only servers can invoke RPCs douche");
// Extract method from component using its name
MethodInfo tMethodInfo = _cComponent.GetType().GetMethod(_sFunction, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
// Ensure the method exists
Logger.WriteErrorOn(tMethodInfo == null, "Could not find method ({0}) in component ({1})", _sFunction, _cComponent.GetType().Name);
// Find network rpc index using the method info
byte bNetworkRpcId = FindNetworkRpcIndexUsingMethodInfo(tMethodInfo);
// Ensure the network rpc was found
Logger.WriteErrorOn(bNetworkRpcId == 0, "The network rpc method ({0}) in component ({1}) is not connected to this network view id ({2})", _sFunction, _cComponent.GetType().Name, this.ViewId);
// Instance new packet stream
CNetworkStream cRpcStream = new CNetworkStream();
// View id
cRpcStream.Write(this.ViewId);
// Prodecure type
cRpcStream.Write((byte)EProdecure.InvokeNetworkRpc);
// Rpc identifier
cRpcStream.Write(bNetworkRpcId);
// Method parameter values
cRpcStream.Write(tMethodInfo, _caParameterValues);
// Send to all players
if (_ulPlayerId == 0)
{
// Process on server straight away
CNetworkView.ProcessInboundStream(0, cRpcStream);
cRpcStream.SetReadOffset(0);
// Append rpc stream to connected non-host players
foreach (KeyValuePair<ulong, CNetworkPlayer> tEntry in CNetwork.Server.FindNetworkPlayers())
{
// Make host execute RPC straight away
if (!tEntry.Value.IsHost)
{
// Append packet data
tEntry.Value.NetworkViewStream.Write(cRpcStream);
//Logger.WriteError("Written {0} bytes into player ({1})", cRpcStream.Size, tEntry.Value.PlayerId);
}
}
// Notice
Logger.Write("Sent RPC call for ({0}) to all players", _sFunction);
}
// Send to individual player
else
{
// Retrieve player instance
CNetworkPlayer cNetworkPlayer = CNetwork.Server.FindNetworkPlayer(_ulPlayerId);
// Make host execute RPC straight away
if (cNetworkPlayer.IsHost)
{
CNetworkView.ProcessInboundStream(0, cRpcStream);
cRpcStream.SetReadOffset(0);
}
else
{
// Append packet data
cNetworkPlayer.NetworkViewStream.Write(cRpcStream);
}
Logger.Write("Sent RPC call for ({0}) to player id ({1})", _sFunction, _ulPlayerId);
}
}
