public override bool Generate(CubeWorld world)
        {
            int fromY = fromYRV.EvaluateInt(world);
            int toY   = toYRV.EvaluateInt(world);

            TileManager tileManager = world.tileManager;

            Random rnd = new Random();

            for (int x = 0; x < tileManager.sizeX; x++)
            {
                for (int z = 0; z < tileManager.sizeZ; z++)
                {
                    for (int y = fromY; y < toY; y++)
                    {
                        TilePosition pos = new TilePosition(x, y, z);
                        if (tileManager.GetTileType(pos) == TileDefinition.EMPTY_TILE_TYPE)
                        {
                            int n = rnd.Next(0, probabilityRange);
                            foreach (TileTypeProbability s in probabilities)
                            {
                                if (n < s.probability)
                                {
                                    tileManager.SetTileType(pos, s.tileType);
                                    break;
                                }
                            }
                        }
                    }
                }
            }

            return(true);
        }
		public DayCycleManager (CubeWorld world)
		{
			this.world = world;

            this.skyColor = skyColorDay;
            this.ambientLightLuminance = Tile.MAX_LUMINANCE;
		}
Exemple #3
0
        public override bool Generate(CubeWorld world)
        {
            int fromY = fromYRV.EvaluateInt(world);
            int toY   = toYRV.EvaluateInt(world);

            TileManager tileManager = world.tileManager;

            for (int x = 0; x < tileManager.sizeX; x++)
            {
                for (int z = 0; z < tileManager.sizeZ; z++)
                {
                    int y = tileManager.GetTopPosition(x, z);

                    if (tileManager.GetTileType(new TilePosition(x, y, z)) != TileDefinition.EMPTY_TILE_TYPE)
                    {
                        y++;
                    }

                    if (y >= fromY)
                    {
                        for (int i = y; i < toY; i++)
                        {
                            tileManager.SetTileType(new TilePosition(x, i, z), waterTileType);
                        }
                    }
                }
            }

            return(true);
        }
        public override bool Generate(CubeWorld world)
        {
            int fromY = fromYRV.EvaluateInt(world);
            int toY = toYRV.EvaluateInt(world);

			TileManager tileManager = world.tileManager;
			
            Random rnd = new Random();

            for (int x = 0; x < tileManager.sizeX; x++)
                for (int z = 0; z < tileManager.sizeZ; z++)
                    for (int y = fromY; y < toY; y++)
                    {
                        TilePosition pos = new TilePosition(x, y, z);
                        if (tileManager.GetTileType(pos) == TileDefinition.EMPTY_TILE_TYPE)
                        {
                            int n = rnd.Next(0, probabilityRange);
                            foreach (TileTypeProbability s in probabilities)
                            {
                                if (n < s.probability)
                                {
                                    tileManager.SetTileType(pos, s.tileType);
                                    break;
                                }
                            }
                        }
                    }

            return true;
        }
        public override bool Generate(CubeWorld world)
        {
            Random random = new Random();

            int iterations = iterationsRV.EvaluateInt(world);
            int minRadius  = minRadiusRV.EvaluateInt(world);
            int maxRadius  = maxRadiusRV.EvaluateInt(world);

            TileManager tileManager = world.tileManager;

            for (int i = 0; i < iterations; i++)
            {
                int cx = random.Next(maxRadius + 1, tileManager.sizeX - maxRadius - 1);
                int cz = random.Next(maxRadius + 1, tileManager.sizeZ - maxRadius - 1);

                int radius = random.Next(minRadius, maxRadius);

                int sum = 0;

                for (int x = cx - radius; x < cx + radius; x++)
                {
                    for (int z = cz - radius; z < cz + radius; z++)
                    {
                        sum += tileManager.GetTopPosition(x, z);
                    }
                }

                int avg = sum / (radius * 2 * radius * 2);

                for (int x = cx - radius; x < cx + radius; x++)
                {
                    for (int z = cz - radius; z < cz + radius; z++)
                    {
                        int y = tileManager.GetTopPosition(x, z);

                        if (avg - y < -1 || avg - y > 1)
                        {
                            if (y > avg)
                            {
                                //Remove tiles
                                for (int dy = avg + 1; dy <= y; dy++)
                                {
                                    tileManager.SetTileType(new TilePosition(x, dy, z), 0);
                                }
                            }
                            else if (y < avg)
                            {
                                //Add tiles
                                for (int dy = y; dy <= avg; dy++)
                                {
                                    tileManager.SetTileType(new TilePosition(x, dy, z), tileType);
                                }
                            }
                        }
                    }
                }
            }

            return(true);
        }
