Esempio n. 1
0
        public Chunk(World world, int wx, int wy, int wz, bool createGround)
        {
            parentWorld = world;
            worldX = wx;
            worldY = wy;
            worldZ = wz;

            boundingSphere = new BoundingSphere(new Vector3(worldX * (X_SIZE * Voxel.SIZE), worldY * (Y_SIZE * Voxel.SIZE), worldZ * (Z_SIZE * Voxel.SIZE)) + (new Vector3(X_SIZE * Voxel.SIZE, Y_SIZE * Voxel.SIZE, Z_SIZE * Voxel.SIZE) / 2f), (X_SIZE * Voxel.SIZE));

            if (createGround)
            {
                for (int y = 0; y < Y_SIZE; y++)
                    for (int x = 0; x < X_SIZE; x++)
                    {
                        for (int z = Chunk.Z_SIZE - 1; z >= Chunk.Z_SIZE - 5; z--)
                        {
                            SetVoxel(x, y, z, true, 0, VoxelType.Ground, new Color(0f, 0.5f + ((float)Helper.Random.NextDouble() * 0.1f), 0f), new Color(0f, 0.3f, 0f));
                        }
                    }
            }
        }
Esempio n. 2
0
 public SaveForm(World world)
 {
     World = world;
     InitializeComponent();
 }
Esempio n. 3
0
        public static void Load(ref World gameWorld)
        {
            //string fileString = "";

            //using (StreamReader fs = new StreamReader(fn))
            //{
            //    fileString = fs.ReadToEnd();
            //}

            //fileString = Decompress(fileString);

            //string[] fileSplit = fileString.Split('\n');

            //int cl = 0;

            //string line;
            //string[] split;

            //line = fileSplit[0];
            //split = line.Split(',');

            //cl+=2;
            OpenFileDialog sfd = new OpenFileDialog();
            sfd.AddExtension = true;
            sfd.DefaultExt = ".vxl";
            sfd.Filter = "Voxel Landscape|*.vxl";
            DialogResult dr = sfd.ShowDialog();

            if (string.IsNullOrEmpty(sfd.FileName) || dr != DialogResult.OK) return;

            byte[] buffer;

            using (FileStream gstr = new FileStream(sfd.FileName, FileMode.Open))
            {
                byte[] lb = new byte[4];
                gstr.Position = gstr.Length - 4;
                gstr.Read(lb, 0,4);
                int msgLength = BitConverter.ToInt32(lb, 0);

                buffer = new byte[msgLength];

                gstr.Position = 0;

                using (GZipStream str = new GZipStream(gstr, CompressionMode.Decompress))
                {

                    str.Read(buffer, 0, msgLength);
                }
            }

            int pos = 2;

            var sw = new StreamReader(new MemoryStream(buffer));
            string codename = sw.ReadLine();
            string dispname = sw.ReadLine();
            sw.Close();

            int foundcount = 0;
            while (foundcount < 2)
            {
                pos++;
                if (buffer[pos - 2] == 13 && buffer[pos - 1] == 10) foundcount++;
            }

            int xs = buffer[pos + 2];
            int ys = buffer[pos + 3];
            int zs = buffer[pos + 4];
            gameWorld = new World(50, 50, 1, false);
            gameWorld.X_CHUNKS = xs;
            gameWorld.Y_CHUNKS = ys;
            gameWorld.Z_CHUNKS = 1;

            gameWorld.Type = (MapType)buffer[pos];
            gameWorld.Theme = (Theme)buffer[pos + 1];

            int numSpawns = buffer[pos + 5];

            pos += 6;

            for (int i = 0; i < numSpawns; i++)
            {
                Spawn s = new Spawn();
                s.Position = new Vector3(BitConverter.ToInt32(buffer, pos), BitConverter.ToInt32(buffer, pos + 4), BitConverter.ToInt32(buffer, pos + 8));
                s.Type = (SpawnType)buffer[pos + 12];
                s.Rotation = buffer[pos + 13];
                gameWorld.Spawns.Add(s);
                pos += 14;
            }

            for (int z = 0; z < gameWorld.Z_CHUNKS; z++)
            {
                for (int y = 0; y < gameWorld.Y_CHUNKS; y++)
                {
                    for (int x = 0; x < gameWorld.X_CHUNKS; x++)
                    {
                        Chunk c = gameWorld.Chunks[x, y, z];

                        while (pos < buffer.Length)
                        {
                            if (Convert.ToChar(buffer[pos]) != 'c')
                            {
                                //str.Seek(-1, SeekOrigin.Current);
                                //str.Read(ba, 0, 10);
                                int vx = buffer[pos];
                                int vy = buffer[pos + 1];
                                int vz = buffer[pos + 2];
                                VoxelType type = (VoxelType)buffer[pos + 3];
                                short destruct = buffer[pos + 4];
                                Color top = new Color(buffer[pos + 5], buffer[pos + 6], buffer[pos + 7]);
                                Color side = new Color(buffer[pos + 8], buffer[pos + 9], buffer[pos + 10]);

                                c.SetVoxel(vx, vy, vz, true, destruct, type, top, side);
                                pos += 11;
                            }
                            else
                            {
                                pos++;
                                break;
                            }

                        }

                        //while (cl<fileSplit.Length)
                        //{
                        //    line = fileSplit[cl];
                        //    if (line == "C") break;
                        //    if (line == "") break;

                        //    split = line.Split(',');

                        //    c.SetVoxel(Convert.ToInt16(split[0]), Convert.ToInt16(split[1]), Convert.ToInt16(split[2]), true, (VoxelType)(Convert.ToInt16(split[3])), GetTopColor((VoxelType)(Convert.ToInt16(split[3]))), GetSideColor((VoxelType)(Convert.ToInt16(split[3]))));

                        //    cl++;
                        //}

                        //cl++;
                    }
                }

            }

            //fileSplit = null;
            //fileString = null;

            gameWorld.UpdateWorldMeshes();

            GC.Collect();
        }
