public void RegisterVar(SyncableVariable var, SyncFrequency frequency, Action <SyncableVariable, NetworkWriter> registerMethod, Action <SyncableVariable, NetworkReader> syncMethod, Func <NetworkWriter, int> byteSizeMethod, bool ignoreAuthority) { if (_varIgnoresAuthority.ContainsKey(var)) { _varIgnoresAuthority.Remove(var); } if (_methods.ContainsKey(var)) { _methods.Remove(var); } if (_varSizesMethods.ContainsKey(var)) { _varSizesMethods.Remove(var); } _varIgnoresAuthority[var] = ignoreAuthority; _methods.Add(var, new NetworkSyncableVarMethods(var, registerMethod, syncMethod)); _frequenciesMasks[(int)frequency] |= var; if (byteSizeMethod == null) { BakeVarSize(var, registerMethod); } else { _varSizesMethods.Add(var, byteSizeMethod); } }
private void SyncEntityEquip(SyncableVariable var, NetworkReader reader) { int count = reader.ReadInt32(); for (int i = 0; i < count; i++) { bool method = reader.ReadBoolean(); EntityEquipable eq = reader.ReadEntityEquipable(); UnsubscribeToEquipEvents(); if (method) { Equip(eq); } else { Unequip(eq); } SubscribeToEquipEvents(); if (References.NetworkIdentity.isServer == true && References.NetworkIdentity.hasAuthority == false) { _equipableSyncMethod.Add(method); _equipablesToSync.Add(eq); PinouNetworkManager.MainBehaviour.SetDirty(master.gameObject, SyncableVariable.EntityEquip); } } }
private void SyncAbilityHit(SyncableVariable var, NetworkReader reader) { if (References.NetworkIdentity.isServer) { _nextSyncResults = new List <AbilityCastResult>(); } int resultsCount = reader.ReadInt32(); for (int i = 0; i < resultsCount; i++) { AbilityCastResult result = reader.ReadAbilityCastResult(); if (References.NetworkIdentity.isServer) { OnReceiveAbilityHit.Invoke(this, result); result.CastData.FillResult(result); _nextSyncResults.Add(result); PinouNetworkManager.MainBehaviour.SetDirty(gameObject, SyncableVariable.EntityAbilityHit); } else if (References.NetworkIdentity.hasAuthority) { OnReceiveAbilityHit.Invoke(this, result); result.CastData.FillResult(result); } if (result.CastData.Caster == this) { return; } OnAbilityHitResult.Invoke(this, result); } }
private void BakeVarSize(SyncableVariable var, Action <SyncableVariable, NetworkWriter> registerMethod) { dummyWriter.Reset(); registerMethod.Invoke(var, dummyWriter); _varSizes[var.GetIndex()] = dummyWriter.Length; }
private void SyncVelocity(SyncableVariable var, NetworkReader reader) { if (_rigidbodyTarget == null) { return; } _targetVel = reader.ReadVector3(); }
private void RegisterRotation(SyncableVariable var, NetworkWriter writer) { if (_rotationTarget == null) { return; } writer.WriteQuaternion(_rotationTarget.rotation); }
private void RegisterPosition(SyncableVariable var, NetworkWriter writer) { if (_positionTarget == null) { return; } writer.WriteVector3(_positionTarget.position); }
public bool IgnoreAuthority(SyncableVariable var) { if (_varIgnoresAuthority.ContainsKey(var) == false) { return(false); } return(_varIgnoresAuthority[var]); }
private void RegisterVelocity(SyncableVariable var, NetworkWriter writer) { if (_rigidbodyTarget == null) { return; } writer.WriteVector3(_rigidbodyTarget.velocity); }
private void RegisterAbilityHit(SyncableVariable var, NetworkWriter writer) { writer.WriteInt32(_nextSyncResults.Count); for (int i = 0; i < _nextSyncResults.Count; i++) { writer.WriteAbilityCastResult(_nextSyncResults[i]); } _nextSyncResults.Clear(); }
public NetworkSyncableGameobjectInfos(GameObject go) { _gameObject = go; _frequenciesMasks = new SyncableVariable[Enum.GetValues(typeof(SyncFrequency)).Length]; _varIgnoresAuthority = new Dictionary <SyncableVariable, bool>(); _varSizes = new int[Enum.GetValues(typeof(SyncableVariable)).Length]; _methods = new Dictionary <SyncableVariable, NetworkSyncableVarMethods>(); _varSizesMethods = new Dictionary <SyncableVariable, Func <NetworkWriter, int> >(); }
private void RegisterCastAbility(SyncableVariable var, NetworkWriter writer) { writer.WriteInt32(_nextAbilitiesCast.Count); for (int i = 0; i < _nextAbilitiesCast.Count; i++) { writer.WriteAbilityCastData(_nextAbilitiesCast[i]); } _nextAbilitiesCast.Clear(); }
private void RegisterDestroyAbilityHitbox(SyncableVariable var, NetworkWriter writer) { writer.WriteInt32(_nextHitboxDestroyed.Count); for (int i = 0; i < _nextHitboxDestroyed.Count; i++) { writer.WriteAbilityCastData(_nextHitboxDestroyed[i]); } _nextHitboxDestroyed.Clear(); }
public void InvokeRegisterMethods(GameObject go, SyncableVariable varFlags, NetworkWriter writer) { for (int i = 0; i < _syncableVariablesEnumValues.Length; i++) { SyncableVariable curVar = (SyncableVariable)_syncableVariablesEnumValues.GetValue(i); if ((curVar & varFlags) > 0) { _gameObjectSyncInfos[go].InvokeRegisterMethod(curVar, writer); } } }
private void ComputeChannelMasks() { Array values = Enum.GetValues(typeof(SyncableVariable)); _channelMasks = new SyncableVariable[CHANNEL_COUNT]; for (int i = 0; i < values.Length; i++) { SyncableVariable var = (SyncableVariable)values.GetValue(i); _channelMasks[var.GetChannel()] |= var; } }
private void SyncPosition(SyncableVariable var, NetworkReader reader) { if (_positionTarget == null) { return; } Vector3 oldPos = _targetPos; _targetPos = reader.ReadVector3(); _posSpeed = (_targetPos - oldPos).magnitude; }
private void SyncRotation(SyncableVariable var, NetworkReader reader) { if (_rotationTarget == null) { return; } Quaternion oldRot = _targetRot; _targetRot = reader.ReadQuaternion(); _rotSpeed = Quaternion.Angle(oldRot, _targetRot); }
private void RegisterEntityEquip(SyncableVariable var, NetworkWriter writer) { writer.WriteInt32(_equipableSyncMethod.Count); for (int i = 0; i < _equipablesToSync.Count; i++) { writer.WriteBoolean(_equipableSyncMethod[i]); writer.WriteEntityEquipable(_equipablesToSync[i]); } _equipableSyncMethod.Clear(); _equipablesToSync.Clear(); }
public static int GetIndex(this SyncableVariable var) { for (int i = 0; i < s_SyncableVariableValues.Length; i++) { if (var == (SyncableVariable)s_SyncableVariableValues.GetValue(i)) { return(i); } } return(-1); }
public int GetSyncVarByteSize(SyncableVariable var) { if (_varSizesMethods.ContainsKey(var)) { dummyWriter.Reset(); return(_varSizesMethods[var].Invoke(dummyWriter)); } else { return(_varSizes[var.GetIndex()]); } }
public static NetworkSyncableVarsDirtyData ReadNetworkSyncableVarsDirtyData(this NetworkReader reader) { GameObject gameObject = reader.ReadGameObject(); SyncableVariable dirtyVars = (SyncableVariable)reader.ReadInt64(); if (gameObject != null) { PinouNetworkManager.MainBehaviour.InvokeSyncMethods(gameObject, dirtyVars, reader); } return(new NetworkSyncableVarsDirtyData(gameObject)); }
private void SyncDestroyAbilityHitbox(SyncableVariable var, NetworkReader reader) { int hitboxCount = reader.ReadInt32(); for (int i = 0; i < hitboxCount; i++) { AbilityCastData castData = reader.ReadAbilityCastData(); AbilityHitbox.DestroyFromCastData(castData); if (References.NetworkIdentity.isServer && References.NetworkIdentity.hasAuthority == false) { _nextHitboxDestroyed.Add(castData); PinouNetworkManager.MainBehaviour.SetDirty(master.gameObject, SyncableVariable.EntityAbilityHitboxDestroyed); } } }
private int ComputeExpectedSize(NetworkSyncableVarsDirtyData dirtyData) { NetworkSyncableGameobjectInfos infos = _gameObjectSyncInfos[dirtyData.GameObject]; int totalSize = 9; for (int i = 0; i < _syncableVariablesEnumValues.Length; i++) { SyncableVariable var = (SyncableVariable)_syncableVariablesEnumValues.GetValue(i); if (dirtyData.IsDirty(var)) { totalSize += infos.GetSyncVarByteSize(var); } } return(totalSize); }
public void RegisterGameObjectSyncVar(GameObject go, SyncableVariable var, SyncFrequency frequency, Action <SyncableVariable, NetworkWriter> registerMethod, Action <SyncableVariable, NetworkReader> syncMethod, Func <NetworkWriter, int> byteSizeMethod, bool ignoreAuthority) { IDestroyableNetworkSyncableGameObject destroyableGameObject = go.GetComponent <IDestroyableNetworkSyncableGameObject>(); if (destroyableGameObject == null) { Debug.LogError("GameObject must have a IDestroyableNetworkSyncableGameObject component."); return; } if (_gameObjectSyncInfos.ContainsKey(go) == false) { _gameObjectSyncInfos.Add(go, new NetworkSyncableGameobjectInfos(go)); } _gameObjectSyncInfos[go].RegisterVar(var, frequency, registerMethod, syncMethod, byteSizeMethod, ignoreAuthority); destroyableGameObject.OnGameObjectDestroyed.SafeSubscribe(OnSyncableGameObjectDestroyed); }
public void InvokeSyncMethods(GameObject go, SyncableVariable varFlags, NetworkReader reader) { for (int i = 0; i < _syncableVariablesEnumValues.Length; i++) { SyncableVariable curVar = (SyncableVariable)_syncableVariablesEnumValues.GetValue(i); if ((curVar & varFlags) > 0) { try { _gameObjectSyncInfos[go].InvokeSyncMethod(curVar, reader); } catch { Debug.LogWarning(go + " | " + curVar + " | not present."); } } } }
private void SyncCastAbility(SyncableVariable var, NetworkReader reader) { int hitboxCount = reader.ReadInt32(); for (int i = 0; i < hitboxCount; i++) { AbilityCastData castData = reader.ReadAbilityCastData(); if (castData.AbilityCast.Hitbox.UnlimitedLifeSpan == true || castData.AbilityCast.Hitbox.LifeSpan > 0) { AbilityHitbox hitBox = AbilityPerformer.HandleSpawnAbilityHitbox(castData); hitBox.ActivateVisualMode(); } OnPerformAbility.Invoke(master, castData); if (References.NetworkIdentity.isServer && References.NetworkIdentity.hasAuthority == false) { _nextAbilitiesCast.Add(castData); PinouNetworkManager.MainBehaviour.SetDirty(master.gameObject, SyncableVariable.EntityAbilityCast); } } }
public static int GetChannel(this SyncableVariable var) { switch (var) { case SyncableVariable.Position: return(2); case SyncableVariable.Rotation: return(2); case SyncableVariable.Velocity: return(1); case SyncableVariable.MovementsParticlesEmission: return(2); case SyncableVariable.MovementsParticlesAngle: return(2); case SyncableVariable.EntityAbilityCast: return(1); case SyncableVariable.EntityAbilityHit: return(1); case SyncableVariable.EntityAbilityHitboxDestroyed: return(1); case SyncableVariable.EntityDeath: return(1); case SyncableVariable.EntityHealth: return(1); case SyncableVariable.EntityEquip: return(0); } return(0); }
private void SyncDeath(SyncableVariable var, NetworkReader reader) { OnDeath.Invoke(master, reader.ReadAbilityCastResult()); }
private void RegisterDeath(SyncableVariable var, NetworkWriter writer) { writer.WriteAbilityCastResult(deathResult); deathResult = null; }
private void SyncHealth(SyncableVariable var, NetworkReader reader) { currentHealth = (float)reader.ReadDouble(); }