Exemple #6
0
        private void PlantTree(int x, int z, CubeWorld world)
        {
            TileManager tileManager = world.tileManager;

            int topY = tileManager.GetTopPosition(x, z);

            if (topY < tileManager.sizeY - (maxTrunkHeight + maxLeavesHeight) * 2)
            {
                if (tileManager.GetTileType(new TilePosition(x, topY, z)) == overTileType)
                {
                    topY++;

                    int trunkHeight  = generator.Next(minTrunkHeight, maxTrunkHeight + 1);
                    int leavesHeight = generator.Next(minLeavesHeight, maxLeavesHeight + 1);
                    int leavesRadius = generator.Next(minLeavesRadius, maxLeavesRadius + 1);

                    int treeHeight = trunkHeight + leavesHeight;

                    if (FreeSpaceAvailable(x, topY, z, leavesRadius, treeHeight, world))
                    {
                        CreateTree(x, topY, z, trunkHeight, leavesHeight, leavesRadius, world);
                    }
                }
            }
        }
        public float Evaluate(CubeWorld world)
        {
            switch (relativeTo)
            {
            case RelativeTo.Nothing:
                return(value);

            case RelativeTo.SizeX:
                return(world.sizeX * value);

            case RelativeTo.SizeY:
                return(world.sizeY * value);

            case RelativeTo.SizeZ:
                return(world.sizeZ * value);

            case RelativeTo.SizeXY:
                return((world.sizeX * world.sizeY) * value);

            case RelativeTo.SizeXZ:
                return((world.sizeX * world.sizeZ) * value);

            case RelativeTo.SizeYZ:
                return((world.sizeY * world.sizeZ) * value);

            case RelativeTo.SizeVolumen:
                return((world.sizeX * world.sizeY * world.sizeZ) * value);
            }

            return(0);
        }
        public override bool Generate(CubeWorld world)
        {
			TileManager tileManager = world.tileManager;
			
            int fromY = fromYRV.EvaluateInt(world);
            int toY = toYRV.EvaluateInt(world);
			
			//C3DPerlinNoise.Init();
			int seed = new Random().Next();
			
			int cutY = (int) (fromY + (toY - fromY) * 0.7f);
			
            for (int x = 0; x < tileManager.sizeX; x++)
			{
                for (int z = 0; z < tileManager.sizeZ; z++)
				{
					float d = GetRandomHeight(x, z, 1.0f, freq, 1.0f, 0.5f, octaves, seed);
					
					int y = (int) (fromY + d * (toY - fromY)) - 1;
					
					if (y > cutY)
						y = cutY;
					else if (y < fromY - 1)
						y = fromY - 1;

                    while (y >= fromY)
                        tileManager.SetTileType(new TilePosition(x, y--, z), tileType);
				}
			}
			
			NoiseInitialized = false;

            return true;
        }
Exemple #9
0
        public DayCycleManager(CubeWorld world)
        {
            this.world = world;

            this.skyColor = skyColorDay;
            this.ambientLightLuminance = Tile.MAX_LUMINANCE;
        }
        public float Evaluate(CubeWorld world)
        {
            switch (relativeTo)
            {
                case RelativeTo.Nothing:
                    return value;

                case RelativeTo.SizeX:
                    return world.sizeX * value;
                case RelativeTo.SizeY:
                    return world.sizeY * value;
                case RelativeTo.SizeZ:
                    return world.sizeZ * value;

                case RelativeTo.SizeXY:
                    return (world.sizeX * world.sizeY) * value;
                case RelativeTo.SizeXZ:
                    return (world.sizeX * world.sizeZ) * value;
                case RelativeTo.SizeYZ:
                    return (world.sizeY * world.sizeZ) * value;

                case RelativeTo.SizeVolumen:
                    return (world.sizeX * world.sizeY * world.sizeZ) * value;
            }

            return 0;
        }
        private void CreateLevel(CubeWorld world, int level)
        {
            int floor_y   = level * LEVEL_HEIGHT;
            int ceiling_y = level * (LEVEL_HEIGHT + 1);

            //Create floor
            for (int x = 0; x < world.sizeX; x++)
            {
                for (int z = 0; z < world.sizeZ; z++)
                {
                    world.tileManager.SetTileType(new TilePosition(x, floor_y, z), tileTypeHardRock);
                }
            }

            //Create walls
            for (int y = floor_y; y < ceiling_y; y++)
            {
                for (int z = 0; z < world.sizeZ; z++)
                {
                    world.tileManager.SetTileType(new TilePosition(0, y, z), tileTypeHardRock);
                    world.tileManager.SetTileType(new TilePosition(world.sizeX - 1, y, z), tileTypeHardRock);
                }
            }
            for (int y = floor_y; y < ceiling_y; y++)
            {
                for (int x = 0; x < world.sizeX; x++)
                {
                    world.tileManager.SetTileType(new TilePosition(x, y, 0), tileTypeHardRock);
                    world.tileManager.SetTileType(new TilePosition(x, y, world.sizeZ - 1), tileTypeHardRock);
                }
            }
        }
        public override bool Generate(CubeWorld world)
        {
            int fromY = fromYRV.EvaluateInt(world);
            int toY = toYRV.EvaluateInt(world);

			TileManager tileManager = world.tileManager;
			
            for (int x = 0; x < tileManager.sizeX; x++)
            {
                for (int z = 0; z < tileManager.sizeZ; z++)
                {
                    int y = tileManager.GetTopPosition(x, z);

                    if (tileManager.GetTileType(new TilePosition(x, y, z)) != TileDefinition.EMPTY_TILE_TYPE)
                        y++;

                    if (y >= fromY)
                    {
                        for (int i = y; i < toY; i++)
                            tileManager.SetTileType(new TilePosition(x, i, z), waterTileType);
                    }
                }
            }

            return true;
        }
        public override CubeWorld.World.Generator.GeneratorProcess Generate(CubeWorld.Configuration.Config config)
        {
            RoguelikeWorldGenerator generator = new RoguelikeWorldGenerator(world);

            this.playerStartPosition = generator.playerStartPosition;

            return world.tileManager.Generate(generator);
        }
        public override bool Generate(CubeWorld world)
        {
            InitTileTypes(world);

            CreateBasicLevels(world);

            return true;
        }
 public RoguelikeWorldGenerator(CubeWorld world)
 {
     playerStartPosition =
         new TilePosition(
             LEVEL_HEIGHT / 2,
             world.sizeY - LEVEL_HEIGHT + 3,
             LEVEL_HEIGHT / 2);
 }
        public override bool Generate(CubeWorld world)
        {
            InitTileTypes(world);

            CreateBasicLevels(world);

            return(true);
        }
Exemple #17
0
    public void Test_GetChunkPos()
    {
        Assert.IsTrue(Chunk.CHUNK_SIZE > 1);
        Assert.AreEqual(CubeWorld.GetChunkPos(new Vector3Int(0, 1, Chunk.CHUNK_SIZE - 1)), new Vector2Int(0, 0));

        Assert.AreEqual(CubeWorld.GetChunkPos(new Vector3Int(-1, 0, 0)), new Vector2Int(-1, 0));
        Assert.AreEqual(CubeWorld.GetChunkPos(new Vector3Int(-Chunk.CHUNK_SIZE, 0, 0)), new Vector2Int(-1, 0));
    }
 public RoguelikeWorldGenerator(CubeWorld world)
 {
     playerStartPosition =
         new TilePosition(
             LEVEL_HEIGHT / 2,
             world.sizeY - LEVEL_HEIGHT + 3,
             LEVEL_HEIGHT / 2);
 }