Esempio n. 4
0
        public static void Save(World gameWorld)
        {
            //StringBuilder sb = new StringBuilder();

            //using (StringWriter str = new StringWriter(sb))
            //{

            SaveFileDialog sfd = new SaveFileDialog();
            sfd.AddExtension = true;
            sfd.DefaultExt = ".vxl";
            sfd.Filter = "Voxel Landscape|*.vxl";
            DialogResult dr = sfd.ShowDialog();

            if (string.IsNullOrEmpty(sfd.FileName) || dr != DialogResult.OK) return;

            byte[] memBytes;
            //using (FileStream str = new FileStream(sfd.FileName, FileMode.Create))
            using (MemoryStream str = new MemoryStream())
            {
                var sw = new StreamWriter(str);
                sw.WriteLine(gameWorld.CodeName);
                sw.WriteLine(gameWorld.DisplayName);
                sw.Flush();

                str.WriteByte((byte)gameWorld.Type);
                str.WriteByte((byte)gameWorld.Theme);
                //str.Write(gameWorld.X_CHUNKS + "," + gameWorld.Y_CHUNKS + "," + gameWorld.Z_CHUNKS + "\n");
                //using (GZipStream gzstr = new GZipStream(str, CompressionMode.Compress))
                //{

                    str.WriteByte(Convert.ToByte(gameWorld.X_CHUNKS));
                    str.WriteByte(Convert.ToByte(gameWorld.Y_CHUNKS));
                    str.WriteByte(Convert.ToByte(gameWorld.Z_CHUNKS));

                    str.WriteByte(Convert.ToByte(gameWorld.Spawns.Count));
                    for (int i = 0; i < gameWorld.Spawns.Count; i++)
                    {
                        str.Write(BitConverter.GetBytes((int)gameWorld.Spawns[i].Position.X),0,4);
                        str.Write(BitConverter.GetBytes((int)gameWorld.Spawns[i].Position.Y), 0, 4);
                        str.Write(BitConverter.GetBytes((int)gameWorld.Spawns[i].Position.Z), 0, 4);
                        str.WriteByte(Convert.ToByte(gameWorld.Spawns[i].Type));
                        str.WriteByte(Convert.ToByte(gameWorld.Spawns[i].Rotation));
                    }

                    for (int z = 0; z < gameWorld.Z_CHUNKS; z++)
                    {
                        for (int y = 0; y < gameWorld.Y_CHUNKS; y++)
                        {
                            for (int x = 0; x < gameWorld.X_CHUNKS; x++)
                            {
                                //str.Write("C\n");

                                Chunk c = gameWorld.Chunks[x, y, z];
                                for (byte vx = 0; vx < Chunk.X_SIZE; vx++)
                                    for (byte vy = 0; vy < Chunk.Y_SIZE; vy++)
                                        for (byte vz = 0; vz < Chunk.Z_SIZE; vz++)
                                        {
                                            if (!c.Voxels[vx, vy, vz].Active) continue;

                                            //string vox = vx + "," + vy + "," + vz + ",";
                                            //vox += ((int)c.Voxels[vx, vy, vz].Type);
                                            //str.Write(vox + "\n");

                                            str.WriteByte(vx);
                                            str.WriteByte(vy);
                                            str.WriteByte(vz);
                                            str.WriteByte((byte)c.Voxels[vx, vy, vz].Type);
                                            str.WriteByte(Convert.ToByte(c.Voxels[vx, vy, vz].Destructable));
                                            str.WriteByte(c.Voxels[vx, vy, vz].TR);
                                            str.WriteByte(c.Voxels[vx, vy, vz].TG);
                                            str.WriteByte(c.Voxels[vx, vy, vz].TB);
                                            str.WriteByte(c.Voxels[vx, vy, vz].SR);
                                            str.WriteByte(c.Voxels[vx, vy, vz].SG);
                                            str.WriteByte(c.Voxels[vx, vy, vz].SB);
                                        }
                                str.WriteByte(Convert.ToByte('c'));
                            }
                        }

                    }

                //}
                str.Flush();
                memBytes = str.ToArray();
            }

            using (FileStream str = new FileStream(sfd.FileName, FileMode.Create))
            {
                using (GZipStream gzstr = new GZipStream(str, CompressionMode.Compress))
                {
                    gzstr.Write(memBytes, 0, memBytes.Length);
                    gzstr.Flush();
                }
            }
            //}

            //using (StreamWriter fs = new StreamWriter(fn))
            //{
            //    fs.Write(Compress(sb.ToString()));
            //    fs.Flush();
            //}

            //sb.Clear();
            //sb = null;

            GC.Collect();
        }
