protected override void OnUpdate()
        {
            // The command buffer to record commands,
            // which are executed by the command buffer system later in the frame
            EntityCommandBuffer.ParallelWriter commandBuffer
                = CommandBufferSystem.CreateCommandBuffer().AsParallelWriter();
            //The DataToSpawn component tells us how many entities with buffers to create
            Entities.ForEach((Entity spawnEntity, int entityInQueryIndex, in DataToSpawn data) =>
            {
                for (int e = 0; e < data.EntityCount; e++)
                {
                    //Create a new entity for the command buffer
                    Entity newEntity = commandBuffer.CreateEntity(entityInQueryIndex);

                    //Create the dynamic buffer and add it to the new entity
                    DynamicBuffer <MyBufferElement> buffer =
                        commandBuffer.AddBuffer <MyBufferElement>(entityInQueryIndex, newEntity);

                    //Reinterpret to plain int buffer
                    DynamicBuffer <int> intBuffer = buffer.Reinterpret <int>();

                    //Optionally, populate the dynamic buffer
                    for (int j = 0; j < data.ElementCount; j++)
                    {
                        intBuffer.Add(j);
                    }
                }

                //Destroy the DataToSpawn entity since it has done its job
                commandBuffer.DestroyEntity(entityInQueryIndex, spawnEntity);
            }).ScheduleParallel();

            CommandBufferSystem.AddJobHandleForProducer(this.Dependency);
        }
 public static NativeArray <ArrayType> AsNativeArrayT <BufferType, ArrayType>(
     this DynamicBuffer <BufferType> buffer)
     where BufferType : unmanaged, IBufferElementData
     where ArrayType : unmanaged
 {
     return(buffer.Reinterpret <ArrayType>().AsNativeArray());
 }
예제 #3
0
        public unsafe PathQueryState FindPath(float2 from, float2 to, float radius, DynamicBuffer <PathSegmentElement> segments, DynamicBuffer <TriangleElement> triangleIds, Navmesh.Navmesh *navmesh, out int cost)
        {
            triangleIds.Clear();
            var result = _astar.Search(from, to, navmesh, _channel, radius, triangleIds, out cost);

            if (result == PathQueryState.PathFound)
            {
                _funnel.GetPath(_channel, from, to, radius, _path);
                triangleIds.Reinterpret <int>().AsNativeArray().Sort();
            }

            for (int i = 0; i < _path.Count; i++)
            {
                var w = _path.FromFront(i);
                Assert.IsTrue(!float.IsNaN(w.To.x) && !float.IsNaN(w.To.y));

                segments.Add(new PathSegmentElement
                {
                    Corner = i > 0 ? _path.FromFront(i - 1).Vertex : w.From,
                    From   = w.From,
                    To     = w.To
                });
            }

            _astar.Clear();
            _channel.Clear();
            _funnel.Clear();
            _path.Clear();
            return(result);
        }
예제 #4
0
        void LocalRefinement(DynamicBuffer <DestroyedTriangleElement> destroyed)
        {
            var verts = V.GetEnumerator();

            while (verts.MoveNext())
            {
                _refinementQueue.PushBack(verts.Current);
            }

            InfiniteLoopDetection.Reset();
            while (_refinementQueue.Count > 0)
            {
                InfiniteLoopDetection.Register(1000, "LocalRefinement");
                var v = (Vertex *)_refinementQueue.PopFront();
                var e = v->GetEdgeEnumerator();
                while (e.MoveNext())
                {
                    if (TriDisturbed(e.Current, out var vRef) || TravsDisturbed(e.Current, out vRef))
                    {
                        // todo are we adding duplicates here?
                        _refinementQueue.PushBack((IntPtr)v);
                        _refinementQueue.PushBack((IntPtr)vRef);
                        break;
                    }
                }
            }

            var tris = DestroyedTriangles.GetEnumerator();

            while (tris.MoveNext())
            {
                destroyed.Add(tris.Current);
            }
            destroyed.Reinterpret <int>().AsNativeArray().Sort();
        }
