public void AssignControl(Connection connection, IMessageRider token)
{
if (IsOwner)
{
if (HasControl)
{
ReleaseControl(token);
}
EntityProxy proxy;
CommandLastExecuted = null;
CommandSequence = 0;
CommandQueue.Clear();
Controller = connection;
Controller.controlling.Add(this);
Controller.entityChannel.CreateOnRemote(this, out proxy);
Controller.entityChannel.ForceSync(this);
// set token
proxy.ControlTokenLost = null;
proxy.ControlTokenGained = token;
Freeze(false);
}
else
{
NetLog.Error("You can not assign control of {0}, you are not the owner", this);
}
}
public static byte[] ToByteArray(this IMessageRider token)
{
if (token == null)
{
return(null);
}
if ((tempBytes == null) || (tempBytes.Length != (Core.Config.packetSize - 256)))
{
tempBytes = new byte[Core.Config.packetSize - 256];
}
if (tempPacket == null)
{
tempPacket = new Packet();
}
// clear data
Array.Clear(tempBytes, 0, tempBytes.Length);
// setup packet
tempPacket.Position = 0;
tempPacket.ByteBuffer = tempBytes;
tempPacket.Size = tempBytes.Length << 3;
tempPacket.WriteByte(Factory.GetTokenId(token));
// write token
token.Write(tempPacket);
return(tempPacket.DuplicateData());
}
void HandleToken(NetworkMsg type, IMessageRider token)
{
byte[] data = token.ToByteArray();
switch (type)
{
case NetworkMsg.Connect:
ConnectToken = data;
break;
case NetworkMsg.Accept:
AcceptToken = data;
break;
case NetworkMsg.Disconnect:
DisconnectToken = data;
break;
case NetworkMsg.Refuse:
RefuseToken = data;
break;
default:
break;
}
}
public bool ReceiveToken(byte[] data, int dataSize, out IMessageRider riderToken, out NetworkMsg type)
{
byte tokType;
int size;
riderToken = socketInterface.ReadToken(dataSize, data, out tokType, out size);
//Null token received
if (size == 0)
{
//NetLog.Info("<color=green> GOT A NULL TOKEN </color>");
}
type = (NetworkMsg)tokType;
if (type != NetworkMsg.Unknown)
{
//Handle null tokens
if (size == 0)
{
return(true);
}
if (riderToken != null)
{
SocketLog.Info("{0} token successfully received from host", type);
return(true);
}
}
SocketLog.Error("Failed to unpack {0} token from host", type);
return(false);
}
public void TakeControl(IMessageRider token)
{
if (IsOwner)
{
if (HasControl)
{
NetLog.Warn("You already have control of {0}", this);
}
else
{
// revoke any existing control
RevokeControl(token);
// take control locally
TakeControlInternal(token);
// de-freeze
Freeze(false);
}
}
else
{
NetLog.Error("Only the owner of {0} can take control of it", this);
}
}
public void ReleaseControlInternal(IMessageRider token)
{
NetAssert.True(Flags & EntityFlags.HAS_CONTROL);
Flags &= ~EntityFlags.HAS_CONTROL;
CommandQueue.Clear();
CommandSequence = 0;
CommandLastExecuted = null;
ControlLostToken = token;
ControlGainedToken = null;
// call to serializer
Serializer.OnControlLost();
// call to user behaviours
foreach (IEntityBehaviour eb in Behaviours)
{
if (ReferenceEquals(eb.entity, this.UnityObject))
{
eb.ControlLost();
}
}
// call user event
GlobalEventListenerBase.ControlOfEntityLostInvoke(UnityObject);
// de-freeze
Freeze(false);
}
/// <summary>
/// Remove a gameObject from the Ascension simulation.
/// </summary>
public static void Destroy(GameObject gameObject, IMessageRider token)
{
if (IsRunning)
{
AscensionEntity entity = gameObject.GetComponent <AscensionEntity>();
if (entity)
{
Core.Destroy(entity, token);
}
else
{
if (token != null)
{
UnityEngine.Debug.LogWarning("Passing protocol token to destroy call for gameobject without ascension entity, token will be ignored");
}
UnityEngine.Object.Destroy(gameObject);
}
}
else
{
if (token != null)
{
UnityEngine.Debug.LogWarning("Passing protocol token to destroy call for gameobject when ascension is not running, token will be ignored");
}
UnityEngine.Object.Destroy(gameObject);
}
}
public void RevokeControl(IMessageRider token)
{
if (IsOwner)
{
if (Controller)
{
EntityProxy proxy;
// force a replication of this
Controller.controlling.Remove(this);
Controller.entityChannel.ForceSync(this, out proxy);
Controller = null;
// clear out everything
CommandLastExecuted = null;
CommandSequence = 0;
CommandQueue.Clear();
// set token
if (proxy != null)
{
proxy.ControlTokenLost = token;
proxy.ControlTokenGained = null;
}
}
Freeze(false);
}
else
{
NetLog.Error("You can not revoke control of {0}, you are not the owner", this);
return;
}
}
private void DestroyIncommingProxy(EntityProxy proxy, IMessageRider token)
{
// remove incomming proxy
_incommingDict.Remove(proxy.NetworkId);
// destroy entity
proxy.Entity.DetachToken = token;
// destroy entity
Core.DestroyForce(proxy.Entity);
}
public static void WriteToken(this Packet packet, IMessageRider token)
{
if (packet.WriteBool(token != null))
{
// write header byte
packet.WriteByte(Factory.GetTokenId(token));
// write token
token.Write(packet);
}
}
public static byte GetTokenId(IMessageRider obj)
{
#if DEBUG
if (_token2id.ContainsKey(obj.GetType()) == false)
{
throw new AscensionException("Unknown token type {0}", obj.GetType());
}
#endif
return(_token2id[obj.GetType()]);
}
public static void SerializeToken(this Packet packet, ref IMessageRider token)
{
if (packet.Write)
{
packet.WriteToken(token);
}
else
{
token = packet.ReadToken();
}
}
public static IMessageRider ReadToken(this Packet packet)
{
IMessageRider token = null;
if (packet.ReadBool())
{
token = Factory.NewToken(packet.ReadByte());
token.Read(packet);
}
return(token);
}
public bool RefuseConnection(SocketConnection conn, IMessageRider token)
{
if (AscensionNetwork.IsClient)
{
SocketLog.Error("Client cannot refuse!");
return(false);
}
//COnstruct byte array of the token
byte[] tokenBytes = WriteToken(token, NetworkMsg.Refuse);
//Send Token
conn.SendToken(tokenBytes, tokenBytes.Length, NetworkMsg.Refuse);
//Disconnect
server.DisconnectPeer(conn.ConnectionInfo.Peer);
return(true);
}
public void SetToken(int dataSize, byte[] data)
{
//Initialization
NetworkMsg msgType = NetworkMsg.Unknown;
byte type;
int size;
//Read the packet and convert it to a byte array
IMessageRider token = SockInterface.ReadToken(dataSize, data, out type, out size);
//Convert the type into a enum readable type
msgType = (NetworkMsg)type;
//Handle the token
HandleToken(msgType, token);
SocketLog.Info("Set token type {0} for connection {1}", msgType, ConnectionInfo.Peer.ConnectId);
}
public void Disconnect(SocketConnection conn, IMessageRider token)
{
if (AscensionNetwork.IsClient && !connected)
{
SocketLog.Error("Cannot disconnect if we are not connected!");
return;
}
//Construct byte array of the token
byte[] tokenBytes = WriteToken(token, NetworkMsg.Disconnect);
//Send Token
conn.SendToken(tokenBytes, tokenBytes.Length, NetworkMsg.Disconnect);
//Disconnect
if (server != null)
{
server.DisconnectPeer(conn.ConnectionInfo.Peer);
}
}
public bool Refuse(IPEndPoint endPoint, IMessageRider token)
{
bool refused = false;
SocketConnection conn = GetPendingConnection(endPoint);
if (conn != null)
{
refused = RefuseConnection(conn, token);
}
else
{
SocketLog.Error("Refuse failed! No connection with the endpoint: {0} found.", endPoint);
return(false);
}
return(refused);
}
/// <summary>
/// Load a scene based on name, only possible on the Server
/// </summary>
/// <param name="scene">The scene to load</param>
/// <param name="token">A data token from the server</param>
public static void LoadScene(string scene, IMessageRider token)
{
VerifyIsRunning();
int sceneIndex = -1;
try
{
sceneIndex = AscensionNetworkInternal.GetSceneIndex(scene);
}
catch (Exception exn)
{
NetLog.Error("Exception thrown while trying to find index of scene '{0}'", scene);
NetLog.Exception(exn);
return;
}
Core.LoadScene(sceneIndex, token);
}
public byte[] WriteToken(IMessageRider token, NetworkMsg type)
{
byte[] tokenArray = token.ToByteArray();
//Handle null tokens
int tokenSize = 0;
if (tokenArray != null)
{
tokenSize = tokenArray.Length;
}
//The size is a byte in bits (8) + the size of the token to transmit
Packet p = new Packet(8 + tokenSize);
p.WriteByte((byte)type);
p.WriteToken(token);
p.FinishWriting(); // Not necessary as our defination of this packet was precise, but still good form
return(p.ByteBuffer);
}
/// <summary>
/// Create a new entity in the simuation from a prefab
/// </summary>
public static AscensionEntity Instantiate(GameObject prefab, IMessageRider token, Vector3 position, Quaternion rotation)
{
VerifyIsRunning();
AscensionEntity ae = prefab.GetComponent <AscensionEntity>();
if (!ae)
{
NetLog.Error("Prefab '{0}' does not have a Ascension Entity component attached", prefab.name);
return(null);
}
if (ae.SerializerGuid == UniqueId.None)
{
NetLog.Error("Prefab '{0}' does not have a serializer assigned", prefab.name);
return(null);
}
return(Core.Instantiate(new PrefabId(ae.prefabId), Factory.GetFactory(ae.SerializerGuid).TypeId, position, rotation, InstantiateFlags.ZERO, null, token));
}
public bool Accept(IPEndPoint endPoint, IMessageRider acceptToken, IMessageRider connectToken)
{
SocketConnection conn = GetPendingConnection(endPoint);
if (conn != null)
{
//Remove from pending
RemovePendingConnection(conn);
//Add to current
AddConnection(conn);
//Send Tokens
SendToken(conn.ConnectionInfo.Peer, acceptToken, NetworkMsg.Accept);
SendToken(conn.ConnectionInfo.Peer, connectToken, NetworkMsg.Connect);
SocketLog.Info("Accepted connection from {0}:{1}", endPoint.Address, endPoint.Port);
return(true);
}
SocketLog.Error("Failed to accept connection {0}:{1}", endPoint.Address, endPoint.Port);
return(false);
}
public bool Connect(SocketEndPoint endPoint, IMessageRider token)
{
//Checks before preceeding
if (IsHost)
{
SocketLog.Error("Cannot connect when we are a host!");
return(false);
}
if (connected)
{
SocketLog.Error("Cannot connect when we are already connected!");
return(false);
}
if (connecting)
{
SocketLog.Error("Cannot connect when we are already connecting!");
return(false);
}
client.Connect(endPoint.address, endPoint.port);
//Set Address and Port
address = endPoint.address;
port = endPoint.port;
//Set the values of this connection
SetConnectionValues(endPoint.address, endPoint.port);
//Create a new instance of connection info
SocketConnectionInfo info = new SocketConnectionInfo(address, port);
//Initialize a new connection
SocketConnection conn;
//Add a connection
AddConnection(info, out conn);
//Cache our connect token to be sent once the communication lines have been established
conn.ConnectToken = WriteToken(token, NetworkMsg.Connect);
//Log our succeeded attempt
SocketLog.Info("Connection Attempt to: {0} : {1}", endPoint.address, endPoint.port);
//Set connecting
connecting = true;
return(true);
}
public void ReleaseControl(IMessageRider token)
{
if (IsOwner)
{
if (HasControl)
{
ReleaseControlInternal(token);
// un-freeze
Freeze(false);
}
else
{
NetLog.Warn("You are not controlling {0}", this);
}
}
else
{
NetLog.Error("You can not release control of {0}, you are not the owner", this);
}
}
void HandleReceivedToken(NetworkMsg type, IMessageRider riderToken)
{
switch (type)
{
case NetworkMsg.Accept:
HandleAccepted(riderToken);
break;
case NetworkMsg.Connect:
break;
case NetworkMsg.Disconnect:
break;
case NetworkMsg.Ready:
break;
case NetworkMsg.Refuse:
break;
default:
break;
}
}
private void ReadResult(Packet packet)
{
while (packet.CanRead())
{
if (packet.ReadBool() == false)
{
break;
}
NetworkId netId = packet.ReadNetworkId();
EntityProxy proxy = IncommingProxiesByNetworkId[netId];
Entity entity = proxy.Entity;
while (packet.CanRead())
{
if (packet.ReadBool() == false)
{
break;
}
TypeId typeId = packet.ReadTypeId();
ushort sequence = packet.ReadUShort(Command.SEQ_BITS);
IMessageRider resultToken = packet.ReadToken();
Command cmd = null;
if (entity != null)
{
var it = entity.CommandQueue.GetIterator();
while (it.Next())
{
int dist = NetMath.SeqDistance(it.val.Sequence, sequence, Command.SEQ_SHIFT);
if (dist > 0)
{
break;
}
if (dist < 0)
{
it.val.Flags |= CommandFlags.DISPOSE;
}
if (dist == 0)
{
cmd = it.val;
break;
}
}
}
if (cmd)
{
cmd.ResultObject.Token = resultToken;
cmd.Flags |= CommandFlags.CORRECTION_RECEIVED;
if (cmd.Meta.SmoothFrames > 0)
{
cmd.BeginSmoothing();
}
cmd.ReadResult(connection, packet);
}
else
{
cmd = Factory.NewCommand(typeId);
cmd.ReadResult(connection, packet);
cmd.Free();
}
}
// remove all disposable commands
if (entity != null)
{
while ((entity.CommandQueue.Count > 1) && (entity.CommandQueue.First.Flags & CommandFlags.DISPOSE))
{
entity.CommandQueue.RemoveFirst().Free();
}
}
}
}
private bool ReadUpdate(Packet packet)
{
if (packet.ReadBool() == false)
{
return(false);
}
// grab networkid
NetworkId networkId = packet.ReadNetworkId();
bool isController = packet.ReadBool();
IMessageRider controlToken = packet.ReadToken();
bool destroyRequested = packet.ReadBool();
// we're destroying this proxy
if (destroyRequested)
{
EntityProxy proxy;
IMessageRider detachToken = packet.ReadToken();
if (_incommingDict.TryGetValue(networkId, out proxy))
{
if (proxy.Entity.HasControl)
{
proxy.Entity.ReleaseControlInternal(controlToken);
}
DestroyIncommingProxy(proxy, detachToken);
}
else
{
NetLog.Warn("Received destroy of {0} but no such proxy was found", networkId);
}
}
else
{
IMessageRider attachToken = null;
bool isSceneObject = false;
bool createRequested = packet.ReadBool();
UniqueId sceneId = UniqueId.None;
PrefabId prefabId = new PrefabId();
TypeId serializerId = new TypeId();
Vector3 spawnPosition = new Vector3();
Quaternion spawnRotation = new Quaternion();
if (createRequested)
{
attachToken = packet.ReadToken();
prefabId = packet.ReadPrefabId();
serializerId = packet.ReadTypeId();
spawnPosition = packet.ReadVector3();
spawnRotation = packet.ReadQuaternion();
isSceneObject = packet.ReadBool();
if (isSceneObject)
{
sceneId = packet.ReadUniqueId();
}
}
Entity entity = null;
EntityProxy proxy = null;
if (createRequested && (_incommingDict.ContainsKey(networkId) == false))
{
// create entity
if (isSceneObject)
{
GameObject go = Core.FindSceneObject(sceneId);
if (!go)
{
NetLog.Warn("Could not find scene object with {0}", sceneId);
go = Core.PrefabPool.Instantiate(prefabId, spawnPosition, spawnRotation);
}
entity = Entity.CreateFor(go, prefabId, serializerId, EntityFlags.SCENE_OBJECT);
}
else
{
GameObject go = Core.PrefabPool.LoadPrefab(prefabId);
// prefab checks (if applicable)
if (go)
{
if (Core.IsServer && !go.GetComponent <AscensionEntity>().allowInstantiateOnClient)
{
throw new AscensionException(
"Received entity of prefab {0} from client at {1}, but this entity is not allowed to be instantiated from clients",
go.name, connection.RemoteEndPoint);
}
}
NetLog.Warn("Creating instance of {0}", prefabId);
entity = Entity.CreateFor(prefabId, serializerId, spawnPosition, spawnRotation);
}
entity.Source = connection;
entity.SceneId = sceneId;
entity.NetworkId = networkId;
// handle case where we are given control (it needs to be true during the initialize, read and attached callbacks)
if (isController)
{
entity.Flags |= EntityFlags.HAS_CONTROL;
}
// initialize entity
entity.Initialize();
// create proxy
proxy = entity.CreateProxy();
proxy.NetworkId = networkId;
proxy.Connection = connection;
// register proxy
_incommingDict.Add(proxy.NetworkId, proxy);
// read packet
entity.Serializer.Read(connection, packet, packet.Frame);
// attach entity
proxy.Entity.AttachToken = attachToken;
proxy.Entity.Attach();
// assign control properly
if (isController)
{
proxy.Entity.Flags &= ~EntityFlags.HAS_CONTROL;
proxy.Entity.TakeControlInternal(controlToken);
}
// log debug info
NetLog.Debug("Received {0} from {1}", entity, connection);
// update last received frame
proxy.Entity.LastFrameReceived = AscensionNetwork.Frame;
proxy.Entity.Freeze(false);
// notify user
GlobalEventListenerBase.EntityReceivedInvoke(proxy.Entity.UnityObject);
}
else
{
// find proxy
proxy = _incommingDict[networkId];
if (proxy == null)
{
throw new AscensionException("Couldn't find entity for {0}", networkId);
}
// update control state yes/no
if (proxy.Entity.HasControl ^ isController)
{
if (isController)
{
proxy.Entity.TakeControlInternal(controlToken);
}
else
{
proxy.Entity.ReleaseControlInternal(controlToken);
}
}
// read update
proxy.Entity.Serializer.Read(connection, packet, packet.Frame);
proxy.Entity.LastFrameReceived = AscensionNetwork.Frame;
proxy.Entity.Freeze(false);
}
}
return(true);
}
/// <summary>
/// Signal Ascension to refuse an incoming connection request
/// </summary>
/// <param name="endpoint">The UDP address of incoming client connection</param>
/// <param name="acceptToken">A data token from the server</param>
public static void Refuse(IPEndPoint endpoint, IMessageRider token)
{
VerifyIsRunning();
Core.RefuseConnection(endpoint, token);
}
public static void Connect(string ip, int port, IMessageRider token)
{
VerifyIsRunning();
Core.Connect(ip, port, token);
}
/// <summary>
/// Connect to a server
/// </summary>
/// <param name="endpoint">Server end point to connect to</param>
public static void Connect(IPEndPoint endpoint, IMessageRider token)
{
VerifyIsRunning();
Core.Connect(endpoint, token);
}
/// <summary>
/// Disconnect this connection with custom data
/// </summary>
/// <param name="token">A data token</param>
public void Disconnect(IMessageRider token)
{
SockConn.Disconnect(token);
}
