public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            while (true)
            {
                IAstronaut currentAstronauth = astronauts.FirstOrDefault(a => a.CanBreath);

                if (currentAstronauth == null)
                {
                    break;
                }

                while (planet.Items.Count != 0)
                {
                    var currentItem = planet.Items.FirstOrDefault();
                    currentAstronauth.Breath();

                    currentAstronauth.Bag.AddItem(currentItem);
                    planet.RemoveItem(currentItem);

                    if (!currentAstronauth.CanBreath)
                    {
                        break;
                    }
                }

                if (planet.Items.Count == 0)
                {
                    break;
                }
            }
        }
        public override void Populate(IDefinitionManager definitionManager, IPlanet planet, IChunkColumn column00, IChunkColumn column10, IChunkColumn column01, IChunkColumn column11)
        {
            // Tree Definitions initialisieren
            if (treeDefinitions == null)
            {
                treeDefinitions = definitionManager.GetDefinitions<ITreeDefinition>().OrderBy(d => d.Order).ToArray();
                foreach (var treeDefinition in treeDefinitions)
                    treeDefinition.Init(definitionManager);
            }

            int salt = (column00.Index.X & 0xffff) + ((column00.Index.Y & 0xffff) << 16);
            Random random = new Random(planet.Seed + salt);

            Index3 sample = new Index3(column00.Index.X * Chunk.CHUNKSIZE_X, column00.Index.Y * Chunk.CHUNKSIZE_Y, column00.Heights[0, 0]);
            foreach (var treeDefinition in treeDefinitions)
            {
                int density = treeDefinition.GetDensity(planet, sample);
                if (density <= 0) continue;

                for (int i = 0; i < density; i++)
                {
                    int x = random.Next(Chunk.CHUNKSIZE_X / 2, Chunk.CHUNKSIZE_X * 3 / 2);
                    int y = random.Next(Chunk.CHUNKSIZE_Y / 2, Chunk.CHUNKSIZE_Y * 3 / 2);
                    int z = LocalBuilder.GetSurfaceHeight(column00, column10, column01, column11, x, y);

                    LocalBuilder builder = new LocalBuilder(x, y, z + 1, column00, column10, column01, column11);
                    treeDefinition.PlantTree(definitionManager, planet, new Index3(x, y, z), builder, random.Next(int.MaxValue));
                }
            }
        }
Exemple #3
0
        /// <summary>
        /// Initilises an instance of the <see cref="Simulation"/> class.
        /// </summary>
        /// <param name="planet">The planet in this simulation</param>
        /// <param name="rovers">The Rovers in this simulation</param>
        public Simulation(IPlanet planet, IEnumerable <IRover> rovers)
        {
            this.Planet = planet;
            this.Rovers = rovers;

            this.Planet.BuildPlanet(this.Rovers);
        }
Exemple #4
0
        public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            while (true)
            {
                if (planet.Items.Count == 0)
                {
                    break;
                }

                IAstronaut astronaut = astronauts.First(a => a.CanBreath);

                astronaut.Breath();
                astronaut.Bag.Items.Add(planet.Items.First());
                planet.Items.Remove(planet.Items.First());

                if (astronaut.CanBreath == false)
                {
                    astronauts.Remove(astronaut);
                }

                if (astronauts.Count == 0)
                {
                    break;
                }
            }
        }
        public string ExplorePlanet(string planetName)
        {
            List <IAstronaut> astronauts = this.astronautRepository.Models
                                           .Where(a => a.Oxygen >= 60)
                                           .ToList();

            IPlanet  planet  = this.planetRepository.FindByName(planetName);
            IMission mission = new Mission();

            if (planetName == "Jupiter")
            {
                ;
            }

            if (astronauts.Count == 0)
            {
                throw new InvalidOperationException(ExceptionMessages.InvalidAstronautCount);
            }

            mission.Explore(planet, astronauts);

            this.exploredPlanets++;

            return(string.Format(OutputMessages.PlanetExplored, planetName, astronauts.Count(a => !a.CanBreath)));
        }
Exemple #6
0
        public static void ExploreArea(IPlanet mars, IRover rover)
        {
            Console.WriteLine(string.Format("Initial rover location- X:{0}, Y:{1}, Direction:{2}", rover.XPosition, rover.YPosition, rover.CurrentDirection.ToString()));
            foreach (char command in rover.Instruction)
            {
                bool resultMove = true;
                Console.WriteLine("Processing : " + command);

                if (command == (char)Common.TurnDirection.L)
                {
                    rover.TurnRight();
                }
                else if (command == (char)Common.TurnDirection.R)
                {
                    rover.TurnLeft();
                }
                else if (command == Common.ForwardCommand)
                {
                    resultMove = mars.MoveRover(rover);
                }
                else
                {
                    Console.WriteLine("Invalid Command: " + command);
                }

                // For each robot position/ instruction in the input, the output should indicate the final grid position and orientation of the robot.
                // If a robot falls off the edge of the grid the word "LOST" should be printed after the position and orientation.
                Console.WriteLine(string.Format("{0}, {1}, {2} {3}", rover.XPosition, rover.YPosition, rover.CurrentDirection.ToString(), resultMove? "": "LOST"));
            }

            Console.WriteLine(string.Format("Final rover location- X:{0}, Y:{1}, Direction:{2}", rover.XPosition, rover.YPosition, rover.CurrentDirection.ToString()));
        }
        public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            while (true)
            {
                IAstronaut astronaut = astronauts.FirstOrDefault(a => a.CanBreath);

                if (astronaut == null)
                {
                    break;
                }

                while (planet.Items.Count != 0)
                {
                    string item = planet.Items.FirstOrDefault();
                    astronaut.Breath();

                    astronaut.Bag.AddItem(item);
                    planet.RemoveItem(item);

                    if (astronaut.CanBreath == false)
                    {
                        break;
                    }
                }

                if (planet.Items.Count == 0)
                {
                    break;
                }
            }
        }
Exemple #8
0
        /* an encircled planet is one that is surrounded by enemy planets */
        /* for now, its only for single planets that have more than 2 connections */

        public bool IsPlanetEncircled(IPlanet planet)
        {
            if (planet == null)
            {
                throw new ArgumentNullException("planet");
            }
            var links = GetLinks(planet);

            if (links == null || links.Count < 2)
            {
                return(false);
            }

            foreach (var link in links)
            {
                string planet1fac = GetPlanet(link.PlanetIDs[0]).FactionName;
                string planet2fac = GetPlanet(link.PlanetIDs[1]).FactionName;
                // if factions differ and neither faction is neutral
                if ((planet1fac == planet2fac) || (planet1fac == null) || (planet2fac == null))
                {
                    return(false);
                }
            }

            return(true);
        }
Exemple #9
0
        public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            foreach (var astronaut in astronauts)
            {
                if (astronaut.CanBreath)
                {
                    List <string> itemsOnPlanet = (List <string>)planet.Items;

                    for (int i = 0; i < itemsOnPlanet.Count; i++)
                    {
                        var currentItem = itemsOnPlanet[i];

                        astronaut.Breath();
                        astronaut.Bag.Items.Add(currentItem);
                        itemsOnPlanet.Remove(currentItem);

                        i--;
                        if (!astronaut.CanBreath)
                        {
                            DeadAstronauts++;
                            break;
                        }
                    }
                }
            }
        }
Exemple #10
0
        public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            while (true)
            {
                IAstronaut astronaut = astronauts.FirstOrDefault(a => a.CanBreath == true);

                if (astronaut == null)
                {
                    break;
                }

                string item = planet.Items.FirstOrDefault();

                if (item == null)
                {
                    break;
                }

                astronaut.Breath();

                if (astronaut.CanBreath == false)
                {
                    continue;
                }

                astronaut.Bag.Items.Add(item);
                planet.Items.Remove(item);
            }
        }