예제 #5
0
        public void SetMovementValues()
        {
            _flowFieldQuery      = GetEntityQuery(typeof(FlowFieldData));
            _flowFieldEntity     = _flowFieldQuery.GetSingletonEntity();
            _flowFieldData       = EntityManager.GetComponentData <FlowFieldData>(_flowFieldEntity);
            _destinationCellData = EntityManager.GetComponentData <DestinationCellData>(_flowFieldEntity);
            _entityBuffer        = EntityManager.GetBuffer <EntityBufferElement>(_flowFieldEntity);
            _gridEntities        = _entityBuffer.Reinterpret <Entity>();

            if (_cellDataContainer.IsCreated)
            {
                _cellDataContainer.Dispose();
            }
            _cellDataContainer = new NativeArray <CellData>(_gridEntities.Length, Allocator.Persistent);

            for (int i = 0; i < _entityBuffer.Length; i++)
            {
                _cellDataContainer[i] = GetComponent <CellData>(_entityBuffer[i]);
            }

            Entities.ForEach((ref EntityMovementData entityMovementData) =>
            {
                entityMovementData.destinationReached = false;
            }).Run();
        }
    // Start is called before the first frame update
    void Start()
    {
        EntityManager entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;                   // get EM reference
        Entity        entity        = entityManager.CreateEntity();                                          //create an entity to play with
        DynamicBuffer <IntBufferElement> dynamicBuffer = entityManager.AddBuffer <IntBufferElement>(entity); //add a buffer to the entity

        dynamicBuffer.Add(new IntBufferElement {
            Value = 1
        });                                                 //instantiate buffer elements
        dynamicBuffer.Add(new IntBufferElement {
            Value = 2
        });
        dynamicBuffer.Add(new IntBufferElement {
            Value = 3
        });

        DynamicBuffer <int> intDynamicBuffer = dynamicBuffer.Reinterpret <int>(); //reinterpret so we don't have to keep instantiating IntBufferElements

        intDynamicBuffer[1] = 5;                                                  // you can alter something already in the buffer
        intDynamicBuffer.Add(1);                                                  // you can add things to the buffer, and it affects the original buffer

        for (int i = 0; i < intDynamicBuffer.Length; i++)
        {
            intDynamicBuffer[i]++;
        }

        DynamicBuffer <IntBufferElement> dynBuff                  //You put what type the buffer holds in the <>
            = entityManager.GetBuffer <IntBufferElement>(entity); //you pass the entity that has the buffer attached to it
    }
        JobHandle ProcessViewEntities(bool mapRegenerated, DynamicBuffer <MapTiles> map, MapData mapData, JobHandle inputDeps)
        {
            // Process Entities with only a view and no memory
            return(Entities
                   .WithReadOnly(map)
                   .WithChangeFilter <Position>()
                   .WithNone <TilesInMemory>()
                   .ForEach((ref DynamicBuffer <TilesInView> view, in Position pos, in ViewRange range) =>
            {
                if (view.Length != map.Length || mapRegenerated)
                {
                    view.ResizeUninitialized(map.Length);
                }

                // Always reset view before rebuilding
                for (int i = 0; i < view.Length; ++i)
                {
                    view[i] = false;
                }

                var visibility = new VisibilityMap(
                    mapData.width,
                    mapData.height,
                    map.Reinterpret <TileType>().AsNativeArray(),
                    view.Reinterpret <bool>().AsNativeArray()
                    );

                FOV.Compute(pos, range, visibility);
            }).Schedule(inputDeps));
        protected override void OnUpdate()
        {
            EntityCommandBuffer commandBuffer = _ecbSystem.CreateCommandBuffer();

            Entities.ForEach((Entity entity, in NewFlowFieldData newFlowFieldData, in FlowFieldData flowFieldData) =>
            {
                commandBuffer.RemoveComponent <NewFlowFieldData>(entity);

                DynamicBuffer <EntityBufferElement> buffer = newFlowFieldData.isExistingFlowField
                                        ? GetBuffer <EntityBufferElement>(entity)
                                        : commandBuffer.AddBuffer <EntityBufferElement>(entity);
                DynamicBuffer <Entity> entityBuffer = buffer.Reinterpret <Entity>();

                float cellRadius   = flowFieldData.cellRadius;
                float cellDiameter = cellRadius * 2;

                int2 gridSize = flowFieldData.gridSize;

                for (int x = 0; x < gridSize.x; x++)
                {
                    for (int y = 0; y < gridSize.y; y++)
                    {
                        float3 cellWorldPos  = new float3(cellDiameter * x + cellRadius, 0, cellDiameter * y + cellRadius);
                        byte cellCost        = CostFieldHelper.instance.EvaluateCost(cellWorldPos, cellRadius);
                        CellData newCellData = new CellData
                        {
                            worldPos      = cellWorldPos,
                            gridIndex     = new int2(x, y),
                            cost          = cellCost,
                            bestCost      = ushort.MaxValue,
                            bestDirection = int2.zero
                        };

                        Entity curCell;
                        if (newFlowFieldData.isExistingFlowField)
                        {
                            int flatIndex = FlowFieldHelper.ToFlatIndex(new int2(x, y), gridSize.y);
                            curCell       = entityBuffer[flatIndex];
                        }
                        else
                        {
                            curCell = commandBuffer.CreateEntity(_cellArchetype);
                            entityBuffer.Add(curCell);
                        }
                        commandBuffer.SetComponent(curCell, newCellData);
                    }
                }

                int2 destinationIndex = FlowFieldHelper.GetCellIndexFromWorldPos(flowFieldData.clickedPos, gridSize, cellDiameter);
                DestinationCellData newDestinationCellData = new DestinationCellData {
                    destinationIndex = destinationIndex
                };
                if (!newFlowFieldData.isExistingFlowField)
                {
                    commandBuffer.AddComponent <DestinationCellData>(entity);
                }
                commandBuffer.SetComponent(entity, newDestinationCellData);
                commandBuffer.AddComponent <CalculateFlowFieldTag>(entity);
            }).Run();
예제 #9
0
 public void Execute(Entity entity,
                     int index,
                     DynamicBuffer <MyBufferElement> buffer)
 {
     foreach (int integer in buffer.Reinterpret <int>())
     {
         sums[index] += integer;
     }
 }
        public void Execute(Entity entity, int index, DynamicBuffer <TrailBufferElement> buffer, ref Translation _Translation, ref TrailComponent _TrailComponent)
        {
            if (buffer.Length > _TrailComponent.MeshCount)
            {
                buffer.RemoveAt(0);
            }
            DynamicBuffer <float3> rbuffer = buffer.Reinterpret <float3>();

            rbuffer.Add(_Translation.Value);
        }
예제 #11
0
 public FlatMeshDataColors(DynamicBuffer <MeshVerticesBuffer> vs,
                           DynamicBuffer <MeshTrianglesBuffer> ts,
                           DynamicBuffer <MeshNormalsBuffer> ns,
                           DynamicBuffer <MeshColorsBuffer> cs)
 {
     m_Vertices  = vs.Reinterpret <float3>();
     m_Triangles = ts.Reinterpret <int>();
     m_Normals   = ns.Reinterpret <float3>();
     m_Colors    = cs.Reinterpret <byte4>();
 }
예제 #12
0
 public FlatMeshDataUVs(DynamicBuffer <MeshVerticesBuffer> vs,
                        DynamicBuffer <MeshTrianglesBuffer> ts,
                        DynamicBuffer <MeshNormalsBuffer> ns,
                        DynamicBuffer <MeshUVsBuffer> uvs)
 {
     m_Vertices  = vs.Reinterpret <float3>();
     m_Triangles = ts.Reinterpret <int>();
     m_Normals   = ns.Reinterpret <float3>();
     m_UVs       = uvs.Reinterpret <float2>();
 }
예제 #13
0
 // NB: vertexColor needs to be as srgb when in gamma space, and in linear otherwise
 public static unsafe void LayoutString(char *text, int textLength, float fontSize, HorizontalAlignment hAlign,
                                        VerticalAlignment vAlign, float4 vertexColor,
                                        ref FontData font, DynamicBuffer <DynamicSimpleVertex> dynMesh, DynamicBuffer <DynamicIndex> dynTriangles,
                                        out AABB aabb)
 {
     LayoutString(text, textLength, fontSize, hAlign, vAlign, vertexColor, ref font,
                  dynMesh.Reinterpret <SimpleVertex>(),
                  dynTriangles.Reinterpret <ushort>(),
                  out aabb);
 }
예제 #14
0
        public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
        {
            NativeArray <Entity> entityArray = chunk.GetNativeArray(entityType);
            BufferAccessor <ReynoldsNearbyFlockPos> nearbyPosBuffers = chunk.GetBufferAccessor <ReynoldsNearbyFlockPos>(nearbyPosBufferType);
            BufferAccessor <ReynoldsNearbyFlockVel> nearbyVelBuffers = chunk.GetBufferAccessor <ReynoldsNearbyFlockVel>(nearbyVelBufferType);
            NativeArray <Translation>            transArray          = chunk.GetNativeArray(translationType);
            NativeArray <ReynoldsFlockBehaviour> flockArray          = chunk.GetNativeArray(flockType);
            NativeArray <PreviousMovement>       preVelArray         = chunk.GetNativeArray(preVelType);
            NativeArray <ReynoldsMovementValues> movementArray       = chunk.GetNativeArray(reynoldsMovementValuesType);

            for (int i = 0; i < chunk.Count; i++)
            {
                Entity entity = entityArray[i];
                DynamicBuffer <ReynoldsNearbyFlockPos> posBuffer = nearbyPosBuffers[i];
                DynamicBuffer <ReynoldsNearbyFlockVel> velBuffer = nearbyVelBuffers[i];
                Translation            trans          = transArray[i];
                ReynoldsFlockBehaviour flockBehaviour = flockArray[i];
                PreviousMovement       preVel         = preVelArray[i];
                ReynoldsMovementValues movement       = movementArray[i];

                float3 agentPosition = trans.Value;                                         // the position of the seeker

                DynamicBuffer <float3> nearCrowdPosList = posBuffer.Reinterpret <float3>(); // reinterpret the buffer so that it is used like a buffer of float3s
                nearCrowdPosList.Clear();

                DynamicBuffer <float3> nearCrowdVelList = velBuffer.Reinterpret <float3>(); // reinterpret the buffer so that it is used like a buffer of float3s
                nearCrowdVelList.Clear();


                float searchRadius = math.max(flockBehaviour.CohesionRadius, flockBehaviour.AvoidanceRadius);                                                                    // Choose the farther radius

                int hashMapKey = MovingQuadrantSystem.GetPositionHashMapKey(trans.Value);                                                                                        // Calculate the hash key of the seeker in question

                FindCrowdAgents(hashMapKey, agentPosition, entity, ref nearCrowdPosList, ref nearCrowdVelList, ref searchRadius);                                                // Seach the quadrant that the seeker is in
                FindCrowdAgents(hashMapKey + 1, agentPosition, entity, ref nearCrowdPosList, ref nearCrowdVelList, ref searchRadius);                                            // search the quadrant to the right
                FindCrowdAgents(hashMapKey - 1, agentPosition, entity, ref nearCrowdPosList, ref nearCrowdVelList, ref searchRadius);                                            // search the quadrant to the left
                FindCrowdAgents(hashMapKey + MovingQuadrantSystem.quadrantYMultiplier, agentPosition, entity, ref nearCrowdPosList, ref nearCrowdVelList, ref searchRadius);     // quadrant above
                FindCrowdAgents(hashMapKey - MovingQuadrantSystem.quadrantYMultiplier, agentPosition, entity, ref nearCrowdPosList, ref nearCrowdVelList, ref searchRadius);     // quadrant below
                FindCrowdAgents(hashMapKey + 1 + MovingQuadrantSystem.quadrantYMultiplier, agentPosition, entity, ref nearCrowdPosList, ref nearCrowdVelList, ref searchRadius); // up right
                FindCrowdAgents(hashMapKey - 1 + MovingQuadrantSystem.quadrantYMultiplier, agentPosition, entity, ref nearCrowdPosList, ref nearCrowdVelList, ref searchRadius); // up left
                FindCrowdAgents(hashMapKey + 1 - MovingQuadrantSystem.quadrantYMultiplier, agentPosition, entity, ref nearCrowdPosList, ref nearCrowdVelList, ref searchRadius); // down right
                FindCrowdAgents(hashMapKey - 1 - MovingQuadrantSystem.quadrantYMultiplier, agentPosition, entity, ref nearCrowdPosList, ref nearCrowdVelList, ref searchRadius); // down left

                movementArray[i] = GetFlockingBehaviour(ref trans, ref preVel.value, ref nearCrowdPosList, ref nearCrowdVelList, ref flockBehaviour, movement);
            }
        }
예제 #15
0
        protected override void OnUpdate()
        {
            Entities.ForEach((BoidAuthoring boidAuthoring) =>
            {
                var entity = GetPrimaryEntity(boidAuthoring);

                DstEntityManager.AddSharedComponentData(entity, new Boid
                {
                    CellRadius           = boidAuthoring.CellRadius,
                    SeparationWeight     = boidAuthoring.SeparationWeight,
                    AlignmentWeight      = boidAuthoring.AlignmentWeight,
                    TargetWeight         = boidAuthoring.TargetWeight,
                    OuterDetectionRadius = boidAuthoring.OuterDetectionRadius,
                    InnerDetectionRadius = boidAuthoring.InnerDetectionRadius,
                    MoveSpeed            = boidAuthoring.MoveSpeed,
                    WanderRadius         = boidAuthoring.WanderRadius,
                    WanderWeight         = boidAuthoring.WanderWeight,
                    VisionAngle          = boidAuthoring.VisionAngle,
                    NavigationRayCount   = boidAuthoring.NavigationRayCount,
                });
                DynamicBuffer <Float3BufferElement> buffer = DstEntityManager.AddBuffer <Float3BufferElement>(entity);
                DynamicBuffer <float3> floatBuffer         = buffer.Reinterpret <float3>();

                for (int i = 0; i < boidAuthoring.NavigationRayCount; i++)
                {
                    float turnFraction = 0.6180f;
                    float t            = i / (boidAuthoring.NavigationRayCount - 1f);
                    float phi          = math.acos(1f - 2f * t);
                    float theta        = 2 * math.PI * turnFraction * i;

                    float x  = math.sin(phi) * math.cos(theta);
                    float y  = math.sin(phi) * math.sin(theta);
                    float z  = math.cos(phi);
                    float3 p = new float3(x, y, z);
                    if (math.acos(math.dot(p, new float3(0, 0, 1))) < boidAuthoring.VisionAngle)
                    {
                        floatBuffer.Add(p);
                    }
                }

                // Remove default transform system components
                DstEntityManager.RemoveComponent <Translation>(entity);
                DstEntityManager.RemoveComponent <Rotation>(entity);
            });
        }
예제 #16
0
        protected override void OnUpdate()
        {
            Camera.onPostRender = null;

            Camera.onPostRender += (Camera camera) => {
                // Pushes the current matrix onto the stack so that can be restored later
                GL.PushMatrix();

                // Loads a new Projection Matrix, you can also use other methods like LoadOrtho() or GL.LoadPixelMatrix()
                //GL.LoadProjectionMatrix(Matrix4x4.Perspective(90, camera.aspect, -10f, 10f));
                GL.LoadPixelMatrix(0, Screen.width, 0, Screen.height);

                // You can also multiply the current matrix in order to do things like translation, rotation and scaling
                // Here I'm rotating and scaling up the current Matrix
                //GL.MultMatrix(Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0, 0, 45), new Vector3(2, 2)));
            };

            Entity entity = m_MinimapQuery.GetSingletonEntity();
            DynamicBuffer <RenderTexture> buffer = EntityManager.GetBuffer <RenderTexture>(entity);
            RectComponent pos = EntityManager.GetComponentData <RectComponent>(entity);

            if (buffer.Capacity > buffer.Length)
            {
                buffer.TrimExcess();
            }

            Texture2D tex = new Texture2D(100, 100);

            tex.SetPixels(buffer.Reinterpret <Color>().AsNativeArray().ToArray());
            tex.Apply();

            tex.wrapMode = TextureWrapMode.Clamp;

            Camera.onPostRender += (Camera camera) => {
                if (tex != null)
                {
                    Graphics.DrawTexture(new Rect(pos.x, pos.y, pos.width, pos.height), tex);
                }
            };

            Camera.onPostRender += (Camera camera) => {
                // Pops the matrix that was just loaded, restoring the old matrix
                GL.PopMatrix();
            };
        }
예제 #17
0
        /// <summary>
        /// Applies percent modifiers on a stat.
        /// </summary>
        protected static void ApplyModifiers <T>(ref float stat, DynamicBuffer <T> modifierBuffer)
            where T : struct, IBufferElementData
        {
            DynamicBuffer <float> modifiers = modifierBuffer.Reinterpret <float>();

            for (int i = modifiers.Length - 1; i >= 0; i--)
            {
                float modifier = modifiers[i];
                modifiers.RemoveAt(i);

                if (stat <= 0)
                {
                    continue;         // Don't multiply negative values
                }
                stat *= 1 + modifier; // Multiply stat
                if (stat < 0)
                {
                    stat = 0;           // Don't reduce stat below 0
                }
            }
        }
    void EntityJobScheduling()
    {
        m_EntityCommandBuffer = m_EntityBufferSystem.CreateCommandBuffer();
        //Lambda doesnt run in normal C#, Unity converts it in a more performant job system construct and burst for better PC resource usage
        Entities.ForEach((Entity entity, in UserData userData, in UpdatedFFData updatedFFData) =>
        {
            m_EntityCommandBuffer.RemoveComponent <UpdatedFFData>(entity);
            DynamicBuffer <EBufferElement> eBuffer = updatedFFData.exists ? GetBuffer <EntityCommandBufferManagedComponentExtensions>(entity) : m_EntityCommandBuffer.AddBuffer <EBufferElement>(entity);
            DynamicBuffer <Entity> m_EntityBuffer  = eBuffer.Reinterpret <Entity>();

            InitGrid(updatedFFData);

            //From Elite framework
            IPoint2 idxInWorld = GetNodeIdxFromWorldPos(userData.GetClickedPos(), IPoint2(nrOfCols, nrOfRows), colSize, rowSize);
            EndNode endNode    = new EndNode(idxInWorld);
            if (!updatedFFData.exists)
            {
                m_EntityCommandBuffer.AddComponent <EndNode>(entity);
            }
            m_EntityCommandBuffer.SetComponent(entity, endNode);
            m_EntityCommandBuffer.AddComponent <TagObstacleCalc>(entity);
        }).Run();
예제 #19
0
    static public void CreateBullet(float3 _StartPosition, float _LifeTime, int _HostID, E_BulletType _Type, int _Damage, float3 _Direction, float _Speed, LayerMask _TargetLayerMask, int _TrailMeshCount = 10)
    {
        int meshcount = _TrailMeshCount;

        Entity entity = m_EntityManger.CreateEntity(m_BulletArchetype);

        m_EntityManger.SetComponentData(entity, new Translation()
        {
            Value = _StartPosition
        });
        m_EntityManger.SetComponentData(entity, new BulletComponent(_HostID, _Type, _Damage, Unity.Mathematics.math.normalize(_Direction), _Speed, _TargetLayerMask));
        m_EntityManger.SetComponentData(entity, new TrailComponent()
        {
            MeshCount = meshcount
        });
        m_EntityManger.SetComponentData(entity, new LifeTimerComponent(_LifeTime));
        DynamicBuffer <TrailBufferElement> buffer = m_EntityManger.GetBuffer <TrailBufferElement>(entity);
        DynamicBuffer <float3>             reinb  = buffer.Reinterpret <float3>();

        for (int i = 0; i < meshcount; ++i)
        {
            reinb.Add(_StartPosition);
        }
    }
예제 #20
0
            //The DataToSpawn component tells us how many entities with buffers to create
            public void Execute(Entity spawnEntity, int index, [ReadOnly] ref DataToSpawn data)
            {
                for (int e = 0; e < data.EntityCount; e++)
                {
                    //Create a new entity for the command buffer
                    Entity newEntity = CommandBuffer.CreateEntity(index);

                    //Create the dynamic buffer and add it to the new entity
                    DynamicBuffer <MyBufferElement> buffer =
                        CommandBuffer.AddBuffer <MyBufferElement>(index, newEntity);

                    //Reinterpret to plain int buffer
                    DynamicBuffer <int> intBuffer = buffer.Reinterpret <int>();

                    //Optionally, populate the dynamic buffer
                    for (int j = 0; j < data.ElementCount; j++)
                    {
                        intBuffer.Add(j);
                    }
                }

                //Destroy the DataToSpawn entity since it has done its job
                CommandBuffer.DestroyEntity(index, spawnEntity);
            }
예제 #21
0
            public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
            {
                NativeArray <NavigationGridData>  navigationGrids    = chunk.GetNativeArray(this.navigationGridType);
                BufferAccessor <AStarNodeElement> nodeBufferAccessor = chunk.GetBufferAccessor(this.nodeBufferType);

                for (int ci = 0, cn = chunk.Count; ci < cn; ci++)
                {
                    NavigationGridData navigationGrid           = outNavigationGrid[0] = navigationGrids[ci];
                    DynamicBuffer <AStarNodeElement> nodeBuffer = nodeBufferAccessor[ci];

                    // Solve path if requested

                    if (navigationGrid.pathRequested)
                    {
                        // All nodes
                        NativeArray <AStarNode> nodes = nodeBuffer.Reinterpret <AStarNode>().ToNativeArray(Allocator.Temp);

                        // Create temp grid
                        AStarGrid aStarGrid = new AStarGrid(navigationGrid.lengthX, navigationGrid.lengthY, nodes);

                        // Start/end nodes
                        AStarNode start = navigationGrid.pathStart;
                        AStarNode end   = navigationGrid.pathEnd;

                        // Solve path
                        NativeList <AStarNode> pathNodeList = new NativeList <AStarNode>(Allocator.Temp);
                        bool pathFound  = AStarSolver.SolvePath(aStarGrid, start, end, ref pathNodeList);
                        int  pathLength = pathNodeList.Length;
                        if (pathFound && navigationGrid.pathMustBeStraightLine)
                        {
                            // Check if path is straight line if specfied as a requirement
                            bool xDiverge = false;
                            bool yDiverge = false;
                            for (int i = 1, n = pathNodeList.Length; i < n; i++)
                            {
                                if (!xDiverge)
                                {
                                    xDiverge = pathNodeList[i].XCoord != pathNodeList[i - 1].XCoord;
                                }
                                if (!yDiverge)
                                {
                                    yDiverge = pathNodeList[i].YCoord != pathNodeList[i - 1].YCoord;
                                }
                                if (xDiverge && yDiverge)
                                {
                                    pathFound = false;
                                    break;
                                }
                            }
                        }


                        // Copy path node list to output array
                        NativeSlice <AStarNode> pathNodeListSlice = new NativeSlice <AStarNode>(pathNodeList.AsArray());
                        NativeSlice <AStarNode> pathNodeSlice     = new NativeSlice <AStarNode>(this.outPathNodes, 0, pathLength);
                        pathNodeSlice.CopyFrom(pathNodeListSlice);

                        // Dispose native containers
                        pathNodeList.Dispose();
                        aStarGrid.Dispose();
                        nodes.Dispose();

                        this.outPathFound[0]                  = pathFound ? 1 : 0;
                        this.outPathFound[1]                  = pathLength;
                        navigationGrid.pathRequested          = false;
                        navigationGrid.pathMustBeStraightLine = false;

                        // Apply changes
                        navigationGrids[ci] = navigationGrid;
                    }
                }
            }
        protected override void OnUpdate( )
        {
            if (group_MMMamager.CalculateChunkCount() == 0)
            {
                Debug.LogWarning("There is no active manager.");
                return;
            }

            EntityCommandBuffer ecb = becb.CreateCommandBuffer();

            EntityCommandBuffer.ParallelWriter ecbp = ecb.AsParallelWriter();


            l_managerSharedData.Clear();
            EntityManager.GetAllUniqueSharedComponentData(l_managerSharedData);

            ComponentDataFromEntity <NNManagerBestFitnessComponent> a_managerBestFitness = GetComponentDataFromEntity <NNManagerBestFitnessComponent> (false);
            ComponentDataFromEntity <NNManagerComponent>            a_manager            = GetComponentDataFromEntity <NNManagerComponent> (true);
            ComponentDataFromEntity <NNScoreComponent> a_managerScore = GetComponentDataFromEntity <NNScoreComponent> (true);

            ComponentDataFromEntity <NNBrainScoreComponent> a_brainScore = GetComponentDataFromEntity <NNBrainScoreComponent> (true);

            ComponentDataFromEntity <NNMangerIsSpawningNewGenerationTag> a_mangerIsSpawningNewGeneration = GetComponentDataFromEntity <NNMangerIsSpawningNewGenerationTag> (false);

            BufferFromEntity <NNInput2HiddenLayersWeightsBuffer>  NNInput2HiddenLayersWeightsBuffer  = GetBufferFromEntity <NNInput2HiddenLayersWeightsBuffer> (false);
            BufferFromEntity <NNHidden2OutputLayersWeightsBuffer> NNHidden2OutputLayersWeightsBuffer = GetBufferFromEntity <NNHidden2OutputLayersWeightsBuffer> (false);

            // BufferFromEntity <NNHiddenLayersNeuronsBiasBuffer> NNHiddenLayersNeuronsBiasBuffer           = GetBufferFromEntity <NNHiddenLayersNeuronsBiasBuffer> ( false ) ;


            // ComponentDataFromEntity <NNScoreComponent> a_managerScore                                           = GetComponentDataFromEntity <NNScoreComponent> ( true ) ;

            BufferFromEntity <NNINdexProbabilityBuffer> indexProbabilityBuffer = GetBufferFromEntity <NNINdexProbabilityBuffer> (false);

            // int i_validManagersCount                                                                     = 0 ;
            // bool canCalculateCrossovers                                                                  = false ;

            for (int i = 0; i < l_managerSharedData.Count; i++)
            {
                NNManagerSharedComponent mangerSharedComponent = l_managerSharedData [i];
                Entity nnManagerEntity = new Entity()
                {
                    Index = mangerSharedComponent.i_entityIndex, Version = mangerSharedComponent.i_entityVersion
                };

                if (a_mangerIsSpawningNewGeneration.HasComponent(nnManagerEntity))
                {
                    group_parentPopulation.SetSharedComponentFilter(mangerSharedComponent);
                    group_offspringPopulation.SetSharedComponentFilter(mangerSharedComponent);

                    NativeArray <Entity> na_parentPopulationEntities    = group_parentPopulation.ToEntityArray(Allocator.TempJob);
                    NativeArray <Entity> na_offspringPopulationEntities = group_offspringPopulation.ToEntityArray(Allocator.TempJob);

                    DynamicBuffer <NNINdexProbabilityBuffer> a_indexProbability = indexProbabilityBuffer [nnManagerEntity];


                    NNScoreComponent managerScore = a_managerScore [nnManagerEntity];
                    // int i_eliteScore                                            = managerScore.i ;



                    Debug.Log("Total score: " + managerScore.i + "; elite score: " + managerScore.i_elite);


                    if (managerScore.i_elite <= 1)
                    {
                        Dependency = new CopyLastBestGenerationDNAJob()
                        {
                            na_parentPopulationEntities    = na_parentPopulationEntities,
                            na_offspringPopulationEntities = na_offspringPopulationEntities,

                            // na_indexProbability              = na_indexProbability,

                            input2HiddenLayersWeightsBuffer  = NNInput2HiddenLayersWeightsBuffer,
                            hidden2OutputLayersWeightsBuffer = NNHidden2OutputLayersWeightsBuffer,

                            // hiddenLayersNeuronsBiasBuffer    = NNHiddenLayersNeuronsBiasBuffer
                        }.Schedule(na_parentPopulationEntities.Length, 256, Dependency);

                        Dependency.Complete();
                    }
                    else
                    {
                        // New score is fine.

                        // Calculate index probability, to get best parents.
                        // Each entity indicies will be in the array, as many times, as many score has
                        // e.g.
                        // 0th entity with 0 points won't be in the array
                        // 1st entity with 2 points will be 2 times
                        // nth entity with xth score will be xth times in the array

                        NNManagerComponent manager = a_manager [nnManagerEntity];

                        NativeMultiHashMap <int, EntityIndex> nmhm_parentEntitiesScore = new NativeMultiHashMap <int, EntityIndex> (na_parentPopulationEntities.Length, Allocator.TempJob);

// Debug.Log ( "crossover parent score" ) ;
                        Dependency = new CommonJobs.GetPopulationScoreJob( )
                        {
                            canGetEachScore       = false,
                            na_populationEntities = na_parentPopulationEntities,
                            a_brainScore          = a_brainScore,

                            nmhm_populationEntitiesScore = nmhm_parentEntitiesScore.AsParallelWriter()
                        }.Schedule(na_parentPopulationEntities.Length, 256, Dependency);

                        Dependency.Complete();

                        NativeArray <int> na_parentSortedKeysWithDuplicates = nmhm_parentEntitiesScore.GetKeyArray(Allocator.TempJob);
                        // This stores key keys in order. But keeps first unique keys at the front of an array.
                        // Total array size matches of total elements.
                        na_parentSortedKeysWithDuplicates.Sort();
                        // Sorted.
                        int i_uniqueKeyCount = na_parentSortedKeysWithDuplicates.Unique();

                        int i_eltieCountTemp = (int)(na_parentSortedKeysWithDuplicates.Length * manager.f_eliteSize);
                        // Minimum elite size mus be met.
                        int i_eltiesCount = i_eltieCountTemp > 0 ? i_eltieCountTemp : na_parentSortedKeysWithDuplicates.Length;

                        if (na_parentSortedKeysWithDuplicates.Length == 0)
                        {
                            Debug.LogError("Not enough elites for training. Please increase population, or elites %.");

                            na_offspringPopulationEntities.Dispose();
                            na_parentPopulationEntities.Dispose();
                            nmhm_parentEntitiesScore.Dispose();
                            na_parentSortedKeysWithDuplicates.Dispose();

                            continue;
                        }

                        NativeArray <EntityIndex> na_elities = new NativeArray <EntityIndex> (i_eltiesCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);

                        DynamicBuffer <NNINdexProbabilityBuffer> a_eliteIndexProbability = indexProbabilityBuffer [nnManagerEntity];
                        int i_totalElitesScore = managerScore.i_elite;
                        a_eliteIndexProbability.ResizeUninitialized(i_totalElitesScore);

                        Dependency = new CommonJobs.GetElitesEntitiesJob()
                        {
                            i_eltiesCount = i_eltiesCount,

                            na_elities         = na_elities,
                            nmhm_entitiesScore = nmhm_parentEntitiesScore,
                            na_currentSortedKeysWithDuplicates = na_parentSortedKeysWithDuplicates
                        }.Schedule();



                        Dependency = new CalculateIndexProbabilityOfPopulationJob()
                        {
                            na_populationEntities = na_elities,

                            a_indexProbability = a_eliteIndexProbability,

                            a_brainScore = a_brainScore
                        }.Schedule(Dependency);


                        NativeArray <int> na_randomValues = new NativeArray <int> (na_parentPopulationEntities.Length, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);

                        random.NextInt2();
                        Dependency = new RandomIntsJob()
                        {
                            na_randomValues = na_randomValues,
                            random          = random
                        }.Schedule(Dependency);

                        Dependency.Complete();

// Debug.LogError ( "parent pop: " + na_parentPopulationEntities.Length + "; offspring pop: " + na_offspringPopulationEntities.Length ) ;
                        Dependency = new DNACrossOverJob()
                        {
                            na_parentPopulationEntities    = na_parentPopulationEntities,
                            na_offspringPopulationEntities = na_offspringPopulationEntities,

                            na_indexProbability = a_eliteIndexProbability.Reinterpret <int> ().AsNativeArray(),

                            input2HiddenLayersWeightsBuffer  = NNInput2HiddenLayersWeightsBuffer,
                            hidden2OutputLayersWeightsBuffer = NNHidden2OutputLayersWeightsBuffer,

                            na_randomValues = na_randomValues,
                            random          = random,

                            // i_eliteScore                     = i_eliteScore
                        }.Schedule(na_parentPopulationEntities.Length, 256, Dependency);

                        Dependency.Complete();

                        na_randomValues.Dispose();
                        na_elities.Dispose();
                        nmhm_parentEntitiesScore.Dispose();
                        na_parentSortedKeysWithDuplicates.Dispose();
                    }

                    ecb.RemoveComponent <NNMangerIsSpawningNewGenerationTag> (nnManagerEntity);
                    becb.AddJobHandleForProducer(Dependency);


                    na_offspringPopulationEntities.Dispose();
                    na_parentPopulationEntities.Dispose();
                }
            } // for


            Entities
            .WithName("GenerationSpawningIsCompleteJob")
            .WithAll <NNBrainTag, IsSpawningTag> ()
            .ForEach((Entity entity, int entityInQueryIndex) =>
            {
                ecbp.RemoveComponent <IsSpawningTag> (entityInQueryIndex, entity);
                ecbp.AddComponent <IsSpawningCompleteTag> (entityInQueryIndex, entity);
            }).ScheduleParallel();

            becb.AddJobHandleForProducer(Dependency);
        }
예제 #23
0
        public void Execute(Entity entity, int index, ref ArmComponent armComponent,
                            [ReadOnly] ref Translation translation, [ReadOnly] ref Rotation rotation)
        {
            float  armBoneLength   = armComponent.armBoneLength;
            float3 handUp          = armComponent.handUp;
            float  armBendStrength = armComponent.armBendStrength;

            Matrix4x4[] matrices = new Matrix4x4[17];

            DynamicBuffer <ArmChainsBuffer>    armChainsBuffer    = armChainsBufferLookup[entity];
            DynamicBuffer <FingerChainsBuffer> fingerChainsBuffer = fingerChainsBufferLookup[entity];
            DynamicBuffer <ThumbChainsBuffer>  thumbChainsBuffer  = thumbChainsBufferLookup[entity];

            ///////////////////////////
            // Resting position for hand
            float time = worldTime + armComponent.timeOffset;

            // solve the arm IK chain first
            float3 anchor = translation.Value;

            //float3 anchor = new float3();
            FABRIK.SolveViaBuffer(armChainsBuffer.Reinterpret <float3>(), armBoneLength, anchor, armComponent.handTarget, handUp * armBendStrength);

            Quaternion q = rotation.Value;
            float3     transformRight = math.normalize(math.mul(q, directions.right));

            // figure out our current "hand vectors" from our arm orientation
            float3 handForward = math.normalize(util.Last(armChainsBuffer.Reinterpret <float3>(), 0) - util.Last(armChainsBuffer.Reinterpret <float3>(), 1));

            handUp = math.normalize(math.cross(handForward, transformRight));
            float3 handRight = math.cross(handUp, handForward);

            // create handspace-to-worldspace matrix
            armComponent.handMatrix = Matrix4x4.TRS(util.Last(armChainsBuffer.Reinterpret <float3>(), 0), Quaternion.LookRotation(handForward, handUp), directions.one);

            // how much are our fingers gripping?
            // (during a reach, this is based on the reach timer)
            float fingerGrabT = armComponent.savedGrabT;

            if (armComponent.heldRock != Entity.Null)
            {
                //Translation heldRockTrans = translationsFromEntity[armComponent.heldRock];
                fingerGrabT = 1.0f; //When holding the rock, we're fully gripped.

                var held = new RockHeldComponent();
                held.rockInHandPosition = armComponent.handMatrix.MultiplyPoint3x4(armComponent.heldRockOffset);
                ecb.AddComponent(index, armComponent.heldRock, held);
                //   armComponent.lastIntendedRockPos =
            }

            // create rendering matrices for arm bones
            util.UpdateMatrices(matrices, armChainsBuffer.Reinterpret <float3>(), 0, armComponent.armBoneThickness, handUp);
            int matrixIndex = armChainsBuffer.Reinterpret <float3>().Length - 1;

            // next:  fingers
            float3 handPos = util.Last(armChainsBuffer.Reinterpret <float3>(), 0);
            // fingers spread out during a throw
            float openPalm = throwCurve.Evaluate(armComponent.throwTimer);

            //TODO add these to arm component?
            float fingerXOffset = -0.12f;
            float fingerSpacing = 0.08f;

            float[] fingerBoneLengths  = { 0.2f, 0.22f, 0.2f, 0.16f };
            float[] fingerThicknesses  = { 0.05f, 0.05f, 0.05f, 0.05f };
            float   fingerBendStrength = 0.2f;

            for (int i = 0; i < 4; i++)
            {
                float3 handRightTemp = handRight * (fingerXOffset + i * fingerSpacing);

                // find knuckle position for this finger
                float3 fingerPos = handPos + handRightTemp;

                // find resting position for this fingertip
                float3 fingerTarget = fingerPos + handForward * (.5f - .1f * fingerGrabT);

                // spooky finger wiggling while we're idle
                fingerTarget += handUp * Mathf.Sin((time + i * .2f) * 3f) * .2f * (1f - fingerGrabT);

                // if we're gripping, move this fingertip onto the surface of our rock
                float3 rockFingerDelta = fingerTarget - armComponent.lastIntendedRockPos;
                float3 rockFingerPos   = armComponent.lastIntendedRockPos + math.normalize(rockFingerDelta) * (armComponent.lastIntendedRockSize * .5f + fingerThicknesses[i]);
                fingerTarget = math.lerp(fingerTarget, rockFingerPos, fingerGrabT);

                // apply finger-spreading during throw animation
                fingerTarget += (handUp * .3f + handForward * .1f + handRight * (i - 1.5f) * .1f) * openPalm;

                // solve this finger's IK chain
                // FABRIK.Solve(fingerChains[i],fingerBoneLengths[i],fingerPos,fingerTarget,handUp*fingerBendStrength);
                int startIdx = i * 4;
                int stopIdx  = startIdx + 4;
                FABRIK.SolveViaBufferSliced(fingerChainsBuffer.Reinterpret <float3>(), fingerBoneLengths[i], fingerPos, fingerTarget, handUp * fingerBendStrength, startIdx, stopIdx);

                // update this finger's rendering matrices
                util.UpdateMatricesSliced(matrices, fingerChainsBuffer.Reinterpret <float3>(), matrixIndex, fingerThicknesses[i], handUp, startIdx, stopIdx);
                matrixIndex += 4 - 1;
            }

            // the thumb is pretty much the same as the fingers
            // (but pointing in a strange direction)
            float thumbXOffset      = -0.05f;
            float thumbThickness    = 0.06f;
            float thumbBendStrength = 0.1f;
            float thumbBoneLength   = 0.13f;

            float3 thumbPos    = handPos + handRight * thumbXOffset;
            float3 thumbTarget = thumbPos - handRight * .15f + handForward * (.2f + .1f * fingerGrabT) - handUp * .1f;

            thumbTarget += handRight * Mathf.Sin(time * 3f + .5f) * .1f * (1f - fingerGrabT);
            // thumb bends away from the palm, instead of "upward" like the fingers
            float3 thumbBendHint = (-handRight - handForward * .5f);

            float3 rockThumbDelta = thumbTarget - armComponent.lastIntendedRockPos;
            float3 rockThumbPos   = armComponent.lastIntendedRockPos + math.normalize(rockThumbDelta) * (armComponent.lastIntendedRockSize * .5f);

            thumbTarget = math.lerp(thumbTarget, rockThumbPos, fingerGrabT);

            FABRIK.SolveViaBuffer(thumbChainsBuffer.Reinterpret <float3>(), thumbBoneLength, thumbPos, thumbTarget, thumbBendHint * thumbBendStrength);
            util.UpdateMatrices(matrices, thumbChainsBuffer.Reinterpret <float3>(), matrixIndex, thumbThickness, thumbBendHint);

            DynamicBuffer <ArmMatrixBuffer> buffer = matrixBufferLookup[entity];

            buffer.Clear();
            for (int i = 0; i < matrices.Length; i++)
            {
                buffer.Add(new ArmMatrixBuffer()
                {
                    Value = matrices[i]
                });
            }
        }
        public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
        {
            var  renderer = GetComponent <Renderer>();
            Mesh mesh;

            if (UseColliderMeshInsteadOfRendererMesh)
            {
                mesh = GetComponent <MeshCollider>().sharedMesh;
            }
            else
            {
                mesh = GetComponent <MeshFilter>().mesh;
            }

            GeometryDataModels.Edge[] edges = new GeometryDataModels.Edge[1];
            dstManager.AddBuffer <GeometryDataModelsEntities.EdgesBuffer>(entity);
            dstManager.AddBuffer <GeometryDataModelsEntities.VerticesBuffer>(entity);
            dstManager.AddBuffer <GeometryDataModelsEntities.TrianglesBuffer>(entity);
            DynamicBuffer <GeometryDataModelsEntities.EdgesBuffer>     eBuffer = dstManager.GetBuffer <GeometryDataModelsEntities.EdgesBuffer>(entity);
            DynamicBuffer <GeometryDataModelsEntities.VerticesBuffer>  vBuffer = dstManager.GetBuffer <GeometryDataModelsEntities.VerticesBuffer>(entity);
            DynamicBuffer <GeometryDataModelsEntities.TrianglesBuffer> tBuffer = dstManager.GetBuffer <GeometryDataModelsEntities.TrianglesBuffer>(entity);
            //Reinterpret to plain int buffer
            DynamicBuffer <GeometryDataModels.Edge> edgesBuffer = eBuffer.Reinterpret <GeometryDataModels.Edge>();
            DynamicBuffer <Vector3> vector3Buffer  = vBuffer.Reinterpret <Vector3>();
            DynamicBuffer <int>     triangleBuffer = tBuffer.Reinterpret <int>();

            //populate the dynamic buffer
            for (int j = 0; j < mesh.vertexCount; j++)
            {
                vector3Buffer.Add(mesh.vertices[j]);
            }

            for (int j = 0; j < mesh.triangles.Length; j++)
            {
                triangleBuffer.Add(mesh.triangles[j]);
            }

            dstManager.AddComponentData(entity, new GeometryDataModelsEntities.LocalToWorldMatrix
            {
                Matrix = renderer.localToWorldMatrix,
            });

            dstManager.AddComponentData(entity, new GeometryDataModelsEntities.Visible
            {
                IsVisible = true,
            });

            var geoInfoData = new GeometryDataModelsEntities.GeoInfoEntityComponent
            {
                Edges     = edgesBuffer,
                Vertices  = vector3Buffer,
                Triangles = triangleBuffer,
                Matrix    = renderer.localToWorldMatrix,
            };

            dstManager.AddComponentData(entity, geoInfoData);

            var targetData = new GeometryDataModels.Target
            {
                position = transform.position,
                projectedTargetPosition = Vector3.zero,
                distanceToRay           = 0,
                distanceToCastOrigin    = 0,
                entity = entity
            };

            dstManager.AddComponentData(entity, targetData);
        }
예제 #25
0
 internal static void SetEntityTextRendererString(DynamicBuffer <TextRendererString> buffer,
                                                  string newText)
 {
     buffer.Reinterpret <char>().FromString(newText);
 }
예제 #26
0
    // Start is called before the first frame update
    void Start()
    {
        mapGen = new MapGeneratorComponent(width, height);

        char[] map = mapGen.GetMap();

        entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;

        MapTranslationComponent mapTranslationComponent = new MapTranslationComponent(map, entityManager, mesh, StoneMaterial, material, width, height);

        NativeArray <Entity> entityArray = mapTranslationComponent.GetEntityArray();

        //Entity e = entityManager.CreateEntity(typeof(MapBuffer));
        Entity f = entityManager.CreateEntity(typeof(MapEntityBuffer));


        //Setup Neighbour components
        for (int i = 0; i < width * height; i++)
        {
            Entity entity = entityArray[i];
            Tile   tile   = entityManager.GetComponentData <Tile>(entity);

            ////Bug, need to add it every iteration or it gets deallocated
            //DynamicBuffer<MapBuffer> bufferFromEntity = entityManager.GetBuffer<MapBuffer>(e);
            //DynamicBuffer<Tile> tileBuffer = bufferFromEntity.Reinterpret<Tile>();
            //tileBuffer.Add(tile);
            DynamicBuffer <MapEntityBuffer> entityBufferFromEntity = entityManager.GetBuffer <MapEntityBuffer>(f);
            DynamicBuffer <Entity>          entityBuffer           = entityBufferFromEntity.Reinterpret <Entity>();
            entityBuffer.Add(entity);

            //NeighbourTiles neighbours = new NeighbourTiles {
            //    eTile = Entity.Null,
            //    neTile = Entity.Null,
            //    seTile = Entity.Null,
            //    nTile = Entity.Null,
            //    nwTile = Entity.Null,
            //    swTile = Entity.Null,
            //    sTile = Entity.Null,
            //    wTile = Entity.Null
            //};

            //if (tile.coordinates.x - 1 >= 0)
            //{
            //    neighbours.wTile = entityArray[(int)math.floor((tile.coordinates.y) * width + (tile.coordinates.x - 1))];
            //    if (tile.coordinates.y - 1 >= 0)
            //        neighbours.swTile = entityArray[(int)math.floor((tile.coordinates.y - 1) * width + tile.coordinates.x - 1)];
            //    if (tile.coordinates.y + 1 < height)
            //        neighbours.nwTile = entityArray[(int)math.floor((tile.coordinates.y + 1) * width + tile.coordinates.x - 1)];
            //}
            //if (tile.coordinates.x + 1 < width)
            //{

            //    neighbours.eTile = entityArray[(int)math.floor((tile.coordinates.y) * width + (tile.coordinates.x + 1))];
            //    if (tile.coordinates.y - 1 >= 0)
            //        neighbours.seTile = entityArray[(int)math.floor((tile.coordinates.y - 1) * width + tile.coordinates.x + 1)];
            //    if (tile.coordinates.y + 1 < height)
            //        neighbours.neTile = entityArray[(int)math.floor((tile.coordinates.y + 1) * width + tile.coordinates.x + 1)];
            //}
            ////Down
            //if (tile.coordinates.y - 1 >= 0)
            //    neighbours.sTile = entityArray[(int)math.floor((tile.coordinates.y - 1) * width + tile.coordinates.x)];

            ////Up
            //if (tile.coordinates.y + 1 < height)
            //    neighbours.nTile = entityArray[(int)math.floor((tile.coordinates.y + 1) * width + tile.coordinates.x)];

            //entityManager.SetComponentData(entity, neighbours);
        }

        SpawnerComponent spawnerComponent = new SpawnerComponent(entityArray);
    }
예제 #27
0
 protected override void OnUpdate()
 {
     if (!sceneLoaded)
     {
         currentScene = SceneManager.GetActiveScene();
         Debug.Log("Scene is not loaded");
         Debug.Log(currentScene.name);
         if (currentScene.name == "AnimationScene")
         {
             Debug.Log("Can we enter here?");
             sceneLoaded = true;
         }
     }
     else
     {
         healthText = GameObject.Find("HealthText").GetComponent <Text>();
         healthBar  = GameObject.Find("Image").GetComponent <Image>();
         backPack   = GameObject.Find("UIBackPack").GetComponent <Text>();
         statText   = GameObject.Find("StatText").GetComponent <Text>();
         //This Grabs everyone with these components
         //AKA the player
         Entities.ForEach((Entity e,
                           ref PlayerComponent playerComponent,
                           ref MovementComponent movementComponent,
                           ref StatsComponent statsComponent,
                           ref VelocityComponent velocityComponent,
                           ref ColliderComponent colliderComponent) =>
         {
             //StatsComponent updateComponent = statsComponent;
             //Entities.ForEach((Entity f,
             //    ref HealthBarComponent healthBarComponent) =>
             //{
             //    healthBarComponent.health = updateComponent.health;
             //    healthBarComponent.attack = updateComponent.attack;
             //    healthBarComponent.attackSpeed = updateComponent.attackSpeed;
             //    healthBarComponent.moveSpeed = updateComponent.moveSpeed;
             //});
             healthText.text = "Current Health: " + statsComponent.health;
             healthBar.rectTransform.sizeDelta = new Vector2(healthTextSize * statsComponent.health / 100, 20);
             statText.text = "Attack Damage: " + statsComponent.attack + "\nAttack Speed: " + statsComponent.attackSpeed + "\nMove Speed: " + statsComponent.moveSpeed;
             DynamicBuffer <IntBufferElement> backpack = entityManager.GetBuffer <IntBufferElement>(e);
             backPack.text = "Backpack: ";
             foreach (var spriteValue in backpack.Reinterpret <IntBufferElement>())
             {
                 string gameObjectString = "Item" + spriteValue.value;
                 if (GameObject.Find(gameObjectString))
                 {
                     //Debug.Log("Already Generated");
                 }
                 else
                 {
                     float myScale       = 1.5f;
                     GameObject itemIcon = new GameObject();
                     Image newImage      = itemIcon.AddComponent <Image>();
                     itemIcon.GetComponent <RectTransform>().SetParent(backPack.transform);
                     itemIcon.transform.position   = itemIcon.transform.position + new Vector3(backPackLeftTransform + (numberOfItems * itemWidth), 35, 0);
                     itemIcon.transform.localScale = new Vector3(myScale, myScale, myScale);
                     Debug.Log(itemIcon.transform.localPosition);
                     Item currentItem         = GlobalObjects.iTable.lookupItem(spriteValue.value);
                     Sprite currentItemSprite = currentItem.itemSprite;
                     newImage.sprite          = currentItemSprite;
                     itemIcon.name            = "Item" + spriteValue.value;
                     numberOfItems++;
                 }
                 //backPack.text = backPack.text + " " + spriteValue.value;
             }
         });
     }
 }