public void FinalizeLoad()
    {
        foreach (WorldPosition position in CellPositions)
        {
            TerrainCell cell = World.GetCell(position);

            if (cell == null)
            {
                throw new System.Exception("Cell missing at position " + position.Longitude + "," + position.Latitude);
            }

            _cells.Add(cell);

            cell.EncompassingTerritory = this;
        }

        foreach (TerrainCell cell in _cells)
        {
            foreach (TerrainCell nCell in cell.Neighbors.Values)
            {
                if (!_cells.Contains(nCell))
                {
                    _borderCells.Add(cell);
                    break;
                }
            }
        }
    }
コード例 #2
0
    private void AddCellDataToInfoPanel_UpdateSpan(TerrainCell cell)
    {
        InfoText.text += "\n";
        InfoText.text += "\n -- Group Update Span Data -- ";
        InfoText.text += "\n";

        if (cell.Group == null)
        {
            InfoText.text += "\n\tNo population at location";

            return;
        }

        int population = cell.Group.Population;

        if (population <= 0)
        {
            InfoText.text += "\n\tNo population at location";

            return;
        }

        long lastUpdateDate = cell.Group.LastUpdateDate;
        long nextUpdateDate = cell.Group.NextUpdateDate;

        InfoText.text += "\nLast Update Date: " + Manager.GetDateString(lastUpdateDate);
        InfoText.text += "\nNext Update Date: " + Manager.GetDateString(nextUpdateDate);
        InfoText.text += "\nTime between updates: " + Manager.GetTimeSpanString(nextUpdateDate - lastUpdateDate);
    }
コード例 #3
0
ファイル: Overworld.cs プロジェクト: Rn4rc1s0/FPS_Project
    public TerrainCellData UnrenderCell(int id)
    {
        if (cellsData.ContainsKey(id))
        {
            return(cellsData[id]);
        }

        if (!cells.ContainsKey(id))
        {
            return(null);
        }

        TerrainCell     cell     = cells[id];
        TerrainCellData cellData = cell.GetData();

        foreach (Actor actor in ActorsAtCoords(cell.coords))
        {
            UnrenderActor(actor.id);
        }

        foreach (Item item in ItemsAtCoords(cell.coords))
        {
            UnrenderItem(item.id);
        }

        cells.Remove(id);
        cell.QueueFree();

        cellsData.Add(id, cellData);
        return(cellData);
    }
コード例 #4
0
        public void FindAdjacentCellsLeftSideTest()
        {
            var map = new TerrainMap(new ShortestPath());

            map.InitializeBoard(7, 6);

            // build a wall of mountains
            for (int i = 0; i < 4; i++)
            {
                map[3, i + 1] = new TerrainCell(3, i + 1, 30);
            }

            var surroundingCells = map.FindAdjacentCells(0, 3, 2, 1)
                                   .OrderBy(u => u.Col)
                                   .ThenBy(u => u.Row)
                                   .ToList();

            Assert.Equal(4, surroundingCells.Count);
            Assert.Equal(0, surroundingCells[0].Col);
            Assert.Equal(2, surroundingCells[0].Row);
            Assert.Equal(0, surroundingCells[1].Col);
            Assert.Equal(4, surroundingCells[1].Row);
            Assert.Equal(1, surroundingCells[2].Col);
            Assert.Equal(2, surroundingCells[2].Row);
            Assert.Equal(1, surroundingCells[3].Col);
            Assert.Equal(3, surroundingCells[3].Row);
        }
コード例 #5
0
        /// <summary>
        /// Converts terrain node data to a 2D TerrainCell array
        /// </summary>
        internal static TerrainCell[,] NodeDataTo2DArray(byte[] data)
        {
            var cells = new TerrainCell[8, 8];

            using (var memStream = new MemoryStream(data))
            {
                var      array = new byte[8];
                GCHandle pin   = GCHandle.Alloc(array, GCHandleType.Pinned);

                for (var i = 0; i < 64; i++)
                {
                    // Source: http://geekswithblogs.net/taylorrich/archive/2006/08/21/88665.aspx
                    if (memStream.Read(array, 0, 8) < 8)
                    {
                        throw new Exception("Unexpected end of byte array");
                    }

                    TerrainCell cell = (TerrainCell)Marshal.PtrToStructure(pin.AddrOfPinnedObject(), typeof(TerrainCell));

                    int x = i % 8;
                    int z = (i - x) / 8;
                    cells[x, z] = cell;
                }

                pin.Free();
            }

            return(cells);
        }