Exemple #11
0
        public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            while (true)
            {
                IAstronaut currentAstronaut = astronauts.FirstOrDefault(x => x.CanBreath);

                if (currentAstronaut == null)
                {
                    break;
                }

                while (planet.Items.Count > 0)
                {
                    string item = planet.Items.FirstOrDefault();

                    currentAstronaut.Breath();
                    currentAstronaut.Bag.Items.Add(item);
                    planet.Items.Remove(item);

                    if (!currentAstronaut.CanBreath)
                    {
                        break;
                    }
                }

                if (planet.Items.Count == 0)
                {
                    break;
                }
            }
        }
Exemple #12
0
        private static List <IRover> ExtractRoverDataFromInput(string inputFile, IPlanet mars)
        {
            try
            {
                List <IRover> roverDataCollection = new List <IRover>();

                string[] lines = File.ReadAllLines(inputFile);
                RoverController.SetMapGrid(mars, lines[0]);

                for (int counter = 1; counter < lines.Length - 1; counter = counter + 2)
                {
                    Rover rover = RoverController.GetRover(lines[counter], lines[counter + 1]);
                    if (rover != null)
                    {
                        roverDataCollection.Add(rover);
                    }
                    else
                    {
                        Console.WriteLine(string.Format("A rover could not be created. Invalid Raw material: {0} {1}", lines[counter], lines[counter + 1]));
                    }
                }

                return(roverDataCollection);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error while processing the input. Please make sure the input file is in correct format." + ex.Message);
                return(null);
            }
        }
Exemple #13
0
        public ITransmission Build(HipsterEngine.Core.HipsterEngine engine, IPlanet planet, float x, float y, float angle, float size)
        {
            _engine = engine;
            Planet  = planet;
            Radius  = size;

            RigidBody = (RigidBodyCircle)_engine.Physics.FactoryBody
                        .CreateRigidCircle()
                        .CreateCircleDef(0.2f, 0.8f, 50, Radius)
                        .CreateBodyDef(x, y, angle, true, false)
                        .Build(1f);

            Paint = new SKPaint
            {
                Style       = SKPaintStyle.Stroke,
                IsAntialias = true,
                PathEffect  = SKPathEffect.CreateDash(new[] { 10.0f, 10.0f }, 10),
                StrokeWidth = 5,
                Color       = new SKColor(100, 70, 30)
            };

            Paint1 = new SKPaint
            {
                Style       = SKPaintStyle.Fill,
                IsAntialias = true,
                Color       = new SKColor(150, 100, 50)
            };

            return(this);
        }
        public IChunk[] GenerateChunk(IEnumerable<IBlockDefinition> blockDefinitions, IPlanet planet, Index2 index)
        {
            IBlockDefinition sandDefinition = blockDefinitions.FirstOrDefault(d => typeof(SandBlockDefinition) == d.GetType());
            ushort sandIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), sandDefinition) + 1);

            IChunk[] result = new IChunk[planet.Size.Z];

            for (int layer = 0; layer < planet.Size.Z; layer++)
                result[layer] = new Chunk(new Index3(index.X, index.Y, layer), planet.Id);

            int part = (planet.Size.Z * Chunk.CHUNKSIZE_Z) / 4;

            for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
            {
                float heightY = (float)Math.Sin((float)(y * Math.PI) / 15f);
                for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
                {
                    float heightX = (float)Math.Sin((float)(x * Math.PI) / 18f);

                    float height = ((heightX + heightY + 2) / 4) * (2 * part);
                    for (int z = 0; z < planet.Size.Z * Chunk.CHUNKSIZE_Z; z++)
                    {
                        if (z < (int)(height + part))
                        {
                            int block = z % (Chunk.CHUNKSIZE_Z);
                            int layer = (int)(z / Chunk.CHUNKSIZE_Z);
                            result[layer].SetBlock(x, y, block, sandIndex);
                        }
                    }
                }
            }

            return result;
        }
        /// <summary>
        /// Lädt eine <see cref="IChunkColumn"/>.
        /// </summary>
        /// <param name="universeGuid">GUID des Universums.</param>
        /// <param name="planet">Index des Planeten.</param>
        /// <param name="columnIndex">Zu serialisierende ChunkColumn.</param>
        /// <returns>Die neu geladene ChunkColumn.</returns>
        public Awaiter Load(out IChunkColumn column, Guid universeGuid, IPlanet planet, Index2 columnIndex)
        {
            string file = Path.Combine(GetRoot(), universeGuid.ToString(), planet.Id.ToString(), string.Format(ColumnFilename, columnIndex.X, columnIndex.Y));

            column = new ChunkColumn();
            if (!File.Exists(file))
            {
                return(null);
            }

            try
            {
                using (Stream stream = File.Open(file, FileMode.Open, FileAccess.Read))
                {
                    using (GZipStream zip = new GZipStream(stream, CompressionMode.Decompress))
                    {
                        var awaiter = new Awaiter();
                        awaiter.Serializable = column;
                        awaiter.SetResult(planet.Generator.GenerateColumn(zip, definitionManager, planet.Id, columnIndex));
                        return(awaiter);
                    }
                }
            }
            catch (IOException)
            {
                try
                {
                    File.Delete(file);
                }
                catch (IOException) { }
                return(null);
            }
        }
Exemple #16
0
        public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            foreach (var astronaut in astronauts.Where(x => x.CanBreath))
            {
                while (true)
                {
                    if (!astronaut.CanBreath)
                    {
                        break;
                    }

                    if (planet.Items.Count == 0)
                    {
                        break;
                    }

                    string item = planet.Items.First();
                    astronaut.Breath();
                    astronaut.Bag.Items.Add(item);
                    planet.Items.Remove(item);
                }

                if (planet.Items.Count == 0)
                {
                    break;
                }
            }
        }
Exemple #17
0
        public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            List <string> items = planet.Items.ToList();

            foreach (var astronaut in astronauts)
            {
                if (!astronaut.CanBreath)
                {
                    continue;
                }
                else
                {
                    while (astronaut.Oxygen > 0)
                    {
                        if (items.Count != 0)
                        {
                            astronaut.Bag.Items.Add(items[0]);
                            items.RemoveAt(0);
                        }
                        else
                        {
                            break;
                        }
                        astronaut.Breath();
                    }
                }
                if (items.Count == 0)
                {
                    break;
                }
            }
        }
        public string ExplorePlanet(string planetName)
        {
            List <IAstronaut> suitableAstronauts = this.astronautRepository
                                                   .Models
                                                   .Where(a => a.Oxygen > 60)
                                                   .ToList();

            if (suitableAstronauts.Count == 0)
            {
                throw new InvalidOperationException(ExceptionMessages.InvalidAstronautCount);
            }

            IPlanet planet = this.planetRepository.FindByName(planetName);

            this.mission.Explore(planet, suitableAstronauts);

            this.exploredPlanetsCount++;

            int deadAstronauts = 0;

            foreach (var astronaut in suitableAstronauts)
            {
                if (astronaut.CanBreath == false)
                {
                    deadAstronauts++;
                }
            }

            return(string.Format(OutputMessages.PlanetExplored, planet.Name, deadAstronauts));
        }
        /// <summary>
        /// Setzt den Zentrums-Chunk für diesen lokalen Cache.
        /// </summary>
        /// <param name="planet">Der Planet, auf dem sich der Chunk befindet</param>
        /// <param name="index">Die Koordinaten an der sich der Chunk befindet</param>
        /// <param name="successCallback">Routine die Aufgerufen werden soll, falls das setzen erfolgreich war oder nicht</param>
        public bool SetCenter(IPlanet planet, Index2 index, Action <bool> successCallback = null)
        {
            if (IsPassive && !globalCache.IsChunkLoaded(planet.Id, index))
            {
                return(false);
            }

            // Planet resetten falls notwendig
            if (Planet != planet)
            {
                InitializePlanet(planet);
            }

            CenterPosition = index;

            if (_loadingTask != null && !_loadingTask.IsCompleted)
            {
                _cancellationToken.Cancel();
                _cancellationToken = new CancellationTokenSource();
                _loadingTask       = _loadingTask.ContinueWith(_ => InternalSetCenter(_cancellationToken.Token, planet, index, successCallback));
            }
            else
            {
                _cancellationToken = new CancellationTokenSource();
                _loadingTask       = Task.Factory.StartNew(() => InternalSetCenter(_cancellationToken.Token, planet, index, successCallback));
            }

            return(true);
        }