Exemple #19
0
        public GeneratorProcess(CubeWorldGenerator generator, CubeWorld world)
        {
            this.finished  = false;
            this.generator = generator;
            this.world     = world;

            generator.Prepare();
            totalCost = generator.GetTotalCost();
        }
        public override bool Generate(CubeWorld world)
        {
            int iterations = iterationsRV.EvaluateInt(world);
            int minRadius  = minRadiusRV.EvaluateInt(world);
            int maxRadius  = maxRadiusRV.EvaluateInt(world);
            int minDepth   = minDepthRV.EvaluateInt(world);
            int maxDepth   = maxDepthRV.EvaluateInt(world);

            TileManager tileManager = world.tileManager;

            Random random = new Random();

            for (int i = 0; i < iterations; i++)
            {
                int cx = random.Next(maxRadius + 1, tileManager.sizeX - maxRadius - 1);
                int cz = random.Next(maxRadius + 1, tileManager.sizeZ - maxRadius - 1);

                int radiusX = random.Next(minRadius, maxRadius);
                int radiusZ = random.Next(minRadius, maxRadius);

                int depth = random.Next(minDepth, maxDepth);

                int sum = 0;

                for (int x = cx - radiusX; x < cx + radiusX; x++)
                {
                    for (int z = cz - radiusZ; z < cz + radiusZ; z++)
                    {
                        sum += tileManager.GetTopPosition(x, z);
                    }
                }

                int avg = sum / (radiusX * 2 * radiusZ * 2);

                if (avg - depth > 1)
                {
                    for (int x = cx - radiusX; x < cx + radiusX; x++)
                    {
                        for (int z = cz - radiusZ; z < cz + radiusZ; z++)
                        {
                            int y = tileManager.GetTopPosition(x, z);

                            if (y > avg - depth)
                            {
                                //Remove tiles
                                for (int dy = (avg - depth) + 1; dy <= y; dy++)
                                {
                                    tileManager.SetTileType(new TilePosition(x, dy, z), 0);
                                }
                            }
                        }
                    }
                }
            }

            return(true);
        }
        public GeneratorProcess(CubeWorldGenerator generator, CubeWorld world)
        {
            this.finished = false;
            this.generator = generator;
            this.world = world;

            generator.Prepare();
            totalCost = generator.GetTotalCost();
        }
Exemple #22
0
    public void Test_GetBlockPos()
    {
        float cubeSize = CubeWorld.CUBE_SIZE;

        Assert.AreEqual(CubeWorld.GetBlockPos(new Vector3(1, 2, 3) * cubeSize), new Vector3Int(1, 2, 3));
        Assert.AreEqual(CubeWorld.GetBlockPos(new Vector3(1.01f, 2.99f, 3.5f) * cubeSize), new Vector3Int(1, 2, 3));

        Assert.AreEqual(CubeWorld.GetBlockPos(new Vector3(-1.5f, 0f, 3.5f) * cubeSize), new Vector3Int(-2, 0, 3));
    }
Exemple #23
0
    bool CanBuild(Vector3Int blockPos)
    {
        Vector3Int playerBlockPos = CubeWorld.GetBlockPos(gameObject.transform.position);

        if (blockPos.x == playerBlockPos.x && blockPos.z == playerBlockPos.z &&
            Mathf.Abs(playerBlockPos.y - blockPos.y) <= 2)
        {
            return(false);            //prevent building inside yourself and falling through the new mesh
        }
        return(world.GetBlockType(blockPos) == BLOCK_AIR);
    }
Exemple #24
0
        public virtual void Clear()
        {
            if (components != null)
            {
                foreach (CWComponent component in components)
                    component.RemovedFromObject();

                components.Clear();
            }

            world = null;
        }
