/// <summary>
 /// Tracks the given entity with given range
 /// </summary>
 /// <param name="entity">Entity</param>
 /// <param name="range">Range</param>
 private void TrackEntityWithRange(MyEntity entity, double range)
 {
     if (m_trackedEntities.ContainsKey(entity))
     {
         m_trackedEntities[entity].Radius = range;
     }
     else
     {
         MyEntityTracker tracker = new MyEntityTracker(entity, range);
         m_trackedEntities.Add(entity, tracker);
     }
 }
        /// <summary>
        /// Tracks an entity with given track range. The range determines,
        /// how far the entity affects generation
        /// </summary>
        /// <param name="entity">MyEntity to track</param>
        /// <param name="range">Tracking range</param>
        public void TrackEntityRanged(MyEntity entity, double range)
        {
            MyEntityTracker tracker;

            if (m_trackedEntities.TryGetValue(entity, out tracker) || m_toTrackedEntities.TryGetValue(entity, out tracker))
            {
                tracker.Radius = range;
            }
            else
            {
                tracker = new MyEntityTracker(entity, range);
                m_toTrackedEntities.Add(entity, tracker);
                entity.OnMarkForClose += (e) =>
                {
                    m_toRemoveTrackedEntities.Add(e);
                    asteroidModule.MarkToUnloadCells(tracker.BoundingVolume);
                };
            }
        }
        public override void UpdateGpsForPlayer(MyEntityTracker tracker)
        {
            if (!(tracker.Entity is MyCharacter))
            {
                return;
            }

            var entity        = tracker.Entity as MyCharacter;
            var systemObjects = MyStarSystemGenerator.Static.StarSystem.GetAllObjects();
            var settings      = MySettingsSession.Static.Settings.GeneratorSettings.GPSSettings;

            if (settings.PlanetGPSMode != MyGPSGenerationMode.DISCOVERY && settings.MoonGPSMode != MyGPSGenerationMode.DISCOVERY)
            {
                return;
            }

            foreach (var obj in systemObjects)
            {
                if ((obj.Type == MySystemObjectType.MOON && settings.MoonGPSMode == MyGPSGenerationMode.DISCOVERY) || (obj.Type == MySystemObjectType.PLANET && settings.PlanetGPSMode == MyGPSGenerationMode.DISCOVERY))
                {
                    var distance = Vector3D.Distance(tracker.CurrentPosition, obj.CenterPosition);

                    if (distance <= 50000000)
                    {
                        if (MyGPSManager.Static.DynamicGpsExists(obj.Id, entity.GetPlayerIdentityId()))
                        {
                            MyGPSManager.Static.ModifyDynamicGps(obj.DisplayName, GPS_COLOR, obj.CenterPosition, entity.GetPlayerIdentityId(), obj.Id);
                        }
                        else
                        {
                            MyGPSManager.Static.AddDynamicGps(obj.DisplayName, GPS_COLOR, obj.CenterPosition, entity.GetPlayerIdentityId(), obj.Id);
                        }
                        continue;
                    }

                    MyGPSManager.Static.RemoveDynamicGps(entity.GetPlayerIdentityId(), obj.Id);
                }
            }
        }
Ejemplo n.º 4
0
        public void UpdateGps(MyEntityTracker tracker)
        {
            foreach (MySystemItem p in SystemGenerator.Static.m_objects)
            {
                if (p.Type != SystemObjectType.PLANET || ((MyPlanetItem)p).PlanetRing == null)
                {
                    continue;
                }

                MyPlanetRingItem ring      = ((MyPlanetItem)p).PlanetRing;
                Vector3D         entityPos = tracker.Entity.PositionComp.GetPosition();

                string pre    = ((MyPlanetItem)p).DisplayName;
                var    center = ((MyPlanetItem)p).CenterPosition;
                int    l      = (int)(Math.Sqrt(center.X * center.X + center.Y * center.Y + center.Z * center.Z)) % 1000;
                pre = Regex.Replace(pre, @"-[\d\w]+$| \d+ \d+ - \w+$", " " + l.ToString());

                string name = pre + " Ring";

                if (Vector3D.Subtract(ring.Center, entityPos).Length() > 5000000)
                {
                    GlobalGpsManager.Static.RemoveDynamicGps(name, ((MyCharacter)tracker.Entity).GetPlayerIdentityId());
                    continue;
                }

                AsteroidRingShape shape = AsteroidRingShape.CreateFromRingItem(ring);

                if (shape.Contains(tracker.LastPosition) == ContainmentType.Contains)
                {
                    GlobalGpsManager.Static.RemoveDynamicGps(name, ((MyCharacter)tracker.Entity).GetPlayerIdentityId());
                    continue;
                }

                Vector3D pos = shape.ClosestPointAtRingCenter(entityPos);
                GlobalGpsManager.Static.AddOrUpdateDynamicGps(name, ((MyCharacter)tracker.Entity).GetPlayerIdentityId(), pos, Color.Gold);
            }
        }
 public abstract void UpdateGpsForPlayer(MyEntityTracker entity);
        public override void UpdateGpsForPlayer(MyEntityTracker entity)
        {
            if (!(entity.Entity is MyCharacter))
            {
                return;
            }

            var settings = MySettingsSession.Static.Settings.GeneratorSettings.GPSSettings;

            if (settings.AsteroidGPSMode != MyGPSGenerationMode.DISCOVERY)
            {
                return;
            }

            var         objects = MyStarSystemGenerator.Static.StarSystem.GetAllObjects();
            MyCharacter player  = entity.Entity as MyCharacter;

            foreach (var obj in objects)
            {
                if (obj.Type != MySystemObjectType.ASTEROIDS)
                {
                    continue;
                }

                MySystemAsteroids asteroid       = obj as MySystemAsteroids;
                Vector3D          entityPosition = player.PositionComp.GetPosition();
                var provider = MyAsteroidObjectsManager.Static.AsteroidObjectProviders[asteroid.AsteroidTypeName];

                IMyAsteroidObjectShape shape = provider.GetAsteroidObjectShape(asteroid);

                if (shape == null)
                {
                    continue;
                }

                if (shape.Contains(entityPosition) != ContainmentType.Disjoint)
                {
                    MyGPSManager.Static.RemoveDynamicGps(player.GetPlayerIdentityId(), asteroid.Id);
                }

                Vector3D closestPos = shape.GetClosestPoint(entityPosition);
                double   distance   = Vector3D.Subtract(entityPosition, closestPos).Length();
                if (distance > 5000000)
                {
                    MyGPSManager.Static.RemoveDynamicGps(player.GetPlayerIdentityId(), asteroid.Id);
                }
                else if (distance > 5)
                {
                    if (MyGPSManager.Static.DynamicGpsExists(asteroid.Id, player.GetPlayerIdentityId()))
                    {
                        MyGPSManager.Static.ModifyDynamicGps(asteroid.DisplayName, Color.Yellow, closestPos, player.GetPlayerIdentityId(), asteroid.Id);
                        continue;
                    }
                    MyGPSManager.Static.AddDynamicGps(asteroid.DisplayName, Color.Yellow, closestPos, player.GetPlayerIdentityId(), asteroid.Id);
                }
                else
                {
                    MyGPSManager.Static.RemoveDynamicGps(player.GetPlayerIdentityId(), asteroid.Id);
                }
            }
        }