Exemple #20
0
 public SuperBiomeBase(IPlanet planet, float valueRangeOffset, float valueRange)
 {
     this.Planet           = planet;
     this.SubBiomes        = new List <IBiome>();
     this.ValueRangeOffset = valueRangeOffset;
     this.ValueRange       = valueRange;
 }
        public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            if (astronauts.Count > 0)
            {
                foreach (var astronaut in astronauts)
                {
                    List <string> items = planet.Items.ToList();
                    for (int itemNum = 0; itemNum < planet.Items.Count; itemNum++)
                    {
                        if (astronaut.Oxygen > 0)
                        {
                            astronaut.Bag.Items.Add(items[itemNum]);
                            items.Remove(items[itemNum]);
                            astronaut.Breath();
                        }

                        if (astronaut.Oxygen <= 0)
                        {
                            break;
                        }
                    }
                }
            }
            else
            {
                throw new ArgumentException(ExceptionMessages.InvalidAstronautCount);
            }
        }
Exemple #22
0
        public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            while (true)
            {
                IAstronaut astronautCurrent = astronauts.FirstOrDefault(a => a.CanBreath);
                if (astronautCurrent == null)
                {
                    break;
                }

                string item = planet.Items.FirstOrDefault();
                if (item == null)
                {
                    break;
                }

                astronautCurrent.Bag.Items.Add(item);
                astronautCurrent.Breath();
                planet.Items.Remove(item);

                //if (!astronautCurrent.CanBreath)
                //{
                //    break;
                //}
            }
        }
        public string ExplorePlanet(string planetName)
        {
            List <IAstronaut> suitables = this.astronautRepository.Models
                                          .Where(x => x.Oxygen > 60)
                                          .ToList();

            if (suitables.Count == 0)
            {
                throw new InvalidOperationException(ExceptionMessages.InvalidAstronautCount);
            }

            IPlanet planet = this.planetRepository
                             .FindByName(planetName);

            this.mission.Explore(planet, suitables);

            this.exploredPlanetsCount++;

            int deadAstronauts = suitables
                                 .Where(x => x.Oxygen == 0)
                                 .Count();

            return(string.Format(OutputMessages.PlanetExplored,
                                 planetName,
                                 deadAstronauts));
        }
        /// <summary>
        /// Lädt eine <see cref="IChunkColumn"/>.
        /// </summary>
        /// <param name="universeGuid">GUID des Universums.</param>
        /// <param name="planet">Index des Planeten.</param>
        /// <param name="columnIndex">Zu serialisierende ChunkColumn.</param>
        /// <returns>Die neu geladene ChunkColumn.</returns>
        public IChunkColumn LoadColumn(Guid universeGuid, IPlanet planet, Index2 columnIndex)
        {
            string file = Path.Combine(GetRoot(), universeGuid.ToString(), planet.Id.ToString(), string.Format(ColumnFilename, columnIndex.X, columnIndex.Y));

            if (!File.Exists(file))
            {
                return(null);
            }

            try {
                using (Stream stream = File.Open(file, FileMode.Open, FileAccess.Read))
                {
                    using (GZipStream zip = new GZipStream(stream, CompressionMode.Decompress))
                    {
                        return(planet.Generator.GenerateColumn(zip, DefinitionManager.Instance, planet.Id, columnIndex));
                    }
                }
            }
            catch (IOException)
            {
                try
                {
                    File.Delete(file);
                }
                catch (IOException) { }
                return(null);
            }
        }
Exemple #25
0
        public string ExplorePlanet(string planetName)
        {
            IList <IAstronaut> availableAtsra = new List <IAstronaut>();

            foreach (var item in astronauts.Models)
            {
                if (item.Oxygen > 60)
                {
                    availableAtsra.Add(item);
                }
            }

            if (availableAtsra.Count == 0)
            {
                throw new InvalidOperationException(string.Format(Utilities.Messages.ExceptionMessages.InvalidAstronautCount));
            }

            Mission mission = new Mission();
            string  result;

            this.exploredPlanetCounnt++;

            IPlanet planet = planets.Models.FirstOrDefault(n => n.Name == planetName);

            mission.Explore(planet, (IList <IAstronaut>)availableAtsra);
            int countOfDeadAstro = availableAtsra.Where(a => a.CanBreath == false).Count();

            result = string.Format(Utilities.Messages.OutputMessages.PlanetExplored, planet.Name, countOfDeadAstro);


            return(result);
        }
        public List <IVector> GetFinalsVectors(IPlanet mars)
        {
            List <IVector> finalVectorList = new List <IVector>();

            foreach (var rover in mars.RoverList)
            {
                Queue <Directive> directiveQueue = _directiveBusiness.GetDirectiveQueue(rover.DirectiveList);

                while (directiveQueue.Count > 0)
                {
                    Directive directive = directiveQueue.Dequeue();
                    switch (directive)
                    {
                    case Directive.R:
                        rover.Vector.Direction = _roverBusiness.TurnRight(rover.Vector.Direction);
                        break;

                    case Directive.L:
                        rover.Vector.Direction = _roverBusiness.TurnLeft(rover.Vector.Direction);
                        break;

                    case Directive.M:
                        rover.Vector = _roverBusiness.Move(rover.Vector);
                        break;

                    default:
                        break;
                    }
                }
                finalVectorList.Add(rover.Vector);
            }

            return(finalVectorList);
        }
 public SuperBiomeBase(IPlanet planet, float valueRangeOffset, float valueRange)
 {
     this.Planet = planet;
     this.SubBiomes = new List<IBiome>();
     this.ValueRangeOffset = valueRangeOffset;
     this.ValueRange = valueRange;
 }
Exemple #28
0
        // TODO: dependency injection

        static void Main(string[] args)
        {
            // The first line of input is the upper-right coordinates of the rectangular world, the lower-left coordinates are assumed to be 0, 0.
            Console.WriteLine("Hello to Martian Robot sequence!");
            Console.WriteLine("Please, the file path with then instructions");

            string filepath = Console.ReadLine();

            IPlanet mars = CreatePlanet("Mars");

            List <IRover> rovers = ExtractRoverDataFromInput(filepath, mars);

            if (rovers == null)
            {
                Console.WriteLine("Could not create any rover with provided instructions");
            }

            foreach (IRover rover in rovers)
            {
                Console.WriteLine("----Processing Rover------");
                if (!mars.AddRover(rover))
                {
                    Console.WriteLine("Could not add rover to plateau.");
                }
                else
                {
                    RoverController.ExploreArea(mars, rover);
                }
            }

            Console.Read();
            return;
        }
        public IChunk[] GenerateChunk(IPlanet planet, Index2 index)
        {
            IChunk[] result = new IChunk[planet.Size.Z];

            for (int layer = 0; layer < planet.Size.Z; layer++)
                result[layer] = new Chunk(new Index3(index.X, index.Y, layer), planet.Id);

            int part = (planet.Size.Z * Chunk.CHUNKSIZE_Z) / 4;

            for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
            {
                float heightY = (float)Math.Sin((float)(y * Math.PI) / 15f);
                for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
                {
                    float heightX = (float)Math.Sin((float)(x * Math.PI) / 18f);

                    float height = ((heightX + heightY + 2) / 4) * (2 * part);
                    for (int z = 0; z < planet.Size.Z * Chunk.CHUNKSIZE_Z; z++)
                    {
                        if (z < (int)(height + part))
                        {
                            int block = z % (Chunk.CHUNKSIZE_Z);
                            int layer = (int)(z / Chunk.CHUNKSIZE_Z);
                            result[layer].SetBlock(x, y, block, new SandBlock());
                        }
                    }
                }
            }

            return result;
        }
        /// <summary>
        /// Lädt eine <see cref="IChunkColumn"/>.
        /// </summary>
        /// <param name="universeGuid">GUID des Universums.</param>
        /// <param name="planet">Index des Planeten.</param>
        /// <param name="columnIndex">Zu serialisierende ChunkColumn.</param>
        /// <returns>Die neu geladene ChunkColumn.</returns>
        public IChunkColumn LoadColumn(Guid universeGuid, IPlanet planet, Index2 columnIndex)
        {
            string file = Path.Combine(GetRoot(), universeGuid.ToString(), planet.Id.ToString(), string.Format(ColumnFilename, columnIndex.X, columnIndex.Y));
            if (!File.Exists(file))
                return null;

            try {
            using (Stream stream = File.Open(file, FileMode.Open, FileAccess.Read))
            {
                using (GZipStream zip = new GZipStream(stream, CompressionMode.Decompress))
                {
                    return planet.Generator.GenerateColumn(zip, DefinitionManager.Instance, planet.Id, columnIndex);
                }
                }
            }
            catch (IOException)
            {
                try
                {
                    File.Delete(file);
                }
                catch (IOException) { }
                return null;
            }
        }
        /// <summary>
        /// Speichert einen Planeten.
        /// </summary>
        /// <param name="universeGuid">Guid des Universums</param>
        /// <param name="planet">Zu speichernder Planet</param>
        public void SavePlanet(Guid universeGuid, IPlanet planet)
        {
            string path = Path.Combine(GetRoot(), universeGuid.ToString(), planet.Id.ToString());

            Directory.CreateDirectory(path);

            string generatorInfo = Path.Combine(path, PlanetGeneratorInfo);

            using (Stream stream = File.Open(generatorInfo, FileMode.Create, FileAccess.Write))
            {
                using (BinaryWriter bw = new BinaryWriter(stream))
                {
                    bw.Write(planet.Generator.GetType().FullName);
                }
            }

            string file = Path.Combine(path, PlanetFilename);

            using (Stream stream = File.Open(file, FileMode.Create, FileAccess.Write))
            {
                using (GZipStream zip = new GZipStream(stream, CompressionMode.Compress))
                {
                    planet.Serialize(zip);
                }
            }
        }
