Ejemplo n.º 1
0
    protected override JobHandle OnUpdate(JobHandle input_deps)
    {
        float dt           = Time.DeltaTime;
        int   person_count = SimulationManager.sim.person_count;
        int   wearing_mask = SimulationManager.sim.wearing_mask;

        var deps = Entities.ForEach(
            (int entityInQueryIndex, ref URPMaterialPropertyBaseColor c, in PersonData p) =>
        {
            if (p.infected)
            {
                c = new URPMaterialPropertyBaseColor()
                {
                    Value = new float4(1f, 0f, 0f, 1f)
                };
            }
            else if (p.resistence)
            {
                c = new URPMaterialPropertyBaseColor()
                {
                    Value = new float4(0f, 0f, 1f, 1f)
                };
            }
            else if (entityInQueryIndex > person_count - wearing_mask)
            {
                c = new URPMaterialPropertyBaseColor()
                {
                    Value = new float4(1f, 0.3f, 0.66f, 1f)
                };
            }
            else
            {
                c = new URPMaterialPropertyBaseColor()
                {
                    Value = new float4(240f / 256, 184f / 256, 160f / 256, 1f)
                };
            }
        }).Schedule(input_deps);

        return(deps);
    }
Ejemplo n.º 2
0
    private void InstantiateBuildings(ref Rooms apartment)
    {
        int buildings_per_block = tiles_per_block * tiles_per_block - 2 * tiles_per_block + 1;
        int building_count      = buildings_per_block * block_count.x * block_count.y;
        var buildings           = manager.Instantiate(building, building_count, Allocator.Temp);

        var buildings_occupied = manager.Instantiate(
            building_occupied, building_count * rooms_per_apartment, Allocator.Temp);

        float marker_spacing           = 3f;
        int   occupied_markers_per_row = (int)((tile_size - 4f) / marker_spacing);

        int idx  = 0;
        int hash = 0;

        apartment.max_room_idx = 0;
        for (int x = 0; x < tile_count.x - tiles_per_block; x++)
        {
            for (int y = 0; y < tile_count.y - tiles_per_block; y++)
            {
                if (x % tiles_per_block > 0 && y % tiles_per_block > 0)
                {
                    var b = buildings[idx];

                    var scale = Random.Range(250, 750);

                    var T = new Translation();
                    T.Value = new Vector3(
                        x * tile_size + bounds.min.x,
                        scale / 200f,
                        y * tile_size + bounds.min.y);
                    manager.AddComponentData(b, T);

                    var S = new NonUniformScale();
                    S.Value = new Vector3(2500f, scale, 2500f);
                    manager.AddComponentData(b, S);

                    var cidx = Random.Range(0, building_colors.Length);

                    var color = new URPMaterialPropertyBaseColor()
                    {
                        Value = new float4(
                            building_colors[cidx].r,
                            building_colors[cidx].g,
                            building_colors[cidx].b,
                            building_colors[cidx].a)
                    };
                    manager.AddComponentData(b, color);

                    var data = new BuildingData()
                    {
                        type            = BuildingType.Apartment,
                        start_hash      = hash,
                        end_hash        = hash + rooms_per_apartment,
                        people_per_room = people_per_room_apartment
                    };
                    manager.AddComponentData(b, data);

                    for (int h = 0; h < rooms_per_apartment; h++)
                    {
                        var b_o = buildings_occupied[h + hash];

                        var T_o = new Translation()
                        {
                            Value = T.Value +
                                    new float3(tile_size / 2 - 3f, 0f, tile_size / 2 - 3f) -
                                    marker_spacing * new float3(
                                h % occupied_markers_per_row, 0f, (int)(h / occupied_markers_per_row))
                        };
                        manager.AddComponentData(b_o, T_o);

                        var color_o = new URPMaterialPropertyBaseColor()
                        {
                            Value = new float4(0f, 0f, 0f, 0f)
                        };
                        manager.AddComponentData(b_o, color_o);

                        var occ_data = new OccupiedData()
                        {
                            base_color = new float4(1f, 1f, 1f, 1f)
                        };
                        manager.AddComponentData(b_o, occ_data);

                        apartment.space[h + hash]       = rooms_per_apartment;
                        apartment.coordinates[h + hash] = new int2(x, y);

                        apartment.max_room_idx++;
                    }

                    hash += rooms_per_apartment;

                    idx++;
                }
            }
        }

        buildings.Dispose();
        buildings_occupied.Dispose();
    }
Ejemplo n.º 3
0
    private void InstantiatePeople(ref Rooms apartment)
    {
        var people = manager.Instantiate(person, person_count, Allocator.Temp);
        var seed   = new System.Random();

        for (int i = 0; i < person_count; i++)
        {
            Entity p     = people[i];
            Spawn  spawn = GetSpawnPoint();

            Vector3 pos = new Vector3(
                spawn.pos.x, 2.15f, spawn.pos.y);

            Translation R = new Translation();
            R.Value = pos;

            manager.AddComponentData(p, R);

            float virus    = 0f;
            bool  infected = false;

            int house_idx = -1;
            while (house_idx < 0)
            {
                house_idx = Random.Range(0, apartment.max_room_idx);
                if (apartment.space[house_idx] == 0)
                {
                    house_idx = -1;
                }
                else
                {
                    apartment.space[house_idx] -= 1;
                }
            }

            bool is_nightowl = Random.Range(0f, 1f) < 0.25f;

            PersonData person_data = new PersonData()
            {
                virus            = virus,
                infected         = infected,
                antibodies       = 0f,
                resistence       = false,
                home_coordinates = apartment.coordinates[house_idx],
                home_idx         = house_idx,
                is_home          = false,
                schedule_phase   = (is_nightowl ? 0 : 1) + Random.Range(-0.25f, 0.25f)
            };
            manager.AddComponentData(p, person_data);

            HeadingData heading_data = new HeadingData()
            {
                speed             = person_speed + Random.Range(-person_speed_spread, person_speed_spread),
                direction         = spawn.dir,
                goal_coordinate   = apartment.coordinates[house_idx],
                next_cross_margin = Random.Range(1f, 6f),
                rng = new Unity.Mathematics.Random((uint)seed.Next())
            };
            manager.AddComponentData(p, heading_data);

            URPMaterialPropertyBaseColor color = new URPMaterialPropertyBaseColor()
            {
                Value = new float4(1f, 1f, 1f, 1f)
            };
            manager.AddComponentData(p, color);
        }

        people.Dispose();
    }