Exemple #25
0
    public void Test_GetChunkOffset()
    {
        Assert.IsTrue(Chunk.CHUNK_SIZE > 1);
        Assert.AreEqual(CubeWorld.GetChunkOffset(new Vector3Int(1, 2, 3)), new Vector3Int(1, 2, 3));
        Assert.AreEqual(CubeWorld.GetChunkOffset(new Vector3Int(Chunk.CHUNK_SIZE + 1, 2, 3)), new Vector3Int(1, 2, 3));

        Assert.AreEqual(CubeWorld.GetChunkOffset(new Vector3Int(-1, 0, 0)), new Vector3Int(15, 0, 0));
        Assert.AreEqual(CubeWorld.GetChunkOffset(new Vector3Int(-15, 0, 0)), new Vector3Int(1, 0, 0));
        Assert.AreEqual(CubeWorld.GetChunkOffset(new Vector3Int(-16, 0, 0)), new Vector3Int(0, 0, 0));
        Assert.AreEqual(CubeWorld.GetChunkOffset(new Vector3Int(-17, 0, 0)), new Vector3Int(15, 0, 0));
        Assert.AreEqual(CubeWorld.GetChunkOffset(new Vector3Int(-32, 0, 0)), new Vector3Int(0, 0, 0));
    }
        public override bool Generate(CubeWorld world)
        {
            Random random = new Random();

            int iterations = iterationsRV.EvaluateInt(world);
            int minRadius = minRadiusRV.EvaluateInt(world);
            int maxRadius = maxRadiusRV.EvaluateInt(world);

			TileManager tileManager = world.tileManager;
			
            for (int i = 0; i < iterations; i++)
            {
                int cx = random.Next(maxRadius + 1, tileManager.sizeX - maxRadius - 1);
                int cz = random.Next(maxRadius + 1, tileManager.sizeZ - maxRadius - 1);

                int radius = random.Next(minRadius, maxRadius);

                int sum = 0;

                for (int x = cx - radius; x < cx + radius; x++)
                    for (int z = cz - radius; z < cz + radius; z++)
                        sum += tileManager.GetTopPosition(x, z);

                int avg = sum / (radius * 2 * radius * 2);

                for (int x = cx - radius; x < cx + radius; x++)
                {
                    for (int z = cz - radius; z < cz + radius; z++)
                    {
                        int y = tileManager.GetTopPosition(x, z);

                        if (avg - y < -1 || avg - y > 1)
                        {
                            if (y > avg)
                            {
                                //Remove tiles
                                for (int dy = avg + 1; dy <= y; dy++)
                                    tileManager.SetTileType(new TilePosition(x, dy, z), 0);
                            }
                            else if (y < avg)
                            {
                                //Add tiles
                                for (int dy = y; dy <= avg; dy++)
                                    tileManager.SetTileType(new TilePosition(x, dy, z), tileType);
                            }
                        }
                    }
                }
            }

            return true;
        }
        private void CreateBasicLevels(CubeWorld world)
        {
            for (int level = 0; level < world.sizeY / LEVEL_HEIGHT; level++)
                CreateLevel(world, level);

            //Create ceiling
            for (int x = 0; x < world.sizeX; x++)
                for (int z = 0; z < world.sizeZ; z++)
                    if (x % 3 == 0 && z % 3 == 0)
                        world.tileManager.SetTileType(new TilePosition(x, world.sizeY - 1, z), tileTypeCeilingGlass);
                    else
                        world.tileManager.SetTileType(new TilePosition(x, world.sizeY - 1, z), tileTypeHardRock);
        }
        public override bool Generate(CubeWorld world)
        {
            if (currentGeneratorIndex < generators.Count)
            {
                if (generators[currentGeneratorIndex].Generate(world) == true)
                {
                    currentCost += generators[currentGeneratorIndex].GetTotalCost();
                    currentGeneratorIndex++;
                }
            }

            return currentGeneratorIndex == generators.Count;
        }
        public override void Init(CubeWorld.World.CubeWorld world)
        {
            base.Init(world);

            stats = MultiplayerStats.Singleton;
            stats.Reset();
            stats.serverMode = true;
            stats.connected = true;

            baseGameplay.Init(world);

            server = new MultiplayerServer(9999, this, this);
        }
        public override bool Generate(CubeWorld world)
        {
            if (currentGeneratorIndex < generators.Count)
            {
                if (generators[currentGeneratorIndex].Generate(world) == true)
                {
                    currentCost += generators[currentGeneratorIndex].GetTotalCost();
                    currentGeneratorIndex++;
                }
            }

            return(currentGeneratorIndex == generators.Count);
        }
        public override bool Generate(CubeWorld world)
        {
            int iterations = iterationsRV.EvaluateInt(world);
            int minRadius = minRadiusRV.EvaluateInt(world);
            int maxRadius = maxRadiusRV.EvaluateInt(world);
            int minDepth = minDepthRV.EvaluateInt(world);
            int maxDepth = maxDepthRV.EvaluateInt(world);
			
			TileManager tileManager = world.tileManager;

            Random random = new Random();

            for (int i = 0; i < iterations; i++)
            {
                int cx = random.Next(maxRadius + 1, tileManager.sizeX - maxRadius - 1);
                int cz = random.Next(maxRadius + 1, tileManager.sizeZ - maxRadius - 1);

                int radiusX = random.Next(minRadius, maxRadius);
                int radiusZ = random.Next(minRadius, maxRadius);

                int depth = random.Next(minDepth, maxDepth);

                int sum = 0;

                for (int x = cx - radiusX; x < cx + radiusX; x++)
                    for (int z = cz - radiusZ; z < cz + radiusZ; z++)
                        sum += tileManager.GetTopPosition(x, z);

                int avg = sum / (radiusX * 2 * radiusZ * 2);

                if (avg - depth > 1)
                {
                    for (int x = cx - radiusX; x < cx + radiusX; x++)
                    {
                        for (int z = cz - radiusZ; z < cz + radiusZ; z++)
                        {
                            int y = tileManager.GetTopPosition(x, z);

                            if (y > avg - depth)
                            {
                                //Remove tiles
                                for (int dy = (avg - depth) + 1; dy <= y; dy++)
                                    tileManager.SetTileType(new TilePosition(x, dy, z), 0);
                            }
                        }
                    }
                }
            }

            return true;
        }
Exemple #32
0
        public virtual void Clear()
        {
            if (components != null)
            {
                foreach (CWComponent component in components)
                {
                    component.RemovedFromObject();
                }

                components.Clear();
            }

            world = null;
        }