Exemple #32
0
        public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            IAstronaut astronaut = astronauts.FirstOrDefault(a => a.CanBreath);

            if (planet == null)
            {
                return;
            }
            if (astronauts == null)
            {
                return;
            }
            if (planet.Items.Count == 0)
            {
                return;
            }

            while (astronauts.Any(a => a.CanBreath) && planet.Items.Count > 0)
            {
                string item = planet.Items.FirstOrDefault();
                if (!astronaut.CanBreath)
                {
                    astronaut = astronauts.FirstOrDefault(a => a.CanBreath);
                    continue;
                }
                else
                {
                    astronaut.Breath();
                    astronaut.Bag.Items.Add(item);
                    planet.Items.Remove(item);
                }
            }
        }
Exemple #33
0
        public string ExplorePlanet(string planetName)
        {
            List <IAstronaut> astronautsForMission = new List <IAstronaut>();
            IMission          mission         = new Mission();
            IPlanet           planetToExplore = planets.FindByName(planetName);

            foreach (var astronaut in astronauts.Models)
            {
                if (astronaut.Oxygen > 60)
                {
                    astronautsForMission.Add(astronaut);
                }
            }

            if (!astronautsForMission.Any())
            {
                throw new InvalidOperationException("You need at least one astronaut to explore the planet");
            }

            int deadAstronauts = astronautsForMission.Count(x => !x.CanBreath);

            mission.Explore(planetToExplore, astronautsForMission);

            this.explorePlanetes++;

            return($"Planet: {planetName} was explored! Exploration finished with {deadAstronauts} dead astronauts!");
        }
        public void Explore(IPlanet planet, ICollection <IAstronaut> astronauts)
        {
            while (true)
            {
                var astronaut = astronauts
                                .FirstOrDefault(x => x.CanBreath);

                if (astronaut == null)
                {
                    break;
                }

                var item = planet
                           .Items
                           .FirstOrDefault();

                if (item == null)
                {
                    break;
                }

                astronaut.Breath();

                astronaut
                .Bag
                .Items
                .Add(item);

                planet
                .Items
                .Remove(item);
            }
        }
Exemple #35
0
        public string ExplorePlanet(string planetName)
        {
            var suitable = this.astronauts.Models.Where(a => a.Oxygen > 60).ToList();

            if (!suitable.Any())
            {
                throw new InvalidOperationException(ExceptionMessages.InvalidAstronautCount);
            }

            int beforeCount = suitable.Count();

            IPlanet planet = this.planets.FindByName(planetName);

            this.mission.Explore(planet, suitable);
            this.exploredPlanetsCount++;

            int after = 0;

            foreach (var astronaut in suitable)
            {
                if (!astronaut.CanBreath)
                {
                    after++;
                }
            }

            return(String.Format(OutputMessages.PlanetExplored, planetName, after));
        }
Exemple #36
0
        public ActorHost(Player player)
        {
            Player = player;
            localChunkCache = new Cache<Index3, IChunk>(10, loadChunk, null);
            planet = ResourceManager.Instance.GetPlanet(Player.Position.Planet);

            ActiveTool = null;
        }
 public OceanBiomeGenerator(IPlanet planet, float minVal, float maxVal, float valueRangeOffset, float valueRange)
 {
     this.Planet = planet;
     this.MinValue = minVal;
     this.MaxValue = maxVal;
     this.ValueRangeOffset = valueRangeOffset;
     this.ValueRange = valueRange;
 }
 public FlatlandBiome(IPlanet planet, float minValue, float maxValue, float valueRangeOffset, float valueRange)
 {
     this.BiomeNoiseGenerator = new SimplexNoiseGenerator(planet.Seed + 2) { FrequencyX = 1f / 256, FrequencyY = 1f / 256, Persistance = 0.25f, Octaves = 3, Factor = 1f };
     this.Planet = planet;
     this.MinValue = minValue;
     this.MaxValue = maxValue;
     this.ValueRangeOffset = valueRangeOffset;
     this.ValueRange = valueRange;
 }
 /// <summary>
 /// Default constructor
 /// </summary>
 /// <param name="planet">Planet to render</param>
 /// <param name="effectPath">Path to the terrain effect</param>
 public PlanetPackTextureTechnique( IPlanet planet, string effectPath )
 {
     Arguments.CheckNotNull( planet, "planet" );
     Arguments.CheckNotNullOrEmpty( effectPath, "effectPath" );
     m_Planet = planet;
     m_NoiseTexture = ( ITexture2d )AssetManager.Instance.Load( "Terrain/TiledNoise.noise.jpg" );
     m_Effect = new EffectAssetHandle( effectPath, true );
     m_Effect.OnReload += Effect_OnReload;
     m_Technique = new TechniqueSelector( m_Effect, "DefaultTechnique" );
 }
Exemple #40
0
        public ActorHost(Player player)
        {
            Player = player;
            planet = ResourceManager.Instance.GetPlanet(Player.Position.Planet);

            localChunkCache = new LocalChunkCache(ResourceManager.Instance.GlobalChunkCache, 2, 1, true);
            _oldIndex = Player.Position.ChunkIndex;

            ActiveTool = null;
            ReadyState = false;
        }
        public override void PlantTree(IDefinitionManager definitionManager, IPlanet planet, Index3 index, LocalBuilder builder, int seed)
        {
            ushort ground = builder.GetBlock(0, 0, -1);
            if (ground == water) return;

            Random rand = new Random(seed);
            int height = rand.Next(2, 4);

            for (int i = 0; i < height; i++)
                builder.SetBlock(0, 0, i, cactus);
        }
        public ActorHost(Player player, IChunkLoader chunkLoader)
        {
            _chunkLoader = chunkLoader;

            Player = player;
            planet = ResourceManager.Instance.GetPlanet(Player.Position.Planet);

            _oldIndex = Player.Position.ChunkIndex;

            ActiveTool = null;
            State = WorldState.Loading;
        }