コード例 #6
0
        public void FindShortestPath()
        {
            var shortest = new ShortestPath();
            var map      = new TerrainMap(shortest);

            map.InitializeBoard(10, 10);

            //mountains 4,1 - 4,8
            for (var i = 1; i < 9; i++)
            {
                var cube = HexGridMath.OffsetToCube(4, i);
                map[4, i] = new TerrainCell(cube.X, cube.Y, cube.Z, 30);
            }

            // 1,3 to 8,4
            shortest.ComputeShortestPath(map, 1, 3, 8, 4, 0);

            Assert.Equal(new Offset(2, 3), shortest.WayPoint[0]);
            Assert.Equal(new Offset(3, 2), shortest.WayPoint[1]);
            Assert.Equal(new Offset(3, 1), shortest.WayPoint[2]);
            Assert.Equal(new Offset(3, 0), shortest.WayPoint[3]);
            Assert.Equal(new Offset(4, 0), shortest.WayPoint[4]);
            Assert.Equal(new Offset(5, 0), shortest.WayPoint[5]);
            Assert.Equal(new Offset(6, 1), shortest.WayPoint[6]);
            Assert.Equal(new Offset(7, 1), shortest.WayPoint[7]);
            Assert.Equal(new Offset(8, 2), shortest.WayPoint[8]);
            Assert.Equal(new Offset(8, 3), shortest.WayPoint[9]);
            Assert.Equal(new Offset(8, 4), shortest.WayPoint[10]);
        }
コード例 #7
0
        void LoadCellsIntoWaterTerrain(TerrainCell[] cells)
        {
            Terrain     t  = waterTerrain;
            TerrainData td = t.terrainData;

            float[,] heights = td.GetHeights(0, 0, td.heightmapWidth, td.heightmapHeight);

            for (int x = 0; x < heights.GetLength(0); x++)
            {
                for (int z = 0; z < heights.GetLength(1); z++)
                {
                    TerrainCell c = cells[x + z * td.heightmapWidth];
                    if (c.waterDepth < erosionSettings.minWaterDepthDisplay)
                    {
                        heights[x, z] = Mathf.Max(0.01f, c.height - 0.01f);
                    }
                    else
                    {
                        heights[x, z] = c.height + c.waterDepth / 10;
                    }
                }
            }

            td.SetHeights(0, 0, heights);
        }
コード例 #8
0
    public Agent(CellGroup birthGroup, long birthDate, long idOffset)
    {
        World = birthGroup.World;

        BirthCell         = birthGroup.Cell;
        BirthCellPosition = BirthCell.Position;

        BirthRegionInfo   = BirthCell.Region.Info;
        BirthRegionInfoId = BirthRegionInfo.Id;

        Language   = birthGroup.Culture.Language;
        LanguageId = Language.Id;

        BirthDate = birthDate;

        idOffset += birthGroup.Id;

        Profiler.BeginSample("new Agent - GenerateUniqueIdentifier");

        Id = birthGroup.GenerateUniqueIdentifier(birthDate, 1000L, idOffset);

        Profiler.EndSample();

        Profiler.BeginSample("new Agent - GenerateBio");

        GenerateBio(birthGroup);

        Profiler.EndSample();
    }
コード例 #9
0
    private void AddCellDataToInfoPanel_FarmlandDistribution(TerrainCell cell)
    {
        float cellArea           = cell.Area;
        float farmlandPercentage = cell.FarmlandPercentage;

        InfoText.text += "\n";
        InfoText.text += "\n -- Cell Farmland Distribution Data -- ";
        InfoText.text += "\n";

        InfoText.text += "\nFarmland Percentage: " + farmlandPercentage.ToString("P");
        InfoText.text += "\n";

        if (cell.Group == null)
        {
            InfoText.text += "\n\tNo population at location";

            return;
        }

        int population = cell.Group.Population;

        if (population <= 0)
        {
            InfoText.text += "\n\tNo population at location";

            return;
        }

        if (farmlandPercentage > 0)
        {
            float farmlandArea = farmlandPercentage * cellArea;

            InfoText.text += "\nFarmland Area per Pop: " + (farmlandArea / (float)population).ToString("0.000") + " Km^2 / Pop";
        }
    }
