예제 #1
0
        public WorldPointContinent ContinentPointToWorldPoint(ContinentPoint point, WorldCreationStatic Sim)
        {
            Vector2 mod    = Vector2.zero;
            Vector2 newPos = point.Pos + WorldPointCenter.Pos;

            if (newPos.x > Sim.Width - 1)
            {
                mod = new Vector2(-Sim.Width, 0);
            }
            if (newPos.x > Sim.Width * 2 - 1)
            {
                mod = new Vector2(-Sim.Width * 2, 0);
            }
            if (newPos.x < 0)
            {
                mod = new Vector2(Sim.Width, 0);
            }
            if (newPos.x < -Sim.Width)
            {
                mod = new Vector2(Sim.Width * 2, 0);
            }
            if (newPos.y >= 100)
            {
                return(null);
            }
            if (newPos.y < 0)
            {
                return(null);
            }
            if (!Sim.WorldPointContinents.ContainsKey(newPos + mod))
            {
                Debug.Log("Bad Vector: " + (point.Pos + WorldPointCenter.Pos + mod) + " points: " + point.Pos + WorldPointCenter.Pos + mod);
            }
            return(Sim.WorldPointContinents[point.Pos + WorldPointCenter.Pos + mod]);
        }
예제 #2
0
        public void CreateContinents()
        {
            int Ocean = WorldPointContinents.Count;
            int Land  = 0;

            //for (int i = 0; i < 7; i++)
            while (true)
            {
                Continent cont = new Continent(new WorldPointContinent(new Vector2(Random.Range(0, Width), Random.Range(0, Height))));
                Continents.Add(cont);
                Dictionary <Vector2, bool> Map = new ZoomLandCreation(5, 5).Create(3);
                int            width           = (int)Map.Select(p => p.Key.x).Max() / (int)2;
                List <Vector2> LandPoints      = new List <Vector2>();
                foreach (var pair in Map)
                {
                    if (pair.Value)
                    {
                        LandPoints.Add(pair.Key);
                    }
                }
                foreach (var p in LandPoints)
                {
                    ContinentPoint cp = new ContinentPoint(p - new Vector2(width, width), cont);
                    if (cont.Points.ContainsKey(p - new Vector2(width, width)))
                    {
                        continue;
                    }
                    cont.Points.Add(p - new Vector2(width, width), cp);
                    WorldPointContinent wp = cont.ContinentPointToWorldPoint(cp, this);
                    if (wp != null && wp.contPoint == null)
                    {
                        wp.contPoint = cp;
                        Land++;
                        Ocean--;
                    }
                }
                if ((float)Land / (float)(Ocean + Land) > 0.3f)
                {
                    break;
                }
            }
            foreach (WorldPointContinent wp in WorldPointContinents.Values)
            {
                GameObject go = Instantiate(cubePrefab);
                go.transform.position = wp.Pos;
                go.GetComponent <MeshRenderer>().material       = Resources.Load <Material>("green");
                go.GetComponent <MeshRenderer>().material.color = wp.contPoint == null ? Color.blue : Color.green;
                wp.go = go;
            }
        }