Exemple #43
0
        public void DeployTo(IPlanet planet, int landingPointX, int landingPointY, Movement.CardinalHeading landingCardinalHeading)
        {
            this.DeployedTo = planet;

            if (landingPointX < 0 ||
                landingPointY < 0 ||
                landingPointX > planet.Size.Width ||
                landingPointY > planet.Size.Height)
            {
                throw new ArgumentException("Rover cannot be deployed to a point outside the bounds of a planet.");
            }
            this.Position = new Position(landingPointX, landingPointY, landingCardinalHeading);
        }
        public SurfaceBiomeGenerator(IPlanet planet, int seaLevel)
            : base(planet, 0f, 1f)
        {
            this.SeaLevel = seaLevel;
            BiomeNoiseGenerator = new SimplexNoiseGenerator(planet.Seed) { FrequencyX = 1f / 10000, FrequencyY = 1f / 10000, Factor = 1f };

            float offset = (float)seaLevel / (Planet.Size.Z * Chunk.CHUNKSIZE_Z);

            SubBiomes.Add(new OceanBiomeGenerator(planet, 0f, 0.3f, 0f, offset));
            SubBiomes.Add(new LandBiomeGenerator(planet, 0.5f, 1f, offset, 1 - offset));

            SortSubBiomes();
        }
 /// <summary>
 /// Setzt den Zentrums-Chunk für diesen lokalen Cache.
 /// </summary>
 /// <param name="planet">Der Planet, auf dem sich der Chunk befindet</param>
 /// <param name="index">Die Koordinaten an der sich der Chunk befindet</param>
 /// <param name="successCallback">Routine die Aufgerufen werden soll, falls das setzen erfolgreich war oder nicht</param>
 public void SetCenter(IPlanet planet, Index3 index, Action<bool> successCallback = null)
 {
     if (_loadingTask != null && !_loadingTask.IsCompleted)
     {
         _cancellationToken.Cancel();
         _cancellationToken = new CancellationTokenSource();
         _loadingTask = _loadingTask.ContinueWith(_ => InternalSetCenter(_cancellationToken.Token, planet, index, successCallback));
     }
     else
     {
         _cancellationToken = new CancellationTokenSource();
         _loadingTask = Task.Factory.StartNew(() => InternalSetCenter(_cancellationToken.Token, planet, index, successCallback));
     }
 }
        /// <summary>
        /// Setup constructor
        /// </summary>
        /// <param name="projectType">Project type that created this project</param>
        /// <param name="name">Project name</param>
        /// <param name="modelFactory">Factory used for creating environment models from templates</param>
        /// <param name="renderFactory">Factory used for creating environment renderers from models</param>
        /// <param name="template">ProjectType to use</param>
        /// <param name="planet">Planet to use</param>
        protected PlanetProject( ProjectType projectType, string name, IPlanetEnvironmentModelFactory modelFactory, IPlanetEnvironmentRendererFactory renderFactory, IPlanetModelTemplate template, IPlanet planet )
            : base(projectType, name, null, null)
        {
            Arguments.CheckNotNull( template, "template" );
            Arguments.CheckNotNull( modelFactory, "modelFactory" );
            Arguments.CheckNotNull( renderFactory, "renderFactory" );
            Arguments.CheckNotNull( planet, "planet" );

            new PlanetTemplateWatcher( template, planet, modelFactory, renderFactory );

            m_Planet = planet;
            m_PlanetTemplate = template;
            template.CreateModelInstance( planet.Model, modelFactory, InstanceContext );
        }
        /// <summary>
        /// Setup constructor
        /// </summary>
        public PlanetTemplateWatcher( IPlanetModelTemplate planetTemplate, IPlanet planet, IPlanetEnvironmentModelFactory modelFactory, IPlanetEnvironmentRendererFactory rendererFactory )
        {
            Arguments.CheckNotNull( planetTemplate, "planetTemplate" );
            Arguments.CheckNotNull( planet, "planet" );
            m_ModelFactory = modelFactory;
            m_RendererFactory = rendererFactory;
            m_PlanetTemplate = planetTemplate;
            m_Planet = planet;

            m_PlanetTemplate.ComponentAdded += OnTemplateAdded;
            m_PlanetTemplate.ComponentRemoved += OnTemplateRemoved;

            m_Planet.Model.ComponentAdded += OnModelAdded;
            m_Planet.Model.ComponentRemoved += OnModelRemoved;
        }
        public override void PlantTree(IDefinitionManager definitionManager, IPlanet planet, Index3 index, LocalBuilder builder, int seed)
        {
            ushort ground = builder.GetBlock(0, 0, -1);
            if (ground == water) return;

            Random rand = new Random(seed);
            int height = rand.Next(3, 5);
            int radius = rand.Next(3, height);

            builder.FillSphere(0, 0, height, radius, leave);

            for (int i = 0; i < height + 2; i++)
            {
                builder.SetBlock(0, 0, 0 + i, wood);
            }
        }
        public LandBiomeGenerator(IPlanet planet, float minVal, float maxVal, float valueRangeOffset, float valueRange)
            : base(planet, valueRangeOffset, valueRange)
        {

            BiomeNoiseGenerator = new SimplexNoiseGenerator(planet.Seed + 1) { FrequencyX = 1f / 1000, FrequencyY = 1f / 1000, Persistance = 0.25f, Octaves = 5, Factor = 1f };
            
            
            this.MinValue = minVal;
            this.MaxValue = maxVal;

            SubBiomes.Add(new FlatlandBiome(planet, 0f, 0.2f, 0f, 0.1f));
            SubBiomes.Add(new HillsBiome(planet, 0.3f, 0.5f, 0.1f, 0.4f));
            SubBiomes.Add(new HighMountainBiome(planet, 0.8f, 1f, 0.2f, 0.8f));


            SortSubBiomes();
        }
        /// <summary>
        /// Sets up the terrain rendering effect
        /// </summary>
        protected virtual void SetupTerrainEffect( IEffect effect, IPlanet planet )
        {
            IPlanetTerrainPackTextureModel textureModel = ( IPlanetTerrainPackTextureModel )planet.PlanetModel.TerrainModel;
            ITexture2d packTexture = textureModel.TerrainPackTexture;
            ITexture2d typesTexture = textureModel.TerrainTypesTexture;

            effect.Parameters[ "PlanetMaximumTerrainHeight" ].Set( planet.PlanetModel.TerrainModel.MaximumHeight.ToRenderUnits );
            effect.Parameters[ "TerrainPackTexture" ].Set( packTexture );
            effect.Parameters[ "TerrainTypeTexture" ].Set( typesTexture );
            effect.Parameters[ "NoiseTexture" ].Set( m_NoiseTexture );

            IPlanetAtmosphereRenderer atmosphereRenderer = planet.PlanetRenderer.AtmosphereRenderer;
            if ( atmosphereRenderer != null )
            {
                atmosphereRenderer.SetupAtmosphereEffectParameters( effect, true, false );
            }
        }
