public Entity CreateClientProjectile(Entity projectileEntity) { var projectileData = m_entityManager.GetComponentData <ProjectileData>(projectileEntity); // Create client projectile var pool = pools[projectileData.projectileTypeRegistryIndex]; var instanceIndex = Reserve(pool); var gameObjectEntity = pool.instances[instanceIndex]; gameObjectEntity.gameObject.SetActive(true); var clientProjectileEntity = gameObjectEntity.Entity; var clientProjectile = m_entityManager.GetComponentObject <ClientProjectile>(clientProjectileEntity); GameDebug.Assert(clientProjectile.projectile == Entity.Null, "Entity not null"); clientProjectile.projectile = projectileEntity; clientProjectile.SetVisible(false); if (ProjectileModuleClient.logInfo.IntValue > 0) { GameDebug.Log(string.Format("Creating clientprojectile {0} for projectile {1}]", clientProjectile, projectileEntity)); } // Add clientProjectileOwner to projectile var clientProjectileOwner = new ClientProjectileOwner { clientProjectile = clientProjectileEntity }; m_entityManager.AddComponentData(projectileEntity, clientProjectileOwner); return(clientProjectileEntity); }
void OnConnect(int connectionId) { if (m_Connection != null && m_Connection.connectionId == connectionId) { GameDebug.Assert(connectionState == ConnectionState.Connecting); } }
public GameWorld(string name = "world") { if (gameobjectHierarchy.IntValue == 1) { m_sceneRoot = new GameObject(name); GameObject.DontDestroyOnLoad(m_sceneRoot); } #if UNITY_EDITOR // When running in editor the world could be created, so we silently keep it. m_ECSWorld = World.Active != null ? World.Active : new World(name); #else GameDebug.Assert(World.Active == null); m_ECSWorld = new World(name); #endif World.Active = m_ECSWorld; m_EntityManager = m_ECSWorld.GetOrCreateManager <EntityManager>(); GameDebug.Assert(m_EntityManager.IsCreated); worldTime.tickRate = 60; nextTickTime = Game.frameTime; s_Worlds.Add(this); m_destroyDespawningSystem = m_ECSWorld.CreateManager <DestroyDespawning>(); }
EffectTypeData RegisterImpactType(VisualEffectAsset template) { GameDebug.Assert(!m_EffectTypeData.ContainsKey(template)); GameObject go = new GameObject(template.name); go.transform.parent = m_rootGameObject.transform; go.transform.position = Vector3.zero; go.transform.rotation = Quaternion.identity; go.transform.localScale = Vector3.one; var vfx = go.AddComponent <VisualEffect>(); vfx.visualEffectAsset = template; vfx.Reinit(); vfx.Stop(); var data = new EffectTypeData { visualEffect = vfx, eventAttribute = vfx.CreateVFXEventAttribute(), }; m_EffectTypeData.Add(template, data); return(data); }
public void RetrieveCommand(uint tick) { var localPlayerState = m_world.EntityManager.GetComponentData <LocalPlayer>(m_LocalPlayer); GameDebug.Assert(localPlayerState.playerEntity != null, "No player state set"); if (localPlayerState.controlledEntity == Entity.Null) { return; } if (!m_world.EntityManager.HasComponent <PlayerControlled.State>(localPlayerState.controlledEntity)) { return; } var buf = m_world.EntityManager.GetBuffer <UserCommand>(m_LocalPlayer); var userCommand = m_world.EntityManager.GetComponentData <PlayerControlled.State>(localPlayerState.controlledEntity); // Normally we can expect commands to be present, but if client has done hardcatchup commands might not have been generated yet // so we just use the defaultCommand var command = UserCommand.defaultCommand; var found = buf.GetDataAtTick(tick, out command); //GameDebug.Assert(found, "Failed to find command for tick:{0}", tick); userCommand.prevCommand = userCommand.command; userCommand.command = command; m_world.EntityManager.SetComponentData(localPlayerState.controlledEntity, userCommand); }
protected bool CanSendPackage(ref BitOutputStream output) { if (!outstandingPackages.Available(outSequence)) // running out here means we hit 64 packs without any acks from client... { // We have too many outstanding packages. We need the other end to send something to us, so we know he // is alive. This happens for example when we break the client in the debugger while the server is still // sending messages but potentially it could also happen in extreme cases of congestion or package loss. // We will try to send empty packages with low frequency to see if we can get the connection up and running again if (Game.frameTime >= chokedTimeToNextPackage) { chokedTimeToNextPackage = Game.frameTime + NetworkConfig.netChokeSendInterval.FloatValue; // Treat the last package as lost int chokedSequence; var info = outstandingPackages.TryGetByIndex(outSequence % outstandingPackages.Capacity, out chokedSequence); GameDebug.Assert(info != null); NotifyDelivered(chokedSequence, info, false); counters.chokedPackagesOut++; info.Reset(); outstandingPackages.Remove(chokedSequence); // Send empty package TPackageInfo emptyPackage; BeginSendPackage(ref output, out emptyPackage); CompleteSendPackage(emptyPackage, ref output); } return(false); } return(true); }
static void AddTranslateScaleChains(TranslateScale.TranslateScaleChain translateScaleChain) { if (!translateScaleChain.HasValidData()) { return; } GameDebug.Assert(s_SourceJoints.length < k_MaxDrivers, "You are trying to add more translate scale chains then there is allocated space for."); GameDebug.Assert(s_DrivenJoints.length + translateScaleChain.drivenJoints.Count <= k_MaxDrivenJoints, "You are trying to add more driven joint then there is allocated space for."); s_SourceJoints.Add(translateScaleChain.driver); s_SourceData[s_DriverIndex] = new SourceData { bindpose = translateScaleChain.bindpose }; for (var j = 0; j < translateScaleChain.drivenJoints.Count; j++) { if (translateScaleChain.drivenJoints[j].joint != null) { s_DrivenJoints.Add(translateScaleChain.drivenJoints[j].joint); s_TargetData[s_DrivenIndex] = new TargetData { sourceIndex = s_DriverIndex, bindpose = translateScaleChain.drivenJoints[j].bindpose, stretchFactor = translateScaleChain.drivenJoints[j].strectchFactor, scaleFactor = translateScaleChain.drivenJoints[j].scaleFactor }; s_DrivenIndex++; } } s_DriverIndex++; }
public void Initialize(EntityManager entityManager, Entity owner, Entity character) { m_Animator = entityManager.GetComponentObject <Animator>(owner); m_Animator.fireEvents = fireAnimationEvents; GameDebug.Assert(animStateDefinition != null, "No animStateDefinition defined for AnimStateController:" + this.name); Profiler.BeginSample("Create graph"); m_PlayableGraph = PlayableGraph.Create(name); Profiler.EndSample(); #if UNITY_EDITOR GraphVisualizerClient.Show(m_PlayableGraph); #endif Profiler.BeginSample("Instantiate playables"); m_animGraph = animStateDefinition.Instantiate(entityManager, owner, m_PlayableGraph, character); Profiler.EndSample(); m_animGraphLogic = m_animGraph as IGraphLogic; m_PlayableGraph.Play(); var outputPlayable = Playable.Null; var outputPort = 0; m_animGraph.GetPlayableOutput(0, ref outputPlayable, ref outputPort); // Set graph output var animationOutput = AnimationPlayableOutput.Create(m_PlayableGraph, "Animator", m_Animator); animationOutput.SetSourcePlayable(outputPlayable); animationOutput.SetSourceOutputPort(outputPort); }
public TwoBoneIkAnimNode(Animator animator, Skeleton skeleton, PlayableGraph graph, AnimGraph_TwoBoneIk settings) { m_graph = graph; var targetBone = skeleton.bones[skeleton.GetBoneIndex(settings.targetBone.GetHashCode())]; var drivenBone = skeleton.bones[skeleton.GetBoneIndex(settings.drivenBone.GetHashCode())]; // Setup settings var ikSettings = new TwoBoneIKJob.IkChain(); ikSettings.target.target = targetBone; ikSettings.target.readFrom = TwoBoneIKJob.TargetType.Stream; ikSettings.driven.type = TwoBoneIKJob.IkType.Generic; ikSettings.driven.genericEndJoint = drivenBone; // ikSettings.driven.humanoidLimb = AvatarIKGoal.LeftFoot; // Create job var leftArmIkJob = new TwoBoneIKJob(); var initialized = leftArmIkJob.Setup(animator, ikSettings, typeof(AnimStateController), "leftArmIK.weight.value", "leftArmIK.weight.propertyOffset", "leftArmIK.target.offset"); GameDebug.Assert(initialized, "Failed to initialize TwoBoneIKJob"); m_ikPlayable = AnimationScriptPlayable.Create(graph, leftArmIkJob, 1); m_ikPlayable.SetInputWeight(0, 1); }
public void WriteBytesOffset(byte[] data, int srcIndex, int offset, int length) { GameDebug.Assert(data != null); NetworkUtils.MemCopy(data, srcIndex, m_Buffer, offset, length); m_CurrentByteIdx += length; }
protected override void OnUpdate() { // Add entities that needs change to buffer (as we cant destroy/create while iterating) var gameEntityTypeArray = Group.GetComponentDataArray <PresentationOwnerData>(); var entityArray = Group.GetEntityArray(); m_entityBuffer.Clear(); m_typeDataBuffer.Clear(); for (int i = 0; i < gameEntityTypeArray.Length; i++) { var typeData = gameEntityTypeArray[i]; if (typeData.variation == typeData.currentVariation) { continue; } m_entityBuffer.Add(entityArray[i]); m_typeDataBuffer.Add(typeData); } for (int i = 0; i < m_entityBuffer.Count; i++) { var entity = m_entityBuffer[i]; var typeData = m_typeDataBuffer[i]; var replicatedData = EntityManager.GetComponentData <ReplicatedEntityData>(entity); WeakAssetReference presentationGuid; var found = m_presentationRegistry.GetPresentation(replicatedData.assetGuid, out presentationGuid); if (!found) { continue; } // var registryEntry = m_assetRegistry.GetEntry(replicatedData.assetGuid); // // if (registryEntry == null) // continue; // // if (registryEntry.factory == null) // continue; //var presentation = registryEntry.factory.CreateVariation(EntityManager, m_resourceManager, m_world, entity, 0); var presentation = m_resourceManager.CreateEntity(presentationGuid); GameDebug.Assert(presentation != Entity.Null, "failed to create presentation"); typeData.currentVariation = typeData.variation; typeData.currentVariationEntity = presentation; EntityManager.SetComponentData(entity, typeData); var presentationEntity = EntityManager.GetComponentObject <PresentationEntity>(presentation); presentationEntity.ownerEntity = entity; } }
public void SendChatAnnouncement(CharBufView message) { var time = (Game.Clock.ElapsedMilliseconds - m_StartTime) / 1000; var minutes = (int)time / 60; var seconds = (int)time % 60; var formatted_length = StringFormatter.Write(ref _buf, 0, "<color=#ffffffff>[{0}:{1:00}]</color><color=#ffa500ff> {2}</color>", minutes, seconds, message); unsafe { fixed(char *ptr = message.buf) { GameDebug.Assert(message.length <= NativeString512.MaxLength); var msg = new NativeString512(); msg.CopyFrom(ptr, (ushort)message.length); var connectionEntities = m_ConnectionQuery.ToEntityArray(Allocator.TempJob); for (int i = 0; i < connectionEntities.Length; ++i) { var connectionEntity = connectionEntities[i]; m_RpcChatQueue.Schedule(EntityManager.GetBuffer <OutgoingRpcDataStreamBufferComponent>(connectionEntity), new RpcChatMessage { Message = msg }); } connectionEntities.Dispose(); } } }
public Instance(EntityManager entityManager, Entity owner, PlayableGraph graph, AnimGraph_CameraNoise settings) { m_Settings = settings; m_graph = graph; m_EntityManager = entityManager; m_Owner = owner; GameDebug.Assert(entityManager.HasComponent <Animator>(owner), "Owner has no Animator component"); var animator = entityManager.GetComponentObject <Animator>(owner); GameDebug.Assert(entityManager.HasComponent <Skeleton>(owner), "Owner has no Skeleton component"); var skeleton = entityManager.GetComponentObject <Skeleton>(owner); var cameraBone = skeleton.bones[skeleton.GetBoneIndex(settings.cameraBone.GetHashCode())]; var characterRootBone = skeleton.bones[skeleton.GetBoneIndex(settings.characterRootBone.GetHashCode())]; var cameraNoiseSettings = new CameraNoiseJob.EditorSettings(); cameraNoiseSettings.cameraBone = cameraBone; cameraNoiseSettings.characterRootBone = characterRootBone; cameraNoiseSettings.jobSettings = settings.cameraNoiseJobSettings; var noiseJob = new CameraNoiseJob(); var initialized = noiseJob.Setup(animator, cameraNoiseSettings); GameDebug.Assert(initialized, "Failed to initialize AimDragJob"); m_NoisePlayable = AnimationScriptPlayable.Create(graph, noiseJob, 1); m_NoisePlayable.SetInputWeight(0, 1); }
public void Register(int entityId, Entity entity, INetworkSerializable[] serializableArray) { // Grow to make sure there is room for entity if (entityId >= m_replicatedData.Count) { var count = entityId - m_replicatedData.Count + 1; var emptyData = new ReplicatedData(); for (var i = 0; i < count; i++) { m_replicatedData.Add(emptyData); } } GameDebug.Assert(m_replicatedData[entityId].entity == Entity.Null, "ReplicatedData has entity set:{0}", m_replicatedData[entityId].entity); // Sort serializables by type name so server and client agree on order networkSerializables.Clear(); networkSerializables.AddRange(serializableArray); networkSerializables.Sort((p1, p2) => p1.GetType().Name.CompareTo(p2.GetType().Name)); var data = new ReplicatedData { entity = entity, serializableArray = networkSerializables.ToArray() }; m_replicatedData[entityId] = data; }
static void AddTwistChain(Twist.TwistChain twistChain) { if (!twistChain.HasValidData()) { return; } GameDebug.Assert(s_SourceJoints.length < k_MaxSetups, "You are trying to add more twist joint chains then there is allocated space for."); GameDebug.Assert(s_TwistJoints.length + twistChain.twistJoints.Count <= k_MaxTwistJoints, "You are trying to add more twist joint then there is allocated space for."); s_SourceJoints.Add(twistChain.driver); s_SourceData[s_SetupIndex] = new SourceData { bindpose = twistChain.bindpose }; for (var j = 0; j < twistChain.twistJoints.Count; j++) { if (twistChain.twistJoints[j].joint != null) { s_TwistJoints.Add(twistChain.twistJoints[j].joint); s_TargetData[s_TwistIndex] = new TargetData { sourceIndex = s_SetupIndex, twistFactor = twistChain.twistJoints[j].factor }; s_TwistIndex++; } } s_SetupIndex++; }
public static void GenerateHuffmanCodes(byte[] symboLCodes, int symbolCodesOffset, byte[] symbolLengths, int symbolLengthsOffset, int alphabetSize, int maxCodeLength) { GameDebug.Assert(alphabetSize <= 256); GameDebug.Assert(maxCodeLength <= 8); var lengthCounts = new byte[maxCodeLength + 1]; var symbolList = new byte[maxCodeLength + 1, alphabetSize]; //byte[] symbol_list[(MAX_HUFFMAN_CODE_LENGTH + 1u) * MAX_NUM_HUFFMAN_SYMBOLS]; for (int symbol = 0; symbol < alphabetSize; symbol++) { int length = symbolLengths[symbol + symbolLengthsOffset]; GameDebug.Assert(length <= maxCodeLength); symbolList[length, lengthCounts[length]++] = (byte)symbol; } uint nextCodeWord = 0; for (int length = 1; length <= maxCodeLength; length++) { int length_count = lengthCounts[length]; for (int i = 0; i < length_count; i++) { int symbol = symbolList[length, i]; GameDebug.Assert(symbolLengths[symbol + symbolLengthsOffset] == length); symboLCodes[symbol + symbolCodesOffset] = (byte)ReverseBits(nextCodeWord++, length); } nextCodeWord <<= 1; } }
public Instance(EntityManager entityManager, Entity owner, PlayableGraph graph, Entity animStateOwner, AnimGraph_Banking settings) { m_Settings = settings; m_EntityManager = entityManager; m_Owner = owner; m_AnimStateOwner = animStateOwner; GameDebug.Assert(entityManager.HasComponent <Animator>(owner), "Owner has no Animator component"); var animator = entityManager.GetComponentObject <Animator>(owner); GameDebug.Assert(entityManager.HasComponent <Skeleton>(owner), "Owner has no Skeleton component"); var skeleton = entityManager.GetComponentObject <Skeleton>(owner); GameDebug.Assert(entityManager.HasComponent <CharPredictedStateData>(m_AnimStateOwner), "Owner has no CharPredictedState component"); var bankTransform = skeleton.bones[skeleton.GetBoneIndex(settings.bankTransform.GetHashCode())]; var bankingSettings = new BankingJob.EditorSettings(); bankingSettings.bankTransform = bankTransform; bankingSettings.settings = settings.bankingSettings; var bankingJob = new BankingJob(); m_HeadLeftRightMuscles = new NativeArray <MuscleHandle>(2, Allocator.Persistent); m_SpineLeftRightMuscles = new NativeArray <MuscleHandle>(3, Allocator.Persistent); var initialized = bankingJob.Setup(animator, bankingSettings, 2312, m_HeadLeftRightMuscles, m_SpineLeftRightMuscles); GameDebug.Assert(initialized, "Failed to initialize BankingJob"); m_Playable = AnimationScriptPlayable.Create(graph, bankingJob); }
public void WriteUIntPacked(long value) { GameDebug.Assert(value >= 0); int outputBits = 1; int numPrefixBits = 0; while (value >= (1L << outputBits)) // RUTODO: Unroll this and merge with bit output. How do we actually verify inlining in C#? { value -= (1L << outputBits); outputBits += 2; numPrefixBits++; } WriteBits(1u << numPrefixBits, numPrefixBits + 1); if (outputBits > 32) { WriteBits((uint)value, 32); WriteBits((uint)(value >> 32), outputBits - 32); } else { WriteBits((uint)value, outputBits); } }
private void OnEnable() { var gameObjectEntity = GetComponent <GameObjectEntity>(); var entityManager = gameObjectEntity.EntityManager; var abilityEntity = gameObjectEntity.Entity; // Default components entityManager.AddComponentData(abilityEntity, new CharacterAbility()); entityManager.AddComponentData(abilityEntity, new AbilityControl()); // Ability components var guid = Guid.Parse(grenadePrefab.guid); var byteArray = guid.ToByteArray(); GameDebug.Assert(byteArray.Length == 16, "Guid byte array length:{0}. SHould be 16", byteArray.Length); settings.SetGrenadePrefabGuid(byteArray); entityManager.AddComponentData(abilityEntity, settings); entityManager.AddComponentData(abilityEntity, new LocalState()); entityManager.AddComponentData(abilityEntity, new PredictedState()); entityManager.AddComponentData(abilityEntity, new InterpolatedState()); // Setup replicated ability var replicatedAbility = entityManager.GetComponentObject <ReplicatedAbility>(abilityEntity); replicatedAbility.predictedHandlers = new IPredictedDataHandler[2]; replicatedAbility.predictedHandlers[0] = new PredictedEntityHandler <AbilityControl>(entityManager, abilityEntity); replicatedAbility.predictedHandlers[1] = new PredictedEntityHandler <PredictedState>(entityManager, abilityEntity); replicatedAbility.interpolatedHandlers = new IInterpolatedDataHandler[1]; replicatedAbility.interpolatedHandlers[0] = new InterpolatedEntityHandler <InterpolatedState>(entityManager, abilityEntity); }
protected override void OnUpdate() { var requestArray = DespawnGroup.ToComponentDataArray <CharacterDespawnRequest>(Allocator.Persistent); if (requestArray.Length == 0) { requestArray.Dispose(); return; } Profiler.BeginSample("HandleCharacterDespawnRequests"); var requestEntityArray = DespawnGroup.ToEntityArray(Allocator.Persistent); for (var i = 0; i < requestArray.Length; i++) { var request = requestArray[i]; GameDebug.Assert(EntityManager.HasComponent <Character.State>(request.characterEntity), "Character despawn requst entity is not a character"); Inventory.Server_DestroyAll(EntityManager, PostUpdateCommands, request.characterEntity); GameDebug.Log(World, Character.ShowLifetime, "Despawning character:{0}", request.characterEntity); PrefabAssetManager.DestroyEntity(EntityManager, request.characterEntity); PostUpdateCommands.DestroyEntity(requestEntityArray[i]); if (Character.ShowLifetime.IntValue > 0) { AnimationGraphHelper.DumpState(World); } } requestEntityArray.Dispose(); requestArray.Dispose(); Profiler.EndSample(); }
public void ProcessSnapshot(ISnapshotConsumer consumer) { // Should we prune list for stuff that is also in despawns? foreach (var id in spawns) { GameDebug.Assert(entities[id].type != null, "Processing spawn of id {0} but type is null", id); consumer.ProcessEntitySpawn(serverTime, id, entities[id].type.typeId); } spawns.Clear(); foreach (var id in updates) { var info = entities[id]; GameDebug.Assert(info.type != null, "Processing update of id {0} but type is null", id); var reader = new NetworkReader(info.lastUpdate, info.type.schema); consumer.ProcessEntityUpdate(serverTime, id, ref reader); } updates.Clear(); foreach (var id in despawns) { consumer.ProcessEntityDespawn(serverTime, id); } despawns.Clear(); }
public float SetBlendPosition(Vector2 position, bool updateGraph = true) { var count = m_Nodes.Count; for (var i = 0; i < count; i++) { m_Positions[i] = m_Nodes[i].position; } CalculateWeights(m_Positions, ref m_Weights, position); // Store results and calculate blendedClipLength m_BlendedClipLength = 0f; for (var i = 0; i < count; i++) { var node = m_Nodes[i]; node.weight = m_Weights[i]; m_Nodes[i] = node; m_BlendedClipLength += node.clipLength / m_Nodes[i].speed * node.weight; } GameDebug.Assert(m_BlendedClipLength > 0f, "blendedClipLength must be more that 0"); m_BlendedClipLength /= masterSpeed; if (updateGraph) { UpdateGraph(); } return(m_BlendedClipLength); }
public GameWorld(string name = "world") { if (gameobjectHierarchy.IntValue == 1) { m_sceneRoot = new GameObject(name); GameObject.DontDestroyOnLoad(m_sceneRoot); } m_ECSWorld = new World(name); World.Active = m_ECSWorld; m_EntityManager = m_ECSWorld.GetOrCreateManager <EntityManager>(); //InjectionHookSupport.RegisterHook(new GameObjectArrayInjectionHook()); //InjectionHookSupport.RegisterHook(new TransformAccessArrayInjectionHook()); InjectionHookSupport.RegisterHook(new ComponentArrayInjectionHook()); GameDebug.Assert(m_EntityManager.IsCreated); worldTime.tickRate = 60; nextTickTime = Game.frameTime; s_Worlds.Add(this); m_destroyDespawningSystem = m_ECSWorld.CreateManager <DestroyDespawning>(); }
protected override void Update(Entity entity, CharacterPresentationSetup charPresentation, RagdollOwner ragdollOwner) { GameDebug.Assert(ragdollOwner.ragdollInstance != null, "Ragdoll instance is NULL for object: {0}", ragdollOwner.gameObject); GameDebug.Assert(EntityManager.Exists(charPresentation.character), "CharPresentation character does not exist"); GameDebug.Assert(EntityManager.HasComponent <RagdollStateData>(charPresentation.character), "CharPresentation character does not have RagdollState"); var ragdollState = EntityManager.GetComponentData <RagdollStateData>(charPresentation.character); if (ragdollState.ragdollActive == 0) { return; } switch (ragdollOwner.phase) { case RagdollOwner.Phase.Inactive: ragdollOwner.timeUntilStart -= m_world.frameDuration; if (ragdollOwner.timeUntilStart <= m_world.worldTime.tickInterval) { // Store bone transforms so they can be used to calculate bone velocity next frame for (int boneIndex = 0; boneIndex < ragdollOwner.targeteBones.Length; boneIndex++) { if (ragdollOwner.targeteBones[boneIndex] == null) { continue; } ragdollOwner.lastBonePositions[boneIndex] = ragdollOwner.targeteBones[boneIndex].position; ragdollOwner.lastBoneRotations[boneIndex] = ragdollOwner.targeteBones[boneIndex].rotation; } ragdollOwner.phase = RagdollOwner.Phase.PoseSampled; } break; case RagdollOwner.Phase.PoseSampled: IntializeRagdoll(ragdollOwner, true, ragdollState.impulse); ragdollOwner.phase = RagdollOwner.Phase.Active; break; case RagdollOwner.Phase.Active: for (int boneIndex = 0; boneIndex < ragdollOwner.targeteBones.Length; boneIndex++) { if (ragdollOwner.targeteBones[boneIndex] == null) { continue; } ragdollOwner.targeteBones[boneIndex].position = ragdollOwner.ragdollSkeleton.bones[boneIndex].position; ragdollOwner.targeteBones[boneIndex].rotation = ragdollOwner.ragdollSkeleton.bones[boneIndex].rotation; } break; } }
public void SendData() { if (m_Connection == null || m_Connection.connectionState == ConnectionState.Disconnected) { return; } if (clientBlockOut.IntValue > 0) { return; } Profiler.BeginSample("NetworkClient.SendData"); #pragma warning disable 0162 // unreachable code switch (NetworkConfig.ioStreamType) { case NetworkCompression.IOStreamType.Raw: m_Connection.SendPackage <RawOutputStream>(); break; case NetworkCompression.IOStreamType.Huffman: m_Connection.SendPackage <HuffmanOutputStream>(); break; default: GameDebug.Assert(false); } #pragma warning restore Profiler.EndSample(); }
protected override void OnUpdate() { var requestArray = DespawnGroup.GetComponentDataArraySt <CharacterDespawnRequest>(); if (requestArray.Length == 0) { return; } Profiler.BeginSample("HandleCharacterDespawnRequests"); var requestEntityArray = DespawnGroup.GetEntityArraySt(); for (var i = 0; i < requestArray.Length; i++) { var request = requestArray[i]; var character = EntityManager .GetComponentObject <Character>(request.characterEntity); GameDebug.Assert(character != null, "Character despawn requst entity is not a character"); GameDebug.Log("Despawning character:" + character.name + " tick:" + m_world.worldTime.tick); m_world.RequestDespawn(character.gameObject, PostUpdateCommands); var charRepAll = EntityManager.GetComponentData <CharacterReplicatedData>(request.characterEntity); m_world.RequestDespawn(PostUpdateCommands, charRepAll.abilityCollection); PostUpdateCommands.DestroyEntity(requestEntityArray[i]); } Profiler.EndSample(); }
public HandleSpatialEffectRequests(GameWorld world, GameObject systemRoot, BundledResourceManager resourceSystem) : base(world) { var effectBundle = resourceSystem.GetResourceRegistry <SpatialEffectRegistry>(); GameDebug.Assert(effectBundle != null, "No HitscanEffectRegistry defined in registry"); m_Pools = new Pool[effectBundle.entries.Length]; for (var i = 0; i < effectBundle.entries.Length; i++) { var entry = effectBundle.entries[i]; var resource = resourceSystem.LoadSingleAssetResource(entry.prefab.guid); GameDebug.Assert(resource != null); var prefab = resource as GameObject; GameDebug.Assert(prefab != null); var pool = new Pool(); pool.instances = new SpatialEffectInstance[entry.poolSize]; for (var j = 0; j < pool.instances.Length; j++) { var go = GameObject.Instantiate(prefab); if (systemRoot != null) { go.transform.SetParent(systemRoot.transform, false); } pool.instances[j] = go.GetComponent <SpatialEffectInstance>(); GameDebug.Assert(pool.instances[j], "Effect prefab does not have SpatialEffectInstance component"); } m_Pools[i] = pool; } }
public Instance(EntityManager entityManager, Entity owner, PlayableGraph graph, Entity animStateOwner, AnimGraph_DamageReaction settings) { m_settings = settings; m_graph = graph; m_EntityManager = entityManager; m_Owner = owner; m_AnimStateOwner = animStateOwner; m_rootMixer = AnimationLayerMixerPlayable.Create(graph, 2); m_rootMixer.SetInputWeight(0, 1f); // Setup blend mixer m_blendMixer = AnimationMixerPlayable.Create(graph, 4); GameDebug.Assert(m_settings.clips != null && m_settings.clips.Length > 0, "No animation clips added to damagereaction settings:{0}", settings.name); for (var i = 0; i < m_settings.clips.Length; i++) { var clipPlayable = AnimationClipPlayable.Create(graph, m_settings.clips[i]); clipPlayable.SetApplyFootIK(false); clipPlayable.Pause(); graph.Connect(clipPlayable, 0, m_blendMixer, i); if (m_settings.clips[i].length > m_reactionAnimDuration) { m_reactionAnimDuration = m_settings.clips[i].length; } } m_reactionAnimAngleSpan = 360 / m_blendMixer.GetInputCount(); graph.Connect(m_blendMixer, 0, m_rootMixer, m_blendMixerPort); m_rootMixer.SetLayerAdditive(m_blendMixerPort, true); }
public void RequestGameLoop(System.Type type, string[] args) { GameDebug.Assert(typeof(IGameLoop).IsAssignableFrom(type)); m_RequestedGameLoopTypes.Add(type); m_RequestedGameLoopArguments.Add(args); GameDebug.Log("Game loop " + type + " requested"); }
public void SetFactory(int registryId, ReplicatedEntityFactory factory) { GameDebug.Assert(entries[registryId].prefab.guid == "", "GUID already set"); GameDebug.Assert(entries[registryId].factory == null, "Factory already set"); entries[registryId].factory = factory; EditorUtility.SetDirty(this); }