Esempio n. 5
0
        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);

            font = Content.Load<SpriteFont>("hudfont");

            gameWorld = new World(50,50,1,true);
            gameCamera = new Camera(GraphicsDevice, GraphicsDevice.Viewport);
            cursor = new Cursor();

            this.EnsurePrefabs();
            List<string> pfs = new List<String>(Directory.EnumerateFiles(Path.Combine(Content.RootDirectory, "prefabs/")));
            LoadSave.LoadAnim(ref spawnSprites, Path.Combine(Content.RootDirectory, "spawns.vxs"));

            foreach (string fn in pfs)
            {
                Prefabs.Add(LoadSave.LoadPrefab(fn));
            }

            drawEffect = new BasicEffect(GraphicsDevice)
            {
                World = gameCamera.worldMatrix,
                View = gameCamera.viewMatrix,
                Projection = gameCamera.projectionMatrix,
                VertexColorEnabled = true,
                //LightingEnabled = true // turn on the lighting subsystem.

            };

            cursorEffect = new BasicEffect(GraphicsDevice)
            {
                World = gameCamera.worldMatrix,
                View = gameCamera.viewMatrix,
                Projection = gameCamera.projectionMatrix,
                VertexColorEnabled = true

            };

            saveForm = new SaveForm(gameWorld);

            GC.Collect();
        }