Exemple #51
0
        /// <summary>
        /// Resolve references to non-service entities.
        /// Subscribe to events.
        /// </summary>
        void Start() {

            // get registry lookups

            planet = registry.LookUp<IPlanet>("Planet");

            gameUI = registry.LookUp<IGameUI>("GameUI");

            // subscribe to events

            time.CountdownFinished += OnCountdownFinished;

            gameUI.onGameReady += OnGameReady;

            // turn on controls

            shipController.Connect();

            // start the first wave

            gameUI.TriggerWaveStartAnimation();
        }
        protected override void LoadContent()
        {
            List<Bitmap> bitmaps = new List<Bitmap>();
            var definitions = BlockDefinitionManager.GetBlockDefinitions();
            foreach (var definition in definitions)
                bitmaps.AddRange(definition.Textures);

            int size = (int)Math.Ceiling(Math.Sqrt(bitmaps.Count));
            Bitmap blocks = new Bitmap(size * TEXTURESIZE, size * TEXTURESIZE);
            using (Graphics g = Graphics.FromImage(blocks))
            {
                int counter = 0;
                foreach (var bitmap in bitmaps)
                {
                    int x = counter % size;
                    int y = (int)(counter / size);
                    g.DrawImage(bitmap, new System.Drawing.Rectangle(TEXTURESIZE * x, TEXTURESIZE * y, TEXTURESIZE, TEXTURESIZE));
                    counter++;
                }
            }

            using (MemoryStream stream = new MemoryStream())
            {
                blocks.Save(stream, ImageFormat.Png);
                stream.Seek(0, SeekOrigin.Begin);
                blockTextures = Texture2D.FromStream(GraphicsDevice, stream);
            }

            planet = ResourceManager.Instance.GetPlanet(0);

            chunkRenderer = new ChunkRenderer[
                ((VIEWRANGE * 2) + 1) *
                ((VIEWRANGE * 2) + 1) *
                ((VIEWHEIGHT * 2) + 1)];

            for (int i = 0; i < chunkRenderer.Length; i++)
            {
                chunkRenderer[i] = new ChunkRenderer(GraphicsDevice, camera.Projection, blockTextures);
                freeChunkRenderer.Enqueue(chunkRenderer[i]);
            }

            // Entfernungsarray erzeugen
            for (int x = -VIEWRANGE; x <= VIEWRANGE; x++)
                for (int y = -VIEWRANGE; y <= VIEWRANGE; y++)
                    for (int z = -VIEWHEIGHT; z <= VIEWHEIGHT; z++)
                        distances.Add(new Index3(x, y, z));
            distances = distances.OrderBy(d => d.LengthSquared()).ToList();

            backgroundThread = new Thread(BackgroundLoop);
            backgroundThread.Priority = ThreadPriority.Lowest;
            backgroundThread.IsBackground = true;
            backgroundThread.Start();

            selectionLines = new[]
            {
                new VertexPositionColor(new Vector3(-0.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
            };

            selectionIndeces = new short[]
            {
                0, 1, 0, 2, 1, 3, 2, 3,
                4, 5, 4, 6, 5, 7, 6, 7,
                0, 4, 1, 5, 2, 6, 3, 7
            };

            selectionEffect = new BasicEffect(GraphicsDevice);
            selectionEffect.VertexColorEnabled = true;

            MiniMapTexture = new RenderTarget2D(GraphicsDevice, 128, 128, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PreserveContents);

            minimapEffect = new BasicEffect(GraphicsDevice);
            minimapEffect.Projection = Matrix.CreateOrthographic(100, 100, 1, 10000);
            minimapEffect.EnableDefaultLighting();

            base.LoadContent();
        }
        public IChunk[] GenerateChunk(IEnumerable<IBlockDefinition> blockDefinitions, IPlanet planet, Index2 index)
        {
            IBlockDefinition sandDefinition = blockDefinitions.FirstOrDefault(d => typeof(SandBlockDefinition) == d.GetType());
            ushort sandIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), sandDefinition) + 1);

            IBlockDefinition groundDefinition = blockDefinitions.FirstOrDefault(d => typeof(GroundBlockDefinition) == d.GetType());
            ushort groundIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), groundDefinition) + 1);

            IBlockDefinition stoneDefinition = blockDefinitions.FirstOrDefault(d => typeof(StoneBlockDefinition) == d.GetType());
            ushort stoneIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), stoneDefinition) + 1);

            IBlockDefinition waterDefinition = blockDefinitions.FirstOrDefault(d => typeof(WaterBlockDefinition) == d.GetType());
            ushort waterIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), waterDefinition) + 1);

            IBlockDefinition grassDefinition = blockDefinitions.FirstOrDefault(d => typeof(GrassBlockDefinition) == d.GetType());
            ushort grassIndex = (ushort)(Array.IndexOf(blockDefinitions.ToArray(), grassDefinition) + 1);

            if (!(planet is ComplexPlanet))
                throw new ArgumentException("planet is not a Type of ComplexPlanet");

            ComplexPlanet localPlanet = (ComplexPlanet)planet;

            float[,] localHeightmap = localPlanet.BiomeGenerator.GetHeightmap(index);

            IChunk[] chunks = new IChunk[planet.Size.Z];
            for (int i = 0; i < planet.Size.Z; i++)
                chunks[i] = new Chunk(new Index3(index, i), planet.Id);

            int obersteSchicht;
            bool surfaceBlock;
            bool ozeanSurface;

            for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
            {
                for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
                {
                    obersteSchicht = 5;
                    surfaceBlock = true;
                    ozeanSurface = false;

                    for (int i = chunks.Length - 1; i >= 0; i--)
                    {
                        for (int z = Chunk.CHUNKSIZE_Z - 1; z >= 0; z--)
                        {
                            int absoluteZ = (z + (i * Chunk.CHUNKSIZE_Z));

                            if (absoluteZ <= localHeightmap[x, y] * localPlanet.Size.Z * Chunk.CHUNKSIZE_Z)
                            {
                                if (obersteSchicht > 0)
                                {
                                    float temp = localPlanet.ClimateMap.GetTemperature(new Index3(index.X * Chunk.CHUNKSIZE_X + x, index.Y * Chunk.CHUNKSIZE_Y + y, i * Chunk.CHUNKSIZE_Z + z));

                                    if ((ozeanSurface || surfaceBlock) && (absoluteZ <= (localPlanet.BiomeGenerator.SeaLevel + 2)) && (absoluteZ >= (localPlanet.BiomeGenerator.SeaLevel - 2)))
                                    {
                                        chunks[i].SetBlock(x, y, z, sandIndex);
                                    }
                                    else if (temp >= 35)
                                    {
                                        chunks[i].SetBlock(x, y, z, sandIndex);
                                    }
                                    else if (absoluteZ >= localPlanet.Size.Z * Chunk.CHUNKSIZE_Z * 0.6f)
                                    {
                                        if (temp > 12)
                                            chunks[i].SetBlock(x, y, z, groundIndex);
                                        else
                                            chunks[i].SetBlock(x, y, z, stoneIndex);
                                    }
                                    else if (temp >= 8)
                                    {
                                        if (surfaceBlock && !ozeanSurface)
                                        {
                                            chunks[i].SetBlock(x, y, z, grassIndex);
                                            surfaceBlock = false;
                                        }
                                        else
                                        {
                                            chunks[i].SetBlock(x, y, z, groundIndex);
                                        }
                                    }
                                    else
                                    {
                                        chunks[i].SetBlock(x, y, z, groundIndex);
                                    }
                                    obersteSchicht--;
                                }
                                else
                                {
                                    chunks[i].SetBlock(x, y, z, stoneIndex);
                                }

                            }
                            else if ((z + (i * Chunk.CHUNKSIZE_Z)) <= localPlanet.BiomeGenerator.SeaLevel)
                            {

                                chunks[i].SetBlock(x, y, z, waterIndex);
                                ozeanSurface = true;
                            }

                        }
                    }
                }
            }

            //float[,] cloudmap = null;
            ////Biomes.BiomeBlockValue[, ,] blockValues = localPlanet.BiomeGenerator.GetBlockValues(index,heightmap,0f,1f);

            ////for (int x = 0; x < Chunk.CHUNKSIZE_X; x++)
            //Parallel.For(0, Chunk.CHUNKSIZE_X, x =>
            //{
            //    for (int y = 0; y < Chunk.CHUNKSIZE_Y; y++)
            //    {
            //        bool grass = true, sand = false;

            //        for (int i = chunks.Length - 1; i >= 0; i--)
            //        {

            //            for (int z = Chunk.CHUNKSIZE_Z - 1; z >= 0; z--)
            //            {
            //                //Biomes.BiomeBlockValue blockValue = blockValues[x, y, z + i * Chunk.CHUNKSIZE_Z];
            //                int blockHeight = Math.Max(z + Chunk.CHUNKSIZE_Z * (i), 0);
            //                //float density = heightmap[x,y] * (Chunk.CHUNKSIZE_Z * (planet.Size.Z)) - blockHeight;
            //                Index3 blockIndex = new Index3(index.X * Chunk.CHUNKSIZE_X + x, index.Y * Chunk.CHUNKSIZE_Y + y, i * Chunk.CHUNKSIZE_Z + z);

            //                if (blockValue.Density > 0.6f || (z < 3 && i == 0))
            //                {
            //                    if (blockValue.IsDessert || (grass | sand) && (z + (i * Chunk.CHUNKSIZE_Z)) <= localPlanet.BiomeGenerator.SeaLevel && (z + (i * Chunk.CHUNKSIZE_Z)) >= localPlanet.BiomeGenerator.SeaLevel - 2)
            //                    {
            //                        chunks[i].SetBlock(new Index3(x, y, z), new SandBlock());
            //                        grass = false;
            //                        sand = true;
            //                    }
            //                    else if (grass && planet.ClimateMap.GetTemperature(blockIndex) > 18.0f)
            //                    {
            //                        chunks[i].SetBlock(new Index3(x, y, z), new GrassBlock());
            //                        grass = false;
            //                    }
            //                    //else if (z < Chunk.CHUNKSIZE_Z - 1 && noiseplus >= resDensity)
            //                    //{
            //                    //    chunks[i].SetBlock(new Index3(x, y, z), new StoneBlock());
            //                    //}
            //                    else
            //                    {
            //                        chunks[i].SetBlock(new Index3(x, y, z), new GroundBlock());
            //                        grass = false;
            //                    }

            //                }
            //                else if ((z + (i * Chunk.CHUNKSIZE_Z)) <= localPlanet.BiomeGenerator.SeaLevel)
            //                {
            //                    grass = false;
            //                    sand = true;
            //                    chunks[i].SetBlock(new Index3(x, y, z), new WaterBlock());
            //                }
            //            }
            //        }
            //    }
            //});

            return chunks;
        }