コード例 #10
0
    public float CalculateDistance(TerrainCell cell, Direction direction)
    {
        float distance = TerrainCell.MaxWidth;

        if ((direction == Direction.Northeast) ||
            (direction == Direction.Northwest) ||
            (direction == Direction.Southeast) ||
            (direction == Direction.Southwest))
        {
            float sqMaxWidth = TerrainCell.MaxWidth * TerrainCell.MaxWidth;

            float widthSum    = (Width + cell.Width) / 2f;
            float sqCellWidth = widthSum * widthSum;

            distance = Mathf.Sqrt(sqMaxWidth + sqCellWidth);
        }
        else if ((direction == Direction.East) ||
                 (direction == Direction.West))
        {
            distance = cell.Width;
        }

        float altitudeDiff = Altitude - cell.Altitude;
        float sqAltDif     = altitudeDiff * altitudeDiff;
        float sqDistance   = distance * distance;

        distance = Mathf.Sqrt(sqAltDif + sqDistance);

        return(distance);
    }
コード例 #11
0
    private void CalculateMostCenteredCell()
    {
        int centerLongitude = 0, centerLatitude = 0;

        foreach (TerrainCell cell in _cells)
        {
            centerLongitude += cell.Longitude;
            centerLatitude  += cell.Latitude;
        }

        centerLongitude /= _cells.Count;
        centerLatitude  /= _cells.Count;

        TerrainCell closestCell       = null;
        int         closestDistCenter = int.MaxValue;

        foreach (TerrainCell cell in _cells)
        {
            int distCenter = Mathf.Abs(cell.Longitude - centerLongitude) + Mathf.Abs(cell.Latitude - centerLatitude);

            if ((closestCell == null) || (distCenter < closestDistCenter))
            {
                closestDistCenter = distCenter;
                closestCell       = cell;
            }
        }

        _mostCenteredCell = closestCell;
    }
    public void Update(long timeSpan)
    {
        TerrainCell groupCell = Group.Cell;

        float randomModifier = groupCell.GetNextLocalRandomFloat(RngOffsets.ACTIVITY_UPDATE + RngOffset);

        randomModifier = 1f - (randomModifier * 2f);
        float randomFactor = MaxChangeDelta * randomModifier;

        float maxTargetValue = 1f;
        float minTargetValue = 0f;
        float targetValue    = 0;

        if (randomFactor > 0)
        {
            targetValue = Value + (maxTargetValue - Value) * randomFactor;
        }
        else
        {
            targetValue = Value - (minTargetValue - Value) * randomFactor;
        }

        float timeEffect = timeSpan / (timeSpan + TimeEffectConstant);

        _newValue = (Value * (1 - timeEffect)) + (targetValue * timeEffect);
    }
コード例 #13
0
 private static async System.Threading.Tasks.Task <GlobeRegion> CreateRegionAsync(Globe globe,
                                                                                  TerrainCell startCell,
                                                                                  IWorldGenerator globeGenerator,
                                                                                  ProgressStorageService progressStorageService)
 {
     return(await globeGenerator.GenerateRegionAsync(globe, startCell));
 }
コード例 #14
0
ファイル: DataConverters.cs プロジェクト: edwinr/VPNet
        /// <summary>
        /// Converts terrain node data to a 2D TerrainCell array
        /// </summary>
        public static TerrainCell[,] TerrainNodeData(byte[] data)
        {
            var cells = new TerrainCell[8,8];

            using (var memStream = new MemoryStream(data))
            {
                var array = new byte[8];
                for (var i = 0; i < 64; i++)
                {
                    // Source: http://geekswithblogs.net/taylorrich/archive/2006/08/21/88665.aspx
                    if (memStream.Read(array, 0, 8) < 8)
                        throw new Exception("Unexpected end of byte array");

                    GCHandle pin = GCHandle.Alloc(array, GCHandleType.Pinned);
                    TerrainCell cell = (TerrainCell) Marshal.PtrToStructure(pin.AddrOfPinnedObject(), typeof(TerrainCell));
                    pin.Free();

                    int row = i % 8;
                    int col = (i - row) / 8;
                    cells[col, row] = cell;
                }
            }

            return cells;
        }
