Landscape.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SharpDX;
using SharpDX.Toolkit;

namespace Project1
{
    using SharpDX.Toolkit.Graphics;
    using SharpDX.Toolkit.Input;
    using System.Diagnostics;
    class Landscape : ColoredGameObject
    {
        //Set the speed of rotaion
        private float speed = 0.006f;
        //The default rotation of the Landscape
        private float rotationX = -0.5f;
        private float rotationY = 0.0f;
        private float rotationZ = 0.0f;
        private float baseline;
        private float pix = 0.0625f; // 0.125f or 0.0625
        float zooming = 4.0f;

        public int level = 1;
        public float landscapeWidth = 4f;
        public float landscapeHeight = 4f;

        public Vector3 corner1;
        public Vector3 corner2;
        public Vector3 corner3;
        public Vector3 corner4;
        //Here to set the Level, TODO create a new screen for level selecting

        //public void setLevel(int level, float landscapeHeight, float landscapeWidth)
        //{
        //    this.landscapeWidth = landscapeWidth;
        //    this.landscapeHeight = landscapeHeight;
        //    this.level = level;
        //}

        // an array of Vectors  without color setting
        private Vector3[] buffer;
        // an array of Vectors  with color setting
        private VertexPositionColor[] colorBuffer;
        BufferGenerator bufferGenerator = new BufferGenerator();


        public Landscape(Project1Game game, int level)
        {
            this.level = level;
            this.SetBuffer();
            vertices = Buffer.Vertex.New(game.GraphicsDevice, colorBuffer);
            setBoxBoundary();
            basicEffect = new BasicEffect(game.GraphicsDevice)
            {
                View = game.camera.View,
                Projection = game.camera.Projection,
                World = Matrix.Identity,
                VertexColorEnabled = true
            };

            inputLayout = VertexInputLayout.FromBuffer(0, vertices);
            this.game = game;
        }

        public override void Update(GameTime gameTime)
        {
            // Listen to the keyboard to rotate the landscape
            //if (game.keyboardState.IsKeyDown(Keys.Left))
            //{
            //    rotationY -= speed;
            //    basicEffect.World = Matrix.RotationX(rotationX) * Matrix.RotationY(rotationY) * Matrix.RotationZ(rotationZ);
            //}
            //if (game.keyboardState.IsKeyDown(Keys.Right))
            //{
            //    rotationY += speed;
            //    basicEffect.World = Matrix.RotationX(rotationX) * Matrix.RotationY(rotationY) * Matrix.RotationZ(rotationZ);
            //}
            //if (game.keyboardState.IsKeyDown(Keys.Up))
            //{
            //    rotationX -= speed;
            //    basicEffect.World = Matrix.RotationX(rotationX) * Matrix.RotationY(rotationY) * Matrix.RotationZ(rotationZ);
            //}
            //if (game.keyboardState.IsKeyDown(Keys.Down))
            //{
            //    rotationX += speed;
            //    basicEffect.World = Matrix.RotationX(rotationX) * Matrix.RotationY(rotationY) * Matrix.RotationZ(rotationZ);
            //}
            //if (game.keyboardState.IsKeyDown(Keys.W))
            //{
            //    zooming = zooming + 0.1f;
            //}
            //if (game.keyboardState.IsKeyDown(Keys.S))
            //{
            //    zooming = zooming - 0.1f;
            //    if (zooming < 2.0f)
            //    {
            //        zooming = 2.0f;
            //    }
            //}
            //basicEffect.World = Matrix.RotationX(0.1f) * Matrix.RotationY(0.2f) * Matrix.RotationZ(0);
           // basicEffect.World = Matrix.RotationX(0.1f) * Matrix.RotationY(0.2f) * Matrix.RotationZ(0);
           // basicEffect.Projection = Matrix.PerspectiveFovLH((float)Math.PI / zooming, (float)game.GraphicsDevice.BackBuffer.Width / game.GraphicsDevice.BackBuffer.Height, 0.1f, 100.0f);
        }