예제 #3
0
        public void CreateContinents()
        {
            List <Vector2> ContinentPoints = new List <Vector2>()
            {
                new Vector2(30, 30), new Vector2(51, 65), new Vector2(106, 53), new Vector2(106, 23), new Vector2(140, 34), new Vector2(138, 74)
            };

            for (int i = 0; i < 6; i++)
            {
                Continent cont = new Continent(new WorldPointContinent(new Vector2(ContinentPoints[i].x, Height - ContinentPoints[i].y)));
                Continents.Add(cont);
                Dictionary <Vector2, bool> Map = new Dictionary <Vector2, bool>();
                while (Map.Count < 2300)
                {
                    Map = new ZoomLandCreation(5, 5).Create(4);
                }
                int            width      = (int)Map.Select(p => p.Key.x).Max() / (int)2;
                List <Vector2> LandPoints = new List <Vector2>();
                foreach (var pair in Map)
                {
                    if (pair.Value)
                    {
                        LandPoints.Add(pair.Key);
                    }
                }
                foreach (var p in LandPoints)
                {
                    ContinentPoint cp = new ContinentPoint(p - new Vector2(width, width), cont);
                    if (cont.Points.ContainsKey(p - new Vector2(width, width)))
                    {
                        continue;
                    }
                    cont.Points.Add(p - new Vector2(width, width), cp);
                    WorldPointContinent wp = cont.ContinentPointToWorldPoint(cp, this);
                    if (wp != null && wp.contPoint == null)
                    {
                        wp.contPoint = cp;
                    }
                }
            }
            foreach (WorldPointContinent wp in WorldPointContinents.Values)
            {
                GameObject go = Instantiate(cubePrefab);
                go.transform.position = wp.Pos;
                go.GetComponent <MeshRenderer>().material       = Resources.Load <Material>("green");
                go.GetComponent <MeshRenderer>().material.color = wp.contPoint == null ? Color.blue : Color.green;
                wp.go = go;
                gos.Add(go);
            }
        }
예제 #4
0
 public void AdditionalSubduction(WorldPointContinent origSubductionPoint, Continent subductingContinent, Continent growingContinent)
 {
     //if (Random.Range(0, 2) == 0)
     {
         if (WorldPointContinents.ContainsKey(origSubductionPoint.Pos + subductingContinent.driftDirection))
         {
             WorldPointContinent AddedHeightPoint = WorldPointContinents[origSubductionPoint.Pos + subductingContinent.driftDirection];
             ContinentPoint      cp = WorldPointContinentToContinentPoint(AddedHeightPoint, growingContinent);
             if (cp != null)
             {
                 cp.height++;
             }
         }
     }
 }
예제 #5
0
        public List <ContinentPoint> GetXNeighbors(ContinentPoint point, int width)
        {
            List <ContinentPoint> Neighbors = new List <ContinentPoint>();

            for (int x = -width; x <= width; x++)
            {
                for (int y = -width; y <= width; y++)
                {
                    if (x == 0 && y == 0)
                    {
                        continue;
                    }
                    if (Points.ContainsKey(new Vector2(x + point.Pos.x, y + point.Pos.y)))
                    {
                        Neighbors.Add(Points[new Vector2(x + point.Pos.x, y + point.Pos.y)]);
                    }
                }
            }
            return(Neighbors);
        }