コード例 #15
0
        private void TryGenerateEventMessage()
        {
            DiscoveryEventMessage eventMessage = null;

            World       world = Group.World;
            TerrainCell cell  = Group.Cell;

            if (!world.HasEventMessage(_discovery.UId))
            {
                eventMessage = new DiscoveryEventMessage(_discovery, cell, _discovery.UId, TriggerDate);

                world.AddEventMessage(eventMessage);
            }

            if (cell.EncompassingTerritory != null)
            {
                Polity encompassingPolity = cell.EncompassingTerritory.Polity;

                if (!encompassingPolity.HasEventMessage(_discovery.UId))
                {
                    if (eventMessage == null)
                    {
                        eventMessage = new DiscoveryEventMessage(_discovery, cell, _discovery.UId, TriggerDate);
                    }

                    encompassingPolity.AddEventMessage(eventMessage);
                }
            }
        }
コード例 #16
0
    private void AddCellDataToInfoPanel_Language(TerrainCell cell)
    {
        InfoText.text += "\n";
        InfoText.text += "\n -- Group Language Data -- ";
        InfoText.text += "\n";

        if (cell.Group == null)
        {
            InfoText.text += "\n\tNo population at location";

            return;
        }

        int population = cell.Group.Population;

        if (population <= 0)
        {
            InfoText.text += "\n\tNo population at location";

            return;
        }

        Language groupLanguage = cell.Group.Culture.Language;

        if (groupLanguage == null)
        {
            InfoText.text += "\n\tNo major language spoken at location";

            return;
        }

        InfoText.text += "\n\tPredominant language at location: " + groupLanguage.Id;
    }
コード例 #17
0
    public static float CalculateNeighborhoodWaterPresenceIn(CellGroup group)
    {
        float neighborhoodPresence;

        int groupCellBonus = 1;
        int cellCount      = groupCellBonus;

        TerrainCell groupCell = group.Cell;

        float totalPresence = groupCell.WaterBiomePresence * groupCellBonus;

        foreach (TerrainCell c in groupCell.Neighbors.Values)
        {
            totalPresence += c.WaterBiomePresence;
            cellCount++;
        }

        neighborhoodPresence = totalPresence / cellCount;

        if ((neighborhoodPresence < 0) || (neighborhoodPresence > 1))
        {
            throw new System.Exception("Neighborhood sea presence outside range: " + neighborhoodPresence);
        }

        return(neighborhoodPresence);
    }
コード例 #18
0
    void ConstructCell(Vector3 offset, Vector3[] blockPoints, int modulus, int cellNumber)
    {
        TerrainCell cell = cells[cellNumber];

        Vector3[] triVerts = new Vector3[3];
        int       index;

        for (int i = 0; i < cell.triCount; i += 3)
        {
            for (int j = 0; j < 3; j++)
            {
                index         = cell.tris[i + j];
                triVerts[j]   = cell.vertices[modulus, index];
                triVerts[j].y = 0;

                for (int k = 0; k < 4; k++)
                {
                    triVerts[j].y += blockPoints[(k + modulus) % 4].y * cell.heightWeights[index][k];
                }
                triVerts[j].x += blockPoints[0].x * cell.wallWeights[index][(3 + 4 - modulus) % 4] + blockPoints[1].x * cell.wallWeights[index][(1 + 4 - modulus) % 4];
                triVerts[j].z += blockPoints[0].z * cell.wallWeights[index][(4 - modulus) % 4] + blockPoints[3].z * cell.wallWeights[index][(2 + 4 - modulus) % 4];
                triVerts[j]   += offset;
            }
            MakeTri(triVerts);
        }
    }
