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 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;
}
}
public bool QueueInput(Command cmd)
{
if (canQueueCommands)
{
NetAssert.True(HasControl);
if (CommandQueue.Count < Core.Config.commandQueueSize)
{
cmd.ServerFrame = Core.ServerFrame;
cmd.Sequence = CommandSequence = NetMath.SeqNext(CommandSequence, Command.SEQ_MASK);
}
else
{
NetLog.Error("Input queue for {0} is full", this);
return(false);
}
CommandQueue.AddLast(cmd);
return(true);
}
else
{
NetLog.Error("You can only queue commands to the host in the 'SimulateController' callback");
return(false);
}
}
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 void SetIdle(Connection connection, bool idle)
{
if (idle && IsController(connection))
{
NetLog.Error("You can not idle {0} on {1}, as it is the controller for this entity", this, connection);
return;
}
connection.entityChannel.SetIdle(this, idle);
}
public override void SetDynamic(NetworkObj obj, object value)
{
if (MecanimDirection == MecanimDirection.UsingAnimatorMethods)
{
NetLog.Error("Can't call SetDynamic on a trigger in 'UsingAnimatorMethods' mode");
return;
}
obj.Storage.Values[obj[this]].TriggerLocal.Update(Core.Frame, true);
}
bool VerifyCallbackPath(string path)
{
if (Meta.CallbackPaths.Contains(path))
{
return(true);
}
NetLog.Error("No callback path '{0}' available on {1}", path, this);
return(false);
}
/// <summary>
/// Get the state if this entity
/// </summary>
public TState GetState <TState>()
{
if (AEntity.Serializer is TState)
{
return((TState)(object)AEntity.Serializer);
}
NetLog.Error("You are trying to access the state of {0} as '{1}'", AEntity, typeof(TState));
return(default(TState));
}
static object Create(UniqueId id)
{
#if DEBUG
if (_factoriesByKey.ContainsKey(id) == false)
{
NetLog.Error("Unknown {0}", id);
}
#endif
return(_factoriesByKey[id].Create());
}
public void SetParent(Entity entity)
{
if (IsOwner || HasPredictedControl)
{
SetParentInternal(entity);
}
else
{
NetLog.Error("You are not allowed to assign the parent of this entity, only the owner or a controller with local prediction can");
}
}
public void InvokeRepeating(Command command, CommandCallback callback, int period)
{
NetAssert.True(period > 0);
if (!canQueueCallbacks)
{
NetLog.Error("Can only queue callbacks when commands with 'IsFirstExecution' set to true are executing");
return;
}
//CommandCallbacks.Add(new CommandCallbackItem { Command = command, Callback = callback, Start = command.Number + 1, End = command.Number + period, Mode = CommandCallbackModes.InvokeRepeating });
}
public void InvokeOnce(Command command, CommandCallback callback, int delay)
{
NetAssert.True(delay > 0);
if (!canQueueCallbacks)
{
NetLog.Error("Can only queue callbacks when commands with 'IsFirstExecution' set to true are executing");
return;
}
//CommandCallbacks.Add(new CommandCallbackItem { Command = command, Callback = callback, Start = -1, End = command.Number + delay, Mode = CommandCallbackModes.InvokeOnce });
}
public static IFactory GetFactory(UniqueId id)
{
#if DEBUG
if (!_factoriesByKey.ContainsKey(id))
{
NetLog.Error("Unknown factory {0}", id);
return(null);
}
#endif
return(_factoriesByKey[id]);
}
public void SetScope(Entity entity, bool inScope)
{
if (Core.Config.scopeMode == ScopeMode.Automatic)
{
NetLog.Error("SetScope has no effect when Scope Mode is set to Automatic");
return;
}
if (ReferenceEquals(entity.Source, connection))
{
return;
}
if (inScope)
{
if (_incommingDict.ContainsKey(entity.NetworkId))
{
return;
}
EntityProxy proxy;
if (_outgoingDict.TryGetValue(entity.NetworkId, out proxy))
{
if (proxy.Flags & ProxyFlags.DESTROY_REQUESTED)
{
if (proxy.Flags & ProxyFlags.DESTROY_PENDING)
{
proxy.Flags |= ProxyFlags.DESTROY_IGNORE;
}
else
{
proxy.Flags &= ~ProxyFlags.DESTROY_IGNORE;
proxy.Flags &= ~ProxyFlags.DESTROY_REQUESTED;
}
}
}
else
{
CreateOnRemote(entity);
}
}
else
{
if (_outgoingDict.ContainsKey(entity.NetworkId))
{
DestroyOnRemote(entity);
}
}
}
public override bool Write(Connection connection, NetworkObj obj, NetworkStorage storage, Packet packet)
{
try
{
packet.WriteToken(storage.Values[obj[this]].ProtocolToken);
return(true);
}
catch (Exception exn)
{
NetLog.Error("User code threw exception while serializing protocol token");
NetLog.Exception(exn);
return(false);
}
}
public void PacketDelivered(Packet packet)
{
try
{
for (int i = 0; i < channels.Length; ++i)
{
channels[i].Delivered(packet);
}
}
catch (Exception exn)
{
NetLog.Exception(exn);
NetLog.Error("exception thrown while handling delivered packet to {0}", sockConn.RemoteEndPoint);
}
}
public void PacketLost(Packet packet)
{
for (int i = 0; i < channels.Length; ++i)
{
channels[i].Lost(packet);
}
try
{
}
catch (Exception exn)
{
NetLog.Exception(exn);
NetLog.Error("exception thrown while handling lost packet to {0}", sockConn.RemoteEndPoint);
}
}
public override void SetDynamic(NetworkObj obj, object value)
{
if (MecanimDirection == MecanimDirection.UsingAnimatorMethods)
{
NetLog.Error("Can't call SetDynamic on a float in 'UsingAnimatorMethods' mode");
return;
}
var v = (float)value;
if (NetworkValue.Diff(obj.Storage.Values[obj[this]].Float0, v))
{
obj.Storage.Values[obj[this]].Float0 = v;
obj.Storage.PropertyChanged(obj.OffsetProperties + this.OffsetProperties);
}
}
public void PacketReceived(Packet Packet)
{
try
{
using (Packet packet = Core.AllocatePacket())
{
packet.Set(Packet); //This copies the values into the newly acquired packet
//Read signature & frame
packet.Type = packet.ReadByte();
packet.Frame = packet.ReadIntVB();
if (packet.Frame > remoteFrameActual)
{
remoteFrameAdjust = true;
remoteFrameActual = packet.Frame;
}
//OLD method
//bitsSecondInAcc += packet.ActualSize;
bitsSecondInAcc += packet.Position;
packetsReceived += 1;
for (int i = 0; i < channels.Length; ++i)
{
channels[i].Read(packet);
}
//for (int i = 0; i < channels.Length; ++i)
//{
// channels[i].ReadDone();
//}
packetStatsIn.Enqueue(packet.Stats);
NetAssert.False(Packet.Overflowing);
//SocketLog.Info("Received packet of length {0}", packet.ActualSize);
}
}
catch (Exception exn)
{
NetLog.Exception(exn);
NetLog.Error("exception thrown while unpacking data from {0}, disconnecting", sockConn.RemoteEndPoint);
Disconnect();
}
}
void OnDestroy()
{
if (entity && entity.IsAttached && Application.isPlaying)
{
if (entity.IsOwner)
{
NetLog.Warn("{0} is being destroyed/disabled without being detached, forcing detach", AEntity);
}
else
{
NetLog.Error("{0} is being destroyed/disabled without being detached by the owner, this will cause this peer to disconnect the next time it receives an update for this entity", AEntity);
}
// force detach
entity.Detach();
entity = null;
}
}
/// <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));
}
/// <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 static GameObject Find(PrefabId id)
{
if (lookup == null || instance == null)
{
LoadInstance();
UpdateLookup();
}
GameObject prefab;
if (lookup.TryGetValue(id, out prefab))
{
return(prefab);
}
else
{
NetLog.Error("Could not find game object for {0}", id);
return(null);
}
}
Vector3 CalculateVelocity(NetworkTransform nt, Vector3 position)
{
switch (Extrapolation.VelocityMode)
{
case ExtrapolationVelocityModes.CalculateFromPosition:
return((GetPosition(nt.Simulate) - position) * Core.Config.framesPerSecond);
case ExtrapolationVelocityModes.CopyFromRigidbody:
return(nt.Simulate.GetComponent <Rigidbody>().velocity);
case ExtrapolationVelocityModes.CopyFromRigidbody2D:
return(nt.Simulate.GetComponent <Rigidbody2D>().velocity);
case ExtrapolationVelocityModes.CopyFromCharacterController:
return(nt.Simulate.GetComponent <CharacterController>().velocity);
default:
NetLog.Error("Unknown velocity extrapolation mode {0}", Extrapolation.VelocityMode);
return((GetPosition(nt.Simulate) - position) * Core.Config.framesPerSecond);
}
}
void Update()
{
try
{
if ((Time.timeScale != 1f) && RuntimeSettings.Instance.overrideTimeScale)
{
// log this error
NetLog.Error("Time.timeScale value is incorrect: {0}f", Time.timeScale);
// force this
Time.timeScale = 1f;
// log that we forced timescale to 1
NetLog.Error("Time.timeScale has been set to 1.0f by Ascension");
}
}
finally
{
Core.Update();
}
}
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);
}
}
public void SetParentInternal(Entity entity)
{
if (entity != Parent)
{
if ((entity != null) && (entity.IsAttached == false))
{
NetLog.Error("You can't assign a detached entity as the parent of another entity");
return;
}
try
{
// notify serializer
Serializer.OnParentChanging(entity, Parent);
}
finally
{
// set parent
Parent = entity;
}
}
}
public NetAssertFailedException(string msg)
: base(msg)
{
NetLog.Error("ASSERT FAILED: " + msg);
}
public NetAssertFailedException()
{
NetLog.Error("ASSERT FAILED");
}
public void Raise(Event ev)
{
IEventFactory factory = Factory.GetEventFactory(ev.Meta.TypeId);
List <CallbackWrapper> newCallbacks;
if (callbacks.TryGetValue(ev.GetType(), out newCallbacks))
{
for (int i = 0; i < callbacks.Count; ++i)
{
newCallbacks[i].Wrapper(ev);
}
}
for (int i = 0; i < targets.Count; ++i)
{
EventListener mb = targets[i];
if (mb.Behaviour)
{
// dont call on disabled behaviours
if (mb.Behaviour.enabled == false)
{
if ((mb.Listener == null) || (mb.Listener.InvokeIfDisabled == false))
{
continue;
}
}
// dont call on behaviours attached to inactive game objects
if (mb.GameObject.activeInHierarchy == false)
{
if ((mb.Listener == null) || (mb.Listener.InvokeIfGameObjectIsInactive == false))
{
continue;
}
}
// invoke event
try
{
factory.Dispatch(ev, mb.Behaviour);
}
catch (Exception exn)
{
NetLog.Error("User code threw exception when invoking {0}", ev);
NetLog.Exception(exn);
}
}
else
{
// remove callback if this behaviour is destroyed
targets.RemoveAt(i);
//
--i;
continue;
}
}
}