예제 #6
0
        public void RecalculateWorldPointContinents(Continent Cont)
        {
            //foreach (Continent plate in Plates)
            {
                Dictionary <ContinentPoint, ContinentPoint> Collisions = new Dictionary <ContinentPoint, ContinentPoint>();
                foreach (ContinentPoint point in Cont.Points.Values)
                {
                    WorldPointContinent wp = Cont.ContinentPointToWorldPoint(point, this);
                    if (wp != null)
                    {
                        if (wp.contPoint != null)
                        {
                            Collisions.Add(wp.contPoint, point);
                        }
                        else
                        {
                            wp.contPoint = point;
                        }
                    }
                }
                foreach (Continent collCont in Collisions.Select(p => p.Key.cont).Distinct())
                {
                    Dictionary <ContinentPoint, ContinentPoint> ContinentCollisionPoints = Collisions.Where(p => p.Key.cont == collCont).ToDictionary(p => p.Key, p => p.Value);


                    if (ContinentCollisionPoints.Count < 10)
                    //if ((float)ContinentCollisionPoints.Count / (float)collCont.Points.Count < 0.025f)
                    {
                        foreach (var pair in ContinentCollisionPoints)
                        {
                            //not big enough to be collision, smaller one subducts
                            WorldPointContinent wp         = collCont.ContinentPointToWorldPoint(pair.Key, this);
                            ContinentPoint      theirPoint = pair.Key;
                            ContinentPoint      ourPoint   = pair.Value;
                            if (Cont.GetNeighbors(ourPoint).Count < 3)
                            {
                                //island or something, we give it to them
                                theirPoint.height += 2;
                                Cont.Points.Remove(ourPoint.Pos);

                                /*Vector2 worldPosition = collCont.WorldPointCenter.Pos + theirPoint.Pos;
                                 * ContinentPoint theirNewPoint = new ContinentPoint(worldPosition - Cont.WorldPointCenter.Pos, Cont);
                                 * theirNewPoint.height = theirPoint.height;
                                 * if (!collCont.Points.ContainsKey(theirNewPoint.Pos))
                                 * {
                                 *  collCont.Points.Add(theirNewPoint.Pos, theirNewPoint);
                                 *  WorldPointContinent wp2 = collCont.ContinentPointToWorldPoint(theirNewPoint, this);
                                 *  if (wp2 != null)
                                 *      wp2.contPoint = theirNewPoint;
                                 * }*/
                                // if(Random.Range(0,2) == 0)
                                AdditionalSubduction(wp, Cont, collCont);
                            }
                            else if (collCont.GetNeighbors(theirPoint).Count < 3)
                            {
                                //we are colliding with an island
                                ourPoint.height += 2;
                                wp.contPoint     = ourPoint;
                                collCont.Points.Remove(theirPoint.Pos);

                                /* Vector2 worldPosition = collCont.WorldPointCenter.Pos + theirPoint.Pos;
                                 * ContinentPoint ourNewPoint = new ContinentPoint(worldPosition - Cont.WorldPointCenter.Pos, Cont);
                                 * ourNewPoint.height = theirPoint.height;
                                 * if (!Cont.Points.ContainsKey(ourNewPoint.Pos))
                                 * {
                                 *   Cont.Points.Add(ourNewPoint.Pos, ourNewPoint);
                                 *   WorldPointContinent wp2 = Cont.ContinentPointToWorldPoint(ourNewPoint, this);
                                 *   if (wp2 != null)
                                 *       wp2.contPoint = ourNewPoint;
                                 * }*/
                                AdditionalSubduction(wp, collCont, Cont);
                            }
                            else if (ourPoint.height > theirPoint.height) //cont already there subducts
                            {
                                ourPoint.height += 2;
                                wp.contPoint     = ourPoint;
                                collCont.Points.Remove(theirPoint.Pos);
                                // if (Random.Range(0, 2) == 0)
                                AdditionalSubduction(wp, collCont, Cont);
                            }
                            else //our cont subducts
                            {
                                theirPoint.height += 2;
                                Cont.Points.Remove(ourPoint.Pos);
                                //if (Random.Range(0, 2) == 0)
                                AdditionalSubduction(wp, Cont, collCont);
                            }
                        }
                    }
                    else
                    {
                        //big enough, the continents become one
                        //first fix collision points
                        foreach (var pair in ContinentCollisionPoints)
                        {
                            WorldPointContinent wp         = collCont.ContinentPointToWorldPoint(pair.Key, this);
                            ContinentPoint      theirPoint = pair.Key;
                            ContinentPoint      ourPoint   = pair.Value;
                            wp.contPoint = ourPoint;
                            ourPoint.height++;
                            collCont.Points.Remove(theirPoint.Pos);
                            AdditionalSubduction(wp, collCont, Cont);
                        }
                        //then move their cont points to our continent
                        foreach (ContinentPoint theirPoint in collCont.Points.Values)
                        {
                            Vector2        worldPosition = collCont.WorldPointCenter.Pos + theirPoint.Pos;
                            ContinentPoint ourNewPoint   = new ContinentPoint(worldPosition - Cont.WorldPointCenter.Pos, Cont);
                            ourNewPoint.height = theirPoint.height;
                            if (!Cont.Points.ContainsKey(ourNewPoint.Pos))
                            {
                                Cont.Points.Add(ourNewPoint.Pos, ourNewPoint);
                                WorldPointContinent wp = Cont.ContinentPointToWorldPoint(ourNewPoint, this);
                                if (wp != null)
                                {
                                    wp.contPoint = ourNewPoint;
                                }
                            }
                        }
                        DeletedContinents.Add(collCont);
                    }
                }
            }
        }