コード例 #19
0
    private void OnValidate()
    {
        terrainSystem = gameObject.GetComponent <TerrainSystem>();

        cells    = new TerrainCell[21];
        cells[0] = new TerrainCell(M0000);
        cells[1] = new TerrainCell(M000A);
        cells[2] = new TerrainCell(M000A, true, 3);// 000B
        cells[3] = new TerrainCell(M00AB);
        cells[4] = new TerrainCell(M00BA);
        cells[5] = new TerrainCell(M0A0B);

        cells[6]  = new TerrainCell(M0AAB);
        cells[7]  = new TerrainCell(M0AAB, true, 1); // 0ABB
        cells[8]  = new TerrainCell(M0BBA);
        cells[9]  = new TerrainCell(M0BBA, true, 1); // 0BAA
        cells[10] = new TerrainCell(M0ABA);
        cells[11] = new TerrainCell(M0ABA, true, 1); // 0BAB

        cells[12] = new TerrainCell(MAAAB);
        cells[13] = new TerrainCell(MAAAB, true, 0);// ABBB
        cells[14] = new TerrainCell(MAABB0);
        cells[15] = new TerrainCell(MAABB1);
        cells[16] = new TerrainCell(MAABB1, true, 0);// AABB2
        cells[17] = new TerrainCell(MABAB0);
        cells[18] = new TerrainCell(MABAB1);
        cells[19] = new TerrainCell(MABAB2);
        cells[20] = new TerrainCell(MABAB3);
    }
コード例 #20
0
    public TerrainCellAlteration(TerrainCell cell, bool addLayerData = true)
    {
        Longitude = cell.Longitude;
        Latitude  = cell.Latitude;

        Position = cell.Position;

        BaseAltitudeValue    = cell.BaseAltitudeValue;
        BaseTemperatureValue = cell.BaseTemperatureValue;
        BaseRainfallValue    = cell.BaseRainfallValue;

        BaseTemperatureOffset = cell.BaseTemperatureOffset;
        BaseRainfallOffset    = cell.BaseRainfallOffset;

        FarmlandPercentage = cell.FarmlandPercentage;
        Accessibility      = cell.Accessibility;
        Arability          = cell.Arability;

        if (addLayerData)
        {
            foreach (CellLayerData data in cell.LayerData)
            {
                if (data.Offset == 0)
                {
                    continue;
                }

                LayerData.Add(new CellLayerData(data));
            }
        }

        Modified = cell.Modified;
    }
コード例 #21
0
        public TerrainCell[,] CalculateWatershed(TerrainCell[,] input, float cellWidth,
                                                 int iterations)
        {
            var start = EditorApplication.timeSinceStartup;

            int width  = input.GetLength(0);
            int length = input.GetLength(1);

            Debug.Log($"{width} {length}");

            TerrainCell[,] output = new TerrainCell[width, length];

            int cellSize = System.Runtime.InteropServices.Marshal.SizeOf(typeof(TerrainCell));

            ComputeBuffer inputBuffer = new ComputeBuffer(input.Length, cellSize);

            inputBuffer.SetData(input);
            ComputeBuffer outputBuffer = new ComputeBuffer(output.Length, cellSize);
            int           kernel       = shader.FindKernel("CalculateWatershed");

            LoadShaderSettings();

            shader.SetInt("width", width);
            shader.SetFloat("cellWidth", cellWidth);

            for (int i = 0; i < iterations; i++)
            {
                if (i % 2 == 0)
                {
                    shader.SetBuffer(kernel, "working1", inputBuffer);
                    shader.SetBuffer(kernel, "working2", outputBuffer);
                }
                else
                {
                    shader.SetBuffer(kernel, "working1", outputBuffer);
                    shader.SetBuffer(kernel, "working2", inputBuffer);
                }

                var startDispatch = EditorApplication.timeSinceStartup;
                shader.Dispatch(kernel, input.Length, 1, 1);
                Debug.Log($"dispatch time: {EditorApplication.timeSinceStartup - startDispatch}");
            }

            if (iterations % 2 == 1)
            {
                outputBuffer.GetData(output);
            }
            else
            {
                inputBuffer.GetData(output);
            }

            inputBuffer.Release();
            outputBuffer.Release();

            Debug.Log(EditorApplication.timeSinceStartup - start);

            return(output);
        }
コード例 #22
0
        public void TerrainDoubledOnRoad()
        {
            var terrainCell = new TerrainCell(0, 0, 0, 0);

            terrainCell.Roads = RoadType.Road1;

            Assert.Equal(0.5, terrainCell.GroundUnitTerrainModifier);
        }
コード例 #23
0
ファイル: Island.cs プロジェクト: hafewa/IslandDesigner
    public bool ChangeTerrainTall(Vector2Int position, TerrainTall tall)
    {
        TerrainCell cell = getCell(position);

        cell.Tall = tall;

        return(true);
    }