        public Boolean checkBoundary(Vector3 position)
        {

            if (position.Y > corner1.Y || position.Y > corner2.Y || position.Y > corner3.Y || position.Y > corner4.Y)
                if(position.X >= corner1.X && position.X <= corner2.X && position.Z<=corner1.Z && position.Z>= corner4.Z)
                    return true;
            return false;
        }

        private void setBoxBoundary()
        {
            //The position of 4 connors of the landscape
           corner1 = new Vector3(0.0f - landscapeWidth / 2, 0.0f, 0.0f + landscapeWidth / 2);//look from the top, left up conor
           corner2 = new Vector3(0.0f + landscapeWidth / 2, 0.0f, 0.0f + landscapeHeight / 2);//look from the top, right up conor
           corner3 = new Vector3(0.0f + landscapeWidth / 2, 0.0f, 0.0f - landscapeHeight / 2);//look from the top, right down conor
           corner4 = new Vector3(0.0f - landscapeWidth / 2, 0.0f, 0.0f - landscapeHeight / 2);//look from the top, left down conor
        }

        public override void Draw(GameTime gameTime)
        {
            // Setup the vertices
            game.GraphicsDevice.SetVertexBuffer(vertices);
            game.GraphicsDevice.SetVertexInputLayout(inputLayout);

            // Apply the basic effect technique and draw the rotating cube
            basicEffect.CurrentTechnique.Passes[0].Apply();
            game.GraphicsDevice.Draw(PrimitiveType.TriangleList, vertices.ElementCount);
        }

        private void SetBuffer()
        {

            bufferGenerator.SetPix(pix);
            
            //To generate a random float number
            Random rd = new Random();
            float c1, c2, c3, c4;
            c1 = (float)rd.NextDouble(0, 1.0);
            c2 = (float)rd.NextDouble(0, 1.0);
            c3 = (float)rd.NextDouble(0, 1.0);
            c4 = (float)rd.NextDouble(0, 1.0);
            // to record the baseline of landscape's height
            baseline = (c1 + c2 + c3 + c4) / 4;
            bufferGenerator.SetBaseLine(baseline);
            bufferGenerator.SetLandscapeHeight(this.landscapeHeight);
            bufferGenerator.SetLandscapeWidth(this.landscapeWidth);

            //The position of 4 connors of the landscape
            Vector3 dpos1 = new Vector3(0.0f - landscapeWidth/2, c1, 0.0f + landscapeHeight/2);//look from the top, left up conor
            Vector3 dpos2 = new Vector3(dpos1.X + landscapeWidth, c2, dpos1.Z);//look from the top, right up conor
            Vector3 dpos3 = new Vector3(dpos1.X + landscapeWidth, c3, dpos1.Z - landscapeHeight);//look from the top, right down conor
            Vector3 dpos4 = new Vector3(dpos1.X, c4, dpos1.Z - landscapeHeight);//look from the top, left down conor

            float width = Math.Abs(dpos1.X - dpos2.X);
            float height = Math.Abs(dpos1.Z - dpos3.Z);
            this.colorBuffer = new VertexPositionColor[] { };
            this.buffer = new Vector3[] { };
            bufferGenerator.setLevel(level, landscapeHeight,landscapeWidth,dpos1);

            this.buffer = bufferGenerator.DivideGrid(dpos1.X, dpos1.Z, width, height, c1, c2, c3, c4);
            this.bufferGenerator.setColorRanges();
            this.colorBuffer = bufferGenerator.setColor();
            this.colorBuffer = bufferGenerator.setCannonPos();
            this.colorBuffer = bufferGenerator.AddBase(dpos1, dpos2, dpos3, dpos4);
        }
        public float getHeight(float x, float z)
        {
            for (int i = 0; i < colorBuffer.Length-1; i++ )
            {
                if (colorBuffer[i].Position.X == x && colorBuffer[i].Position.Z == z)
                {
                    return colorBuffer[i].Position.Y;
                }     
            }
            return 0f;
            
        }
        public VertexPositionColor getCannonPos()
        {
            return bufferGenerator.getCannonPos();

        }
        public VertexPositionColor getTargetPos()
        {
            return bufferGenerator.getTargetPos();

        }
    }
}