#region Using Statements
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
#endregion

namespace MarcoPolo
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        ContentManager content;
        //Sprites
        private static Texture2D SpriteShark;
        private static Texture2D SpriteShark2;
        private static Texture2D SpriteSharkc;
        private static Texture2D SpriteShark2c;
        private static Texture2D SpriteSharkAnimate;

        private static Texture2D SpriteDragon;
        private static Texture2D SpriteOrange;
        private static Texture2D SpriteOrange2;

        private static Texture2D SpriteOrangeAnimate;

        private static Texture2D SpriteFish;
        private static Texture2D SpriteFish2;
        private static Texture2D SpriteFishc;
        private static Texture2D SpriteFish2c;
        private static Texture2D SpriteFishAnimate;
        private static Texture2D SpriteWallpaper;

        private static SpriteBatch SpriteBatch;
        private Rectangle Wallpaper;
        /*
         * Class player
         * int x
         * int y
         * Boolean jumping
         * Boolean right // is facing right 
         */
        //player1
        private int x = 0;
        private int y = 0;
        private Boolean jumping = false;
        private Boolean right = false;
        private Boolean still = true;
        private int jumpIncrease = 0;
        private int blinkCounter = 0;

        // player2
        private int x2 = 0;
        private int y2 = 0;
        private Boolean jumping2 = false;
        private Boolean right2 = false;

        private Boolean still2 = true;
        private int jumpIncrease2 = 0;

        private int blinkCounter2 = 0;


        // player3
        private int x3 = 0;
        private int y3 = 0;
        private Boolean jumping3 = false;
        private Boolean right3 = false;

        private Boolean still3 = true;
        private int jumpIncrease3 = 0;

        private int blinkCounter3 = 0;
        //other

        private Boolean countdown = false;
        //ADDED

        private Vector2 position2 = new Vector2(0f, 0f); // Specify Position of our Sprite ( unless CenterToScreen == true )

        private Vector2 position3 = new Vector2(0f, 0f); // Specify Position of our Sprite ( unless CenterToScreen == true )

        private Vector2 position = new Vector2(0f, 0f); // Specify Position of our Sprite ( unless CenterToScreen == true )

        private Vector2 origin = new Vector2(32f, 28f); // Change the Sprite Center of Origin to specified coordinates. Default is  0, 0 ( Top, Left corner ) 
        private bool originCentered = false; // If true, Sprite will Rotate around the SpriteTexture's Center
        private bool centerToScreen = true; // Position the Sprite to Center of Screen
        private Vector3 rotation = Vector3.Zero; // The starting rotation value in Radians
        private float spriteSpeed = 4.0f; // A stimulant ingested by rowdy Sprites
        private bool inverted = false; // Invert Controller Joystick Y

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            content = new ContentManager(Services);
//if all else fails use SpriteTexture = Texture.FromFile(...)
        }


        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here
            base.Initialize();


          
        }


        /// <summary>
        /// Load your graphics content.  If loadAllContent is true, you should
        /// load content from both ResourceManagementMode pools.  Otherwise, just
        /// load ResourceManagementMode.Manual content.
        /// </summary>
        /// <param name="loadAllContent">Which type of content to load.</param>
        protected override void LoadGraphicsContent(bool loadAllContent)
        {
            if (loadAllContent)
            {
                // TODO: Load any ResourceManagementMode.Automatic content

                SpriteBatch = new SpriteBatch(graphics.GraphicsDevice);

                SpriteFish = content.Load<Texture2D>("gfx/fish");
               
                SpriteOrange = content.Load<Texture2D>("gfx/orange");

                //SpriteDragon = content.Load<Texture2D>("gfx/dragon");
                SpriteShark = content.Load<Texture2D>("gfx/shark");
                SpriteShark2 = content.Load<Texture2D>("gfx/shark2"); 
                SpriteSharkc = content.Load<Texture2D>("gfx/sharkc");
                SpriteShark2c = content.Load<Texture2D>("gfx/shark2c");
                
                SpriteFish2 = content.Load<Texture2D>("gfx/fish2");
                
                SpriteOrange2 = content.Load<Texture2D>("gfx/orange2");

                SpriteWallpaper = content.Load<Texture2D>("gfx/background");
                SpriteFishAnimate = content.Load<Texture2D>("gfx/fish"); //SpriteFish;
                SpriteOrangeAnimate = content.Load<Texture2D>("gfx/orange"); //SpriteOrange;


                Wallpaper = new Rectangle(0, 0, graphics.GraphicsDevice.Viewport.Width,
                    graphics.GraphicsDevice.Viewport.Height);
            }

            // TODO: Load any ResourceManagementMode.Manual content
        }


        /// <summary>
        /// Unload your graphics content.  If unloadAllContent is true, you should
        /// unload content from both ResourceManagementMode pools.  Otherwise, just
        /// unload ResourceManagementMode.Manual content.  Manual content will get
        /// Disposed by the GraphicsDevice during a Reset.
        /// </summary>
        /// <param name="unloadAllContent">Which type of content to unload.</param>
        protected override void UnloadGraphicsContent(bool unloadAllContent)
        {
            if (unloadAllContent)
            {
                // TODO: Unload any ResourceManagementMode.Automatic content
                content.Unload();
               
            }

            // TODO: Unload any ResourceManagementMode.Manual content
        }


        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {

            //   SpriteBatch.Begin(SpriteBlendMode.AlphaBlend);
      
       //***PLAYER1***
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            if ((GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X == 0) &&
                (GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y == 0) &&
                (GamePad.GetState(PlayerIndex.One).DPad.Right != ButtonState.Pressed) &&

                (GamePad.GetState(PlayerIndex.One).DPad.Left != ButtonState.Pressed) &&

                (GamePad.GetState(PlayerIndex.One).DPad.Up != ButtonState.Pressed) &&

                (GamePad.GetState(PlayerIndex.One).DPad.Down != ButtonState.Pressed))
            {
                still = true;
                if (right)
                {
                    SpriteFishAnimate = SpriteFish2c;
                }
                else
                {
                    //set animation to
                    SpriteFishAnimate = SpriteFish2;
                }
            }
            else
            {
                still = false; //movement is happening
            }
            // TODO: Add your update logic here
            if ((GamePad.GetState(PlayerIndex.One).DPad.Right == ButtonState.Pressed)
           ||  (GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X >0))
            {
                x+=5;
                position.X += GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X * spriteSpeed;
                right = true;
            }

            if ((GamePad.GetState(PlayerIndex.One).DPad.Left == ButtonState.Pressed)
            || (GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X <0))
            {
                x-=5;
                position.X -= GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X * spriteSpeed;
                right = false;
            }

            if ((GamePad.GetState(PlayerIndex.One).DPad.Down == ButtonState.Pressed)
          || (GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y < 0))
            {
                y+=5;
                position.Y += GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y * spriteSpeed;

            }

            if ((GamePad.GetState(PlayerIndex.One).DPad.Up == ButtonState.Pressed)
          || (GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y > 0))
            {
                y-=5;

                position.Y -= GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y * spriteSpeed;
            }
            if (GamePad.GetState(PlayerIndex.One).Buttons.X == ButtonState.Pressed)
            {
                jumping = true;
               
            }

            if (jumping)
            {
                if (jumpIncrease < 280)
                    jumpIncrease+=5;
                else
                {
                    jumping = false;
                
                }
            }
            if (!jumping)
            {
                if (jumpIncrease > 0)
                {
                    jumpIncrease--;
                }
            }


            //***PLAYER2***
            // Allows the game to Exit
            if (GamePad.GetState(PlayerIndex.Two).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            if ((GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.X == 0) &&
              (GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.Y == 0) &&
              (GamePad.GetState(PlayerIndex.Two).DPad.Right != ButtonState.Pressed) &&

              (GamePad.GetState(PlayerIndex.Two).DPad.Left != ButtonState.Pressed) &&

              (GamePad.GetState(PlayerIndex.Two).DPad.Up != ButtonState.Pressed) &&

              (GamePad.GetState(PlayerIndex.Two).DPad.Down != ButtonState.Pressed))
            {
                still2 = true;
                if (right2)
                {
                    SpriteSharkAnimate = SpriteShark2c;
                }
                else
                {
                    //set animation to
                    SpriteSharkAnimate = SpriteShark2;
                }
            }
            else
            {
                still2 = false; //movement is happening
            }

            // TODO: Add your update logic here
            if ((GamePad.GetState(PlayerIndex.Two).DPad.Right == ButtonState.Pressed)
           || (GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.X > 0))
            {
                x2++;
                position2.X += GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.X * spriteSpeed;
                right2 =  true;
            }

            if ((GamePad.GetState(PlayerIndex.Two).DPad.Left == ButtonState.Pressed)
            || (GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.X < 0))
            {
                x2--;
                position2.X -= GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.X * spriteSpeed;
                right2 = false;
            }

            if ((GamePad.GetState(PlayerIndex.Two).DPad.Down == ButtonState.Pressed)
          || (GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.Y < 0))
            {
                y2 += 2;
                position2.Y += GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.Y * spriteSpeed;

            }

            if ((GamePad.GetState(PlayerIndex.Two).DPad.Up == ButtonState.Pressed)
          || (GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.Y > 0))
            {
                y2 -= 2;

                position2.Y -= GamePad.GetState(PlayerIndex.Two).ThumbSticks.Left.Y * spriteSpeed;
            }
            if (GamePad.GetState(PlayerIndex.Two).Buttons.X == ButtonState.Pressed)
            {
                jumping2 = true;

            }

            if (jumping2)
            {
                if (jumpIncrease2 < 280)
                    jumpIncrease2 += 2;
                else
                {
                    jumping2 = false;

                }
            }
            if (!jumping2)
            {
                if (jumpIncrease2 > 0)
                {
                    jumpIncrease2--;
                }
            }

            //***PLAYER3***
            // Allows the game to Exit
            if (GamePad.GetState(PlayerIndex.Three).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            if ((GamePad.GetState(PlayerIndex.Three).ThumbSticks.Left.X == 0) &&
              (GamePad.GetState(PlayerIndex.Three).ThumbSticks.Left.Y == 0) &&
              (GamePad.GetState(PlayerIndex.Three).DPad.Right != ButtonState.Pressed) &&

              (GamePad.GetState(PlayerIndex.Three).DPad.Left != ButtonState.Pressed) &&

              (GamePad.GetState(PlayerIndex.Three).DPad.Up != ButtonState.Pressed) &&

              (GamePad.GetState(PlayerIndex.Three).DPad.Down != ButtonState.Pressed))
            {
                still3 = true;
                if (right3)
                {
                    SpriteSharkAnimate = SpriteOrange2;// SpriteShark2c;
                }
                else
                {
                    //set animation to
                    SpriteSharkAnimate = SpriteOrange2;
                }
            }
            else
            {
                still3 = false; //movement is happening
            }

            // TODO: Add your update logic here
            if ((GamePad.GetState(PlayerIndex.Three).DPad.Right == ButtonState.Pressed)
           || (GamePad.GetState(PlayerIndex.Three).ThumbSticks.Left.X > 0))
            {
                x3++;
                position3.X += GamePad.GetState(PlayerIndex.Three).ThumbSticks.Left.X * spriteSpeed;
                right3 = true;
            }

            if ((GamePad.GetState(PlayerIndex.Three).DPad.Left == ButtonState.Pressed)
            || (GamePad.GetState(PlayerIndex.Three).ThumbSticks.Left.X < 0))
            {
                x3--;
                position3.X -= GamePad.GetState(PlayerIndex.Three).ThumbSticks.Left.X * spriteSpeed;
                right3 = false;
            }

            if ((GamePad.GetState(PlayerIndex.Three).DPad.Down == ButtonState.Pressed)
          || (GamePad.GetState(PlayerIndex.Three).ThumbSticks.Left.Y < 0))
            {
                y3 += 2;
                position3.Y += GamePad.GetState(PlayerIndex.Three).ThumbSticks.Left.Y * spriteSpeed;

            }

            if ((GamePad.GetState(PlayerIndex.Three).DPad.Up == ButtonState.Pressed)
          || (GamePad.GetState(PlayerIndex.Three).ThumbSticks.Left.Y > 0))
            {
                y3 -= 2;

                position3.Y -= GamePad.GetState(PlayerIndex.Three).ThumbSticks.Left.Y * spriteSpeed;
            }
            if (GamePad.GetState(PlayerIndex.Three).Buttons.X == ButtonState.Pressed)
            {
                jumping3 = true;

            }

            if (jumping3)
            {
                if (jumpIncrease3 < 280)
                    jumpIncrease3 += 2;
                else
                {
                    jumping3 = false;

                }
            }
            if (!jumping3)
            {
                if (jumpIncrease3 > 0)
                {
                    jumpIncrease3--;
                }
            }



        //***ALL***
            base.Update(gameTime);
        }


        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
         // 
            graphics.GraphicsDevice.Clear(Color.Black);//CornflowerBlue);
           
            SpriteBatch.Begin();
            SpriteBatch.Draw(SpriteWallpaper, Wallpaper, null, Color.White);
  
            //PLAYER 1
            if (right)
            {
                SpriteFishAnimate = SpriteFish2;
               
                blinkCounter++;
                if (blinkCounter == 50)
                {
                    SpriteFishAnimate = SpriteFish2c;
               
                }
                if (blinkCounter < 55)
                {
                   
                }
                else
                {
                    blinkCounter = 0;
                    SpriteFishAnimate = SpriteFish2;
                }
                SpriteBatch.Draw(SpriteFishAnimate, new Vector2(x + 60, y + 100 + jumpIncrease), null, Color.White, rotation.Z, origin, 1.0f, SpriteEffects.None, 0.0f);
            }
            else
            {
                SpriteFishAnimate = SpriteFish;
                blinkCounter++;
                if (blinkCounter == 50)
                {
                    SpriteFishAnimate = SpriteFishc;
                    blinkCounter = 0;
                }
                if (blinkCounter < 55)
                {
                }
                else
                {
                    blinkCounter = 0;

                    SpriteFishAnimate = SpriteFish;
                }
                SpriteBatch.Draw(SpriteFishAnimate, new Vector2(x + 60, y + 100 + jumpIncrease), null, Color.White, rotation.Z, origin, 1.0f, SpriteEffects.None, 0.0f);
            }
            
            //PLAYER 2
            if (right2)
            {
                SpriteSharkAnimate = SpriteShark2;
                blinkCounter2++;
                if (blinkCounter2 == 50)
                {
                    SpriteSharkAnimate = SpriteShark2c;

                }
                if (blinkCounter2 < 95)
                {
                }
                else
                {
                    blinkCounter2 = 0;
                }
                SpriteBatch.Draw(SpriteSharkAnimate, new Vector2(x2 + 550, y2 + 100 + jumpIncrease2), null, Color.White, rotation.Z, origin, 1.0f, SpriteEffects.None, 0.0f);
            }
            else
            {
                SpriteSharkAnimate = SpriteShark;
                blinkCounter2++;
                if (blinkCounter2 == 50)
                {
                    SpriteSharkAnimate = SpriteSharkc;
            
                }
                if (blinkCounter2 < 95)
                {
                }
                else
                {
                    blinkCounter2 = 0;
                }
                SpriteBatch.Draw(SpriteSharkAnimate, new Vector2(x2 + 550, y2 + 100 + jumpIncrease2), null, Color.White, rotation.Z, origin, 1.0f, SpriteEffects.None, 0.0f);
            }

            //PLAYER 2
            if (right3)
            {
                SpriteOrangeAnimate = SpriteOrange2;
                blinkCounter3++;
                if (blinkCounter3 == 50)
                {
                    SpriteOrangeAnimate = SpriteOrange2;// SpriteOrange2c;

                }
                if (blinkCounter3 < 95)
                {
                }
                else
                {
                    blinkCounter3 = 0;
                }
                SpriteBatch.Draw(SpriteOrangeAnimate, new Vector2(x3 + 50, y3 + 450 + jumpIncrease3), null, Color.White, rotation.Z, origin, 1.0f, SpriteEffects.None, 0.0f);
            }
            else
            {
                SpriteOrangeAnimate = SpriteOrange;// SpriteShark;
                blinkCounter3++;
                if (blinkCounter3 == 50)
                {
                    SpriteOrangeAnimate = SpriteOrange;// SpriteSharkc;

                }
                if (blinkCounter3 < 95)
                {
                }
                else
                {
                    blinkCounter3 = 0;
                }
                SpriteBatch.Draw(SpriteOrangeAnimate, new Vector2(x3 + 50, y3 + 450 + jumpIncrease3), null, Color.White, rotation.Z, origin, 1.0f, SpriteEffects.None, 0.0f);
            }

            SpriteBatch.End();

            base.Draw(gameTime);
        }

        protected void CenterToScreen()
        {
            Viewport viewport = SpriteBatch.GraphicsDevice.Viewport;
            position.X = viewport.Width / 2;
            position.Y = viewport.Height / 2;
            rotation.Z = 0;
        }
    }
}