コード例 #24
0
        public void IndexerTest()
        {
            var terrainMap = new TerrainMap(new ShortestPath());

            terrainMap[2, 2] = new TerrainCell(0, 0, 0, 2);

            Assert.Equal(2, terrainMap[2, 2].BackgroundType);
        }
コード例 #25
0
    private void AddCell(Vector2 position)
    {
        GameObject  newObject = Instantiate(new GameObject("Cell"), new Vector3(position.x, 0f, position.y), Quaternion.identity, transform);
        TerrainCell tc        = newObject.AddComponent <TerrainCell>();

        tc.PrepareTerrainCell(this);
        cells.Add(tc);
    }
コード例 #26
0
        public Vector3[,] CalculateNormals(float[,] heights, float cellWidth)
        {
            var start = EditorApplication.timeSinceStartup;

            int width  = heights.GetLength(0);
            int length = heights.GetLength(1);

            TerrainCell[] input  = new TerrainCell[width * length];
            TerrainCell[] output = new TerrainCell[width * length];

            int cellSize = System.Runtime.InteropServices.Marshal.SizeOf(typeof(TerrainCell));

            Debug.Log($"{width} {length} cellSize: {cellSize}");

            for (int i = 0; i < width; i++)
            {
                for (int j = 0; j < length; j++)
                {
                    input[i + j * width].height = heights[i, j];
                }
            }

            ComputeBuffer inputBuffer = new ComputeBuffer(input.Length, cellSize);

            inputBuffer.SetData(input);
            ComputeBuffer outputBuffer = new ComputeBuffer(output.Length, cellSize);
            int           kernel       = shader.FindKernel("CalculateNormals");

            LoadShaderSettings();

            shader.SetInt("width", width);
            shader.SetBuffer(kernel, "working1", inputBuffer);
            shader.SetBuffer(kernel, "working2", outputBuffer);
            shader.SetFloat("cellWidth", cellWidth);

            var startDispatch = EditorApplication.timeSinceStartup;

            shader.Dispatch(kernel, input.Length, 1, 1);
            Debug.Log($"dispatch time: {EditorApplication.timeSinceStartup - startDispatch}");

            outputBuffer.GetData(output);
            inputBuffer.Release();
            outputBuffer.Release();

            Vector3[,] result = new Vector3[width, length];

            for (int i = 0; i < width; i++)
            {
                for (int j = 0; j < length; j++)
                {
                    result[i, j] = output[i + j * width].normal;
                }
            }

            Debug.Log(EditorApplication.timeSinceStartup - start);

            return(result);
        }
コード例 #27
0
ファイル: Island.cs プロジェクト: hafewa/IslandDesigner
    public bool ChangeTerrainType(Vector2Int position, TerrainType type)
    {
        TerrainCell cell = getCell(position);

        cell.Type = type;

        // TODO
        return(true);
    }
コード例 #28
0
        public static GlobeRegionStorageData Create(GlobeRegion globeRegion, TerrainCell terrainCell)
        {
            var storageData = new GlobeRegionStorageData();

            storageData.Id    = terrainCell.Coords.ToString();
            storageData.Nodes = globeRegion.RegionNodes.Select(x => GlobeRegionNodeStorageData.Create(x)).ToArray();

            return(storageData);
        }