Exemple #54
0
        public SceneControl(ScreenComponent manager, string style = "")
            : base(manager, style)
        {
            player = manager.Player;
            camera = manager.Camera;

            Manager = manager;

            simpleShader = manager.Game.Content.Load<Effect>("simple");
            sunTexture = manager.Game.Content.LoadTexture2DFromFile("./Assets/OctoAwesome.Client/sun.png", manager.GraphicsDevice);

            List<Bitmap> bitmaps = new List<Bitmap>();
            var definitions = DefinitionManager.Instance.GetBlockDefinitions();
            foreach (var definition in definitions)
                bitmaps.AddRange(definition.Textures);

            int size = (int)Math.Ceiling(Math.Sqrt(bitmaps.Count));
            Bitmap blocks = new Bitmap(size * TEXTURESIZE, size * TEXTURESIZE);
            using (Graphics g = Graphics.FromImage(blocks))
            {
                int counter = 0;
                foreach (var bitmap in bitmaps)
                {
                    int x = counter % size;
                    int y = (int)(counter / size);
                    g.DrawImage(bitmap, new System.Drawing.Rectangle(TEXTURESIZE * x, TEXTURESIZE * y, TEXTURESIZE, TEXTURESIZE));
                    counter++;
                }
            }

            using (MemoryStream stream = new MemoryStream())
            {
                blocks.Save(stream, ImageFormat.Png);
                stream.Seek(0, SeekOrigin.Begin);
                blockTextures = Texture2D.FromStream(manager.GraphicsDevice, stream);
            }

            planet = ResourceManager.Instance.GetPlanet(0);

            // TODO: evtl. Cache-Size (Dimensions) VIEWRANGE + 1

            int range = ((int)Math.Pow(2, VIEWRANGE) - 2) / 2;
            localChunkCache = new LocalChunkCache(ResourceManager.Instance.GlobalChunkCache, VIEWRANGE, range);

            chunkRenderer = new ChunkRenderer[
                (int)Math.Pow(2, VIEWRANGE) * (int)Math.Pow(2, VIEWRANGE),
                planet.Size.Z];
            orderedChunkRenderer = new List<ChunkRenderer>(
                (int)Math.Pow(2, VIEWRANGE) * (int)Math.Pow(2, VIEWRANGE) * planet.Size.Z);

            for (int i = 0; i < chunkRenderer.GetLength(0); i++)
            {
                for (int j = 0; j < chunkRenderer.GetLength(1); j++)
                {
                    ChunkRenderer renderer = new ChunkRenderer(simpleShader, manager.GraphicsDevice, camera.Projection, blockTextures);
                    chunkRenderer[i, j] = renderer;
                    orderedChunkRenderer.Add(renderer);
                }
            }

            backgroundThread = new Thread(BackgroundLoop);
            backgroundThread.Priority = ThreadPriority.Lowest;
            backgroundThread.IsBackground = true;
            backgroundThread.Start();

            selectionLines = new[]
            {
                new VertexPositionColor(new Vector3(-0.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
            };

            billboardVertices = new[]
            {
                new VertexPositionTexture(new Vector3(-0.5f, 0.5f, 0), new Vector2(0, 0)),
                new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
                new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
                new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
                new VertexPositionTexture(new Vector3(0.5f, -0.5f, 0), new Vector2(1, 1)),
                new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
            };

            selectionIndeces = new short[]
            {
                0, 1, 0, 2, 1, 3, 2, 3,
                4, 5, 4, 6, 5, 7, 6, 7,
                0, 4, 1, 5, 2, 6, 3, 7
            };

            sunEffect = new BasicEffect(manager.GraphicsDevice);
            sunEffect.TextureEnabled = true;

            selectionEffect = new BasicEffect(manager.GraphicsDevice);
            selectionEffect.VertexColorEnabled = true;

            MiniMapTexture = new RenderTarget2D(manager.GraphicsDevice, 128, 128, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8); // , false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PreserveContents);
            miniMapProjectionMatrix = Matrix.CreateOrthographic(128, 128, 1, 10000);
        }
Exemple #55
0
        void Start()
        {
            ship = registry.LookUp<IShip>("Ship");

            planet = registry.LookUp<IPlanet>("Planet");
        }
 private void savePlanet(int index, IPlanet value)
 {
 }
 public void Show()
 {
     _planet = _planetFactory.Create(DoubleVector3.Zero, PhysicalConstants.RadiusOfEarth);
     _cameraController.AttachToPlanet(_planet);
     _windowManager.ShowAllWindows();
 }
Exemple #58
0
        public SceneControl(ScreenComponent manager, string style = "")
            : base(manager, style)
        {
            player = manager.Player;
            camera = manager.Camera;
            assets = manager.Game.Assets;

            Manager = manager;

            simpleShader = manager.Game.Content.Load<Effect>("simple");
            sunTexture = assets.LoadTexture(typeof(ScreenComponent), "sun");

            //List<Bitmap> bitmaps = new List<Bitmap>();
            var definitions = DefinitionManager.Instance.GetBlockDefinitions();
            int textureCount = 0;
            foreach (var definition in definitions)
            {
                textureCount += definition.Textures.Length;
            }
            int bitmapSize = 128;
            blockTextures = new Texture2DArray(manager.GraphicsDevice, 1, bitmapSize, bitmapSize, textureCount);
            int layer = 0;
            foreach (var definition in definitions)
            {
                foreach (var bitmap in definition.Textures)
                {
                    System.Drawing.Bitmap texture = manager.Game.Assets.LoadBitmap(definition.GetType(), bitmap);

                    var scaled = texture;//new Bitmap(bitmap, new System.Drawing.Size(bitmapSize, bitmapSize));
                    int[] data = new int[scaled.Width * scaled.Height];
                    var bitmapData = scaled.LockBits(new System.Drawing.Rectangle(0, 0, scaled.Width, scaled.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
                    System.Runtime.InteropServices.Marshal.Copy(bitmapData.Scan0, data, 0, data.Length);
                    blockTextures.SetData(data, layer);
                    scaled.UnlockBits(bitmapData);
                    layer++;
                }
            }

            /*int size = (int)Math.Ceiling(Math.Sqrt(bitmaps.Count));
            Bitmap blocks = new Bitmap(size * TEXTURESIZE, size * TEXTURESIZE);
            using (Graphics g = Graphics.FromImage(blocks))
            {
                int counter = 0;
                foreach (var bitmap in bitmaps)
                {
                    int x = counter % size;
                    int y = (int)(counter / size);
                    g.DrawImage(bitmap, new System.Drawing.Rectangle(TEXTURESIZE * x, TEXTURESIZE * y, TEXTURESIZE, TEXTURESIZE));
                    counter++;
                }
            }

            using (MemoryStream stream = new MemoryStream())
            {
                blocks.Save(stream, ImageFormat.Png);
                stream.Seek(0, SeekOrigin.Begin);
                blockTextures = Texture2D.FromStream(manager.GraphicsDevice, stream);
            }*/

            planet = ResourceManager.Instance.GetPlanet(0);

            // TODO: evtl. Cache-Size (Dimensions) VIEWRANGE + 1

            int range = ((int)Math.Pow(2, VIEWRANGE) - 2) / 2;
            localChunkCache = new LocalChunkCache(ResourceManager.Instance.GlobalChunkCache, VIEWRANGE, range);

            chunkRenderer = new ChunkRenderer[
                (int)Math.Pow(2, VIEWRANGE) * (int)Math.Pow(2, VIEWRANGE),
                planet.Size.Z];
            orderedChunkRenderer = new List<ChunkRenderer>(
                (int)Math.Pow(2, VIEWRANGE) * (int)Math.Pow(2, VIEWRANGE) * planet.Size.Z);

            for (int i = 0; i < chunkRenderer.GetLength(0); i++)
            {
                for (int j = 0; j < chunkRenderer.GetLength(1); j++)
                {
                    ChunkRenderer renderer = new ChunkRenderer(simpleShader, manager.GraphicsDevice, camera.Projection, blockTextures);
                    chunkRenderer[i, j] = renderer;
                    orderedChunkRenderer.Add(renderer);
                }
            }

            backgroundThread = new Thread(BackgroundLoop);
            backgroundThread.Priority = ThreadPriority.Lowest;
            backgroundThread.IsBackground = true;
            backgroundThread.Start();

            var selectionVertices = new[]
            {
                new VertexPositionColor(new Vector3(-0.001f, +1.001f, +1.001f), Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, +1.001f, +1.001f), Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, -0.001f, +1.001f), Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, -0.001f, +1.001f), Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, +1.001f, -0.001f), Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, +1.001f, -0.001f), Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, -0.001f, -0.001f), Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, -0.001f, -0.001f), Color.Black * 0.5f),
            };

            var billboardVertices = new[]
            {
                new VertexPositionTexture(new Vector3(-0.5f, 0.5f, 0), new Vector2(0, 0)),
                new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
                new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
                new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
                new VertexPositionTexture(new Vector3(0.5f, -0.5f, 0), new Vector2(1, 1)),
                new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
            };

            var selectionIndices = new short[]
            {
                0, 1, 0, 2, 1, 3, 2, 3,
                4, 5, 4, 6, 5, 7, 6, 7,
                0, 4, 1, 5, 2, 6, 3, 7
            };

            selectionLines = new VertexBuffer(manager.GraphicsDevice, VertexPositionColor.VertexDeclaration, selectionVertices.Length);
            selectionLines.SetData(selectionVertices);

            selectionIndexBuffer = new IndexBuffer(manager.GraphicsDevice, DrawElementsType.UnsignedShort, selectionIndices.Length);
            selectionIndexBuffer.SetData(selectionIndices);

            billboardVertexbuffer = new VertexBuffer(manager.GraphicsDevice, VertexPositionTexture.VertexDeclaration, billboardVertices.Length);
            billboardVertexbuffer.SetData(billboardVertices);

            sunEffect = new BasicEffect(manager.GraphicsDevice);
            sunEffect.TextureEnabled = true;

            selectionEffect = new BasicEffect(manager.GraphicsDevice);
            selectionEffect.VertexColorEnabled = true;

            MiniMapTexture = new RenderTarget2D(manager.GraphicsDevice, 128, 128, PixelInternalFormat.Rgb8); // , false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PreserveContents);
            miniMapProjectionMatrix = Matrix.CreateOrthographic(128, 128, 1, 10000);
        }
        public SceneControl(ScreenComponent manager, string style = "")
            : base(manager, style)
        {
            player = manager.Player;
            camera = manager.Camera;

            Manager = manager;

            simpleShader = manager.Game.Content.Load<Effect>("simple");
            sunTexture = manager.Game.Content.Load<Texture2D>("Textures/sun");

            List<Bitmap> bitmaps = new List<Bitmap>();
            var definitions = DefinitionManager.GetBlockDefinitions();
            foreach (var definition in definitions)
                bitmaps.AddRange(definition.Textures);

            int size = (int)Math.Ceiling(Math.Sqrt(bitmaps.Count));
            Bitmap blocks = new Bitmap(size * TEXTURESIZE, size * TEXTURESIZE);
            using (Graphics g = Graphics.FromImage(blocks))
            {
                int counter = 0;
                foreach (var bitmap in bitmaps)
                {
                    int x = counter % size;
                    int y = (int)(counter / size);
                    g.DrawImage(bitmap, new System.Drawing.Rectangle(TEXTURESIZE * x, TEXTURESIZE * y, TEXTURESIZE, TEXTURESIZE));
                    counter++;
                }
            }

            using (MemoryStream stream = new MemoryStream())
            {
                blocks.Save(stream, ImageFormat.Png);
                stream.Seek(0, SeekOrigin.Begin);
                blockTextures = Texture2D.FromStream(manager.GraphicsDevice, stream);
            }

            planet = ResourceManager.Instance.GetPlanet(0);

            _manager = ResourceManager.Instance.GetManagerForPlanet(planet.Id);

            chunkRenderer = new ChunkRenderer[
                (int)Math.Pow(2, VIEWRANGE) * (int)Math.Pow(2, VIEWRANGE),
                planet.Size.Z];

            for (int i = 0; i < chunkRenderer.GetLength(0); i++)
                for (int j = 0; j < chunkRenderer.GetLength(1); j++)
                    chunkRenderer[i, j] = new ChunkRenderer(simpleShader, manager.GraphicsDevice, camera.Projection, blockTextures);

            // Entfernungsarray erzeugen
            //for (int x = -VIEWRANGE; x <= VIEWRANGE; x++)
            //    for (int y = -VIEWRANGE; y <= VIEWRANGE; y++)
            //        for (int z = 0; z <= planet.Size.Z; z++)
            //            distances.Add(new Index3(x, y, z));
            //distances = distances.OrderBy(d => d.LengthSquared()).ToList();

            backgroundThread = new Thread(BackgroundLoop);
            backgroundThread.Priority = ThreadPriority.Lowest;
            backgroundThread.IsBackground = true;
            backgroundThread.Start();

            selectionLines = new[]
            {
                new VertexPositionColor(new Vector3(-0.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, +1.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, -0.001f, +1.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, +1.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(-0.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
                new VertexPositionColor(new Vector3(+1.001f, -0.001f, -0.001f), Microsoft.Xna.Framework.Color.Black * 0.5f),
            };

            billboardVertices = new[]
            {
                new VertexPositionTexture(new Vector3(-0.5f, 0.5f, 0), new Vector2(0, 0)),
                new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
                new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
                new VertexPositionTexture(new Vector3(0.5f, 0.5f, 0), new Vector2(1, 0)),
                new VertexPositionTexture(new Vector3(0.5f, -0.5f, 0), new Vector2(1, 1)),
                new VertexPositionTexture(new Vector3(-0.5f, -0.5f, 0), new Vector2(0, 1)),
            };

            selectionIndeces = new short[]
            {
                0, 1, 0, 2, 1, 3, 2, 3,
                4, 5, 4, 6, 5, 7, 6, 7,
                0, 4, 1, 5, 2, 6, 3, 7
            };

            sunEffect = new BasicEffect(manager.GraphicsDevice);
            sunEffect.TextureEnabled = true;

            selectionEffect = new BasicEffect(manager.GraphicsDevice);
            selectionEffect.VertexColorEnabled = true;

            MiniMapTexture = new RenderTarget2D(manager.GraphicsDevice, 128, 128, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8); // , false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, 0, RenderTargetUsage.PreserveContents);
            miniMapProjectionMatrix = Matrix.CreateOrthographic(128, 128, 1, 10000);
        }
 public override int GetDensity(IPlanet planet, Index3 index)
 {
     return 4;
 }