예제 #7
0
        public void SplitContinent(Continent c)
        {
            //first split
            Dictionary <Vector2, List <Vector2> > voronoiCenters = new Dictionary <Vector2, List <Vector2> >();
            int worldXMin = (int)c.Points.Min(p => p.Key.x) + (int)c.WorldPointCenter.Pos.x;
            int worldXMax = (int)c.Points.Max(p => p.Key.x) + (int)c.WorldPointCenter.Pos.x;
            int worldYMin = (int)c.Points.Min(p => p.Key.y) + (int)c.WorldPointCenter.Pos.y;
            int worldYMax = (int)c.Points.Max(p => p.Key.y) + (int)c.WorldPointCenter.Pos.y;

            //now split the continent
            Vector2 cont1 = new Vector2(Random.Range(worldXMin, worldXMax), Random.Range(worldYMin, worldYMax));
            Vector2 cont2 = new Vector2(Random.Range(worldXMin, worldXMax), Random.Range(worldYMin, worldYMax));

            if (!WorldPointContinents.ContainsKey(cont1) || !WorldPointContinents.ContainsKey(cont2))
            {
                return;
            }

            Continent newCont1 = new Continent(c.WorldPointCenter);
            Continent newCont2 = new Continent(c.WorldPointCenter);

            for (int i = 0; i < 20; i++)
            {
                Vector2 voronoi = new Vector2(Random.Range(worldXMin, worldXMax), Random.Range(worldYMin, worldYMax));
                voronoiCenters.Add(voronoi, new List <Vector2>());
            }
            foreach (ContinentPoint cp in c.Points.Values)
            {
                Vector2 cpWorldPos   = cp.Pos + c.WorldPointCenter.Pos;
                float   shortestDist = 9999;
                Vector2 voronoi      = Vector2.zero;
                foreach (var pair in voronoiCenters)
                {
                    float dist = Vector2.Distance(cpWorldPos, pair.Key);
                    if (dist < shortestDist)
                    {
                        shortestDist = dist;
                        voronoi      = pair.Key;
                    }
                }
                voronoiCenters[voronoi].Add(cp.Pos);
            }

            List <ContinentPoint> con1Points = new List <ContinentPoint>();
            List <ContinentPoint> con2Points = new List <ContinentPoint>();

            foreach (var pair in voronoiCenters)
            {
                float dist1 = Vector2.Distance(cont1, pair.Key);
                float dist2 = Vector2.Distance(cont2, pair.Key);
                if (dist1 < dist2)
                {
                    foreach (Vector2 v in pair.Value)
                    {
                        ContinentPoint newCP = new ContinentPoint(v - cont1, newCont1);
                        newCP.height = c.Points[v].height;
                        con1Points.Add(newCP);
                    }
                }
                else
                {
                    foreach (Vector2 v in pair.Value)
                    {
                        ContinentPoint newCP = new ContinentPoint(v - cont2, newCont2);
                        newCP.height = c.Points[v].height;
                        con2Points.Add(newCP);
                    }
                }
            }
            newCont1.driftDirection = (cont1 - cont2).normalized;
            newCont1.driftDirection = new Vector2((int)newCont1.driftDirection.x + 1, (int)newCont1.driftDirection.y + 1);
            newCont2.driftDirection = (cont2 - cont1).normalized;
            newCont2.driftDirection = new Vector2((int)newCont2.driftDirection.x + 1, (int)newCont2.driftDirection.y + 1);
            newCont1.driftDuration  = 15;
            newCont2.driftDuration  = 15;
            Continents.Add(newCont1);
            Continents.Add(newCont2);
            Continents.Remove(c);
            lastContBreak = age;
        }