Esempio n. 6
0
        public void PerformAction(Vector3 position, World gameWorld, PrefabChunk prefab, int selectedSpawn, int spawnRot)
        {
            // Need to make it so voxels have a type and then we can check if tree so we don't put trees on top of trees yo

            Vector2 center = new Vector2(position.X, position.Y);

            switch (Mode)
            {
                case CursorMode.LandScape:
                    for (int x = 0; x < 32; x++)
                        for (int y = 0; y < 32; y++)
                            for (int z = Chunk.Z_SIZE - 1; z >= 0; z--)
                            {
                                if(Voxels[x,y,0].Active)
                                    gameWorld.SetVoxel(((int)center.X - 16) + x, ((int)center.Y - 16) + y, z, z >= Chunk.Z_SIZE - Height, 0, VoxelType.Ground, gameWorld.ThemeTopColor(Theme), gameWorld.ThemeSideColor(Theme));
                            }

                    break;

                case CursorMode.Trees:
                    int numTrees = 1 +(Size / 2);
                    for (int i = 0; i < numTrees; i++)
                    {
                        Vector2 pos = Helper.RandomPointInCircle(new Vector2(position.X,position.Y), 0f, Size);

                        //int z = 0;
                        //for (int zz = 0; zz < Chunk.Z_SIZE; zz++) if (gameWorld.GetVoxel((int)Position.X, (int)Position.Y, zz).Active) { z = zz - 1; break; }

                        gameWorld.MakeTree((int)pos.X, (int)pos.Y, (int)position.Z);
                    }

                    //for (float a = 0f; a < MathHelper.TwoPi; a += 0.05f)
                    //{
                    //    for (int r = 0; r < Size; r++)
                    //    {
                    //        Vector3 pos = new Vector3(Helper.PointOnCircle(ref center, r, a), 0f);
                    //        gameWorld.MakeTree((int)pos.X, (int)pos.Y, (int)Position.Z);
                    //    }
                    //}
                    break;
                case CursorMode.Water:
                    for (int x = 0; x < 32; x++)
                        for (int y = 0; y < 32; y++)
                            for (int z = Chunk.Z_SIZE - 1; z >= 0; z--)
                            {
                                if(Voxels[x,y,0].Active)
                                    gameWorld.SetVoxel(((int)center.X - 16) + x, ((int)center.Y - 16) + y, z, z >= Chunk.Z_SIZE - (Height - 1), 0, VoxelType.Water, new Color(0.1f, 0.1f, 0.8f + ((float)Helper.Random.NextDouble() * 0.1f)) * 0.8f, new Color(0.3f, 0.3f, 0.8f + ((float)Helper.Random.NextDouble() * 0.1f)) * 0.8f);
                            }

                    break;
                case CursorMode.Prefab:
                    int startX = (int)position.X - (prefab.X_SIZE/2);
                    int startY = (int)position.Y - (prefab.Y_SIZE/2);
                    int startZ = (Chunk.Z_SIZE - Height) - (prefab.Z_SIZE);
                    for (int x = 0; x < prefab.X_SIZE; x++)
                    {
                        for (int y = 0; y < prefab.Y_SIZE; y++)
                        {
                            for (int z = 0; z < prefab.Z_SIZE; z++)
                            {
                                if (prefab.Voxels[x, y, z].Active)
                                {
                                    gameWorld.SetVoxel(startX + x, startY + y, startZ + z, true, destructable, VoxelType.Prefab, new Color(prefab.Voxels[x, y, z].TR, prefab.Voxels[x, y, z].TG, prefab.Voxels[x, y, z].TB), new Color(prefab.Voxels[x, y, z].SR, prefab.Voxels[x, y, z].SG, prefab.Voxels[x, y, z].SB));
                                }
                            }
                        }
                    }

                    break;
                case CursorMode.Spawn:
                    bool found = false;
                    for (int i = gameWorld.Spawns.Count - 1; i >= 0; i--)
                    {
                        if (gameWorld.Spawns[i].Position == position)
                        {
                            found = true;
                            gameWorld.Spawns.RemoveAt(i);
                        }
                    }
                    if (!found)
                    {
                        gameWorld.Spawns.Add(new Spawn()
                        {
                            Position = position,
                            Rotation = (byte)spawnRot,
                            Type = (SpawnType)selectedSpawn,
                        });
                    }
                    break;
            }
        }
Esempio n. 7
0
 public void PerformAction(World gameWorld, PrefabChunk prefab, int selectedSpawn, int spawnRot)
 {
     PerformAction(Position, gameWorld, prefab, selectedSpawn, spawnRot);
     if (MirrorMode) PerformAction(new Vector3(((gameWorld.X_SIZE)-Position.X),Position.Y,Position.Z), gameWorld, prefab, selectedSpawn, spawnRot);
 }
Esempio n. 8
0
        internal void CutPrefabSapce(World gameWorld, PrefabChunk prefab)
        {
            int startX = (int)Position.X - (prefab.X_SIZE / 2);
            int startY = (int)Position.Y - (prefab.Y_SIZE / 2);
            int startZ = (Chunk.Z_SIZE - Height) - (prefab.Z_SIZE);
            for (int x = 0; x < prefab.X_SIZE; x++)
            {
                for (int y = 0; y < prefab.Y_SIZE; y++)
                {
                    for (int z = 0; z < prefab.Z_SIZE; z++)
                    {

                        gameWorld.SetVoxelActive(startX + x, startY + y, startZ + z, false); // destructable, VoxelType.Prefab, new Color(prefab.Voxels[x, y, z].TR, prefab.Voxels[x, y, z].TG, prefab.Voxels[x, y, z].TB), new Color(prefab.Voxels[x, y, z].SR, prefab.Voxels[x, y, z].SG, prefab.Voxels[x, y, z].SB));
                        if (MirrorMode) gameWorld.SetVoxelActive(((gameWorld.X_SIZE) - startX-prefab.X_SIZE)+x, startY+y, startZ + z, false);
                    }
                }
            }
        }