Exemple #33
0
        public override bool Generate(CubeWorld world)
        {
            if (offInitialized == false)
            {
                Random rnd = new Random();
                offX           = rnd.Next(0, 9999999);
                offY           = rnd.Next(0, 9999999);
                offInitialized = true;
            }

            TileManager tileManager = world.tileManager;

            int fromY = fromYRV.EvaluateInt(world);
            int toY   = toYRV.EvaluateInt(world);

            int cutY = (int)(fromY + (toY - fromY) * 0.9f);
            int midY = fromY + (toY - fromY) / 2;

            for (int x = 0; x < tileManager.sizeX; x++)
            {
                for (int z = 0; z < tileManager.sizeZ; z++)
                {
                    float d = FBM(x + offX, z + offY, octaves, 0.5f, freq, 1.0f / octaves, 2.0f);
                    //float d = MultiFractal(x, z, octaves, 0.5f, freq, 1.0f, 2.0f, 1.0f);

                    int y = midY + (int)(d * (toY - fromY));

                    //This line below can be used to make calderas
                    //if (y > cutY)
                    //    y = cutY - (y - cutY);

                    if (y > cutY)
                    {
                        y = cutY;
                    }
                    else if (y < fromY - 1)
                    {
                        y = fromY - 1;
                    }

                    while (y >= fromY)
                    {
                        tileManager.SetTileType(new TilePosition(x, y--, z), tileType);
                    }
                }
            }


            return(true);
        }
        public override bool Generate(CubeWorld world)
        {
            int iterations = iterationsRV.EvaluateInt(world);
            int minRadius  = minRadiusRV.EvaluateInt(world);
            int maxRadius  = maxRadiusRV.EvaluateInt(world);
            int fromY      = fromYRV.EvaluateInt(world);
            int toY        = toYRV.EvaluateInt(world);

            TileManager tileManager = world.tileManager;

            Random random = new Random();

            for (int i = 0; i < iterations; i++)
            {
                int cx = random.Next(maxRadius + 1, tileManager.sizeX - maxRadius - 1);
                int cy = random.Next(maxRadius + 1, tileManager.sizeY - maxRadius - 1);
                int cz = random.Next(maxRadius + 1, tileManager.sizeZ - maxRadius - 1);

                int radiusX = random.Next(minRadius, maxRadius);
                int radiusY = random.Next(minRadius, maxRadius);
                int radiusZ = random.Next(minRadius, maxRadius);

                for (int x = cx - radiusX; x < cx + radiusX; x++)
                {
                    for (int z = cz - radiusZ; z < cz + radiusZ; z++)
                    {
                        for (int y = cy - radiusY; y < cy + radiusY; y++)
                        {
                            if (y >= fromY && y < toY)
                            {
                                if (random.NextDouble() > 0.25)
                                {
                                    if (allowEmptyAbove || y == tileManager.sizeY || tileManager.GetTileType(new TilePosition(x, y + 1, z)) != TileDefinition.EMPTY_TILE_TYPE)
                                    {
                                        if (tileManager.GetTileType(new TilePosition(x, y, z)) == overTile)
                                        {
                                            tileManager.SetTileType(new TilePosition(x, y, z), tileType);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            return(true);
        }
Exemple #35
0
        public override bool Generate(CubeWorld world)
        {
            int trees = generator.Next(minRV.EvaluateInt(world), maxRV.EvaluateInt(world));

            TileManager tileManager = world.tileManager;

            for (int i = 0; i < trees; i++)
            {
                int x = generator.Next(maxLeavesRadius * 2, tileManager.sizeX - maxLeavesRadius * 2);
                int z = generator.Next(maxLeavesRadius * 2, tileManager.sizeZ - maxLeavesRadius * 2);

                PlantTree(x, z, world);
            }

            return(true);
        }
        public override bool Generate(CubeWorld world)
        {
            int trees = generator.Next(minRV.EvaluateInt(world), maxRV.EvaluateInt(world));

			TileManager tileManager = world.tileManager;
			
            for (int i = 0; i < trees; i++)
            {
                int x = generator.Next(maxLeavesRadius * 2, tileManager.sizeX - maxLeavesRadius * 2);
                int z = generator.Next(maxLeavesRadius * 2, tileManager.sizeZ - maxLeavesRadius * 2);

                PlantTree(x, z, world);
            }

            return true;
        }
Exemple #37
0
    /// <summary>
    /// Get cube after raycast hit from camera
    /// </summary>
    bool GetAimpointNextBlock(out Vector3Int blockPos)
    {
        //raycast to find block empty block position
        Ray        ray = new Ray(Camera.main.transform.position, Camera.main.transform.forward);
        RaycastHit hit;

        if (Physics.Raycast(ray, out hit, distanceLimit))
        {
            //move hit position to roughly be in previous block
            hit.point -= (hit.normal * 0.1f);
            blockPos   = CubeWorld.GetBlockPos(hit.point);
            return(true);
        }

        blockPos = new Vector3Int();
        return(false);
    }
        public override bool Generate(CubeWorld world)
        {
            int fromY = fromYRV.EvaluateInt(world);
            int toY = toYRV.EvaluateInt(world);
			
			TileManager tileManager = world.tileManager;
			
            for (int x = 0; x < tileManager.sizeX; x++)
                for (int z = 0; z < tileManager.sizeZ; z++)
                    for (int y = fromY; y < toY; y++)
                    {
                        TilePosition pos = new TilePosition(x, y, z);
                        if (tileManager.GetTileType(pos) == TileDefinition.EMPTY_TILE_TYPE)
                            tileManager.SetTileType(pos, tileType);
                    }

            return true;
        }
        public override bool Generate(CubeWorld world)
        {
			if (offInitialized == false)
			{
				Random rnd = new Random();
				offX = rnd.Next(0, 9999999);
				offY = rnd.Next(0, 9999999);
				offInitialized = true;
			}

			TileManager tileManager = world.tileManager;
			
            int fromY = fromYRV.EvaluateInt(world);
            int toY = toYRV.EvaluateInt(world);
			
			int cutY = (int) (fromY + (toY - fromY) * 0.9f);
            int midY = fromY + (toY - fromY) / 2;
			
            for (int x = 0; x < tileManager.sizeX; x++)
			{
                for (int z = 0; z < tileManager.sizeZ; z++)
				{
                    float d = FBM(x + offX, z + offY, octaves, 0.5f, freq, 1.0f / octaves, 2.0f);
                    //float d = MultiFractal(x, z, octaves, 0.5f, freq, 1.0f, 2.0f, 1.0f);
					
					int y = midY + (int) (d * (toY - fromY));

                    //This line below can be used to make calderas
                    //if (y > cutY)
                    //    y = cutY - (y - cutY);  
					
					if (y > cutY)
						y = cutY;
					else if (y < fromY - 1)
						y = fromY - 1;

                    while (y >= fromY)
                        tileManager.SetTileType(new TilePosition(x, y--, z), tileType);
				}
			}
			

            return true;
        }
Exemple #40
0
    void Start()
    {
        selectedBlock = BlockRegistry.GetTypeByName("Dirt");

        var worldObject = GameObject.Find("World");

        if (worldObject)
        {
            world = worldObject.GetComponent <CubeWorld>();
        }

        placementCube = GameObject.CreatePrimitive(PrimitiveType.Cube);
        placementCube.GetComponent <MeshRenderer>().material = placementCubeMaterial;
        placementCube.GetComponent <MeshRenderer>().enabled  = false;
        placementCube.GetComponent <BoxCollider>().enabled   = false;

        //cube is slightly bigger, to prevent depth fighting
        placementCube.transform.localScale = new Vector3(CubeWorld.CUBE_SIZE, CubeWorld.CUBE_SIZE, CubeWorld.CUBE_SIZE) * 1.05f;
    }
        public override bool Generate(CubeWorld world)
        {
            TileManager tileManager = world.tileManager;

            int fromY = fromYRV.EvaluateInt(world);
            int toY   = toYRV.EvaluateInt(world);

            width  = tileManager.sizeX;
            height = tileManager.sizeZ;

            map = new float[width + 1, height + 1];

            //StartMidpointDisplacment();
            //Assign the four corners of the intial grid random color values
            //These will end up being the colors of the four corners of the applet.

            float c1, c2, c3, c4;

            c1 = (float)rnd.NextDouble();
            c2 = (float)rnd.NextDouble();
            c3 = (float)rnd.NextDouble();
            c4 = (float)rnd.NextDouble();

            DivideGrid(0, 0, width, height, c1, c2, c3, c4);

            for (int x = 0; x < tileManager.sizeX; x++)
            {
                for (int z = 0; z < tileManager.sizeZ; z++)
                {
                    float d = map[x, z];

                    int y = fromY + (int)(d * (toY - fromY));

                    while (y >= fromY)
                    {
                        tileManager.SetTileType(new TilePosition(x, y--, z), tileType);
                    }
                }
            }

            return(true);
        }
Exemple #42
0
        private bool FreeSpaceAvailable(int x, int y, int z, int radius, int height, CubeWorld world)
        {
            TileManager tileManager = world.tileManager;

            for (int dx = x - radius; dx <= x + radius; dx++)
            {
                for (int dz = z - radius; dz <= z + radius; dz++)
                {
                    for (int dy = y; dy < y + height; dy++)
                    {
                        if (tileManager.GetTileType(new TilePosition(dx, dy, dz)) != TileDefinition.EMPTY_TILE_TYPE)
                        {
                            return(false);
                        }
                    }
                }
            }

            return(true);
        }
        public override bool Generate(CubeWorld world)
        {
            int drops = generator.Next(minDropsRV.EvaluateInt(world), maxDropsRV.EvaluateInt(world));
			
			TileManager tileManager = world.tileManager;

            for (int i = 0; i < drops; i++)
            {
                int x = generator.Next(2, tileManager.sizeX - 2);
                int z = generator.Next(2, tileManager.sizeZ - 2);
                sidesToCheck = generator.Next(3, 10);

                int particles = generator.Next(minParticlesRV.EvaluateInt(world), maxParticlesRV.EvaluateInt(world));

                for (int j = 0; j < particles; j++)
                    DropParticle(x, z, world);
            }

            return true;
        }
        public override bool Generate(CubeWorld world)
        {
            Random rnd = new Random();

			TileManager tileManager = world.tileManager;
			
            for (int x = 0; x < tileManager.sizeX; x++)
            {
                for (int z = 0; z < tileManager.sizeZ; z++)
                {
                    int y = tileManager.GetTopPosition(x, z);
                    TilePosition pos = new TilePosition(x, y, z);

                    if (tileManager.GetTileType(pos) == fromType && rnd.NextDouble() <= probability)
                        tileManager.SetTileType(pos, toType);
                }
            }

            return true;
        }
        public override bool Generate(CubeWorld world)
        {
            int iterations = iterationsRV.EvaluateInt(world);
            int minRadius = minRadiusRV.EvaluateInt(world);
            int maxRadius = maxRadiusRV.EvaluateInt(world);
            int fromY = fromYRV.EvaluateInt(world);
            int toY = toYRV.EvaluateInt(world);
			
			TileManager tileManager = world.tileManager;

            Random random = new Random();

            for (int i = 0; i < iterations; i++)
            {
                int cx = random.Next(maxRadius + 1, tileManager.sizeX - maxRadius - 1);
                int cy = random.Next(maxRadius + 1, tileManager.sizeY - maxRadius - 1);
                int cz = random.Next(maxRadius + 1, tileManager.sizeZ - maxRadius - 1);

                int radiusX = random.Next(minRadius, maxRadius);
                int radiusY = random.Next(minRadius, maxRadius);
                int radiusZ = random.Next(minRadius, maxRadius);

                for (int x = cx - radiusX; x < cx + radiusX; x++)
                    for (int z = cz - radiusZ; z < cz + radiusZ; z++)
                        for (int y = cy - radiusY; y < cy + radiusY; y++)
                        {
                            if (y >= fromY && y < toY)
                            {
                                if (random.NextDouble() > 0.25)
                                {
                                    if (allowEmptyAbove || y == tileManager.sizeY || tileManager.GetTileType(new TilePosition(x, y + 1, z)) != TileDefinition.EMPTY_TILE_TYPE)
                                        if (tileManager.GetTileType(new TilePosition(x, y, z)) == overTile)
                                            tileManager.SetTileType(new TilePosition(x, y, z), tileType);
                                }
                            }
                        }
            }

            return true;
        }
        public override bool Generate(CubeWorld world)
        {
            TileManager tileManager = world.tileManager;

            int fromY = fromYRV.EvaluateInt(world);
            int toY   = toYRV.EvaluateInt(world);

            //C3DPerlinNoise.Init();
            int seed = new Random().Next();

            int cutY = (int)(fromY + (toY - fromY) * 0.7f);

            for (int x = 0; x < tileManager.sizeX; x++)
            {
                for (int z = 0; z < tileManager.sizeZ; z++)
                {
                    float d = GetRandomHeight(x, z, 1.0f, freq, 1.0f, 0.5f, octaves, seed);

                    int y = (int)(fromY + d * (toY - fromY)) - 1;

                    if (y > cutY)
                    {
                        y = cutY;
                    }
                    else if (y < fromY - 1)
                    {
                        y = fromY - 1;
                    }

                    while (y >= fromY)
                    {
                        tileManager.SetTileType(new TilePosition(x, y--, z), tileType);
                    }
                }
            }

            NoiseInitialized = false;

            return(true);
        }
Exemple #47
0
        public override bool Generate(CubeWorld world)
        {
            int drops = generator.Next(minDropsRV.EvaluateInt(world), maxDropsRV.EvaluateInt(world));

            TileManager tileManager = world.tileManager;

            for (int i = 0; i < drops; i++)
            {
                int x = generator.Next(2, tileManager.sizeX - 2);
                int z = generator.Next(2, tileManager.sizeZ - 2);
                sidesToCheck = generator.Next(3, 10);

                int particles = generator.Next(minParticlesRV.EvaluateInt(world), maxParticlesRV.EvaluateInt(world));

                for (int j = 0; j < particles; j++)
                {
                    DropParticle(x, z, world);
                }
            }

            return(true);
        }
        public override bool Generate(CubeWorld world)
        {
			TileManager tileManager = world.tileManager;

            int fromY = fromYRV.EvaluateInt(world);
            int toY = toYRV.EvaluateInt(world);

            width = tileManager.sizeX;
            height = tileManager.sizeZ;

            map = new float[width + 1, height + 1];

            //StartMidpointDisplacment();
            //Assign the four corners of the intial grid random color values
            //These will end up being the colors of the four corners of the applet.		

            float c1, c2, c3, c4;
            c1 = (float)rnd.NextDouble();
            c2 = (float)rnd.NextDouble();
            c3 = (float)rnd.NextDouble();
            c4 = (float)rnd.NextDouble();

            DivideGrid(0, 0, width, height, c1, c2, c3, c4);

            for (int x = 0; x < tileManager.sizeX; x++)
            {
                for (int z = 0; z < tileManager.sizeZ; z++)
                {
                    float d = map[x, z];

                    int y = fromY + (int)(d * (toY - fromY));

                    while (y >= fromY)
                        tileManager.SetTileType(new TilePosition(x, y--, z), tileType);
                }
            }

            return true;
        }
        public override bool Generate(CubeWorld world)
        {
            Random rnd = new Random();

            TileManager tileManager = world.tileManager;

            for (int x = 0; x < tileManager.sizeX; x++)
            {
                for (int z = 0; z < tileManager.sizeZ; z++)
                {
                    int          y   = tileManager.GetTopPosition(x, z);
                    TilePosition pos = new TilePosition(x, y, z);

                    if (tileManager.GetTileType(pos) == fromType && rnd.NextDouble() <= probability)
                    {
                        tileManager.SetTileType(pos, toType);
                    }
                }
            }

            return(true);
        }
        private void PlantTree(int x, int z, CubeWorld world)
        {
			TileManager tileManager = world.tileManager;
			
			int topY = tileManager.GetTopPosition(x, z);

            if (topY < tileManager.sizeY - (maxTrunkHeight + maxLeavesHeight) * 2)
            {
                if (tileManager.GetTileType(new TilePosition(x, topY, z)) == overTileType)
                {
                    topY++;

                    int trunkHeight = generator.Next(minTrunkHeight, maxTrunkHeight + 1);
                    int leavesHeight = generator.Next(minLeavesHeight, maxLeavesHeight + 1);
                    int leavesRadius = generator.Next(minLeavesRadius, maxLeavesRadius + 1);

                    int treeHeight = trunkHeight + leavesHeight;

                    if (FreeSpaceAvailable(x, topY, z, leavesRadius, treeHeight, world))
                        CreateTree(x, topY, z, trunkHeight, leavesHeight, leavesRadius, world);
                }
            }
        }
        private void CreateBasicLevels(CubeWorld world)
        {
            for (int level = 0; level < world.sizeY / LEVEL_HEIGHT; level++)
            {
                CreateLevel(world, level);
            }

            //Create ceiling
            for (int x = 0; x < world.sizeX; x++)
            {
                for (int z = 0; z < world.sizeZ; z++)
                {
                    if (x % 3 == 0 && z % 3 == 0)
                    {
                        world.tileManager.SetTileType(new TilePosition(x, world.sizeY - 1, z), tileTypeCeilingGlass);
                    }
                    else
                    {
                        world.tileManager.SetTileType(new TilePosition(x, world.sizeY - 1, z), tileTypeHardRock);
                    }
                }
            }
        }
        private void CreateLevel(CubeWorld world, int level)
        {
            int floor_y = level * LEVEL_HEIGHT;
            int ceiling_y = level * (LEVEL_HEIGHT + 1);

            //Create floor
            for (int x = 0; x < world.sizeX; x++)
                for (int z = 0; z < world.sizeZ; z++)
                    world.tileManager.SetTileType(new TilePosition(x, floor_y, z), tileTypeHardRock);

            //Create walls
            for (int y = floor_y; y < ceiling_y; y++)
                for (int z = 0; z < world.sizeZ; z++)
                {
                    world.tileManager.SetTileType(new TilePosition(0, y, z), tileTypeHardRock);
                    world.tileManager.SetTileType(new TilePosition(world.sizeX - 1, y, z), tileTypeHardRock);
                }
            for (int y = floor_y; y < ceiling_y; y++)
                for (int x = 0; x < world.sizeX; x++)
                {
                    world.tileManager.SetTileType(new TilePosition(x, y, 0), tileTypeHardRock);
                    world.tileManager.SetTileType(new TilePosition(x, y, world.sizeZ - 1), tileTypeHardRock);
                }
        }
        public override bool Generate(CubeWorld world)
        {
            int fromY = fromYRV.EvaluateInt(world);
            int toY   = toYRV.EvaluateInt(world);

            TileManager tileManager = world.tileManager;

            for (int x = 0; x < tileManager.sizeX; x++)
            {
                for (int z = 0; z < tileManager.sizeZ; z++)
                {
                    for (int y = fromY; y < toY; y++)
                    {
                        TilePosition pos = new TilePosition(x, y, z);
                        if (tileManager.GetTileType(pos) == TileDefinition.EMPTY_TILE_TYPE)
                        {
                            tileManager.SetTileType(pos, tileType);
                        }
                    }
                }
            }

            return(true);
        }
 public SectorManager(CubeWorld.World.CubeWorld world)
 {
     this.world = world;
 }
 public virtual bool Generate(CubeWorld world)
 {
     return true;
 }
Exemple #56
0
 public Sector(CubeWorld.World.CubeWorld world, TilePosition sectorPosition, TilePosition tileOffset)
 {
     this.world = world;
     this.tileOffset = tileOffset;
     this.sectorPosition = sectorPosition;
 }
 public override void FillPlayerInventory(CubeWorld.Items.Inventory inventory)
 {
     baseGameplay.FillPlayerInventory(inventory);
 }
Exemple #58
0
 public virtual void Init(CubeWorld.World.CubeWorld world)
 {
     this.world = world;
 }
        public override bool Generate(CubeWorld world)
        {
            int iterations = iterationsRV.EvaluateInt(world);
            int minRadius = minRadiusRV.EvaluateInt(world);
            int maxRadius = maxRadiusRV.EvaluateInt(world);
            int fromY = fromYRV.EvaluateInt(world); 
            int toY = toYRV.EvaluateInt(world);
			
			TileManager tileManager = world.tileManager;

            Random random = new Random();

            for (int i = 0; i < iterations; i++)
            {
                TilePosition center = new TilePosition(
                    random.Next(maxRadius + 1, world.sizeX - maxRadius - 1),
                    random.Next(fromY, toY),
                    random.Next(maxRadius + 1, world.sizeZ - maxRadius - 1));

                TilePosition radius = new TilePosition(
                    random.Next(minRadius, maxRadius),
                    random.Next(minRadius, maxRadius),
                    random.Next(minRadius, maxRadius));

                TilePosition position = new TilePosition();

                int axis = random.Next(3);

                for (int a1 = center[axis] - radius[axis]; a1 <= center[axis] + radius[axis]; a1++)
                {
                    position[axis] = a1;

                    int axis2 = (axis + random.Next(2) + 1) % 3;
                    int axis3;
                    if (axis == 0 && axis2 == 2 || axis == 2 && axis2 == 0)
                        axis3 = 1;
                    else if (axis == 0 && axis2 == 1 || axis == 1 && axis2 == 0)
                        axis3 = 2;
                    else
                        axis3 = 0;

                    radius[axis2] += random.Next(5) - 2;

                    if (radius[axis2] < minRadius)
                        radius[axis2] = minRadius;
                    else if (radius[axis2] > maxRadius)
                        radius[axis2] = maxRadius;

                    for (int a2 = center[axis2] - radius[axis2]; a2 <= center[axis2] + radius[axis2]; a2++)
                    {
                        position[axis2] = a2;

                        radius[axis3] += random.Next(5) - 2;

                        if (radius[axis3] < minRadius)
                            radius[axis3] = minRadius;
                        else if (radius[axis3] > maxRadius)
                            radius[axis3] = maxRadius;

                        for (int a3 = center[axis3] - radius[axis3]; a3 <= center[axis3] + radius[axis3]; a3++)
                        {
                            position[axis3] = a3;

                            if (position[1] < fromY)
                                position[1] = fromY;
                            else if (position[1] > toY)
                                position[1] = toY;

                            tileManager.SetTileType(position, 0);
                        }
                    }
                }
            }

            return true;
        }
Exemple #60
0
        private void CreateTree(int treeX, int treeY, int treeZ, int trunkHeight, int leavesHeight, int leavesRadius, CubeWorld world)
        {
            TileManager tileManager = world.tileManager;

            int minX = treeX - leavesRadius;
            int maxX = treeX + leavesRadius;

            int minZ = treeZ - leavesRadius;
            int maxZ = treeZ + leavesRadius;

            int minY = treeY + trunkHeight;
            int maxY = treeY + trunkHeight + leavesHeight;

            //Leaves
            for (int y = minY; y < maxY; y++)
            {
                for (int x = minX; x <= maxX; x++)
                {
                    for (int z = minZ; z <= maxZ; z++)
                    {
                        tileManager.SetTileType(new TilePosition(x, y, z), tileTypeLeaves);
                    }
                }
            }

            //Remove extreme leaves
            tileManager.SetTileType(new TilePosition(minX, minY, minZ), 0);
            tileManager.SetTileType(new TilePosition(minX, minY, maxZ), 0);
            tileManager.SetTileType(new TilePosition(maxX, minY, maxZ), 0);
            tileManager.SetTileType(new TilePosition(maxX, minY, minZ), 0);
            tileManager.SetTileType(new TilePosition(minX, maxY - 1, minZ), 0);
            tileManager.SetTileType(new TilePosition(minX, maxY - 1, maxZ), 0);
            tileManager.SetTileType(new TilePosition(maxX, maxY - 1, maxZ), 0);
            tileManager.SetTileType(new TilePosition(maxX, maxY - 1, minZ), 0);

            //Trunk
            for (int y = treeY; y < treeY + trunkHeight + leavesHeight / 2; y++)
            {
                tileManager.SetTileType(new TilePosition(treeX, y, treeZ), tileTypeTrunk);
            }
        }