コード例 #29
0
    public void CreateRiverNode(TerrainCell nodeCell)
    {
        Vector3 riverPosition = new Vector3();

        riverPosition = new Vector3((nodeCell.position.x / terData.heightmapResolution) * terData.size.x, nodeCell.heightAtCell * terData.size.y, (nodeCell.position.y / terData.heightmapResolution) * terData.size.z);

        AddNode(riverPosition, riverWidth);
        CreateMesh(riverSmooth, true);
    }
    protected void AddPolityProminenceEffectInternal(CulturalSkill politySkill, PolityProminence polityProminence, long timeSpan, float timeEffectFactor)
    {
        float targetValue      = politySkill.Value;
        float prominenceEffect = polityProminence.Value;

        TerrainCell groupCell = Group.Cell;

        float randomEffect = groupCell.GetNextLocalRandomFloat(RngOffsets.SKILL_POLITY_PROMINENCE + RngOffset + unchecked ((int)polityProminence.PolityId));

        float timeEffect = timeSpan / (timeSpan + timeEffectFactor);

        // _newvalue should have been set correctly either by the constructor or by the Update function
        float change = (targetValue - _newValue) * prominenceEffect * timeEffect * randomEffect;

//#if DEBUG
//        if (Manager.RegisterDebugEvent != null)
//        {
//            if (Manager.TracingData.Priority <= 0)
//            {
//                if (Group.Id == Manager.TracingData.GroupId)
//                {
//                    string groupId = "Id:" + Group.Id + "|Long:" + Group.Longitude + "|Lat:" + Group.Latitude;

//                    SaveLoadTest.DebugMessage debugMessage = new SaveLoadTest.DebugMessage(
//                        "PolityCulturalProminenceInternal - Group:" + groupId,
//                        "CurrentDate: " + Group.World.CurrentDate +
//                        ", Name: " + Name +
//                        ", timeSpan: " + timeSpan +
//                        ", timeEffectFactor: " + timeEffectFactor +
//                        ", randomEffect: " + randomEffect +
//                        ", polity Id: " + polityProminence.PolityId +
//                        ", polityProminence.Value: " + prominenceEffect +
//                        ", politySkill.Value: " + targetValue +
//                        ", Value: " + Value +
//                        ", change: " + change +
//                        "", Group.World.CurrentDate);

//                    Manager.RegisterDebugEvent("DebugMessage", debugMessage);
//                }
//            }
//            else if (Manager.TracingData.Priority <= 1)
//            {
//                string groupId = "Id:" + Group.Id + "|Long:" + Group.Longitude + "|Lat:" + Group.Latitude;

//                SaveLoadTest.DebugMessage debugMessage = new SaveLoadTest.DebugMessage(
//                    "PolityCulturalProminenceInternal - Group:" + groupId,
//                    "CurrentDate: " + Group.World.CurrentDate +
//                    "", Group.World.CurrentDate);

//                Manager.RegisterDebugEvent("DebugMessage", debugMessage);
//            }
//        }
//#endif

        _newValue = _newValue + change;
    }
コード例 #31
0
    public override void FinalizeLoad()
    {
        MigrationDirection = (Direction)MigrationDirectionInt;

        base.FinalizeLoad();

        TargetCell = World.TerrainCells[TargetCellLongitude][TargetCellLatitude];

        SourceGroup = World.GetGroup(SourceGroupId);
    }
コード例 #32
0
    public void CreateRiverNode(TerrainCell nodeCell)
    {
        Vector3 riverPosition = new Vector3();

        riverPosition = new Vector3((nodeCell.position.x/terData.heightmapResolution) * terData.size.x, nodeCell.heightAtCell * terData.size.y , (nodeCell.position.y/terData.heightmapResolution) * terData.size.z);

        AddNode(riverPosition, riverWidth);
        CreateMesh(riverSmooth, true);
    }
コード例 #33
0
    void OnSceneGUI()
    {
        Event currentEvent = Event.current;

        if (riverScript.nodeObjects != null && riverScript.nodeObjects.Length != 0 && !riverScript.finalized)
        {
            int n = riverScript.nodeObjects.Length;
            for (int i = 0; i < n; i++)
            {
                RiverNodeObject node = riverScript.nodeObjects[i];
                node.position = Handles.PositionHandle(node.position, Quaternion.identity);
            }
        }

        if(riverScript.riverNodeMode == true)
        {
            if(currentEvent.isKey && currentEvent.character == 'r')
            {
                Vector3 riverNode = GetTerrainCollisionInEditor(currentEvent, KeyCode.R);

                TerrainCell riverNodeCell = new TerrainCell();
                riverNodeCell.position.x = riverNode.x;
                riverNodeCell.position.y = riverNode.z;
                riverNodeCell.heightAtCell = riverNode.y;

                riverScript.CreateRiverNode(riverNodeCell);
                riverScript.riverNodeMode = false;
            }
        }

         if (GUI.changed)
        {
            if(!riverScript.finalized)
            {
                EditorUtility.SetDirty(riverScript);
                riverScript.CreateMesh(riverScript.riverSmooth, false);
            }
        }
    }